בתעמולה עמוקה באלגוריתמים הממלצים עם מקרה מלומדת מ Netflix וטכנולוגיית למידה עמוקה של NVIDIA

מהם אלגוריתמי המלצה?

מנועי המלצה הם הסוד מאחורי כל עסקה באינטרנט, בין אם זה אמזון, נטפליקס, פליפקארט, יוטיוב, טיקטוק, אפילו לינקדאין, פייסבוק, X(טוויטר), סנאפצ'ט, מדיום, סאבסטאק, HackerNoon… כל האתרים הללו וכמעט כל אתר שאחראי על תוכן או שוק מקוון באינטרנט מרוויחים הרבה כסף מאלגוריתמי המלצה.

בפשטות, אלגוריתם המלצה בונה מודל של מה שאתה אוהב, לא אוהב, העדפות, דברים שאתה מעדיף, ז'אנרים שאתה מעדיף, ומוצרים שאתה מעדיף, וכאשר מתבצעת עסקה אחת באתר, הם כמעט קוראים את מחשבותיך ומנבאים את המוצר הבא שתקנה. חלק מאלגוריתמי ההמלצה ביוטיוב ובטיקטוק מדויקים כל כך שהם יכולים להשאיר משתמשים מרותקים במשך שעות. הייתי מופתע אם אפילו קורא אחד לא היה מדווח על בינג' יוטיוב שהתפתח כתוצאה מגלילה ולחיצה/נגיעה למשך כעשר דקות.

זה מוביל למעורבות לקוחות טובה יותר, חוויית לקוח טובה יותר, עלייה בהכנסות, ויותר כסף לפלטפורמה עצמה. ההתמכרות נבנית על הדיוק והביצועים המפחידים של אלגוריתמים אלה, שהותאמו בצורה מקסימלית.

כך הענקים הללו בונים את הקהל שלהם.

מספר המבקרים החודשיים ביוטיוב, טיקטוק, אינסטגרם ופייסבוק הוא (source):

פייסבוק: 2.9 מיליארד
יוטיוב: 2.2 מיליארד
אינסטגרמ: 1.4 מיליארד
טיקטוק: 1 מיליארד

וסוד ההצלחה שלהם: אלגוריתמים מדהימים להצעת מועדות.

סוגים של אלגוריתמים להצעת מועדות

סיוע משותף (מבוסס על המשתמש)

סיוע משותף מבוסס על המשתמש הוא טכניקה להצעת מועדות המניחה שמשתמשים עם העדפות דומות יחודים בערך אותן. הוא משתמש במידע על יחסי האינטראקציה בין המשתמשים לעיצוב את הדומים בין המשתמשים, לרוב על-ידי שימוש במדדים כמו דומי קוסיני או קורRELATIONSHIP. השיטה מחיזה את הדרגות או העדפות של משתמש בהתבסס על הדרגות שנתנו על-ידי משתמשים דומים.

ועדיין, יכול להתמודד עם אתגרים, כמו בעיית ההתחלה הקרה עבור משתמשים חדשים שעדיין לא פעלו עם המערכת, ויכולות להתחיל בעיות בסקליביליות כשמתמודדים עם מספר גדול של משתמשים.

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

משתמש את דומי קוסיני כדי לחשב את הדומים בין המשתמשים
מוצא את k המשתמשים הכי דומים למשתמש המטרה
מסכם את הדרגות של המשתמשים הדומים כדי ליצור מועדות
שוב את הדרגה הממוצעת לכל חפץ מאחד המשתמשים הדומים
היישום פשוט שיכול להיות קל לשנות או להרחיב

סיוע משותף (מבוסס על החפץ)

סינון משתף מבוסס פריטים מניח שמשתמשים יעדיפו פריטים הדומים לאלו שאהבו בעבר. הוא מחשב את הדמיון בין פריטים על בסיס דירוגים או אינטראקציות של משתמשים. גישה זו לעיתים קרובות ניתנת להרחבה יותר מאשר סינון משתף מבוסס משתמשים, במיוחד כאשר ישנם משתמשים רבים ומספר מועט יותר של פריטים. היא מאפשרת חישוב מוקדם של דמיון בין פריטים, מה שיכול להפוך המלצות בזמן אמת למהירות יותר.

בעוד שהיא מתמודדת טוב יותר עם משתמשים חדשים לעומת שיטות מבוססות משתמשים, היא עשויה להתקשות עם פריטים חדשים החסרים דירוגים מספיקים. בנוסף, היא פחות מושפעת משינויים בהעדפות המשתמשים לאורך זמן.

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

משכפלת את מטריצת הדירוגים כדי לחשב דמיון פריט-פריט
מוצאת את k הפריטים הדומים ביותר לפריט המטרה
מאגדת את דירוגי המשתמשים עבור פריטים דומים
מחזירה את דירוג המשתמש הממוצע בהתבסס על פריטים דומים
יעילה למערכות עם יותר משתמשים מאשר פריטים

פירוק מטריצות

פירוק מטריצות מפרקת את מטריצת האינטראקציה בין משתמשים לפריטים למטריצות ממדים נמוכים יותר, בהנחה שהעדפות משתמשים ומאפייני פריטים יכולים להיות מיוצגים על ידי גורמים סמויים. טכניקות כמו פירוק ערכים סינגולרי (SVD) או ריבועים פחותים מתחלפים (ALS) משמשות לעיתים קרובות למטרה זו.

גישה זו יכולה להתמודד ביעילות עם מערכי נתונים גדולים ודלילים ולעיתים קרובות מספקת דיוק טוב יותר בהשוואה לשיטות סינון משתף מבוססות זיכרון. בנוסף, היא יכולה לשלב טכניקות רגולריזציה כדי למנוע התאמת יתר, מה שמשפר את הכללת המודל לנתונים לא נראים.

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

מיישם אלגוריתם בסיסי של פירוק מטריצות
משתמש בירידת מדרון כדי למזער את השגיאה בין דירוגים חזויים ודירוגים בפועל
משלב רגולריזציה כדי למנוע התאמת יתר
מעדכן באופן איטרטיבי גורמים סמויים של משתמשים ופריטים
נעצר כאשר השגיאה יורדת מתחת לסף או שמגיעים למספר צעדים מקסימלי

סינון מבוסס תוכן

סינון מבוסס תוכן ממליץ על פריטים על סמך המאפיינים שלהם והעדפות המשתמש. הוא בונה פרופיל עבור כל משתמש ופריט בהתבסס על מאפייניהם.

טכניקות כמו TF-IDF (תדירות מונח-היפוך תדירות מסמך) לניתוח טקסט ודמיון קוסינוסי להתאמה נפוצות בשימוש. גישה זו מתמודדת ביעילות עם בעיית הפריט החדש, שכן היא לא מסתמכת על אינטראקציות קודמות של המשתמש.

עם זאת, היא עלולה לסבול מהתמחות יתר, מה שמוביל לחוסר גיוון בהמלצות. בנוסף, יישום יעיל דורש הנדסת תכונות טובה כדי להבטיח שמאפיינים רלוונטיים של פריטים ייקלטו במדויק.

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

משתמש ב-TF-IDF כדי להמיר תיאורי טקסט לווקטורים מספריים
מחשב את הדמיון הקוסינוסי בין פרופיל המשתמש לתיאורי הפריטים
מחזיר את k הפריטים הדומים ביותר לפרופיל המשתמש
יעיל למערכות עם מאפייני פריטים מוגדרים היטב
ניתן להרחבה בקלות כדי לכלול סוגי תכונות מרובים

מערכת המלצות היברידית

שיטות הממלאות ההיברידיות משלבות שתי או יותר טכניקות ממלאות כדי לנצל את החוזקות המסוימות שלהן. על ידי שילוב גישות מרובות, מערכות היברידיות יכולות למתן את החולשות של שיטות יחידות, כמו בעיית ההתחלה הקרה. השילובים הנפוצים כוללים סינון שיתופי ובהתבסס על תוכן. מתקנים שונים משמשים לשילוב הטכניקות הללו, כמו שיטות משוקלות, החלפות, מעורבות או גישות ברמת המטא.

מערכות היברידיות נובעות לעתים קרובות ממלאות יותר ברובוטיות ודיוקיות בהשוואה למערכות עם גישה יחידתית.

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

משלבת שיתופי סינון והדמיות מבוססות תוכן
משתמשת בשיטת סכום משוקלות עם הפרמטר אלפא
מוצאת משתמשים דומים בהתבסס על הדמיית היברידיות
יוצרת ממלאות מדירוגים של משתמשים דומים
מאפשרת תיאום קל של האיזון בין CF וגישות מבוססות תוכן

חילוק ערכי יחיד (SVD)

חילוק ערכי יחיד (SVD) הוא שיטת חילוק מטריצה שמחלקת מטריצה לשלושה רכיבים: U, Σ ו V^T. בחלוקה זו, U ו V מייצגים את הוויקטורים הימניים והשמאליים במקרה, בעוד Σ מכיל את ערכי היחיד.

SVD מוריד את מימדיותו על ידי שימור רק של ערכי היחיד העליונים k, שעוזרים לחשוף גורמים נסתרים באינטראקציות משתמש-פריט.

שיטה זו יעילה לטיפול במטריצות גדולות ודלילות, שנפוצות במערכות המלצה. בנוסף, SVD מספק איזון טוב בין דיוק ליעילות חישובית, מה שהופך אותו לבחירה פופולרית ליצירת המלצות.

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

משתמש בפונקציית svds של scipy לביצוע SVD מקוצר
משחזר את מטריצת הדירוג תוך שימוש רק ב-k הערכים הסינגולרים הגבוהים ביותר
מחזיר מטריצה צפופה של דירוגים חזויים עבור כל זוגות המשתמשים והפריטים
יעיל למטריצות דירוג גדולות ודלילות
ניתן לשילוב בקלות במערכת המלצות רחבה יותר

פירוק טנזורים

טכניקת פירוק טנזורים מרחיבה את פירוק המטריצות המסורתי לנתונים רב-ממדיים, ומאפשרת שילוב של מידע הקשרי כגון זמן ומיקום בהמלצות. היא עושה שימוש בשיטות כמו פירוק CP, שמפרקת טנזור לסכום של טנזורים רכיבים, ותופסת אינטראקציות מורכבות בין מספר גורמים. גישה זו דורשת יותר נתונים ומשאבי חישוב בהשוואה לשיטות דו-ממדיות, שכן היא מטפלת במערכים רב-ממדיים.

עם זאת, היא יכולה לספק המלצות מותאמות אישית ומודעות להקשר באמצעות ניצול הממדים הנוספים של הנתונים. המורכבות המוגברת של מבנה הנתונים מאפשרת הבנה מעמיקה יותר של העדפות המשתמש בהקשרים שונים, ומשפרת את דיוק ההמלצות הכולל.

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

משתמש בספריית TensorLy לביצוע פעולות פירוק טנזורים
מיישם פירוק PARAFAC על הטנזור הקלט.
משחזר את הטנזור מהגורמים המפורקים
מחזיר את הטנזור המשוחזר כהמלצות
יכול לטפל בנתונים רב-ממדיים (למשל, משתמש-פריט-הקשר)

סינון שיתופי מבוסס רשתות עצביות

מערכות המלצה מבוססות למידת עומק משלבות טכניקות סינון שיתופי עם רשתות עצביות. גישה זו מאפשרת ללמוד אינטראקציות לא-לינאריות בין משתמשים לפריטים, דבר שעלול להיות מאתגר עבור שיטות פירוק מטריצות מסורתיות. ממליצי למידת עומק משתמשים בדרך כלל בשכבות הטמעה כדי לייצג משתמשים ופריטים במרחב צפוף וממד נמוך. זה מאפשר שילוב קל של תכונות נוספות או מידע צדדי, כמו דמוגרפיה של משתמשים או תיאורי פריטים, כדי לשפר את ביצועי ההמלצה.

כאשר מאמנים מערכות מבוססות למידת עומק על מערכי נתונים גדולים, הן יכולות לעיתים קרובות להציג ביצועים טובים יותר משיטות פירוק מטריצות מסורתיות מבחינת דיוק. עם זאת, יתרון זה כרוך בעלות של מורכבות חישובית מוגברת וצורך בכמויות גדולות של נתונים.

ממליצי למידת עומק דורשים גם כיוונון זהיר של היפרפרמטרים כדי להגיע לתוצאות מיטביות, מה שהופך אותם למאתגרים יותר ליישום ולתחזוקה בהשוואה לגישות סינון שיתופי פשוטות יותר.

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

משתמש ב-TensorFlow ו-Keras לבניית מודל רשת עצבית
יוצר שכבות הטמעה עבור משתמשים ופריטים
משלב את ההטמעות של המשתמש והפריט
מוסיף שכבות צפופות ללימוד אינטראקציות לא-לינאריות.
מוכרח להשתמש במודל מוכנה לאימוץ ולהכשירה

מחקר מקרה של Netflix

המסע של אלגוריתם ההיעד של Netflix החל ב-2000 עם CineMatch, אלגוריתם של סיוע משותף שהשתמש בדירוגים של חברים כדי לערוך את הסיסמה של האורך של השמחה של משתמש בסרט. ב-2006 נישא פרס Netflix Prize של 1 מליון דולר כדי לאתגר את מדעני המידע ליצירת מודל שיכפל את CineMatch ב-10%. אלגוריתם הניצח ניטש אחר כך בתוך מערכת הנתונים של Netflix.

Netflix החל בקבלת משתמשים והיתה תפנית אל מידע על הסרטונים ב-2007. צפים נחשקו לאלגוריתמים של למידה בעזרת תמריצים ואלגוריתמים להתקבצות המייצרים הלאה את ההצעות. כשהאלגוריתם השתפר, יותר ויותר משתמשים החלו לעבור לNetflix בגלל האפקטיביות של אלגוריתם ההיעד. כ-80% מהתוכן הנצפה בNetflix מוצע על-ידי אלגוריתם ההיעד.

החברה מעריכה שהיא חוסכת 1 מליון דולר בשנה מאנשים שנעדרו בגלל אפקטיביות אלגוריתם ההיעד.

Netflix משתמש בטכניקות מדעיות מתקדמות ובהתקבצות בעזרת מערכת של 1300 קבוצות בהתבסס על מידע על הסרטים שהמשתמשים צופים בהם. זה מאפשר להם לספק הצעות מותאמות באופן מאוד את המשתמשים שלהם. אך Netflix מהר נתקע בבעיה: המונחים. כשמספר המשתמשים החודשי עלה למיליונים, וסך המשתמשים המקסימ

בפשטות, הם מעברו את כל הנתונים לשרותים של אמזול ווב סרבס (AWS), התחלו ב-2008. תהליך המעבר המלא נמשך שנים והסתיים ב-2015. Netflix מציע שמשמרת על ידיהם מעל מיליארד דולר בשנה על ידי שימוש בAWS. AWS גם מספק תמיכה בבנויה עבור למידת מכונה, שנטליות משמשת לגמרי על ידי Netflix. Netflix מציע שהם השתמשו במעל 100,000 שרתי AWS ו-1,000 שרידי Kinesis עבור קהלם גלובלי ב-2022.

מ-2015 ובהלאה, Netflix החל גם בספק הפקודות המקוריות שלהם, בסדרה רבה של סרטים ותכניות בצורות רחבות של תערובת. האלגוריתמים המומחים של Netflix הם מאוד אוטומטיים ומבצעים אלפי בדיקות A/B למשתמשים ביום. היום, המשתתפים בNetflix מתגלגלים מעל 500 מליון.

למרות שעכשיו Netflix מתמודדת עם תחרות חזקה, בעיקר מאחר ודיסני+ רכשה את הפריסה של Marvel ושל מלחמת הכוכבים, החברה משאירה מטרתה להיות 500 מליון משתתפים עד ל-2025.

בשנה שעברה, Netflix הרוויחה 31 מיליארד בהכנסה.

חלקים העיקריים של מערכת ההמלצות שלהם מורכבים מ:

למידת חיזורית: בהתבסס על התנהגות המשתמשים, Netflix משנה את התוכן על המסך בזמן אמת. כך שהמערכת במצב של משתנות קבועה ומשנה בהתאם לאינterאקציות המשתמשים.
מערכות מוח עמוקות: בגלל המידה הענקית של הנתונים (מעל 15,000 תוכניות וכמעט 300 מליון משתמשים), טכניקות ML רגילות קשורות למאמצים פשוטים אינן קלות ליישם. למידה עמוקה משמשת בהרבה, בעזרת טכנולוגיית NVIDIA. (ראו בקץ המאמר לתוכנה שמשתמשת בטכנולוגיית Merlin עמוקה חדשה של NVIDIA).
התמצית מטריצות: דרך מועילה ביצוע התנתונים המייצגים (SVD) על מטריצות מאוד רעדות ומאוד נרחבות, נטפלים בנטפלים של Netflix באחדות ובתעניינות של כל משתמש לסוגים מסוימים של תוכניות וסרטים.
למידה מאבץ: שילובים חכמים של האלגוריתמים הבאים מסודרים את המושגים באופן דינמי כך שלא שני משתמשים רואים את אותו מסך. ההתאמה האישית הזאת היא שוליית הכסף הגדול ומשאירה Netflix מעל את כל הפלטפורמות OTT.

וכל המודלים האלה וההאטמציות נרץות מאותם הדברים ביותר מפעם ביום עבור מאותם המאות אלפים של משתמשים.

טכנולוגיית למידה עמוקה מודרנית

עם המידה הזאת, אף מחשב יחיד לא יכול לבצע את האלגוריתמים האלה לבד. זו הסיבה שAWS מנהלת את האלגוריתמים בדרך מובנה מפורט על מאות אלפים של מחשבים.

NVIDIA לאחרונה 发布 סדרת מוצרים בשם מערכות הממלאות המלאי של מושגים מומלצים. מערכות הממלאות המוצעות של NVIDIA משחקות תפקיד גדול בייצור האלגוריתמים של המלאי. NVIDIA לאחרונה 发布 Merlin, אלגוריתם מומלץ עם ביצועים גבוהים שמותאם לרציית על אלפי מכונות ונתנות תוצאות מובילות. זה היה אולי רק שאל של זמן, בגלל שגודל המאגרים הזמנים עברו את הגבול של מה שמכונות יחידות יכולות לעבד.

מערכות הממלאות המודרניות משתמשות בלמידה עמוקה באופן רבo. כחלק מהלמידה העמוקה, מערכות חישוב של GPU/TPU משתמשים באופן רבo כדי להאיץ את החישוב.

חלק מהמתוכניות החדשות של NVIDIA לMerlin מכילים:

מערכות הממלאות של NVIDIA

(ממאמר Announcing NVIDIA Merlin: An Application Framework for Deep Recommender Systems)

זה זמין כפרויקט פתוח-סrc:

NVTabular

NVTabular הוא ספרת התכונות ועיבוד קדמי מאפשרת עיבוד מידע בקנה מידה של טריליונים בקלות ומהירות. היא מאוד מועדת למערכות מוצעות, שדורשות דרך מסוימת מסחרה לעיבוד מידע נוסף, כמו מידע על המשתמשים והפריטים, ומידע הקשור בהקשר. היא מספקת התאבשות גבוהה בכדי לשים פתאום את הקוד בפשטות ומאיץ את החישוב על הGPU בעזרת ספרת הגרסאות RAPIDS cuDF. בעזרת NVTabular, בעזרת רק 10-20 שורות של קוד בAPI גבוה מדיוק, ניתן להגדיר ציר העיבוד המידעי ולהשיג עד 10 מרחבים יותר מהמערכות המועדות על הCPU בעזרת הגיונים מוגדרים, בלי להגיע למגבלות בגודל של המידע, ללא קשר ליכולת הזיכרון של הGPU/CPU.

HugeCTR

HugeCTR הוא פרימטיב גבוה ביעילות להוראת מודלים מוצעים, שמיועד גם לביצועים גבוהים וגם לקלות השימוש. הוא תומך במודלים עמוקים פשוטים וגם במודלים הייצעים המקדמים כמו W&D, Deep Cross Network ו DeepFM. אנחנו גם עובדים על הפעלת DLRM עם HugeCTR. פרטי המודל וההיפרפרמטרים יכולים להיות ספציפיים בקשת JSON, מה שמאפשר לנו לבחור מצורף של מודלים מדוברים בקשר מהם.

TensorRT ושרת Triton עבור השלמת ההערכה

NVIDIA TensorRT הוא SDK עבור ביצועי הניבוי הגבוה ביצועים של מערכות מידע על רצף. הוא כולל מתווכי אינפרציה ומערכת הרצת הזמן המביאה בעירוד נמוך ודרישה גבוהה עבור יישומי הניבוי. TensorRT יכול לקבל רשתות מוח מכל פרימיטיב מערכות המידע העל בעזרת מקום פתוח, התבנית הפתוחה לסחר ברשתות מוח (ONNX).

NVIDIA Triton Inference Server מעניק פתרון ספירת הערך בעזרת הגפייה הניווטית של NVIDIA. השרת מספק שירות הניבוי דרך קישור HTTP או gRPC, מאפשר ללקוחות מרוחקים לבקש ניבוי עבור כל מודל שננהל על ידי השרת. שרת Triton יכול לספק מודלי המומלצה על-ידי השרת בעזרת מספר סוגי בסיסים, כולל תוכנה TensorFlow, PyTorch (TorchScript), תהליך העבדה ONNX ותהליך העבדה TensorRT.

דוגמא קוד

דוגמא הקוד הבאה מראה על ידי עיבוד עבור עבודת קדם-מיזען שהוגדרה עם רק עשרה שורות קוד בעזרת NVTabular על מנת לשנות את נתוני הפרסום Criteo Ads בגודל 1-TB. בקצרה, עמודות מספרים ועמודות קטגוריות מוגדרים. אחר כך, מיזען NVTabular ומספק קבצים ללמידה ובדיקה מתמשכים. אז, פעולות קדם-מיזען נוספות למערכת, והנתונים משמרים על הדיסק. בהשוואה, קוד יצירה מותאם מוגדר, כמו של השימוש ב NumPy בתוכנה data util בהיקשרה של Facebook ל DLRM, יכול להיות 500-1000 שורות קוד עבור א

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
 
# אתחול גלישת עבודה
proc = nvt.Worfklow(cat_names=cat_names, cont_names=cont_names, label_name=label_names)
 

# יצירת קבוצות נתונים מקובצי הקלט
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)
 

# הוספת פעולות הנדסת תכונות וטיפול בקדם לגלישת עבודה
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))
 

# חישוב סטטיסטיקה, שינוי נתונים, ייצוא לדיסק
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))

המערכת הטכנולוגית המלאה ניתן למצוא במאגר הגיטהאב הבא:

NVIDIA-Merlin (github.com)

מסקנה

מערכות ההמלצה הלך דרך דרך ארוכה.

ממודלים סטטיסטיים פשוטים, סינון לפי תוכן, וסינון שיתופי, אנו עוברים כיום לרשתות נוירליות עמוקות, נקודות מחשוב גבוה, פיצוח מטריצות וההרחבה שלו למימדים גדולים, פיצוח טנסורים.

מערכת ההמלצה המכניסה ביותר לנפטרי הזרמה היא של NVIDIA, והם מפעילים את כל האלגוריתמים למידה המכונה שלהם על הענן עם AWS.

מערכות ההמלצה משמשות בכל מקום, מגוגל ומיקרוסופט לאמזון ופליפקארט. זהו חלק קריטי של החברה המודרנית, ואין חברה מקוונת שלא משתמשת בו בצורה אחת או אחרת.

יש היום הרבה חברות שמציעות מערכות המלצה מותאמות אישית באינטרנט.

כמה מהחברות המובילות הן:

Netflix: ידועה במנוע ההמלצה המתוחכם שלה שמנתח התנהגויות צפייה המשתמשים כדי להמליץ על סרטים וסדרות
Amazon: משתמשת במנוע המלצה ה
Spotify: משתמשת במערכת המלצות שמייצרת פלייליסטים של מוזיקה והמלצות לשירים על סמך היסטוריית ההאזנה של המשתמש
YouTube: משתמשת במנוע המלצות כדי להציע סרטונים בהתבסס על דפוסי הצפייה והעדפות של המשתמשים
LinkedIn: ממליצה על משרות, קשרים ותוכן בהתבסס על פרופילי משתמשים והיסטוריה מקצועית
Zillow: מציעה נכסי נדל"ן המותאמים להעדפות המשתמש ולהיסטוריית החיפוש
Airbnb: מספקת המלצות על מקומות לינה על בסיס היסטוריית הנסיעות והעדפות המשתמש
Uber: ממליצה על אפשרויות נסיעה על פי העדפות המשתמש ונסיעות קודמות
IBM Corporation: חברה מובילה בשוק מנועי ההמלצות, המציעה מגוון פתרונות מונעי AI
Google LLC (Alphabet Inc.): מספקת מערכות המלצה ברחבי הפלטפורמות שלה, תוך שימוש בניתוח נתונים נרחב

בתקווה, יום אחד, החברה שלך תהיה בין הרשימה היוקרתית הזו. בהצלחה לעסק שלך.

לא משנה באיזה תחום אתה עוסק, אם יש לך נוכחות מקוונת, אתה צריך להשתמש במערכות המלצה בדרך זו או אחרת. המשך לחקור את התחום הזה, ואם יש לך מומחיות מצוינת, תהיה בטוח שתהיה מבוקש ביותר.

לעולם אל תפסיק ללמוד. שמור על ההתלהבות. תמיד תאמין בפוטנציאל האינסופי שלך לצמיחה. העתיד שלך בידיים שלך. תעשה אותו יוצא דופן!

References

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