/recommender-system-by-daniel-aime

Projet d'étude système de recommendation en utilisant filtrage collaboratif

Primary LanguagePython

recommender-system

Projet d'étude système de recommendation en utilisant filtrage collaboratif


Methode et approche utilisé

Pour un système de recommandation basé sur SVD, voici une stratégie très simple : trouver l'utilisateur le plus similaire à l'aide des matrices bidimensionnelles ci-dessus avec l'un des algorithmes de calcul de similarité et comparer ses éléments à celui du nouvel utilisateur ; prenez les articles que l'utilisateur similaire a évalués et que le nouvel utilisateur n'a pas évalués et retournez-les pour le nouvel utilisateur. De la même manière, pour un nouvel élément, recherchez l'élément le plus similaire à l'aide des matrices bidimensionnelles ci-dessus avec l'un des algorithmes de calcul de similarité et comparez l'élément similaire évalué par les utilisateurs avec le nouvel élément ; prendre les utilisateurs qui notent un article similaire mais pas le nouvel article et renvoyer les notes pour le nouvel article

  • User-based similarité Dans la recommandation SVD, afin de décider si deux utilisateurs sont similaires, la matrice réduite Uki est utilisée[1]. Dans la (mxk)Ukmatrice, chaque ligne représente un utilisateur. Plus deux lignes sont similaires, plus les utilisateurs se ressemblent. Une étape critique de l'algorithme SVD consiste à calculer la similarité entre les utilisateurs, puis à sélectionner les utilisateurs les plus similaires. Il existe plusieurs façons de calculer la similarité entre les utilisateurs. Voici deux de ces méthodes : la similarité basée sur le cosinus et la comparaison des distances euclidiennes dans l'espace à k dimensions.

    • cosinus simularité: La similarité de deux vecteurs lignes pourrait être calculée avec la similarité en cosinus afin de décider si deux utilisateurs sont similaires ou non. Formellement, la similarité entre les utilisateurs i et ji est indiquée en (2).

    Pour trouver l'utilisateur le plus similaire à l'utilisateur 1, les distances entre le point numéro 1 et tous les points doivent être calculées et l'utilisateur qui a la plus petite distance au point 1 est l'utilisateur le plus similaire à l'utilisateur 1.

    METHODE DE REQUETAGE POUR(Utilisateur=x, Item= y, Note = ?)

    Demande de recommandation (Utilisateur= x, Item= y, Note =?) 1.Trouvez les utilisateurs qui ont noté Item = y à partir de la matrice d'origine A. 2.Trouvez l'utilisateur le plus similaire à Utilisateur = x parmi les utilisateurs qui ont noté Item = y en utilisant la matrice réduite Uk. 3.Obtenez la note de l'utilisateur le plus similaire à Item = y à partir de la matrice d'origine A et attribuez-la à User = x , Item= y

    Pour la deuxième partie de l'algorithme, si l'utilisateur = x est un utilisateur déjà existant, il existe dans la matrice réduite Ukas une ligne. Si l'utilisateur = x est un nouvel utilisateur, avant de commencer les contrôles de similarité, l'utilisateur doit être projeté de n dimensions à k dimensions. Soit la notation du nouveau vecteur utilisateur Nu(1xn). La projection P vers la matrice réduite Ukis est faite par la formule[1]

  • Comment recommender le produits pour un utilisateur x?

    • Recherchez le produit que l'utilisateur similaire y a notes et supprimer le produit que x a deja noté

    def SGD(self,n_factor=None, n_epoches=None, alpha=0.025):

    data, dict_users, dict_items = df.encode_ids(self.user_item)
    self.n_factor = self.low_rank_approximate() # number factor with low-rank approximation
    n_users = len(self.all_user_id) #numbers of unique users
    n_items = len(self.all_item__id) #numbers of unique items
    
    # Random initialize the user and item factor
    p = np.random.normal(0, .1, (n_users, self.n_factor))
    q = np.random.normal(0, .1, (n_items, self.n_factor))
    # p = self.left_singular_vector
    # q = self.right_singular_vector.transpose()
    # print(p[1])
    # print(q[1])
    #Minimisation and optimization procedure
    for epoches in range(n_epoches):
        print(f"tour numero: {epoches}")
        # break
        #loop over the rows in data
        for index in range(data.shape[0]):
            row = data.iloc[[index]]
            for column in list(row.columns):
                u = int(row.index.values)                #current user_id = position in the p vector
                i = int(column)                          #current item_id = position in the q vector
                r_ui = float(data.loc[u, i])        #rating associate to the couple (user u, item i)
                # print(f"u={u}, i={i}, rating={r_ui}")
                # Error between the predicted rating (p_u * q_i) and the know rating r_ui
                error = r_ui - np.dot(np.dot(p[u], self.fill_sigma(nbr_factor=self.n_factor)), q[i].transpose())
    
                # Update vector p_u and q_i using partial deverive
                p_old = p[u]
                p[u] = (p[u] + alpha * error * q[i]).astype('float')
                q[i] = (q[i] + alpha * error * p_old).astype('float')
                # print(p[u])
                # break
    
    return p, q