Accelerare la generazione di candidati nei sistemi di raccomandazione usando Milvus abbinato a PaddlePaddle
Se hai esperienza nello sviluppo di un sistema di raccomandazione, è probabile che tu sia caduto vittima di almeno uno dei seguenti problemi:
- Il sistema è estremamente lento nel restituire i risultati a causa dell'enorme quantità di dataset.
- I dati appena inseriti non possono essere elaborati in tempo reale per la ricerca o la query.
- Il deployment del sistema di raccomandazione è scoraggiante.
Questo articolo mira ad affrontare i problemi menzionati sopra e a fornirti alcuni spunti introducendo un progetto di sistema di raccomandazione di prodotti che utilizza Milvus, un database vettoriale open-source, abbinato a PaddlePaddle, una piattaforma di deep learning.
Questo articolo si propone di descrivere brevemente il workflow minimo di un sistema di raccomandazione. Poi passa a introdurre i componenti principali e i dettagli di implementazione di questo progetto.
Il workflow di base di un sistema di raccomandazione
Prima di approfondire il progetto stesso, diamo prima un'occhiata al workflow di base di un sistema di raccomandazione. Un sistema di raccomandazione può restituire risultati personalizzati in base agli interessi e alle esigenze uniche dell'utente. Per realizzare tali raccomandazioni personalizzate, il sistema attraversa due fasi: generazione dei candidati e ranking.
Figura 1.
La prima fase è la generazione dei candidati, che restituisce i dati più rilevanti o simili, come un prodotto o un video che corrisponde al profilo dell'utente. Durante la generazione dei candidati, il sistema confronta le caratteristiche dell'utente con i dati memorizzati nel suo database e recupera quelli simili. Poi, durante il ranking, il sistema assegna un punteggio e riordina i dati recuperati. Infine, i risultati in cima alla lista vengono mostrati agli utenti.
Nel nostro caso di un sistema di raccomandazione di prodotti, esso confronta innanzitutto il profilo dell'utente con le caratteristiche dei prodotti in inventario per filtrare un elenco di prodotti che soddisfano le esigenze dell'utente. Poi il sistema assegna un punteggio ai prodotti in base alla loro somiglianza con il profilo dell'utente, li classifica e infine restituisce i primi 10 prodotti all'utente.
Figura 2.
Architettura del sistema
Il sistema di raccomandazione di prodotti in questo progetto utilizza tre componenti: MIND, PaddleRec e Milvus.
MIND
MIND, abbreviazione di "Multi-Interest Network with Dynamic Routing for Recommendation at Tmall", è un algoritmo sviluppato da Alibaba Group. Prima che MIND venisse proposto, la maggior parte dei modelli di IA prevalenti per la raccomandazione utilizzava un singolo vettore per rappresentare i vari interessi di un utente. Tuttavia, un singolo vettore è ben lontano dall'essere sufficiente per rappresentare gli interessi esatti di un utente. Pertanto, l'algoritmo MIND è stato proposto per trasformare i molteplici interessi di un utente in diversi vettori.
Nello specifico, MIND adotta una rete multi-interesse con routing dinamico per elaborare i molteplici interessi di un utente durante la fase di generazione dei candidati. La rete multi-interesse è uno strato di estrattore multi-interesse costruito sul meccanismo di capsule routing. Può essere utilizzata per combinare i comportamenti passati di un utente con i suoi molteplici interessi, per fornire un profilo utente accurato.
Il diagramma seguente illustra la struttura di rete di MIND.
Figura 3.
Per rappresentare le caratteristiche degli utenti, MIND prende come input i comportamenti e gli interessi degli utenti, quindi li inserisce nel livello di embedding per generare vettori utente, inclusi vettori di interesse utente e vettori di comportamento utente. Poi i vettori di comportamento utente vengono inseriti nel livello di estrattore multi-interesse per generare capsule di interesse degli utenti. Dopo aver concatenato le capsule di interesse utente con gli embedding di comportamento utente e aver utilizzato diversi livelli ReLU per trasformarli, MIND produce diversi vettori di rappresentazione dell'utente. Questo progetto ha definito che MIND produrrà infine quattro vettori di rappresentazione dell'utente.
D'altra parte, le caratteristiche del prodotto passano attraverso il layer di embedding e vengono convertite in vettori item sparsi. Poi ogni vettore item passa attraverso un layer di pooling per diventare un vettore denso.
Quando tutti i dati vengono convertiti in vettori, viene introdotto un layer di attenzione aggiuntivo label-aware per guidare il processo di training.
PaddleRec
PaddleRec è una libreria di modelli di ricerca su larga scala per la raccomandazione. Fa parte dell'ecosistema Baidu PaddlePaddle. PaddleRec mira a fornire agli sviluppatori una soluzione integrata per costruire un sistema di raccomandazione in modo facile e rapido.
Figura 4.
Come menzionato nel paragrafo introduttivo, gli ingegneri che sviluppano sistemi di raccomandazione spesso devono affrontare le sfide della scarsa usabilità e del deployment complicato del sistema. Tuttavia, PaddleRec può aiutare gli sviluppatori nei seguenti aspetti:
Facilità d'uso: PaddleRec è una libreria open-source che incapsula vari modelli popolari nel settore, inclusi modelli per la generazione di candidati, ranking, reranking, multitasking e altro ancora. Con PaddleRec, puoi testare immediatamente l'efficacia del modello e migliorarne l'efficienza tramite iterazione. PaddleRec ti offre un modo semplice per addestrare modelli per sistemi distribuiti con prestazioni eccellenti. È ottimizzato per l'elaborazione di dati su larga scala di vettori sparsi. Puoi facilmente scalare PaddleRec orizzontalmente e accelerarne la velocità di calcolo. Pertanto, puoi creare rapidamente ambienti di training su Kubernetes usando PaddleRec.
Supporto per il deployment: PaddleRec fornisce soluzioni di deployment online per i suoi modelli. I modelli sono immediatamente pronti per l'uso dopo il training, offrendo flessibilità e alta disponibilità.
Milvus
Milvus è un database vettoriale caratterizzato da un'architettura cloud-native. È open source su GitHub e può essere utilizzato per archiviare, indicizzare e gestire enormi vettori di embedding generati da reti neurali profonde e altri modelli di machine learning (ML). Milvus incapsula diverse librerie di ricerca approximate nearest neighbor (ANN) di prima classe, tra cui Faiss, NMSLIB e Annoy. Puoi anche scalare Milvus in base alle tue necessità. Il servizio Milvus è altamente disponibile e supporta l'elaborazione unificata batch e stream. Milvus si impegna a semplificare il processo di gestione dei dati non strutturati e a fornire un'esperienza utente coerente in diversi ambienti di deployment. Ha le seguenti funzionalità:
Alte prestazioni durante l'esecuzione della ricerca vettoriale su dataset enormi.
Una community developer-first che offre supporto multi-lingua e toolchain.
Scalabilità cloud e alta affidabilità anche in caso di interruzione.
Ricerca ibrida ottenuta abbinando il filtraggio scalare alla ricerca di similarità vettoriale.
Milvus viene utilizzato per la ricerca di similarità vettoriale e la gestione dei vettori in questo progetto perché può risolvere il problema degli aggiornamenti frequenti dei dati mantenendo al contempo la stabilità del sistema.
Implementazione del sistema
Per costruire il sistema di raccomandazione dei prodotti in questo progetto, devi seguire i seguenti passaggi:
- Elaborazione dei dati
- Training del modello
- Test del modello
- Generazione dei candidati item di prodotto
- Archiviazione dei dati: i vettori item vengono ottenuti tramite il modello addestrato e archiviati in Milvus.
- Ricerca dei dati: quattro vettori utente generati da MIND vengono inseriti in Milvus per la ricerca di similarità vettoriale.
- Ranking dei dati: ciascuno dei quattro vettori ha i propri vettori item simili
top_k, e quattro set di vettoritop_kvengono classificati per restituire un elenco finale deitop_kvettori più simili.
Il codice sorgente di questo progetto è ospitato sulla piattaforma Baidu AI Studio. La sezione seguente è una spiegazione dettagliata del codice sorgente per questo progetto.
Passaggio 1. Elaborazione dei dati
Il dataset originale proviene dal dataset di libri Amazon fornito da ComiRec. Tuttavia, questo progetto utilizza i dati scaricati da PaddleRec ed elaborati da PaddleRec. Consulta l'AmazonBook dataset nel progetto PaddleRec per ulteriori informazioni.
Il dataset per l'addestramento dovrebbe presentarsi nel seguente formato, con ogni colonna che rappresenta:
Uid: ID utente.item_id: ID dell'articolo del prodotto su cui l'utente ha fatto clic.Time: Il timestamp o l'ordine del clic.
Il dataset per il test dovrebbe presentarsi nel seguente formato, con ogni colonna che rappresenta:
Uid: ID utente.hist_item: ID dell'articolo del prodotto nel comportamento storico dei clic dell'utente. Quando sono presenti piùhist_item, vengono ordinati in base al timestamp.eval_item: La sequenza effettiva in cui l'utente fa clic sui prodotti.
Passaggio 2. Addestramento del modello
L'addestramento del modello utilizza i dati elaborati nel passaggio precedente e adotta il modello di generazione dei candidati, MIND, costruito su PaddleRec.
1. Input del modello
In dygraph_model.py, esegui il seguente codice per elaborare i dati e trasformarli in input del modello. Questo processo ordina gli articoli cliccati dallo stesso utente nei dati originali in base al timestamp e li combina per formare una sequenza. Quindi, seleziona casualmente un item``_``id dalla sequenza come target_item ed estrae i 10 articoli precedenti a target_item come hist_item per l'input del modello. Se la sequenza non è abbastanza lunga, può essere impostata a 0. seq_len dovrebbe essere la lunghezza effettiva della sequenza hist_item.
def create_feeds_train(self, batch_data):
hist_item = paddle.to_tensor(batch_data[0], dtype="int64")
target_item = paddle.to_tensor(batch_data[1], dtype="int64")
seq_len = paddle.to_tensor(batch_data[2], dtype="int64")
return [hist_item, target_item, seq_len]
Consulta lo script /home/aistudio/recommend/model/mind/mind_reader.py per il codice di lettura del dataset originale.
2. Rete del modello
Il codice seguente è un estratto di net.py. class Mind_Capsual_Layer definisce il livello estrattore multi-interesse costruito sul meccanismo di routing delle capsule di interesse. La funzione label_aware_attention() implementa la tecnica di attenzione consapevole dell'etichetta nell'algoritmo MIND. La funzione forward() nella class MindLayer modella le caratteristiche dell'utente e genera i corrispondenti vettori di peso.
class Mind_Capsual_Layer(nn.Layer):
def __init__(self):
super(Mind_Capsual_Layer, self).__init__()
self.iters = iters
self.input_units = input_units
self.output_units = output_units
self.maxlen = maxlen
self.init_std = init_std
self.k_max = k_max
self.batch_size = batch_size
# B2I routing
self.routing_logits = self.create_parameter(
shape=[1, self.k_max, self.maxlen],
attr=paddle.ParamAttr(
name="routing_logits", trainable=False),
default_initializer=nn.initializer.Normal(
mean=0.0, std=self.init_std))
# bilinear mapping
self.bilinear_mapping_matrix = self.create_parameter(
shape=[self.input_units, self.output_units],
attr=paddle.ParamAttr(
name="bilinear_mapping_matrix", trainable=True),
default_initializer=nn.initializer.Normal(
mean=0.0, std=self.init_std))
class MindLayer(nn.Layer):
def label_aware_attention(self, keys, query):
weight = paddle.sum(keys * query, axis=-1, keepdim=True)
weight = paddle.pow(weight, self.pow_p) # [x,k_max,1]
weight = F.softmax(weight, axis=1)
output = paddle.sum(keys * weight, axis=1)
return output, weight
def forward(self, hist_item, seqlen, labels=None):
hit_item_emb = self.item_emb(hist_item) # [B, seqlen, embed_dim]
user_cap, cap_weights, cap_mask = self.capsual_layer(hit_item_emb, seqlen)
if not self.training:
return user_cap, cap_weights
target_emb = self.item_emb(labels)
user_emb, W = self.label_aware_attention(user_cap, target_emb)
return self.sampled_softmax(
user_emb, labels, self.item_emb.weight,
self.embedding_bias), W, user_cap, cap_weights, cap_mask
Fai riferimento allo script /home/aistudio/recommend/model/mind/net.py per la struttura di rete specifica di MIND.
3. Ottimizzazione del modello
Questo progetto utilizza l'algoritmo Adam come ottimizzatore del modello.
def create_optimizer(self, dy_model, config):
lr = config.get("hyper_parameters.optimizer.learning_rate", 0.001)
optimizer = paddle.optimizer.Adam(
learning_rate=lr, parameters=dy_model.parameters())
return optimizer
Inoltre, PaddleRec scrive gli iperparametri in config.yaml, quindi devi solo modificare questo file per vedere un chiaro confronto tra l'efficacia dei due modelli e migliorare l'efficienza del modello. Durante l'addestramento del modello, uno scarso effetto del modello può derivare da underfitting o overfitting del modello. Puoi quindi migliorarlo modificando il numero di cicli di addestramento. In questo progetto, devi solo cambiare il parametro epochs in config.yaml per trovare il numero perfetto di cicli di addestramento. Inoltre, puoi anche cambiare l'ottimizzatore del modello, optimizer.class, o learning_rate per il debug. Di seguito è mostrata una parte dei parametri in config.yaml.
runner:
use_gpu: True
use_auc: False
train_batch_size: 128
epochs: 20
print_interval: 10
model_save_path: "output_model_mind"
# hyper parameters of user-defined network
hyper_parameters:
# optimizer config
optimizer:
class: Adam
learning_rate: 0.005
Fai riferimento allo script /home/aistudio/recommend/model/mind/dygraph_model.py per l'implementazione dettagliata.
4. Addestramento del modello
Esegui il seguente comando per avviare l'addestramento del modello.
python -u trainer.py -m mind/config.yaml
Fai riferimento a /home/aistudio/recommend/model/trainer.py per il progetto di addestramento del modello.
Passaggio 3. Test del modello
Questo passaggio utilizza il dataset di test per verificare le prestazioni, come il tasso di recall del modello addestrato.
Durante il test del modello, tutti i vettori degli item vengono caricati dal modello e poi importati in Milvus, il database vettoriale open-source. Leggi il dataset di test tramite lo script /home/aistudio/recommend/model/mind/mind_infer_reader.py. Carica il modello del passaggio precedente e inserisci il dataset di test nel modello per ottenere quattro vettori di interesse dell'utente. Cerca in Milvus i 50 vettori degli item più simili ai quattro vettori di interesse. Puoi consigliare agli utenti i risultati restituiti.
Esegui il seguente comando per testare il modello.
python -u infer.py -m mind/config.yaml -top_n 50
Durante il test del modello, il sistema fornisce diversi indicatori per valutare l'efficacia del modello, come Recall@50, NDCG@50 e HitRate@50. Questo articolo introduce solo la modifica di un parametro. Tuttavia, nel tuo scenario applicativo, devi addestrare più epochs per ottenere un effetto migliore del modello. Puoi anche migliorare l'efficacia del modello utilizzando ottimizzatori diversi, impostando learning rate diversi e aumentando il numero di cicli di test. Si consiglia di salvare diversi modelli con effetti differenti, quindi scegliere quello con le migliori prestazioni e che meglio si adatta alla tua applicazione.
Passaggio 4. Generazione di candidati item di prodotto
Per creare il servizio di generazione dei candidati prodotto, questo progetto utilizza il modello addestrato nei passaggi precedenti, abbinato a Milvus. Durante la generazione dei candidati, FASTAPI viene utilizzato per fornire l'interfaccia. Quando il servizio viene avviato, puoi eseguire direttamente i comandi nel terminale tramite curl.
Esegui il seguente comando per generare candidati preliminari.
uvicorn main:app
Il servizio fornisce quattro tipi di interfacce:
- Insert : Esegui il seguente comando per leggere i vettori degli elementi dal tuo modello e inserirli in una collection in Milvus.
curl -X 'POST' \
'http://127.0.0.1:8000/rec/insert_data' \
-H 'accept: application/json' \
-d ''
- Generate preliminary candidates: Inserisci la sequenza in cui i prodotti vengono cliccati dall'utente e individua il prossimo prodotto che l'utente potrebbe cliccare. Puoi anche generare candidati di elementi prodotto in batch per diversi utenti in un'unica operazione.
hist_itemnel seguente comando è un vettore bidimensionale, e ogni riga rappresenta una sequenza dei prodotti che l'utente ha cliccato in passato. Puoi definire la lunghezza della sequenza. I risultati restituiti sono anch'essi insiemi di vettori bidimensionali, ogni riga rappresenta gliitem idrestituiti per gli utenti.
curl -X 'POST' \
'http://127.0.0.1:8000/rec/recall' \
-H 'accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
"top_k": 50,
"hist_item": [[43,23,65,675,3456,8654,123454,54367,234561],[675,3456,8654,123454,76543,1234,9769,5670,65443,123098,34219,234098]]
}'
- Query the total number of product items: Esegui il seguente comando per restituire il numero totale di vettori degli elementi archiviati nel database Milvus.
curl -X 'POST' \
'http://127.0.0.1:8000/rec/count' \
-H 'accept: application/json' \
-d ''
- Delete: Esegui il seguente comando per eliminare tutti i dati archiviati nel database Milvus .
curl -X 'POST' \
'http://127.0.0.1:8000/qa/drop' \
-H 'accept: application/json' \
-d ''
Se esegui il servizio di generazione dei candidati sul tuo server locale, puoi anche accedere alle interfacce sopra indicate a 127.0.0.1:8000/docs. Puoi sperimentare cliccando sulle quattro interfacce e inserendo il valore per i parametri. Quindi clicca su "Try it out" per ottenere il risultato della raccomandazione.
Figure 5.
Figure 6.
Riepilogo
Questo articolo si concentra principalmente sulla prima fase della generazione dei candidati nella costruzione di un sistema di raccomandazione. Fornisce inoltre una soluzione per accelerare questo processo combinando Milvus con l'algoritmo MIND e PaddleRec e quindi ha affrontato il problema proposto nel paragrafo iniziale.
E se il sistema fosse estremamente lento nel restituire risultati a causa dell'enorme quantità di dataset? Milvus, il database vettoriale open-source, è progettato per ricerche di similarità fulminee su dataset di vettori densi contenenti milioni, miliardi o persino trilioni di vettori.
E se i dati appena inseriti non potessero essere elaborati in tempo reale per la ricerca o la query? Puoi usare Milvus poiché supporta l'elaborazione unificata batch e stream e consente di cercare e interrogare i dati appena inseriti in tempo reale. Inoltre, il modello MIND è in grado di convertire il nuovo comportamento degli utenti in tempo reale e inserire istantaneamente i vettori utente in Milvus.
E se il deployment complicato fosse troppo intimidatorio? PaddleRec, una potente libreria appartenente all'ecosistema PaddlePaddle, può fornirti una soluzione integrata per distribuire il tuo sistema di raccomandazione o altre applicazioni in modo facile e rapido.
Informazioni sull'autrice
Yunmei Li, Data Engineer di Zilliz, si è laureata in informatica presso la Huazhong University of Science and Technology. Da quando è entrata in Zilliz, ha lavorato all'esplorazione di soluzioni per il progetto open source Milvus e aiutato gli utenti ad applicare Milvus in scenari reali. Il suo principale interesse riguarda NLP e i sistemi di raccomandazione, e vorrebbe approfondire ulteriormente questi due ambiti. Le piace trascorrere del tempo da sola e leggere.
Cerchi altre risorse?
- Altri casi d’uso per la creazione di un sistema di raccomandazione:
- Creazione di un sistema di raccomandazione di prodotti personalizzato con Vipshop e Milvus
- Creazione di un’app per la pianificazione del guardaroba e degli outfit con Milvus
- Creazione di un sistema intelligente di raccomandazione di notizie all’interno dell’app Sohu News
- Filtraggio collaborativo basato sugli elementi per un sistema di raccomandazione musicale
- Making with Milvus: raccomandazione di notizie basata sull’IA all’interno del browser mobile di Xiaomi
- Altri progetti Milvus in collaborazione con altre community:
- Interagisci con la nostra community open-source:
Continua a leggere
Top 10 Context Engineering Techniques You Should Know for Production RAG
A practical guide to context engineering for production LLM systems, covering RAG, context processing, memory, agents, and multimodal context.
Similarity Metrics for Vector Search
Exploring five similarity metrics for vector search: L2 or Euclidean distance, cosine distance, inner product, and hamming distance.
Legal Document Analysis: Harnessing Zilliz Cloud's Semantic Search and RAG for Legal Insights
Enhance legal document analysis with Zilliz Cloud’s Semantic Search and RAG. Improve accuracy, efficiency, and scalability for contracts, case law, and compliance.