Een diepgaande blik in aanbevelingsalgoritmen met Netflix Case Study en NVIDIA diep leertechnologie

Wat zijn aanbevelingsalgoritmen?

Recommendation Engines zijn de geheimzinnige achtergrond van elke internettransactie, of het nu gaat om Amazon, Netflix, Flipkart, YouTube, TikTok, of zelfs LinkedIn, Facebook, X(Twitter), Snapchat, Medium, Substack, HackerNoon enzovoort. Al deze websites en bijna elke inhoudencuration of productmarktplaats op het internet behalen hun grote inkomsten met behulp van aanbevelingsalgoritmen.

Vrijgezet gezegd, bouwt een aanbevelingsalgoritme een model van uw voorkeuren, afkeuren, favorieten, dingen die u voorkeurt, genres die u voorkeurt en items die u voorkeurt. En als er een transactie op de website plaatsvindt, worden ze in de praktijk bijna altijd in uw gedachten lezen en voorschrijven welke volgende producten u waarschijnlijk zal kopen. Enkele van de aanbevelingsalgoritmen op YouTube en TikTok zijn zo nauwkeurig, dat ze gebruikers voor uren vast kunnen zitten houden. Ik zou verrast zijn als er maar een lezer zou zijn die niet een YouTube-verslaving heeft gemeld die ontstond door alleen maar te scrollen en te klikken/tappen voor ongeveer tien minuten.

Dit leidt tot betere klantengagement, een betere klantbeleving, een toegenomen omzet en meer geld voor de platformen zelf. Verslaving wordt gebouwd op de nauwkeurigheid en de schokkende prestaties van deze ultra-geoptimaliseerde algoritmen.

Dit is hoe deze giganters hun publiek opbouwen.

De maandelijkse bezoekersaantallen aan YouTube, TikTok, Instagram en Facebook zijn (bron):

Facebook: 2,9 miljard
YouTube: 2,2 miljard
Instagram: 1,4 miljard
TikTok: 1 miljard

En het geheim van hun succes: fantastische aanbevelingsalgoritmen.

Soorten aanbevelingsalgoritmen

Gebruikersgebaseerd samenwerkend filter (Collaborative Filtering)

Gebruikersgebaseerd samenwerkend filter is een aanbevelingstechniek die van uitgaat dat gebruikers met vergelijkbare voorkeuren ook eenvoudigweg vergelijkbare smaken zullen hebben. Het maakt gebruik van gegevens over de interactie tussen gebruikers en items om overeenkomsten tussen gebruikers te identificeren, vaak met behulp van maatstaven als cosinesimilitudebenadering of de Pearsonscore. Deze methode voorspelt de waarderingen of voorkeuren van een gebruiker op basis van de door vergelijkbare gebruikers gegeven waarderingen.

Het kan echter uitdagingen tegenkomen, zoals het probleem van de cold-start voor nieuwe gebruikers die nog geen interactie hebben gehad met het systeem, en scalabele problemen kunnen optreden bij het behandelen van een grote groep gebruikers.

Python

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

Gebruikt cosinesimilitudebenadering om de overeenkomsten tussen gebruikers te berekenen
Vindt de k meest vergelijkbare gebruikers aan de doelgebruiker
Sterkt de waarderingen van vergelijkbare gebruikers bij om aanbevelingen te genereren
Geeft de gemiddelde waardering weer voor elk item van vergelijkbare gebruikers
Eenvoudige implementatie die gemakkelijk kan worden aangepast of uitgebreid

Samenwerkend filter (Item-Based)

Itemgebaseerd colllaboratiefilteren gaat uit van het voorwaarde dat gebruikers items zullen verkiezen die opmerkelijk zijn op basis van items die ze in het verleden hebben gewaardeerd. Het bereken de gelijkenis tussen items op basis van gebruikersbeoordelingen of interacties. Dit aanpak is vaak scalabelder dan gebruikergebaseerd colllaboratiefilteren, vooral wanneer er veel gebruikers zijn en weinig items. Het biedt de mogelijkheid voor de voorafberekening van itemgelijkenissen, wat de realtime aanbevelingen sneller kan maken.

Het gaat beter om met nieuwe gebruikers dan met gebruikergebaseerde methodes, maar het kan moeite doen met nieuwe items die niet genoeg beoordelingen hebben. Bovendien wordt het minder beïnvloed door veranderingen in gebruikersvoorkeuren over tijd.

Python

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

Transponeert de beoordelingsmatrix om item-itemgelijkenissen te berekenen
Vindt de k meest verwante items aan de doelitem
Aggregeert gebruikersbeoordelingen voor verwante items
Geeft de gemiddelde beoordeling terug voor elke gebruiker op basis van verwante items
Efficiënt voor systemen met meer gebruikers dan items

Matrix Factorisatie

Matrix factorisatie deelt de gebruiker-iteminteractiematrix in in lagere dimensie matrices, aanname dat gebruikersvoorkeuren en itemkarakteristieken kunnen worden weergegeven door latente factoren. Technieken zoals Singular Value Decomposition (SVD) of Alternating Least Squares (ALS) worden hiervoor vaak gebruikt.

Dit aanpak kan efficiënt grote, ruime datasets behandelen en biedt vaak betere nauwkeurigheid dan geheugengebaseerde colllaboratiefilteren. Bovendien kan het reguliere technieken incorporeren om overfitting te voorkomen, verbeterde de generalisatie van het model voor ongeziene data.

Python

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

Implementeert een basis matrix factorisatie algoritme
Bruikt afgeleide afname om het verschil tussen voorspelde en werkelijke cijfers te minimaliseren
Integreert regulering om overfitting te voorkomen
Bijwerkt iteratief gebruikers- en item-latente factoren
Stop bij error onder een drempel of bij bereiken van maximaal aantal stappen

Inhoudgebonden filteringsysteem

Inhoudgebonden filtering aanbeveelt items op basis van hun eigenschappen en gebruikersvoorkeuren. Het bouwt een profiel voor elke gebruiker en item op basis van hun kenmerken.

Technieken zoals TF-IDF (Term Frequency-Inverse Document Frequency) voor tekstanalyse en cosinesimmetrie voor overeenkomst vaststellen worden veelvuldig toegepast. Deze aanpak lost effectief het nieuw artikel probleem op, aangezien ze niet afhankelijk is van eerdere gebruikersinteracties.

Het kan echter aan overspecialisatie lijden, waardoor een gebrek aan diversiteit in aanbevelingen optreedt. Bovendien vereist effectieve implementatie goede kenmergenbouw om accurate weergave van relevante eigenschappen van items te verzekeren.

Python

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

Bruikt TF-IDF om tekstbeschrijvingen in numerieke vectoren te converteren
Berekent de cosinesimmetrie tussen gebruikersprofiel en itembeschrijvingen
Geeft de k meest verwante items terug aan het gebruikersprofiel
Efficiënt voor systemen met goed gedefinieerde itemkenmerken
Kan gemakkelijk worden uitgebreid om meerdere kenmerktypen in te sluiten

Hybride aanbevelingssysteem

Hybride aanbevelingssystemen combineren twee of meer aanbevelingstechnieken om hun respectievelijke sterktes te benutten. door de integratie van meerdere aanpakken kunnen hybride systemen de zwaktes van individuele methodes aanvallen, zoals het probleem van de cold-start. Veel voorkomende combinaties omvatten colllaboratieve en content-gebaseerde filters. Verschillende methodes worden gebruikt om deze technieken te combineren, zoals gewogen, schakelende, gemengde of meta-niveau aanpakken.

Hybride systemen bieden vaak sterker en accuratere aanbevelingen dan enkele aanpak systemen. Echter, effectieve implementatie vereist minuten tuning om de verschillende componenten in evenwicht te brengen en de optimale prestatie te waarborgen.

Python

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

Kombineert collaborative filtering en content-gebaseerde overeenkomsten
Gebruikt een gewogen sommige aanpak met parameter alpha
Vindt gelijke gebruikers op basis van de hybride overeenkomst
Genereert aanbevelingen uit de beoordelingen van gelijke gebruikers
Staat toe om gemakkelijk het evenwicht tussen CF en content-gebaseerde aanpakken aan te passen

Singular Value Decomposition (SVD)

Singular Value Decomposition (SVD) is een matrixfactorisatietechniek die een matrix in drie componenten opdecomposeert: U, Σ, en V^T. In deze decompositie, U en V de linker en rechter singularvector representeren, terwijl Σ de singularwaarden bevat.

SVD reduceert de dimensie door alleen de top k singularwaarden te behouden, wat help om de verborgen factoren in de gebruikers-itemsinteracties onthuldt.

Deze methode is effectief voor het behandelen van grote, ruime matrizen die veelvoorkomend zijn in aanbevelingssystemen. Bovendien biedt SVD een goed balans tussen nauwkeurigheid en computatieve efficientie, waardoor het een populaire keuze is voor het genereren van aanbevelingen.

Python

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

Gebruikt scipy’s svdfunctie om een afgekorte SVD uit te voeren
Hersteld de beoordelingsmatrix door alleen de top k singuliere waarden te gebruiken
Geeft een dichte matrix van voorspelde beoordelingen voor alle gebruiker-itemparen
Efficiënt voor grote, ruime beoordelingsmatrices
Kan gemakkelijk worden geïntegreerd in een groter aanbevelingssysteem

Tensorfactorisatie

Het techniek van tensorfactorisatie wordt uitgebreid tot meerdimensionale data, waardoor contextuele informatie zoals tijd en locatie in aanbevelingen kan worden ingebed. Het maakt gebruik van methodes als de CP-decompositie, die een tensor opdecomposeert in een som van componenttensor, en die complexe interacties tussen meerdere factoren vastlegt. Dit aanpak vereist meer gegevens en computatieleveringen dan tweedimensionale methodes, aangezien hij werkt met hogedimensionale array’s.

Hij kan echter zeer persoonlijke en contextgevoelige aanbevelingen leveren door de extra dimensies van de gegevens te benutten. Het verhoogde complexiteit van de gegevensstructuur biedt een meer gedifferentieerde kijk op de gebruikersvoorkeuren in verschillende contexten, die de algehele nauwkeurigheid van de aanbevelingen verbetert.

Python

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

Gebruikt de TensorLy-bibliotheek voor tensoroperaties en decompositie
ParaFAC-decompositie toegepast op de ingevoerde tensor.
Herstelt de tensor uit de gedecomposeerde factoren
Geeft de herbouwde tensor terug als aanbevelingen
Kan meerdimensionale data verwerken (bijv., gebruiker-item-context)

Neurale samenwerkende filterings

Diep leren-gebaseerde aanbevelingssystemen combineren samenwerkende filterings technieken met neurale netwerken. Deze aanpak maakt het mogelijk non-lineaire gebruikers-iteminteracties te leren, die traditionele matrixfactorisatietechnieken mogelijk tegenkomen. Diep leren aanbevelers gebruiken meestal inspringende lagen om gebruikers en items in een dichte, lage dimensie ruimte weer te geven. Dit maakt gemakkelijke integratie van extra kenmerken of bijgegevens mogelijk, zoals gebruikersdemografie of itemomschrijvingen, om de aanbevelingsprestaties te verbeteren.

Bij trainning op grote datasets kunnen diep leren-gebaseerde systemen vaak de traditionele matrixfactorisatietechnieken in prestatie voor accuracy overschrijden. Echter, deze voordeel komt met het kostte van verhoogde computatiele complexiteit en de behoefte aan grote hoeveelheden data.

Diep leren aanbevelers vereisen ook voorzichtige hyperparameter aanpassingen om de beste resultaten te behalen, waardoor ze moeilijker te implementeren en onderhouden zijn vergeleken met eenvoudigere samenwerkende filteringsmethodes.

Python

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

Gebruikt TensorFlow en Keras om een neurale netwerkmodel te bouwen
Creëert inspringende lagen voor gebruikers en items
Konketteert gebruikers- en iteminspringingen
Voegt dichte lagen toe voor het leren van non-lineaire interacties
Geeft een gecompileerd model terug dat klaar is voor training

Het Case Study van Netflix

De reis van de Netflix aanbevelingsalgoritme begon in 2000 met CineMatch, een colaboratieve filteringsalgoritme dat gebruikersbeoordelingen gebruikte om te schatten hoeveel een gebruiker een film zou genieten. In 2006 werd het Netflix Prize van 1 miljoen dollar gelanceerd om data scientists een uitdaging te stellen om een model te maken dat CineMatch zou verslaan met 10%. Het winnende algoritme werd dan geïmplementeerd in de interne gegevens van Netflix.

Netflix begon al snel aan de accumulatie van gebruikers en veranderde in 2007 naar streaminggegevens. Kijkers werden blootgesteld aan kostelijk leren algoritmen en kluisingsalgoritmen die suggesties in real time genereerden. Met de verbetering van het algoritme, begonnen meer en meer gebruikers over te stappen naar Netflix, simpelweg vanwege de effectiviteit van de aanbevelingsalgoritme. Bijna 80% van de bekeken content op Netflix wordt aangereikt door de aanbevelingsalgoritme.

De bedrijf schat dat het elk jaar ruim 1 miljard spaart door verliezen aan gebruikers tegen te gaan dankzij de effectiviteit van de aanbevelingsalgoritme.

Netflix gebruikt geavanceerde machine learning technieken en kluisingsmethodes met een systeem van meer dan 1300 kluizen gebaseerd op de metadata van de films die de gebruikers kijken. Dit laat ze toe om hun gebruikers zeer geoptimaliseerde suggesties te leveren. Maar Netflix kwam al snel tegen een probleem: schaal. Met de toename van de maandelijkse gebruikers tot honderden miljoenen, en het totaal aantal gebruikers naar boven de 200 miljoen, ging Netflix alles in op cloud computing.

In eenvoudige termen, hebben zij alle data overgenomen naar Amazon Web Services (AWS), dat begon in 2008. Het volledige transitieproces duurde enkele jaren en werd in 2015 voltooid. Netflix zou gemiddeld 1 miljard dollar per jaar besparen door AWS te gebruiken. AWS biedt ook ingebouwde ondersteuning voor machine learning, die Netflix volledig gebruikt. Volgens rapporten gebruikte Netflix meer dan 100.000 AWS-servers en 1.000 Kinesis-shards voor zijn wereldwijde publiek begin 2022.

Vanaf 2015 heeft Netflix ook zijn eigen producties aanbevolen, met duizenden films en series in een breed scala aan formaten. De Netflix-recommenderalgoritmen zijn zeer geautomatiseerd en voert elke dag duizenden A/B-testen uit voor gebruikers. Het aantal abonnees van Netflix is nu overgedragen aan 280 miljoen.

Ondertussen面临 sterke concurrentie, vooral vanaf Disney+, die de Marvel en de Star Wars-franchise heeft aangekocht, maar de bedoeling van de onderneming is om in 2025 de 500 miljoen abonnees te halen.

Gisteren jaar behaalde Netflix een bovennormale omvang van 31 miljard in omzet.

De belangrijkste onderdelen van zijn huidige aanbevelingssystemen omvatten:

Reinforcement learning: Afhankelijk van het gedrag van de gebruiker verandeert Netflix de inhoud op het scherm in real-time. Daardoor is het systeem in een constante stroom van veranderingen en verandeert het afhankelijk van de interacties van de gebruiker.
diepvorkernelsystemen: Door de omvang van de gegevens (meer dan 15.000 shows en bijna 300 miljoen gebruikers) is het niet gemakkelijk om standaard ML technieken toe te passen. diep leren wordt extensief gebruikt, met behulp van technologie van NVIDIA. (Zie het einde van dit artikel voor een programma dat NVIDIA’s nieuwste Merlin diep leertechnologie gebruikt).
matrix factorisatie: door effectief de Singular Value Decomposition (SVD) uit te voeren op hoog ongedempte en hoog uitgebreide matrices, schat Netflix de belangrijkheid en de aantrekkingskracht van elke gebruiker voor bepaalde genres en shows.
verzamelen van kennis: slimme combinaties van de bovenstaande algoritmen aanpassen de aanbevelingen in real-time zodat geen twee gebruikers dezelfde scherm zien. Deze personalisering is het gehele geld en houdt Netflix bovenaan alle OTT-platformen.

En alle deze modellen en optimalisaties worden honderden duizend keren per dag uitgevoerd voor honderden duizend gebruikers.

Modern diep leertechnologie

Met dergelijke schalen kan geen enkele computer deze ML-modellen alleenondersteunen. Dat is waarom AWS de ML-algoritmen in een verspreidingsmodus over duizenden machines uitvoert.

NVIDIA heeft最近 verschillende producten gelanceerd om aanbevelingssystemen op schaal uit te voeren. De GPU-clusters van NVIDIA spelen ook een grote rol in de uitvoering van de machine learning-algoritmen. NVIDIA heeft recentelijk Merlin gelanceerd, een hoogperformende aanbevelingsalgoritme dat is geoptimaliseerd om op duizenden machines te worden uitgevoerd en uitstekende resultaten te leveren. Dit was misschien alleen een kwestie van tijd, aangezien de grootte van de datasets langszij de capaciteit van enkele computers uitbreidden.

Modern aanbevelingssystemen gebruiken diep leren uitgebreid. Als onderdeel van DL worden GPU/TPU-berekeningssystemen intensief gebruikt om de berekeningen te versnellen.

Enkele van de recentste aanbiedingen van NVIDIA voor Merlin zijn:

NVIDIA Aanbevelingssystemen

(Uit Aankondiging NVIDIA Merlin: Een toepassingsframework voor diepgaande aanbevelingssystemen)

Beschikbaar als open-source projecten:

NVTabular

NVTabular is een geavanceerde bibliotheek voor kenmerkengineering en voorbereiding van gegevens, ontworpen om op eenvoudige wijze petabytegrootte datasets te bewerken. Het is geschikt voor aanbevelingssystemen die een schaalbare manier nodig hebben om bijvoeglijke informatie te verwerken, zoals metadata voor gebruikers en items en contextuele informatie. Het biedt een hoog niveau van abstraction om de code eenvoudiger te maken en versnelt de berekeningen op de GPU met behulp van de RAPIDS cuDF-bibliotheek. Met NVTabular kun je met slechts 10-20 regels hoog niveau API-code een gegevensengineeringpijpleiding opzetten en tot 10x sneller worden dan met geoptimaliseerde CPU-gebaseerde methodes, terwijl je geen beperkingen van datasetgrootte krijgt, ongeacht de geheugencapaciteit van de GPU/CPU.

HugeCTR

HugeCTR is een zeer efficiënte GPU-框架 (framework) ontworpen voor het trainen van aanbevelingsmodellen, dat zowel hoge prestaties als gemakkelijke gebruiksmogelijkheden nastreeft. Het ondersteunt zowel eenvoudige diepte-modellen als de meest moderne hybride modellen zoals W&D, Deep Cross Network en DeepFM. We werken ook aan het activeren van DLRM met HugeCTR. De modellen en hun hyperparameters kunnen gemakkelijk in JSON-formaat gespecificeerd worden, wat snelheid biedt bij het kiezen uit een gamma van algemene modellen.

TensorRT en Triton Server voor Invoer

NVIDIA TensorRT is een SDK voor hoge-performance diepe leer inferentie. Het bevat een inferentieoptimalisator en runtime die laag latentie en hoge doorvoers biedt voor inferentieapplicaties. TensorRT kan geëvalueerde neurale netwerken aan接受 van alle diepe leer frameworks gebruiken via een common interface, de openbare neural network exchange format (ONNX).

NVIDIA Triton Inference Server biedt een cloud-inferentiesolutie geoptimaliseerd voor NVIDIA GPU’s. Het server biedt een inferentieservice via een HTTP of gRPC endpoint, waardoor externe clients inferentie aanvragen kunnen voor elke model dat wordt beheerd door het server. Triton Server kan DL aanbevelingsmodellen dienen met verschillende backends, inclusief TensorFlow, PyTorch (TorchScript), ONNX runtime, en TensorRT runtime.

Code Voorbeeld

Het volgende codevoorbeeld toont een actuele voorbereidingswerkflow nodig om de 1-TB Criteo Ads dataset te transformeren, geïmplementeerd met slechts een dozijn regels code met NVTabular. Kortom, numerieke en categorische kolommen worden gespecificeerd. Vervolgens definiëren we een NVTabular workflow en leveren een set train- en validatiefiles. Daarna worden voorbereidingsoperaties toegevoegd aan de workflow, en wordt de data op schijf opgeslagen. In vergelijking daarmee, worden aangepaste verwerkingscodes, zoals de NumPy-gebaseerde data util in de Facebook DLRM implementatie, kan 500-1000 regels code hebben voor dezelfde pipeline.

Python

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
 
# initialiseer Workflow
proc = nvt.Worfklow(cat_names=cat_names, cont_names=cont_names, label_name=label_names)
 
# creëer datasets vanuit inputbestanden
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)
 
# voeg feature engineering en voorbehandelingsoperaties toe aan 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))
 
# berekend statistieken, transformeer gegevens, exporteer naar schijf
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))

De gehele technologische stack kan worden gevonden in het volgende GitHub-repository:

NVIDIA-Merlin (github.com)

Conclusie

Recommendatiesystemen zijn een lange weg achter de rug.

Van eenvoudige statistische modellen, content-gebaseerde filterings en colaboratieve filterings zijn we nu uitgegroeid tot diep lerende neurale netwerken, HPC-nodes, matrix factorisatie en zijn uitbreiding naar grotere dimensies, tensor factorisatie.

Het meest winstgevende aanbevelingssysteem voor streaming is NVIDIA, en ze runnen hun gehele Machine Learning-algoritmen op de cloud met AWS.

Recommendatiesystemen worden overal gebruikt, van Google tot Microsoft tot Amazon tot Flipkart. Het is een kritiek onderdeel van de moderne onderneming en geen enkele online onderneming gebruikt het niet in een vorm of anders.

Vandaag de dag bieden veel bedrijven online aangepaste aanbevelingssystemen aan.

Enkele van de vooraanstaande zijn:

Netflix: bekend om zijn geavanceerde aanbevelingsengine die gebruikersbekijken gewoonten analyseert om films en TV-shows te suggesteren
Amazon: Maakt gebruik van een krachtig aanbevelingssysteem dat producten suggesties baseert op de geschiedenis van de aankopen en het browsersgedrag van de gebruiker.
Spotify: Maakt gebruik van een aanbevelingssysteem dat muziekafspeellijsten en liedjesuggesties samenstelt op basis van de luistergeschiedenis van de gebruiker.
YouTube: Gebruikt een aanbevelingsengine om video’s aan te raden op basis van de kijkgewoonten en voorkeuren van de gebruiker.
LinkedIn: Stelt banen, connecties en inhoud voor op basis van de gebruikersprofielen en beroepshistorie.
Zillow: Stelt vastgoedobjecten voor die aangepast zijn aan de voorkeuren en zoekgeschiedenis van de gebruiker.
Airbnb: Biedt accommodatiesuggesties aan op basis van de reisgeschiedenis en voorkeuren van de gebruiker.
Uber: Stelt aanvullende opties voor voorraden op basis van de voorkeuren en eerdere ritten van de gebruiker.
IBM Corporation: Een leider op de markt van aanbevelingssystemen, biedende diverse AI-gebaseerde oplossingen.
Google LLC (Alphabet Inc.): Biedt aanbevelingssystemen op zijn platforms, gebruik makende van uitgebreide dataanalyse.

Hopelijk zal uw bedrijf op een dag deel uitmaken van deze selecte lijst. En heel veel succes met uw onderneming.

Gewisselde sector u zit in, als u een online aanwezigheid heeft, moet u aanbevelingssystemen op een of andere manier gebruiken. Blijf in dit segment te ontdekken, en als u goed in deze expertise bent, kunt u zeker zijn dat u in hoogste demand zult zijn.

Stop nooit met leren. Houd de enthousiasme vast. gelieve altijd in uw onbegrenzde potentiële vooruitgang. Uw toekomst ligt in uw handen. Maak het uitzonderlijk!

Referenties

Source:
https://dzone.com/articles/a-deep-dive-into-recommendation-algorithms-with-ne