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 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.
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()}')
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]}')
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')
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]
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)
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
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.
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()}')
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]}')
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)
ModelTF-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')
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]
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)
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.
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!