Le moteur de recommandation est souvent utilisé dans les API WEB, etc., et il est nécessaire de renvoyer les résultats rapidement tout en maintenant la précision. Par conséquent, dans cet article, lors de la mise en œuvre de la fonction de recommandation basée sur l'historique de visionnage du film, nous utilisons l'analyse des composants principaux et le clustering K-means pour maintenir autant que possible la précision de recommandation et l'équilibrer avec la vitesse de calcul afin qu'elle puisse résister à l'utilisation de l'API. Prendre.
La logique de recommandation utilisée cette fois est un simple filtrage coopératif basé sur des éléments qui extrait et recommande des films avec des évaluations d'utilisateurs similaires pour le film sélectionné.
L'analyse en composantes principales (ACP) est une méthode qui extrait uniquement les composants principaux des vecteurs de haute dimension ou super-dimensionnels et abaisse les dimensions du vecteur pour réduire la quantité de données. Étant donné que le nombre de dimensions après l'analyse du composant principal peut être déterminé à l'avance, la quantité de données peut également être déterminée en déterminant les dimensions du composant principal, de sorte que la quantité de calcul peut être maintenue constante même si les dimensions du vecteur source à analyser deviennent énormes.
De plus, en regroupant dans une certaine mesure avec le clustering Kmeans, nous limiterons les films à évaluer, réduirons le nombre de comparaisons et viserons à améliorer la vitesse de réponse.
Cette fois, nous utiliserons MovieLens, un ensemble de données de classification de films gratuit. https://grouplens.org/datasets/movielens/100k/
Vous devriez également aimer les films qui ont des évaluations similaires des utilisateurs aux films que vous aimez! !! Cependant, il serait difficile de comparer avec tout le monde car cela prendrait beaucoup de temps, alors commencez par créer un groupe de personnes à peu près similaires (regroupement), et extrayez uniquement l'évaluation du film qui semble être plus importante (analyse des composants principaux) ) Comparons!
Par exemple, si vous avez des données d'évaluation pour 10 000 films et qu'il y a des films que tout le monde regarde ou des données que presque personne ne regarde, ce ne sera pas une très bonne information, vous pouvez donc l'exclure de la comparaison. .. Réduisons à environ 100, qui sont faciles à obtenir les caractéristiques. (Strictement parlant, c'est différent, mais c'est presque comme ça.)
https://grouplens.org/datasets/movielens/100k/ Téléchargez et décompressez ml-100k.zip à partir de. Il y a quelques fichiers à l'intérieur, mais ils sont expliqués dans le README. Cette fois, j'utilise principalement u1.base.
Je vais écrire un commentaire dans le programme et le suivre comme suit.
recommend.py
import numpy as np
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
#Lecture des données au format TSV
datum = np.loadtxt("u1.base", delimiter="\t", usecols=(0, 1, 2), skiprows=1)
#Préparez une liste d'ID utilisateur et d'ID de film
user_ids = []
movie_ids = []
for row in datum:
user_ids.append( row[0] )
movie_ids.append( row[1] )
user_ids = list(set(user_ids))
movie_ids = list(set(movie_ids))
#Organiser les données d'évaluation par ID de film
vectors = {}
for movie_id in sorted(movie_ids):
vectors[movie_id] = {}
for user_id in user_ids:
#Les films que vous n'avez pas regardés sont les films par défaut-1 Évaluation
vectors[movie_id][user_id] = -1
#Stockez chaque note d'utilisateur dans un vecteur
for row in datum:
vectors[row[1]][row[0]] = row[2]
dataset = []
#Formater les données
for movie_id in vectors:
temp_data = []
for user_id in sorted(vectors[movie_id]):
temp_data.append(vectors[movie_id][user_id])
dataset.append(temp_data)
#Classé en 3 clusters par Kmeans
predict = KMeans(n_clusters=3).fit_predict(dataset)
#Nombre de dimensions après analyse des composants principaux
DIMENTION_NUM = 128
#Analyse des composants principaux
pca = PCA(n_components=DIMENTION_NUM)
dataset = pca.fit_transform(dataset)
print('Taux de cotisation cumulé: {0}'.format(sum(pca.explained_variance_ratio_)))
#Rechercher un film similaire au film ID1
MOVIE_ID = 1
#Obtenez l'ID de cluster de l'ID1 du film
CLUSTER_ID = predict[movie_ids.index(MOVIE_ID)]
distance_data = {}
for index in range(len(predict)):
#Comparez les distances vectorielles si elles sont dans le même cluster
if predict[index] == CLUSTER_ID:
distance = np.linalg.norm( np.array(dataset[index], dtype=float) - np.array(dataset[movie_ids.index(MOVIE_ID)], dtype=float) )
distance_data[movie_ids[index]] = distance
#Affiché dans l'ordre des distances vectorielles
print(sorted(distance_data.items(), key=lambda x: x[1]))
Taux de cotisation cumulé: 0.7248119795849713
[(1.0, 0.0), (121.0, 67.0315681132561), (117.0, 69.90161652852805), (405.0, 71.07049485275981), (151.0, 71.39559068741323), (118.0, 72.04600188124728), (222.0, 72.78595965661094), (181.0, 74.18442192660996), (742.0, 76.10520742268852), (28.0, 76.27732956739469), (237.0, 76.31850794116573), (25.0, 76.82773190547944), (7.0, 76.96541606511116), (125.0, 77.07961442692692), (95.0, 77.42577990621398), (257.0, 77.87452368514414), (50.0, 78.80566867021435), (111.0, 78.9631520879044), (15.0, 78.97825600046046), (69.0, 79.22663656944697), (588.0, 79.64989759225082), (82.0, 80.23718315576053), (71.0, 80.26936193506091), (79.0, 81.02025503780014).....
Le film avec ID = 1 était Toy Story, et l'ID de film le plus proche = 121 était Independence Day. Le taux de cotisation de 0,72 signifie qu'environ 72% des données originales peuvent être restaurées avec uniquement les composants principaux. J'ai l'impression de pouvoir le comprendre d'une manière ou d'une autre! !! !!
Cette fois, je suis passé par la mise en forme des données, le clustering, l'analyse des composants principaux et la comparaison avec un script. À l'origine, les données qui ont été analysées pour les principaux composants sont stockées dans la base de données, et sont implémentées de sorte que seule la comparaison soit effectuée à chaque fois.
De plus, les données de films et les données d'évaluation augmenteront de jour en jour, alors décidez d'une période appropriée et essayez de refaire le regroupement et l'analyse des composants principaux par lots.
Lors de la conversion vers l'API, nous ajusterons la précision des recommandations et la vitesse de réponse en utilisant pleinement le nombre de dimensions et de clusters du composant principal, le cache API, etc. Cette * précision de recommandation * peut être vérifiée dans un premier temps pour voir si elle correspond à un sens, mais si vous utilisez pleinement l'apprentissage en profondeur qui prend en compte les données réelles en combinaison avec le CTR et le CVR, il sera encore plus moderne. C'est comme l'apprentissage automatique.
La prochaine fois, j'écrirai sur l'utilisation du flacon de Python, etc. pour en faire une API.