Accélération de la génération de candidats dans les systèmes de recommandation à l’aide de Milvus associé à PaddlePaddle

Si vous avez de l’expérience dans le développement d’un système de recommandation, vous avez probablement été victime d’au moins l’un des éléments suivants :

• Le système est extrêmement lent lors du retour des résultats en raison de l’énorme quantité d’ensembles de données.
• Les données nouvellement insérées ne peuvent pas être traitées en temps réel pour la recherche ou la requête.
• Le déploiement du système de recommandation est intimidant.

Cet article vise à résoudre les problèmes mentionnés ci-dessus et à vous fournir quelques informations en introduisant un projet de système de recommandation de produits qui utilise Milvus, une base de données vectorielle open source, associée à PaddlePaddle, une plate-forme d’apprentissage en profondeur.

Cet article se propose de décrire brièvement le flux de travail minimal d’un système de recommandation. Ensuite, il présente les principaux composants et les détails de mise en œuvre de ce projet.

Le flux de travail de base d’un système de recommandation

Avant d’approfondir le projet lui-même, examinons d’abord le flux de travail de base d’un système de recommandation. Un système de recommandation peut renvoyer des résultats personnalisés en fonction des intérêts et des besoins uniques des utilisateurs. Pour faire de telles recommandations personnalisées, le système passe par deux étapes, la génération de candidats et le classement.

La première étape est la génération de candidats, qui renvoie les données les plus pertinentes ou similaires, comme un produit ou une vidéo qui correspond au profil de l’utilisateur. Lors de la génération de candidats, le système compare la caractéristique de l’utilisateur avec les données stockées dans sa base de données et récupère celles qui sont similaires. Ensuite, lors du classement, le système note et réorganise les données récupérées. Enfin, les résultats en haut de la liste sont présentés aux utilisateurs.

Dans notre cas d’un système de recommandation de produits, il compare d’abord le profil de l’utilisateur avec les caractéristiques des produits en stock pour filtrer une liste de produits répondant aux besoins de l’utilisateur. Ensuite, le système note les produits en fonction de leur similitude avec le profil de l’utilisateur, les classe et renvoie finalement les 10 meilleurs produits à l’utilisateur.

Architecture du système

Le système de recommandation de produits de ce projet utilise trois composants : MIND, PaddleRec et Milvus.

DÉRANGE

Le schéma suivant illustre la structure du réseau de MIND.

Pour représenter le trait des utilisateurs, MIND prend les comportements des utilisateurs et les intérêts des utilisateurs comme entrées, puis les alimente dans la couche d’intégration pour générer des vecteurs d’utilisateurs, y compris des vecteurs d’intérêts d’utilisateurs et des vecteurs de comportement d’utilisateurs. Ensuite, les vecteurs de comportement des utilisateurs sont introduits dans la couche d’extraction multi-intérêts pour générer des capsules d’intérêt des utilisateurs. Après avoir concaténé les capsules d’intérêt de l’utilisateur avec des intégrations de comportement de l’utilisateur et utilisé plusieurs couches ReLU pour les transformer, MIND génère plusieurs vecteurs de représentation de l’utilisateur. Ce projet a défini que MIND produira finalement quatre vecteurs de représentation utilisateur.

D’autre part, les caractéristiques du produit traversent la couche d’intégration et sont converties en vecteurs d’éléments épars. Ensuite, chaque vecteur d’élément passe par une couche de mise en commun pour devenir un vecteur dense. Lorsque toutes les données sont converties en vecteurs, une couche d’attention supplémentaire sensible aux étiquettes est introduite pour guider le processus d’apprentissage.

PaddleRec

Comme mentionné dans le paragraphe d’ouverture, les ingénieurs qui développent des systèmes de recommandation doivent souvent faire face aux défis d’une faible convivialité et d’un déploiement compliqué du système. Cependant, PaddleRec peut aider les développeurs dans les aspects suivants :

• Facilité d’utilisation : PaddleRec est une bibliothèque open source qui encapsule divers modèles populaires dans l’industrie, y compris des modèles pour la génération de candidats, le classement, le reclassement, le multitâche, etc. Avec PaddleRec, vous pouvez tester instantanément l’efficacité du modèle et améliorer son efficacité par itération. PaddleRec vous offre un moyen simple de former des modèles pour des systèmes distribués avec d’excellentes performances. Il est optimisé pour le traitement de données à grande échelle de vecteurs clairsemés. Vous pouvez facilement mettre à l’échelle PaddleRec horizontalement et accélérer sa vitesse de calcul. Par conséquent, vous pouvez rapidement créer des environnements de formation sur Kubernetes à l’aide de PaddleRec.
• Prise en charge du déploiement : PaddleRec fournit des solutions de déploiement en ligne pour ses modèles. Les modèles sont immédiatement prêts à l’emploi après la formation, offrant flexibilité et haute disponibilité.

Milvus

• Hautes performances lors de la recherche de vecteurs sur des ensembles de données volumineux.
• Une communauté axée sur les développeurs qui offre un support et une chaîne d’outils multilingues.
• Évolutivité du cloud et haute fiabilité même en cas de perturbation.
• La recherche hybride est réalisée en associant un filtrage scalaire à une recherche de similarité vectorielle.

Milvus est utilisé pour la recherche de similarité vectorielle et la gestion des vecteurs dans ce projet, car il peut résoudre le problème des mises à jour fréquentes des données tout en maintenant la stabilité du système.

Mise en place du système

Pour créer le système de recommandation de produits dans ce projet, vous devez suivre les étapes suivantes :

1. Traitement de l’information
2. Formation de modèle
3. Test de modèle
4. Générer des produits candidats
   1. Stockage des données : les vecteurs d’éléments sont obtenus via le modèle entraîné et sont stockés dans Milvus.
   2. Recherche de données : quatre vecteurs utilisateur générés par MIND sont introduits dans Milvus pour la recherche de similarité de vecteur.
   3. Classement des données : chacun des quatre vecteurs a son propre top_k vecteurs d’éléments similaires et quatre ensembles de top_k les vecteurs sont classés pour renvoyer une liste finale de top_k vecteurs les plus similaires.

Étape 1. Traitement des données

L’ensemble de données pour la formation devrait apparaître dans le format suivant, chaque colonne représentant :

• Uid: Identifiant d’utilisateur.
• item_id: ID de l’article sur lequel l’utilisateur a cliqué.
• Time: l’horodatage ou l’ordre de clic.

L’ensemble de données à tester devrait apparaître dans le format suivant, chaque colonne représentant :

• Uid: Identifiant d’utilisateur.
• hist_item: ID de l’élément de produit dans le comportement de clic de l’utilisateur historique. Lorsqu’il y a plusieurs hist_item, ils sont triés en fonction de l’horodatage.

• eval_item: La séquence réelle dans laquelle l’utilisateur clique sur les produits.

Étape 2. Formation du modèle

L’entraînement du modèle utilise les données traitées à l’étape précédente et adopte le modèle de génération de candidats, MIND, construit sur PaddleRec.

1. Modèle Ientrée

Dans dygraph_model.py, exécutez le code suivant pour traiter les données et les transformer en entrée de modèle. Ce processus trie les éléments cliqués par le même utilisateur dans les données d’origine en fonction de l’horodatage et les combine pour former une séquence. Ensuite, sélectionnez au hasard un item_id de la séquence en tant que target_item, et extraire les 10 éléments avant target_item comme le hist_item pour la saisie du modèle. Si la séquence n’est pas assez longue, elle peut être définie sur 0. seq_len doit être la longueur réelle du hist_item séquence.

   
   

    
        def create_feeds_train(self, batch_data):
        hist_item = paddle.to_tensor(batch_data[0], dtype="int64")
        target_item = paddle.to_tensor(batch_data[1], dtype="int64")
        seq_len = paddle.to_tensor(batch_data[2], dtype="int64")
        return [hist_item, target_item, seq_len]
   
   
   

Référez-vous au script /home/aistudio/recommend/model/mind/mind_reader.py pour le code de lecture de l’ensemble de données d’origine.

2. Réseautage de modèles

Le code suivant est un extrait de net.py. class Mind_Capsual_Layer définit la couche d’extraction multi-intérêts construite sur le mécanisme de routage des capsules d’intérêts. La fonction label_aware_attention() implémente la technique d’attention sensible aux étiquettes dans l’algorithme MIND. Les forward() fonction dans le class MindLayer modélise les caractéristiques de l’utilisateur et génère les vecteurs de poids correspondants.

   
   

    
        class Mind_Capsual_Layer(nn.Layer):
        def __init__(self):
            super(Mind_Capsual_Layer, self).__init__()
            self.iters = iters
            self.input_units = input_units
            self.output_units = output_units
            self.maxlen = maxlen
            self.init_std = init_std
            self.k_max = k_max
            self.batch_size = batch_size
            # B2I routing
            self.routing_logits = self.create_parameter(
                shape=[1, self.k_max, self.maxlen],
                attr=paddle.ParamAttr(
                    name="routing_logits", trainable=False),
                   default_initializer=nn.initializer.Normal(
                    mean=0.0, std=self.init_std))
            # bilinear mapping
               self.bilinear_mapping_matrix = self.create_parameter(
   
                   shape=[self.input_units, self.output_units],
                   attr=paddle.ParamAttr(
                       name="bilinear_mapping_matrix", trainable=True),
                   default_initializer=nn.initializer.Normal(
                       mean=0.0, std=self.init_std))
       class MindLayer(nn.Layer):
           def label_aware_attention(self, keys, query):
              weight = paddle.sum(keys * query, axis=-1, keepdim=True)
              weight = paddle.pow(weight, self.pow_p)  # [x,k_max,1]
               weight = F.softmax(weight, axis=1)
               output = paddle.sum(keys * weight, axis=1)
               return output, weight
           def forward(self, hist_item, seqlen, labels=None):
               hit_item_emb = self.item_emb(hist_item)  # [B, seqlen, embed_dim]
   
               user_cap, cap_weights, cap_mask = self.capsual_layer(hit_item_emb, seqlen)
               if not self.training:
                   return user_cap, cap_weights
              ...