Was sind Empfehlungssysteme und wie werden sie verwendet?

Ein Empfehlungssystem oder Empfehlungssystem ist ein Algorithmus, der zum Filtern von Informationen verwendet wird. Das Sammeln von Informationen liefert Vorschläge, die für einen bestimmten Benutzer am relevantesten sind. Dies ist hilfreich, wenn sich jemand für eine Plattform entscheiden muss, auf der es eine überwältigende Menge an Informationen gibt.

Kollaboratives Filtern

Durch die kollaborative Filterung wird ein Modell erstellt, das die früheren Entscheidungen des Benutzers, wie z. B. frühere Uhren oder Bewertungen eines bestimmten Produkts, und ähnliche Verhaltensweisen anderer Benutzer nutzt, um vorherzusagen, was dem Benutzer gefallen könnte. Es verwendet eine Benutzerbewertungsmatrix und erfordert neben den Bewertungen keine weiteren Benutzerinformationen wie Demografie oder andere Informationen. Dies ist eine große Stärke der kollaborativen Filterung, da sie auf minimalen Informationen basiert und Elemente empfehlen kann, ohne deren Inhalt zu verstehen.

Last.fm empfiehlt Songs, indem es beobachtet, welche Bands und einzelne Titel der Nutzer regelmäßig gehört hat, und diese mit dem Hörverhalten anderer Nutzer vergleicht. Last.fm spielt Titel ab, die nicht in der Bibliothek des Benutzers erscheinen, aber häufig von anderen Benutzern mit ähnlichen Interessen abgespielt werden. Da dieser Ansatz das Verhalten von Benutzern nutzt, ist er ein Beispiel für eine kollaborative Filtertechnik. Last.fm benötigt viele Informationen über einen Benutzer, um genaue Empfehlungen abgeben zu können. Dies ist ein Beispiel für das Kaltstartproblem, das bei kollaborativen Filtersystemen häufig vorkommt. (Quelle: WiKipedia, https://en.wikipedia.org/wiki/Recommender_system)

Bei der kollaborativen Filterung wird davon ausgegangen, dass Personen, die in der Vergangenheit zugestimmt haben, auch in Zukunft zustimmen werden. Es identifiziert einen anderen Benutzer mit einem ähnlichen Verlauf wie der aktuelle Benutzer und generiert anhand dieser Nachbarschaft Vorhersagen. Diese Methoden gelten als speicherbasierte und modellbasierte Ansätze.

Einige Probleme, die die kollaborativen Filteralgorithmen beeinträchtigen können, sind Kaltstart, Skalierbarkeit und Sparsity. Kaltstarts bezieht sich auf den Mangel an Daten, um genaue Empfehlungen abzugeben. Außerdem ist eine große Rechenleistung erforderlich, die häufig zur Berechnung von Empfehlungen erforderlich ist, wodurch der Algorithmus weniger skalierbar wird. Außerdem gibt es im Internet eine riesige Menge an Produkten und Artikeln, sodass die Bewertungen eher spärlich ausfallen.

Implementieren Sie kollaboratives Filtern in Python

Wir werden einen Datensatz verwenden, der die Top-Marken und Kosmetikbewertungen enthält. Dieser Datensatz ist auf der Kaggle-Website zu finden: https://www.kaggle.com/datasets/jithinanievarghese/cosmetics-and-beauty-products-reviews-top-brands

rating_list = pd.read_csv('top_brands_cosmetics_product_reviews.csv', sep=',', usecols=['author', 'product_title', 'product_rating', 'review_date'])

items = pd.read_csv('top_brands_cosmetics_product_reviews.csv', 
                    usecols=['product_title', 'product_url', 'brand_name'], encoding='latin-1')

print(f'Number of ratings: {rating_list.author.nunique()} | Number of items: {items.product_title.nunique()}')

Pivotieren Sie das Training mithilfe der Benutzer-Item-Matrix.

X_train, X_test, y_train, y_test = train_test_split(rating_list, rating_list.product_rating, test_size=0.1, random_state=42)

ratings = X_train.pivot_table(index=['author'], columns=['product_title'], values='product_rating').fillna(0)
mean_ratings = ratings.mean(axis=1)
print(f'Number of users: {ratings.shape[0]} | Number of items: {ratings.shape[1]}')

Ähnlichkeit berechnen.

def get_all_recommendations(user_id, model, use_means=True):
    distance, knn = model.kneighbors(ratings.fillna(0)) # nearest neighbors
    knn = pd.DataFrame(knn + 1, index=ratings.index)
    sim = pd.DataFrame(1 - distance, index=ratings.index) # invert the distance
    neighbors = knn.loc[user_id, 1:]
    similarities = sim.loc[user_id, 1:]
    similarities.index = ratings.loc[neighbors].index

    if use_means:
        return pd.Series(mean_ratings.loc[user_id] + ratings.loc[neighbors].subtract(mean_ratings.loc[neighbors], axis='index').mul(similarities, axis='index').sum(axis='index') / similarities.sum(), name='recommendation')
    else:
        return pd.Series(ratings.loc[neighbors].mul(similarities, axis='index').sum(axis='index') / similarities.sum(), name='recommendation')

Berechnen Sie eine einzelne Empfehlung für einen bestimmten Benutzer, ein bestimmtes Produkt und ein bestimmtes Modell

def get_recommendations (user_id, product_id, model, use_means=True):
    if product_id not in ratings.columns:
        return 2.5
    recommendations = get_all_recommendations(user_id, model, use_means=use_means)
    return recommendations.loc[product_id]

Berechnen Sie den quadratischen Mittelfehler (Root Mean Squared Error, RMSE), um Bewertungen für alle Produkte für jeden Benutzer im Datensatz vorherzusagen. Vergleichen Sie dann die vorhergesagten Bewertungen mit den tatsächlichen Bewertungen im Testsatz und berechnen Sie den RMSE.7.

model = NearestNeighbors(n_neighbors=40, metric='cosine')
model.fit(ratings.fillna(0))

def get_RMSE(X_test, model, use_means=True):
    group = X_test[['product_title', 'product_rating']].groupby(X_test.author)
    mse = []
    i = 0
    for key in group.groups:
        if key not in rating_list['author']:
            continue  # Skip users not in the dataset
        predictions = get_all_recommendations(key, model=model, use_means=use_means)
        rated_products = group.get_group(key).set_index('product_title')
        df = rated_products.join(predictions).dropna().reset_index()
        mse.append(df)
        if i % 100 == 0:
            score = np.sqrt(mean_squared_error(df.product_rating, df.recommendation))
            print(f'{i}/{X_test.author.nunique()} - RMSE: {score:.4f}')
        i += 1
    mse = pd.concat(mse).reset_index(drop=True)
    score = np.sqrt(mean_squared_error(mse.product_rating, mse.recommendation))
    print(f'{X_test.author.nunique()}/{X_test.author.nunique()} - RMSE: {score:.4f}')

get_RMSE(X_test, model)

ratings_dict = {
    "item": [1, 2, 1, 2, 1, 2, 1, 2, 1],
    "user": ['A', 'A', 'B', 'B', 'C', 'C', 'D', 'D', 'E'],
    "rating": [1, 2, 2, 4, 2.5, 4, 4.5, 5, 3],
}

df = pd.DataFrame(ratings_dict)
reader = Reader(rating_scale=(1, 5))

data = Dataset.load_from_df(df[["user", "item", "rating"]], reader)

movielens = Dataset.load_builtin('ml-100k') 
trainingSet = movielens.build_full_trainset()
algo.fit(trainingSet)

def get_recommendation(id_user, id_movie, ratings):
    #cosine similarity of the ratings
    similarity_matrix = cosine_similarity(ratings.fillna(0), ratings.fillna(0))
    similarity_matrix_df = pd.DataFrame(similarity_matrix, index=ratings.index, columns=ratings.index)

    cosine_scores = similarity_matrix_df[id_user]
    ratings_scores = ratings[id_movie]
    ratings_scores.dropna().dot(cosine_scores[~ratings_scores.isna()]) / cosine_scores[~ratings_scores.isna()].sum()
    return np.dot(ratings_scores.dropna(), cosine_scores[~ratings_scores.isna()]) / cosine_scores[
        ~ratings_scores.isna()].sum()

get_recommendation(196, 8, ratings) # get recommandations for user 196 for movie 8 

Inhaltsbasierte Filterung

Inhaltsbasierte Filteransätze nutzen eine Reihe diskreter, vorab markierter Merkmale eines Artikels, um weitere Artikel mit ähnlichen Eigenschaften zu empfehlen. Es verwendet Artikelfunktionen, um Artikel auszuwählen und zurückzugeben, die für die Suche des Benutzers relevant sind. Einige inhaltsbasierte Empfehlungsalgorithmen ordnen Elemente anhand ihrer Beschreibung und nicht anhand des tatsächlichen Inhalts zu.

Pandora nutzt die Eigenschaften eines Songs oder Künstlers, um eine Warteschlange zu erstellen, die Musik mit ähnlichen Eigenschaften abspielt. Benutzerfeedback wird verwendet, um die Ergebnisse des Senders zu verfeinern, indem bestimmte Attribute weniger betont werden, wenn ein Benutzer ein bestimmtes Lied „nicht mag“, und andere Attribute hervorgehoben werden, wenn ein Benutzer ein Lied „mag“. Dies ist ein Beispiel für einen inhaltsbasierten Ansatz. Pandora benötigt für den Start nur sehr wenige Informationen, der Umfang ist weitaus eingeschränkter (es kann beispielsweise nur Empfehlungen aussprechen, die dem Original-Seed ähneln). (Quelle: Wikipedia, https://en.wikipedia.org/wiki/Recommender_system)

Die Methode nutzt die Beschreibung des Produkts und das Profil des Benutzers und eignet sich daher für Situationen, in denen bekannte Daten zu einem Artikel, aber nicht zum Benutzer vorhanden sind. Inhaltsbasierte Empfehlungsgeber behandeln Empfehlungen als benutzerspezifisches Klassifizierungsproblem und lernen einen Klassifikator für die Vorlieben und Abneigungen des Benutzers basierend auf den Merkmalen eines Artikels. Zur Beschreibung von Elementen werden Schlüsselwörter verwendet, und es wird ein Benutzerprofil erstellt, um die Vorlieben und Abneigungen des Benutzers aufzulisten. Verschiedene Kandidatenartikel werden mit zuvor vom Benutzer bewerteten Artikeln verglichen und die am besten passenden Artikel empfohlen. Ein weit verbreiteter Algorithmus ist die TF-IDF-Darstellung. Es gibt Techniken des maschinellen Lernens wie Bayes'sche Klassifikatoren, Clusteranalyse, Entscheidungsbäume und künstliche neuronale Netze, um die Wahrscheinlichkeit abzuschätzen, dass dem Benutzer der Artikel gefallen wird.

Inhaltsbasierte Filterung kann jedoch häufig dazu führen, dass Elemente vorgeschlagen werden, die dem, was einem Benutzer bereits gefällt, sehr ähnlich sind, was die Vielfalt einschränkt und es schwieriger macht, neue Dinge zu entdecken. Dadurch kann eine „Blase“ entstehen, in der Benutzer nur bestimmte Arten von Inhalten sehen. Es hängt auch davon ab, wie gut Elemente beschriftet oder beschrieben sind. Dies kann ein Problem sein, wenn nicht genügend Informationen vorhanden sind oder wenn der Benutzer neu ist und noch nicht mit vielen Inhalten interagiert hat.

Implementierung der inhaltsbasierten Filterung in Python (mit BOW)

rating_list = pd.read_csv('top_brands_cosmetics_product_reviews.csv', sep=',', usecols=['author', 'product_title', 'product_rating', 'review_date'])

items = pd.read_csv('top_brands_cosmetics_product_reviews.csv', 
                    usecols=['product_title', 'product_url', 'brand_name'], encoding='latin-1')

print(f'Number of ratings: {rating_list.author.nunique()} | Number of items: {items.product_title.nunique()}')

Transformieren Sie die Plotzusammenfassungen in Vektordarstellungen, um numerische Algorithmen für maschinelles Lernen anwenden zu können.

X_train, X_test, y_train, y_test = train_test_split(rating_list, rating_list.product_rating, test_size=0.1, random_state=42)

ratings = X_train.pivot_table(index=['author'], columns=['product_title'], values='product_rating').fillna(0)
mean_ratings = ratings.mean(axis=1)
print(f'Number of users: {ratings.shape[0]} | Number of items: {ratings.shape[1]}')

Jede Handlungszusammenfassung wird in eine Folge von Wörtern umgewandelt, um auf einen hochdimensionalen semantischen Raum zu verweisen (hier wird das TF-IDF-Modell verwendet). Dabei wird gezählt, wie oft ein Wort im Dokument vorkommt, um die Wichtigkeit des Wortes im Dokument zu bestimmen.

print(f'Matrix enthält {tfidf_model.shape[0]} Zeilen und {tfidf_model.shape[1]} Spalten')

Das BOW (Bag of Words)-Modell zählt, wie oft ein Wort in einem Dokument vorkommt (spärlich, die meisten Einträge im Vektor sind 0)

TF-IDF (Term Frequency – Inverse Document Frequency) Das Modell zählt, wie oft ein Wort in einem Dokument vorkommt, berücksichtigt aber auch, wie oft das Wort in allen Dokumenten vorkommt. Es gewichtet Wörter, die in Dokumenten häufig vorkommen, herab, sodass sie weniger informativ sind als solche, die selten vorkommen. Jede Handlungszusammenfassung wird als einzelner Vektor codiert, dessen Länge der Größe des Vokabulars aller Handlungszusammenfassungen entspricht. TD-IDF wandelt die Handlungszusammenfassungen in eine Matrix um. Es ignoriert Wörter, die in mehr als 80 % der Bewertungen vorkommen, und solche, die in weniger als 2 vorkommen → das Rauschen wird reduziert.

Untersuchen Sie das TF-IDF-Modell anhand des gängigen Make-up-Vokabulars.

def get_all_recommendations(user_id, model, use_means=True):
    distance, knn = model.kneighbors(ratings.fillna(0)) # nearest neighbors
    knn = pd.DataFrame(knn + 1, index=ratings.index)
    sim = pd.DataFrame(1 - distance, index=ratings.index) # invert the distance
    neighbors = knn.loc[user_id, 1:]
    similarities = sim.loc[user_id, 1:]
    similarities.index = ratings.loc[neighbors].index

    if use_means:
        return pd.Series(mean_ratings.loc[user_id] + ratings.loc[neighbors].subtract(mean_ratings.loc[neighbors], axis='index').mul(similarities, axis='index').sum(axis='index') / similarities.sum(), name='recommendation')
    else:
        return pd.Series(ratings.loc[neighbors].mul(similarities, axis='index').sum(axis='index') / similarities.sum(), name='recommendation')

Wenden Sie die Kosinusähnlichkeit zwischen verschiedenen Produkten basierend auf der Häufigkeit des Vorkommens und der Signatur ihres Plotzusammenfassungsbegriffs an.

def get_recommendations (user_id, product_id, model, use_means=True):
    if product_id not in ratings.columns:
        return 2.5
    recommendations = get_all_recommendations(user_id, model, use_means=use_means)
    return recommendations.loc[product_id]

Wenden Sie die Funktion auf jedes Produkt im Datensatz an.

model = NearestNeighbors(n_neighbors=40, metric='cosine')
model.fit(ratings.fillna(0))

def get_RMSE(X_test, model, use_means=True):
    group = X_test[['product_title', 'product_rating']].groupby(X_test.author)
    mse = []
    i = 0
    for key in group.groups:
        if key not in rating_list['author']:
            continue  # Skip users not in the dataset
        predictions = get_all_recommendations(key, model=model, use_means=use_means)
        rated_products = group.get_group(key).set_index('product_title')
        df = rated_products.join(predictions).dropna().reset_index()
        mse.append(df)
        if i % 100 == 0:
            score = np.sqrt(mean_squared_error(df.product_rating, df.recommendation))
            print(f'{i}/{X_test.author.nunique()} - RMSE: {score:.4f}')
        i += 1
    mse = pd.concat(mse).reset_index(drop=True)
    score = np.sqrt(mean_squared_error(mse.product_rating, mse.recommendation))
    print(f'{X_test.author.nunique()}/{X_test.author.nunique()} - RMSE: {score:.4f}')

get_RMSE(X_test, model)

Hybridsysteme

Sie können die beiden Algorithmen auch kombinieren, um eine verfeinerte Empfehlung anzubieten. Empfehlungssysteme helfen Benutzern dabei, Elemente zu entdecken, die sie sonst möglicherweise nicht gefunden hätten. Empfehlungssysteme werden oft mithilfe von Suchmaschinen implementiert, die nicht-traditionelle Daten indizieren.

Abschluss

Zusammenfassend lässt sich sagen, dass Empfehlungssysteme eine Schlüsselrolle dabei spielen, Benutzern dabei zu helfen, relevante Inhalte und Produkte zu entdecken, indem sie personalisierte Vorschläge bereitstellen. Sie verbessern das Erlebnis, indem sie den Zeit- und Arbeitsaufwand für die Suche nach dem, was sie interessiert, reduzieren.

** Schauen Sie sich den vollständigen Code auf GitHub an: https://github.com/alexiacismaru/recommender-systems

Das obige ist der detaillierte Inhalt vonWas sind Empfehlungssysteme und wie werden sie verwendet?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!