Rumah > pembangunan bahagian belakang > Tutorial Python > Apakah Sistem Pengesyor dan cara menggunakannya

Apakah Sistem Pengesyor dan cara menggunakannya

DDD
Lepaskan: 2024-11-09 02:05:02
asal
940 orang telah melayarinya

What are Recommender Systems and how to use them

Sistem pengesyoran, atau sistem pengesyoran, ialah algoritma yang digunakan untuk menapis maklumat. Mengumpul maklumat menyediakan cadangan yang paling berkaitan dengan pengguna tertentu. Ini berguna apabila seseorang perlu membuat keputusan tentang platform yang mempunyai jumlah maklumat yang banyak.

Penapisan kolaboratif

What are Recommender Systems and how to use them

Penapisan kolaboratif membina model menggunakan keputusan masa lalu pengguna, seperti jam tangan atau penilaian lalu pada produk tertentu dan gelagat serupa daripada pengguna lain untuk meramalkan perkara yang mungkin dinikmati pengguna. Ia menggunakan matriks penilaian pengguna dan tidak memerlukan maklumat pengguna lain seperti demografi atau maklumat lain selain penilaian. Ini adalah kekuatan utama penapisan kolaboratif kerana ia bergantung pada maklumat yang minimum dan boleh mengesyorkan item tanpa memahami kandungannya.

Last.fm mengesyorkan lagu dengan memerhatikan kumpulan dan lagu individu yang sering didengari pengguna dan membandingkannya dengan gelagat mendengar pengguna lain. Last.fm akan memainkan lagu yang tidak muncul dalam pustaka pengguna tetapi sering dimainkan oleh pengguna lain yang mempunyai minat yang sama. Memandangkan pendekatan ini memanfaatkan tingkah laku pengguna, ia merupakan contoh teknik penapisan kolaboratif. Last.fm memerlukan banyak maklumat tentang pengguna untuk membuat pengesyoran yang tepat. Ini adalah contoh masalah permulaan sejuk, biasa dalam sistem penapisan kolaboratif. (sumber: WiKipedia, https://en.wikipedia.org/wiki/Recommender_system)

Penapisan kolaboratif mengandaikan bahawa orang yang bersetuju pada masa lalu akan bersetuju pada masa hadapan. Ia mengenal pasti pengguna lain dengan sejarah yang serupa dengan pengguna semasa dan menjana ramalan menggunakan kejiranan ini. Kaedah ini dianggap sebagai pendekatan berasaskan ingatan dan berasaskan model.

Sesetengah masalah yang mungkin mengganggu algoritma penapisan kolaboratif ialah permulaan sejuk, kebolehskalaan dan keterlaluan. Permulaan sejuk merujuk kepada kekurangan data untuk membuat pengesyoran yang tepat. Terdapat juga keperluan untuk sejumlah besar kuasa pengiraan, yang selalunya diperlukan untuk mengira pengesyoran, menjadikan algoritma kurang berskala. Selain itu, terdapat sejumlah besar produk dan item di internet, bermakna rating agak jarang.

Laksanakan Penapisan Kolaboratif dalam Python

Kami akan menggunakan set data yang mengandungi jenama teratas dan ulasan kosmetik. Set data ini boleh didapati di tapak web Kaggle: 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()}')
Salin selepas log masuk
Salin selepas log masuk

Pivot latihan menggunakan matriks item pengguna.

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]}')
Salin selepas log masuk
Salin selepas log masuk

Kira persamaan.

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')
Salin selepas log masuk
Salin selepas log masuk

Kira satu pengesyoran untuk pengguna, produk dan model tertentu

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]
Salin selepas log masuk
Salin selepas log masuk

Compute Root Mean Squared Error (RMSE) untuk menilai bagi meramalkan penilaian bagi semua produk bagi setiap pengguna dalam set data. Kemudian, gariskan penilaian yang diramalkan dengan penilaian sebenar dalam set ujian dan kirakan 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)
Salin selepas log masuk
Salin selepas log masuk
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)
Salin selepas log masuk
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 
Salin selepas log masuk

Penapisan berasaskan kandungan

What are Recommender Systems and how to use them

Pendekatan penapisan berasaskan kandungan menggunakan satu siri ciri diskret, pra-teg item untuk mengesyorkan item tambahan dengan sifat yang serupa. Ia menggunakan ciri item untuk memilih dan mengembalikan item yang berkaitan dengan perkara yang dicari oleh pengguna. Sesetengah algoritma pengesyoran berasaskan kandungan memadankan item mengikut penerangannya dan bukannya kandungan sebenar.

Pandora menggunakan sifat lagu atau artis untuk menyemai baris gilir yang memainkan muzik dengan sifat yang serupa. Maklum balas pengguna digunakan untuk memperhalusi hasil stesen, mengurangkan penekanan atribut tertentu apabila pengguna "tidak suka" lagu tertentu dan menekankan atribut lain apabila pengguna "suka" lagu. Ini adalah contoh pendekatan berasaskan kandungan. Pandora memerlukan sedikit maklumat untuk bermula, skopnya jauh lebih terhad (contohnya, ia hanya boleh membuat cadangan yang serupa dengan benih asal). (sumber: Wikipedia, https://en.wikipedia.org/wiki/Recommender_system)

Kaedah ini menggunakan perihalan produk dan profil pengguna, menjadikannya sesuai untuk situasi di mana terdapat data yang diketahui pada item tetapi tidak pada pengguna. Pengesyor berasaskan kandungan menganggap pengesyoran sebagai masalah pengelasan khusus pengguna dan pelajari pengelas untuk suka dan tidak suka pengguna berdasarkan ciri item. Kata kunci digunakan untuk menerangkan item dan profil pengguna dibina untuk menyenaraikan suka dan tidak suka pengguna. Pelbagai item calon dibandingkan dengan item yang dinilai sebelum ini oleh pengguna, dan item padanan terbaik disyorkan. Algoritma yang digunakan secara meluas ialah perwakilan TF-IDF. Terdapat teknik pembelajaran mesin seperti Pengelas Bayesian, analisis kelompok, pepohon keputusan dan rangkaian saraf tiruan untuk menganggarkan kebarangkalian pengguna akan menyukai item tersebut.

Walau bagaimanapun, penapisan berasaskan kandungan selalunya boleh mencadangkan item yang hampir serupa dengan perkara yang sudah disukai pengguna, mengehadkan kepelbagaian dan menjadikannya lebih sukar untuk menemui perkara baharu. Ini boleh membuat "gelembung", di mana pengguna hanya melihat jenis kandungan tertentu. Ia juga bergantung pada sejauh mana item dilabel atau diterangkan, yang boleh menjadi masalah jika maklumat tidak mencukupi atau jika pengguna baru dan belum berinteraksi dengan banyak kandungan lagi.

Melaksanakan Penapisan Berasaskan Kandungan dalam Python (menggunakan 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()}')
Salin selepas log masuk
Salin selepas log masuk

Ubah ringkasan plot kepada perwakilan vektor untuk dapat menggunakan algoritma pembelajaran mesin berangka.

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]}')
Salin selepas log masuk
Salin selepas log masuk

Setiap ringkasan plot akan diubah menjadi urutan perkataan untuk menunjuk kepada ruang semantik dimensi tinggi (model TF-IDF digunakan di sini). Ini mengira bilangan kali perkataan muncul dalam dokumen untuk menentukan kepentingan perkataan dalam dokumen.

print(f'Matrix mengandungi {tfidf_model.shape[0]} baris dan {tfidf_model.shape[1]} lajur')

Model BOW (Beg Perkataan) mengira bilangan kali perkataan muncul dalam dokumen (jarang, kebanyakan entri dalam vektor ialah 0)

Model

TF-IDF (Term Frequency — Inverse Document Frequency) mengira bilangan kali perkataan muncul dalam dokumen tetapi juga mempertimbangkan kekerapan perkataan itu muncul dalam semua dokumen. Ia mengurangkan berat perkataan yang kerap muncul di seluruh dokumen, menjadikannya kurang bermaklumat berbanding perkataan yang jarang muncul. Setiap ringkasan plot dikodkan sebagai vektor tunggal yang panjangnya sama dengan saiz perbendaharaan kata semua ringkasan plot, TD-IDF mengubah ringkasan plot menjadi matriks. Ia mengabaikan perkataan yang muncul dalam lebih daripada 80% ulasan dan perkataan yang berlaku dalam masa kurang daripada 2 → bunyi berkurangan.

Periksa model TF-IDF menggunakan perbendaharaan kata solek popular.

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')
Salin selepas log masuk
Salin selepas log masuk

Gunakan persamaan kosinus antara produk yang berbeza berdasarkan rumusan plot tanda-tanda kekerapan kejadian.

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]
Salin selepas log masuk
Salin selepas log masuk

Gunakan fungsi pada mana-mana produk dalam set data.

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)
Salin selepas log masuk
Salin selepas log masuk

Sistem hibrid

Anda juga boleh menggabungkan kedua-dua algoritma untuk menawarkan pengesyoran yang lebih halus. Sistem pengesyor membantu pengguna menemui item yang mereka mungkin tidak temui sebaliknya. Sistem pengesyor sering dilaksanakan menggunakan enjin carian mengindeks data bukan tradisional.

Kesimpulan

Kesimpulannya, sistem pengesyor memainkan peranan penting dalam membantu pengguna menemui kandungan dan produk yang berkaitan dengan memberikan cadangan yang diperibadikan. Mereka meningkatkan pengalaman dengan mengurangkan masa dan usaha yang diperlukan untuk mencari perkara yang menarik minat mereka.

** Lihat kod penuh di GitHub: https://github.com/alexiacismaru/recommender-systems

Atas ialah kandungan terperinci Apakah Sistem Pengesyor dan cara menggunakannya. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

sumber:dev.to
Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Tutorial Popular
Lagi>
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan