Un approcio approfondito agli algoritmi di raccomandazione con caso di studio Netflix e tecnologia di apprendimento profondo di NVIDIA

Che cosa sono gli algoritmi di raccomandazione?

I motori di raccomandazione sono il segreto di ogni transazione su Internet, che si tratti di Amazon, Netflix, Flipkart, YouTube, TikTok, persino LinkedIn, Facebook, X(Twitter), Snapchat, Medium, Substack, HackerNoon… tutti questi siti e quasi tutti i siti di content curation o di marketplace di prodotti su Internet fanno i loro grandi guadagni grazie agli algoritmi di raccomandazione. . tutti questi siti e quasi tutti i siti di content curation o di marketplace di prodotti su Internet fanno soldi a palate grazie agli algoritmi di raccomandazione.

In parole povere, un algoritmo di raccomandazione costruisce un modello dei vostri gusti, delle vostre antipatie, dei vostri preferiti, delle cose che preferite, dei generi che preferite e degli articoli che preferite, e quando viene effettuata una transazione sul sito, praticamente legge la vostra mente e prevede il prodotto successivo che è più probabile che acquistiate. Alcuni algoritmi di raccomandazione su YouTube e TikTok sono così accurati da tenere gli utenti incollati per ore. Sarei sorpreso se anche un solo lettore non riferisse di un’abbuffata su YouTube, nata dal semplice scorrere e cliccare/toccare per una decina di minuti.

Questo porta a un migliore coinvolgimento del cliente, a una migliore esperienza del cliente, a un aumento delle entrate e a maggiori guadagni per la piattaforma stessa. La dipendenza si basa sulla precisione e sulle prestazioni spaventose di questi algoritmi ultra-ottimizzati.

È così che questi giganti costruiscono il loro pubblico.

I visitatori mensili di YouTube, TikTok, Instagram e Facebook sono (fonte):

• Facebook: 2,9 miliardi
• YouTube: 2,2 miliardi
• Instagram: 1,4 miliardi
• TikTok: 1 miliardo

E il segreto del loro successo: fantastici algoritmi di raccomandazione.

Tipi di algoritmi di raccomandazione

Filtraggio collaborativo (basato sull’utente)

Il filtraggio collaborativo basato sull’utente è una tecnica di raccomandazione che presuppone che utenti con preferenze simili abbiano gusti simili. Utilizza i dati di interazione utente-oggetto per identificare le somiglianze tra gli utenti, spesso impiegando misure come la somiglianza del coseno o la correlazione di Pearson. Il metodo predice le valutazioni o le preferenze di un utente in base alle valutazioni date da utenti simili.

Tuttavia, può incontrare delle difficoltà, come il problema dell’avvio a freddo per i nuovi utenti che non hanno ancora interagito con il sistema, e possono sorgere problemi di scalabilità quando si ha a che fare con un gran numero di utenti.

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def user_based_cf(ratings_matrix, user_id, k=5):
    similarities = cosine_similarity(ratings_matrix)
    user_similarities = similarities[user_id]
    similar_users = np.argsort(user_similarities)[::-1][1:k+1]
    
    recommendations = np.zeros(ratings_matrix.shape[1])
    for similar_user in similar_users:
        recommendations += ratings_matrix[similar_user]
    
    return recommendations / k

• Utilizza la somiglianza del coseno per calcolare le somiglianze tra gli utenti
• Trova gli k utenti più simili all’utente target
• Aggrega le valutazioni degli utenti simili per generare raccomandazioni
• Ritrova la valutazione media di ogni articolo da parte degli utenti simili
• Implementazione semplice che può essere facilmente modificata o estesa

Filtraggio collaborativo (basato sugli articoli).basato sugli articoli)

Il filtro collaborativo basato sugli elementi presuppone che gli utenti preferiscano elementi simili a quelli che hanno apprezzato in passato. Calcola la somiglianza tra gli elementi in base alle valutazioni o alle interazioni degli utenti. Questo approccio è spesso più scalabile del filtraggio collaborativo basato sugli utenti, in particolare quando ci sono molti utenti e meno elementi. Consente di precalcolare le somiglianze tra gli elementi, rendendo più rapide le raccomandazioni in tempo reale.

Sebbene gestisca meglio i nuovi utenti rispetto ai metodi basati sugli utenti, può avere difficoltà con i nuovi elementi che non hanno valutazioni sufficienti. Inoltre, è meno influenzato dai cambiamenti delle preferenze degli utenti nel corso del tempo.

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def item_based_cf(ratings_matrix, item_id, k=5):
    similarities = cosine_similarity(ratings_matrix.T)
    item_similarities = similarities[item_id]
    similar_items = np.argsort(item_similarities)[::-1][1:k+1]
    
    recommendations = np.zeros(ratings_matrix.shape[0])
    for similar_item in similar_items:
        recommendations += ratings_matrix[:, similar_item]
    
    return recommendations / k

• Traspone la matrice di valutazione per calcolare le somiglianze tra gli elementi.item
• Ritrova gli k item più simili all’item di destinazione
• Aggrega le valutazioni degli utenti per gli item simili
• Ritrova la valutazione media per ogni utente in base agli item simili
• Efficiente per i sistemi con più utenti che item

Fattorizzazione della matrice

La fattorizzazione della matrice scompone la matrice di interazione utente-matrice di interazione utente-oggetto in matrici di dimensioni inferiori, assumendo che le preferenze degli utenti e le caratteristiche degli item possano essere rappresentate da fattori latenti. A questo scopo vengono comunemente utilizzate tecniche come la Singular Value Decomposition (SVD) o l’Alternating Least Squares (ALS).

Questo approccio è in grado di gestire in modo efficiente insiemi di dati grandi e sparsi e spesso fornisce una migliore accuratezza rispetto ai metodi di filtraggio collaborativo basati sulla memoria. Inoltre, può incorporare tecniche di regolarizzazione per evitare l’overfitting, migliorando la generalizzazione del modello ai dati non visti.

import numpy as np

def matrix_factorization(R, P, Q, K, steps=5000, alpha=0.0002, beta=0.02):
    Q = Q.T
    for step in range(steps):
        for i in range(len(R)):
            for j in range(len(R[i])):
                if R[i][j] > 0:
                    eij = R[i][j] - np.dot(P[i,:], Q[:,j])
                    for k in range(K):
                        P[i][k] += alpha * (2 * eij * Q[k][j] - beta * P[i][k])
                        Q[k][j] += alpha * (2 * eij * P[i][k] - beta * Q[k][j])
        
        e = 0
        for i in range(len(R)):
            for j in range(len(R[i])):
                if R[i][j] > 0:
                    e += pow(R[i][j] - np.dot(P[i,:], Q[:,j]), 2)
                    for k in range(K):
                        e += (beta/2) * (pow(P[i][k], 2) + pow(Q[k][j], 2))
        if e < 0.001:
            break
    return P, Q.T

• Implementa un algoritmo di factorizzazione matriciale di base
• Usa il discendimento gradiente per minimizzare l’errore tra le valutazioni predette e reali
• Incorpora regolarizzazione per prevenire l’overfitting
• Aggiorna iterativamente i fattori latenti degli utenti e degli item
• Termina quando l’errore scende sotto un threshold o quando sono raggiunti i passi massimi

Filtrazione basata sul contenuto

La filtrazione basata sul contenuto consiglia gli item in base alle loro caratteristiche e alle preferenze utente. Costruisce un profilo per ogni utente e item in base alle loro caratteristiche.

Tecniche come TF-IDF (Term Frequency-Inverse Document Frequency) per l’analisi del testo e la similarità di cosine per il matching sono comunemente utilizzate. Questo approcio risolve efficacemente il problema dell’item nuovo, poiché non si basa sulle interazioni precedenti tra utenti.

Tuttavia, può soffrire dalla specializzazione eccessiva, causando una mancanza di diversità nelle raccomandazioni. Inoltre, l’implementazione efficiente richiede una buona engineering特征 per garantire che le caratteristiche rilevanti degli item siano catturate accuratemente.

import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

def content_based_filtering(item_descriptions, user_profile, k=5):
    vectorizer = TfidfVectorizer()
    item_vectors = vectorizer.fit_transform(item_descriptions)
    user_vector = vectorizer.transform([user_profile])
    
    similarities = cosine_similarity(user_vector, item_vectors)
    top_items = np.argsort(similarities[0])[::-1][:k]
    
    return top_items

• Usa TF-IDF per convertire le descrizioni testuali in vettori numerici
• Calcola la similarità di cosine tra il profilo utente e le descrizioni degli item
• Restituisce i k item più simili al profilo utente
• Efficiente per sistemi con caratteristiche di item ben definite
• Può essere facilmente esteso per includere diversi tipi di feature

Sistema di raccomandazione ibrido

I sistemi di raccomandazione ibridi combinano due o più tecniche di raccomandazione per sfruttare le loro rispettive forze. Integrando approcchi diversi, i sistemi ibridi possono attenuate i limiti di ogni metodo individuale, come il problema del cold-start. Le combinazioni comuni comprendono il filtraggio collaborativo e il filtraggio basato sul contenuto. Vengono utilizzati diversi metodi per combinare queste tecniche, come il metodo ponderato, lo switch, la combinazione mista o l’approcchio a livello meta.

I sistemi ibridi spesso forniscono raccomandazioni più robuste e accurate rispetto ai sistemi a approcchio singolo. Tuttavia, una implementazione efficace richiede un’attenta regolazione per equilibrare i diversi componenti e garantire un’efficienza ottimale.

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

def hybrid_recommender(ratings_matrix, content_matrix, user_id, alpha=0.5, k=5):
    cf_similarities = cosine_similarity(ratings_matrix)
    content_similarities = cosine_similarity(content_matrix)
    
    hybrid_similarities = alpha * cf_similarities + (1 - alpha) * content_similarities
    user_similarities = hybrid_similarities[user_id]
    
    similar_users = np.argsort(user_similarities)[::-1][1:k+1]
    
    recommendations = np.zeros(ratings_matrix.shape[1])
    for similar_user in similar_users:
        recommendations += ratings_matrix[similar_user]
    
    return recommendations / k

• Combina il filtraggio collaborativo e le similitudini basate sul contenuto
• Usa una somma ponderata con parametro alpha
• Trova utenti simili in base alla similitudine ibrida
• Genera raccomandazioni dalle valutazioni degli utenti simili
• Permette un facile aggiustamento del bilanciamento tra il filtraggio collaborativo (CF) e le tecniche basate sul contenuto

Decomposizione Singola Valore (SVD)

La Decomposizione Singola Valore (SVD) è una tecnica di fattorizzazione delle matrici che decompose una matrice in tre componenti: U, Σ, e V^T. In questa decomposizione, U e V rappresentano i vettori singolari sinistri e destri, rispettivamente, mentre Σ contiene i valori singolari.

L’SVD riduce la dimensionalità mantenendo solo i k valori singolari superiori, che aiuta a scoprire i fattori latenti negli scambi utente-oggetto.

Questo metodo è efficiente per la gestione di matrici grandi e rade che si trovano comunemente nei sistemi di raccomandazione. Inoltre, SVD offre un buon equilibrio tra accuratezza ed efficienza computazionale, rendendolo una scelta popolare per la generazione di raccomandazioni.

import numpy as np
from scipy.sparse.linalg import svds

def svd_recommender(ratings_matrix, k=5):
    U, s, Vt = svds(ratings_matrix, k=k)
    
    sigma = np.diag(s)
    predicted_ratings = np.dot(np.dot(U, sigma), Vt)
    
    return predicted_ratings

• Usa la funzione svds di scipy per eseguire una SVD troncata
• Ricostruisce la matrice di valutazione usando solo i primi k valori singolari
• Ritrova una matrice densa di valutazioni previste per tutte le coppie utente-voce
• Efficiente per le matrici di valutazione grandi, matrici di valutazione grandi e rade
• Può essere facilmente integrata in un sistema di raccomandazione più ampio

Fattorizzazione dei tensori

La tecnica della fattorizzazione dei tensori estende la tradizionale fattorizzazione delle matrici ai dati multidimensionali, consentendo di incorporare nelle raccomandazioni informazioni contestuali come l’ora e la posizione. Utilizza metodi come la decomposizione CP, che decompone un tensore in una somma di tensori componenti, catturando le interazioni complesse tra più fattori. Questo approccio richiede un maggior numero di dati e risorse computazionali rispetto ai metodi bidimensionali, in quanto tratta array di dimensioni più elevate.

Tuttavia, può fornire raccomandazioni altamente personalizzate e consapevoli del contesto, sfruttando le dimensioni aggiuntive dei dati. La maggiore complessità della struttura dei dati consente una comprensione più sfumata delle preferenze degli utenti in vari contesti, migliorando l’accuratezza complessiva delle raccomandazioni.

import numpy as np
import tensorly as tl
from tensorly.decomposition import parafac

def tensor_factorization_recommender(tensor, rank=10):
    factors = parafac(tensor, rank=rank)
    reconstructed_tensor = tl.kruskal_to_tensor(factors)
    return reconstructed_tensor

• Utilizza la libreria TensorLy per le operazioni sui tensori e la decomposizione
• Applica la decomposizione PARAFAC al tensore di ingresso
• Ricostruisce il tensore dai fattori scomposti
• Restituisce il tensore ricostruito come raccomandazioni
• Può gestire dati multidimensionali (ad esempio, utente-item-contesto)

Filtraggio collaborativo neurale

I sistemi di raccomandazione basati sull’apprendimento profondo combinano tecniche di filtraggio collaborativo con reti neurali. Questo approccio consente di apprendere le interazioni non lineari tra utente e articolo, che i metodi tradizionali di fattorizzazione delle matrici possono ostacolare. I sistemi di raccomandazione basati sull’apprendimento profondo utilizzano in genere strati di incorporazione per rappresentare gli utenti e gli articoli in uno spazio denso e a bassa dimensione. Ciò consente di integrare facilmente ulteriori caratteristiche o informazioni secondarie, come i dati demografici degli utenti o le descrizioni degli articoli, per migliorare le prestazioni di raccomandazione.

Quando addestrati su grandi insiemi di dati, i sistemi basati sul deep learning possono spesso superare i tradizionali metodi di fattorizzazione matriciale in termini di accuratezza. Tuttavia, questo vantaggio ha il costo di una maggiore complessità computazionale e della necessità di grandi quantità di dati.

I raccomandatori basati sull’apprendimento profondo richiedono inoltre un’attenta regolazione degli iperparametri per ottenere risultati ottimali, il che li rende più impegnativi da implementare e mantenere rispetto agli approcci più semplici di filtraggio collaborativo.

import tensorflow as tf
from tensorflow.keras.layers import Input, Embedding, Flatten, Dense, Concatenate
from tensorflow.keras.models import Model

def neural_collaborative_filtering(num_users, num_items, embedding_size=100):
    user_input = Input(shape=(1,), dtype='int32', name='user_input')
    item_input = Input(shape=(1,), dtype='int32', name='item_input')

    user_embedding = Embedding(num_users, embedding_size, name='user_embedding')(user_input)
    item_embedding = Embedding(num_items, embedding_size, name='item_embedding')(item_input)

    user_vecs = Flatten()(user_embedding)
    item_vecs = Flatten()(item_embedding)

    concat = Concatenate()([user_vecs, item_vecs])
    dense1 = Dense(128, activation='relu')(concat)
    dense2 = Dense(64, activation='relu')(dense1)
    output = Dense(1, activation='sigmoid')(dense2)

    model = Model(inputs=[user_input, item_input], outputs=output)
    model.compile(optimizer='adam', loss='binary_crossentropy')

    return model

• Utilizza TensorFlow e Keras per costruire un modello di rete neurale
• Crea strati di incorporamento per utenti e articoli
• Concatena gli incorporamenti di utenti e articoli
• Aggiunge strati densi per l’apprendimento di interazioni non lineari
• Restituisce un modello compilato pronto per l’addestramento

Il caso di studio di Netflix

Il viaggio dell’algoritmo di raccomandazione di Netflix è iniziato con CineMatch nel 2000, un algoritmo di filtraggio collaborativo che utilizzava le valutazioni dei membri per stimare quanto un utente avrebbe apprezzato un film. Nel 2006 è stato lanciato il premio Netflix di 1 milione di dollari per sfidare gli scienziati dei dati a creare un modello in grado di battere CineMatch del 10%. L’algoritmo vincitore è stato poi implementato nei dati interni di Netflix.

Netflix iniziò presto ad accumulare utenti e nel 2007 si passò ai dati in streaming. Gli spettatori furono esposti ad algoritmi di apprendimento per rinforzo e ad algoritmi di clustering che generavano suggerimenti in tempo reale. Con il miglioramento dell’algoritmo, sempre più utenti hanno iniziato a passare a Netflix, semplicemente per l’efficacia dell’algoritmo di raccomandazione. Quasi l’80% dei contenuti visualizzati su Netflix è suggerito dall’algoritmo di raccomandazione.

La società stima di risparmiare 1 miliardo all’anno di utenti persi grazie all’efficacia dell’algoritmo di raccomandazione.

Netflix utilizza tecniche avanzate di machine learning e clustering con un sistema di oltre 1300 cluster basati sui metadati dei film che gli utenti guardano. Questo permette di fornire suggerimenti altamente ottimizzati ai propri utenti. Ma Netflix ha presto incontrato un problema: la scala. Quando il numero di utenti mensili è salito a centinaia di milioni e il numero totale di utenti ha superato i 200 milioni, Netflix ha puntato tutto sul cloud computing.

In poche parole, hanno migrato tutti i dati su Amazon Web Services (AWS), a partire dal 2008. Il processo di transizione completo ha richiesto anni e si è concluso nel 2015. Secondo quanto riferito, Netflix risparmia 1 miliardo all’anno utilizzando AWS. AWS dispone anche di un supporto integrato per l’apprendimento automatico, che Netflix utilizza al meglio. Secondo quanto riferito, nel 2022 Netflix ha utilizzato oltre 100.000 server AWS e 1.000 shard Kinesis per il suo pubblico globale.

Dal 2015, Netflix ha anche iniziato a offrire le proprie produzioni, oltre migliaia di film e spettacoli in un’ampia varietà di formati. Gli algoritmi di raccomandazione di Netflix sono altamente automatizzati ed eseguono migliaia di test A/B per gli utenti al giorno. Oggi la base di abbonamenti degli utenti di Netflix supera i 280 milioni.

Sebbene Netflix debba ora affrontare una forte concorrenza, soprattutto da parte di Disney+, che ha acquisito i franchise di Marvel e Star Wars, l’azienda punta a raggiungere i 500 milioni di abbonati entro il 2025.

L’anno scorso, Netflix ha guadagnato ben 31 miliardi di entrate.

Le parti principali dei suoi attuali sistemi di raccomandazione comprendono:

1. Apprendimento rinforzato: In base al comportamento dell’utente, Netflix cambia i contenuti sullo schermo in tempo reale. Il sistema è quindi in costante evoluzione e cambia a seconda delle interazioni dell’utente.
2. Reti neurali profonde: A causa dell’ampiezza dei dati (oltre 15.000 spettacoli e quasi 300 milioni di utenti), le tecniche ML standard non sono facili da applicare. Il deep learning viene utilizzato in modo estensivo, sfruttando la tecnologia di NVIDIA. (Si veda la fine di questo articolo per un programma che utilizza la più recente tecnologia di deep learning Merlin di NVIDIA).
3. Fattorizzazione di matrici: Eseguendo efficacemente la Singular Value Decomposition (SVD) su matrici molto rade e molto vaste, Netflix stima l’importanza e l’attrazione di ciascun utente per determinati generi e spettacoli.
4. Ensemble learning: Combinazioni intelligenti degli algoritmi sopra elencati regolano le raccomandazioni al volo in modo che nessun utente veda la stessa schermata. Questa personalizzazione è ciò che crea i grandi guadagni e mantiene Netflix in cima a tutte le piattaforme OTT.

E tutti questi modelli e ottimizzazioni vengono eseguiti centinaia di migliaia di volte al giorno per centinaia di migliaia di utenti.

Moderna tecnologia di apprendimento profondo

Con tali dimensioni, nessun singolo computer può eseguire questi modelli di ML da solo. Ecco perché AWS esegue gli algoritmi di ML in modo distribuito su migliaia di macchine.

NVIDIA ha recentemente rilasciato diversi prodotti per consentire la realizzazione di sistemi di raccomandazione a scala. I cluster GPU di NVIDIA giocano un ruolo fondamentale anche nell’esecuzione dell’algoritmo di apprendimento machine. NVIDIA ha recentemente rilasciato Merlin, un algoritmo di raccomandazione ad alto rendimento ottimizzato per essere eseguito su migliaia di macchine e fornire risultati di primo livello. Probabilmente questo è successo solo a tempo certo, visto che le dimensioni dei dataset sono state ben oltre ciò che potevano processare i computer singoli.

I moderni sistemi di raccomandazione usano estensivamente l’apprendimento profondo. Come parte dell’apprendimento profondo, i sistemi di calcolo GPU/TPU sono usati estensivamente per accelerare il calcolo.

Alcune delle offerte recenti di NVIDIA per Merlin includono:

Sistemi di raccomandazione di NVIDIA

(Da Announcing NVIDIA Merlin: An Application Framework for Deep Recommender Systems)

Disponibili come progetti open-source:

• NVTabular
• HugeCTR
• TensorRT
• Triton Inference Server

NVTabular

NVTabular è una libreria per l’ingegneria delle caratteristiche e il preprocessing, progettata per manipolare rapidamente e facilmente dataset a scala terabyte. E’ particolarmente adatta per i sistemi di raccomandazione, che richiedono un metodo scalabile per processare informazioni aggiuntive, come i metadati utente e oggetto e le informazioni contestuali. Fornisce un’abstrattazione a alto livello per semplificare il codice e accelerare il calcolo sulla GPU utilizzando la libreria RAPIDS cuDF. Utilizzando NVTabular, con solo 10-20 righe di codice API a alto livello, è possibile impostare un pipeline di ingegneria dati e ottenere fino a un incremento di velocità di 10 volte rispetto agli approcchi basati su CPU ottimizzati, senza limitazioni di dimensione del dataset, indipendentemente dalla capacità di memoria GPU/CPU.

HugeCTR

HugeCTR è un framework GPU altamente efficiente progettato per l’addestramento di modelli di raccomandazione, che punta sia alla performance elevata che all’usabilità. Supporta sia modelli profondi semplici che anche modelli ibridi d’avanguardia come W&D, Deep Cross Network e DeepFM. Stiamo anche lavorando alla realizzazione di DLRM con HugeCTR. I dettagli del modello e i parametri hyperparametri possono essere specificati facilmente in formato JSON, consentendo una rapida selezione da una gamma di modelli comuni.

TensorRT e Triton Server per l’Inferenza

NVIDIA TensorRT è un SDK per l’inferenza di rete neurale ad alto rendimento. Include un ottimizzatore e un runtime di inferenza che fornisce bassa latenza e alto throughput per le applicazioni di inferenza. TensorRT può accettare reti neurali addestrate da tutti i framework di rete neurale usando un’interfaccia comune, il formato aperto di scambio di rete neurale (ONNX).

Il server di inferenza NVIDIA Triton fornisce una soluzione di inferenza in cloud ottimizzata per le GPU di NVIDIA. Il server fornisce un servizio di inferenza tramite un endpoint HTTP o gRPC, permettendo ai client remoti di richiedere l’inferenza per qualsiasi modello gestito dal server. Il server Triton può servire modelli di raccomandazione di rete neurale usando diversi backend, tra cui TensorFlow, PyTorch (TorchScript), runtime ONNX e runtime TensorRT.

Esempio di codice

L’esempio di codice seguente mostra uno workflow di preprocessing reale necessario per trasformare il dataset di pubblicità di Criteo da 1 TB, implementato con solo una dozzina di righe di codice usando NVTabular. In breve, vengono specificate le colonne numeriche e categoriche. Successivamente, si definisce un workflow NVTabular e si forniscono una serie di file di training e validazione. Poi, vengono aggiunte operazioni di preprocessing al workflow e i dati vengono persistenti su disco. In confronto, i codici di processamento personalizzati, come il data util basato su NumPy nell’implementazione di DLRM di Facebook, possono avere da 500 a 1000 righe di codice per lo stesso pipeline.

import nvtabular as nvt
import glob
 
cont_names = ["I"+str(x) for x in range(1, 14)] # specify continuous feature names
cat_names = ["C"+str(x) for x in range(1, 27)] # specify categorical feature names
label_names = ["label"] # specify target feature
columns = label_names + cat_names + cont_names # all feature names
 
Inizializza Workflow
proc = nvt.Worfklow(cat_names=cat_names, cont_names=cont_names, label_name=label_names)
 
Crea dataset dai file di input
train_files = glob.glob("./dataset/train/*.parquet")
valid_files = glob.glob("./dataset/valid/*.parquet")
 
train_dataset = nvt.dataset(train_files, gpu_memory_frac=0.1)
valid_dataset = nvt.dataset(valid_files, gpu_memory_frac=0.1)
 
Aggiungi operazioni di ingegneria delle features e di preprocessing al Workflow
proc.add_cont_feature([nvt.ops.ZeroFill(), nvt.ops.LogOp()])
proc.add_cont_preprocess(nvt.ops.Normalize())
proc.add_cat_preprocess(nvt.ops.Categorify(use_frequency=True, freq_threshold=15))
 
Calcola le statistiche, trasforma i dati, esporta sul disco
proc.apply(train_dataset, shuffle=True, output_path="./processed_data/train", num_out_files=len(train_files))
proc.apply(valid_dataset, shuffle=False, output_path="./processed_data/valid", num_out_files=len(valid_files))

Tutta la pila tecnologica può essere trovata nel seguente repository GitHub:

• NVIDIA-Merlin (github.com)

Conclusione

I sistemi di raccomandazione sono molto evoluti.

Da modelli statistici semplici, filtraggio contenuto-base e filtraggio collaborativo, ora abbiamo reti neurali deep learning, nodi HPC, factorizzazione di matrice e sue estensioni ad aree più ampie, factorizzazione tensoriale.

Il sistema di raccomandazione più redditizio per il streaming è NVIDIA, e lanciano le loro intere algoritmi di apprendimento automatico sul cloud con AWS.

I sistemi di raccomandazione sono utilizzati ovunque, da Google a Microsoft ad Amazon a Flipkart. È una parte critica dell’impresa moderna, e non esiste nessuna azienda online che non li utilizzi in una forma o nell’altra.

Oggi molte aziende offrono sistemi di raccomandazione personalizzati online.

Alcuni dei principali sono:

1. Netflix: Noto per il suo sofisticato motore di raccomandazione che analizza i comportamenti di visualizzazione degli utenti per suggerire film e programmi TV
2. Amazon: Utilizza un potente motore di raccomandazione che suggerisce prodotti in base alla storia di acquisti degli utenti e al comportamento di navigazione.
3. Spotify: Utilizza un sistema di raccomandazione che cura playlist musicali e suggerimenti di canzoni in base alla storia di ascolto utente.
4. YouTube: Usa un motore di raccomandazione per suggerire video in base ai modelli di visualizzazione e ai gusti degli utenti.
5. LinkedIn: Raccomanda lavori, connessioni e contenuti in base ai profili utente e alla storia professionale.
6. Zillow: Suggista proprietà immobiliari personalizzate secondo le preferenze utente e la storia di ricerca.
7. Airbnb: Fornisce raccomandazioni di alloggi in base alla storia di viaggio e ai gusti utente.
8. Uber: Raccomanda opzioni di trasporto in base alle preferenze utente e ai precedenti viaggi.
9. IBM Corporation: Un leader nel mercato dei motori di raccomandazione, offrendo varie soluzioni basate su tecnologie AI.
10. Google LLC (Alphabet Inc.): Fornisce sistemi di raccomandazione su tutti i suoi platform, sfruttando le analisi dati estese.

Speriamo che un giorno la tua azienda sia tra questa elitaria lista. E tutto il meglio per la tua impresa.

Indipendentemente dalla sezione in cui operi, se hai una presenza online, devi utilizzare sistemi di raccomandazione in qualche modo. Continua a esplorare questo settore e, se hai un’esperienza eccellente, sei sicuro di essere in alta richiesta.

Non smetti di imparare. Tieni il tuo entusiasmo. Credi sempre nel tuo infinito potenziale di crescita. Il tuo futuro è nelle tue mani. Rendilo straordinario!

Riferimenti

1. Sistemi di raccomandazione – Wikipedia
2. Cos’è un sistema di raccomandazione? – GeeksforGeeks
3. Tipi di sistemi di raccomandazione: come funzionano e casi d’uso (almabetter.com)
4. Sistemi di raccomandazione e apprendimento automatico (itransition.com)
5. Sistemi di raccomandazione in Python 101 (kaggle.com)
6. Algoritmi di sistemi di raccomandazione: un’overview – KDnuggets