Platform For AI:Gérer les features avec le SDK FeatureStore

Méthode 1 : Utiliser la console

1. Créez un projet FeatureStore.

   1. Connectez-vous à la console PAI. Dans le volet de navigation de gauche, cliquez sur Data Preparation > FeatureStore.

   2. Sélectionnez un espace de travail et cliquez sur Enter FeatureStore.

   3. Cliquez sur Create Project. Dans la boîte de dialogue qui s'affiche, configurez les paramètres du projet.

      Parameter	Suggested value
      Name	Saisissez un nom personnalisé. Cette rubrique utilise fs_demo à titre d'exemple.
      Description	Saisissez une description personnalisée.
      Offline Store	Sélectionnez la source de données MaxCompute que vous avez créée.
      Online Store	Sélectionnez la source de données FeatureDB que vous avez créée.

   4. Cliquez sur Submit pour créer le projet FeatureStore.

2. Créez une entité de fonctionnalité.

   1. Sur la page Projects de FeatureStore, cliquez sur le nom du projet pour ouvrir la page des détails du projet.

   2. Sous l'onglet Feature Entity, cliquez sur Create Feature Entity. Dans la boîte de dialogue qui s'affiche, configurez les paramètres de l'entité de fonctionnalité utilisateur.

      Parameter	Suggested value
      Feature Entity Name	Saisissez un nom personnalisé. Cette rubrique utilise user à titre d'exemple.
      Join Id	user_id

   3. Cliquez sur Submit.

   4. Cliquez sur Create Feature Entity. Dans la boîte de dialogue qui s'affiche, configurez les paramètres de l'entité de fonctionnalité d'élément.

      Parameter	Suggested value
      Feature Entity Name	Saisissez un nom personnalisé. Cette rubrique utilise item à titre d'exemple.
      Join Id	item_id

   5. Cliquez sur Submit pour créer l'entité de fonctionnalité.

3. Créez une vue de fonctionnalité.

   1. Sous l'onglet Feature View de la page des détails du projet, cliquez sur Create Feature View. Dans la boîte de dialogue qui s'affiche, configurez les paramètres de la vue de fonctionnalité utilisateur.

      Parameter	Suggested value
      View Name	Saisissez un nom personnalisé. Cette rubrique utilise user_table_preprocess_all_feature_v1 à titre d'exemple.
      Type	Offline
      Write Mode	Use Offline Table
      Store	Sélectionnez la source de données MaxCompute que vous avez créée.
      Feature Table	Sélectionnez la table utilisateur que vous avez préparée : rec_sln_demo_user_table_preprocess_all_feature_v1.
      Feature Field	Sélectionnez la clé primaire user_id.
      Synchronize Online Feature Table	Yes
      Feature Entity	user
      Feature Lifecycle	Conservez la valeur par défaut.

   2. Cliquez sur Submit.

   3. Cliquez sur Create Feature View. Dans la boîte de dialogue qui s'affiche, configurez la vue de fonctionnalité d'élément.

      Parameter	Suggested value
      View Name	Saisissez un nom personnalisé. Cette rubrique utilise item_table_preprocess_all_feature_v1 à titre d'exemple.
      Type	Offline
      Write Mode	Use Offline Table
      Store	Sélectionnez la source de données MaxCompute que vous avez créée.
      Feature Table	Sélectionnez la table d'éléments que vous avez préparée : rec_sln_demo_item_table_preprocess_all_feature_v1.
      Feature Field	Sélectionnez la clé primaire item_id.
      Synchronize Online Feature Table	Yes
      Feature Entity	item
      Feature Lifecycle	Conservez la valeur par défaut.

   4. Une fois la configuration terminée, cliquez sur Submit pour créer la vue de fonctionnalité.

4. Créez une table d'étiquettes.

   1. Sous l'onglet Label Table de la page des détails du projet, cliquez sur Create Label Table. Dans la boîte de dialogue qui s'affiche, configurez les informations de la table d'étiquettes.

      Parameter	Suggested value
      Store	Sélectionnez la source de données MaxCompute que vous avez créée.
      Table Name	Sélectionnez la table d'étiquettes que vous avez préparée : rec_sln_demo_label_table.

   2. Cliquez sur Submit.

5. Créez une fonctionnalité de modèle.

   1. Sous l'onglet Model Features de la page des détails du projet, cliquez sur Create Model Feature. Dans la boîte de dialogue qui s'affiche, configurez les paramètres de la fonctionnalité de modèle.

      Parameter	Suggested value
      Model Feature Name	Saisissez un nom personnalisé. Cette rubrique utilise fs_rank_v1 à titre d'exemple.
      Select Feature	Sélectionnez les vues de fonctionnalités utilisateur et d'élément que vous avez créées.
      Label Table Name	Sélectionnez la table d'étiquettes que vous avez créée : rec_sln_demo_label_table.

   2. Cliquez sur Submit pour créer la fonctionnalité de modèle.

   3. Sur la page de liste des fonctionnalités de modèle, cliquez sur Details à droite de votre modèle.

   4. Dans la boîte de dialogue Model Feature Details qui s'affiche, sous l'onglet Basic Information, vous pouvez consulter le champ Export Table Name, dont la valeur est fs_demo_fs_rank_v1_trainning_set. Cette table est utilisée pour la production ultérieure de fonctionnalités et l'entraînement du modèle.

6. Installez le SDK Python FeatureStore. Pour plus d'informations, consultez Utiliser FeatureStore pour gérer les fonctionnalités dans un système de recommandation.

Méthode 2 : Utiliser le SDK Python FeatureStore

1. Connectez-vous à la console DataWorks.

2. Dans le volet de navigation de gauche, cliquez sur Resource Groups.

3. Sous l'onglet Exclusive Resource Groups, repérez le groupe de ressources dont l'Purpose est Data Scheduling. Cliquez sur l'icône située à côté de sa ressource de planification et sélectionnez O&M Assistant.

4. Cliquez sur Create Command. Dans la boîte de dialogue qui s'affiche, configurez les paramètres de la commande.

   Parameter	Suggested value
   Command Name	Saisissez un nom personnalisé. Cette rubrique utilise install à titre d'exemple.
   Command Type	Manual Input (pip Command Cannot Be Used To Install Third-party Packages)
   Command Content	/home/tops/bin/pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple https://feature-store-py.oss-cn-beijing.aliyuncs.com/package/feature_store_py-2.0.2-py3-none-any.whl
   Timeout	Définissez une durée personnalisée.

5. Cliquez sur Create pour créer la commande.

6. Cliquez sur Run Command. Dans la boîte de dialogue qui s'affiche, cliquez sur Run.

7. Vous pouvez cliquer sur Refresh pour afficher le dernier état d'exécution. Lorsque l'état passe à Success, l'installation est terminée.

Pour connaître les étapes détaillées d'utilisation du SDK, consultez la galerie DSW.

Python SDK

Pour plus d'informations, consultez la rubrique Utilisation du SDK FeatureStore Python pour construire un système de recommandation.

Go SDK

Le SDK FeatureStore Go est open source. Pour plus d'informations, reportez-vous au dépôt aliyun-pai-featurestore-go-sdk.

1. Installation

   Exécutez la commande suivante pour installer le SDK FeatureStore Go.

   go get github.com/aliyun/aliyun-pai-featurestore-go-sdk/v2

2. Utilisation

   1. Exécutez la commande suivante pour initialiser le client.

      accessId := os.Getenv("AccessId") 
      accessKey := os.Getenv("AccessKey") 
      regionId := "cn-hangzhou" 
      projectName := "fs_test_ots" 
      
      client, err := NewFeatureStoreClient(regionId, accessId, accessKey, projectName)

      Remarque

      Le SDK se connecte directement à la source de données en ligne. Par conséquent, le client doit s'exécuter dans un environnement VPC. Par exemple, Hologres exige que les connexions proviennent d'un VPC spécifique.

   2. Récupérez les données de fonctionnalités depuis une vue de fonctionnalités (feature view).

      // get project by name 
      project, err := client.GetProject("fs_test_ots") 
      if err != nil {     
      	// t.Fatal(err) 
      } 
      // get featureview by name 
      user_feature_view := project.GetFeatureView("user_fea") 
      if user_feature_view == nil {     
      	// t.Fatal("feature view not exist") 
      } 
      
      // get online features 
      features, err := user_feature_view.GetOnlineFeatures([]interface{}{"100043186", "100060369"}, []string{"*"}, nil)

      Ici, []string{"*"} signifie que toutes les fonctionnalités de la vue sont récupérées. Vous pouvez également spécifier les noms des fonctionnalités que vous souhaitez obtenir.

      Voici un exemple des données renvoyées :

      [     
      {         
      "city":"Hefei",    "follow_cnt":1,         "gender":"male",         "user_id":"100043186"    
       },     {                     
       "city":"",         "follow_cnt":5,         "gender":"male",         "user_id":"100060369"     
      } 
      ]

   3. Récupérez les données de fonctionnalités à partir d'une fonctionnalité de modèle (model feature).

      Une fonctionnalité de modèle peut être associée à plusieurs entités de fonctionnalités. Vous pouvez fournir plusieurs ID de jointure pour récupérer les fonctionnalités correspondantes simultanément.

      Cet exemple utilise trois ID de jointure : join_id, user_id et item_id. Lors de l'extraction des fonctionnalités, vous devez fournir une valeur pour chaque ID de jointure.

      // get project by name 
      project, err := client.GetProject("fs_test_ots") 
      if err != nil {     
      	// t.Fatal(err) 
      }
      
      // get ModelFeature by name 
      model_feature := project.GetModelFeature("rank") 
      if model_feature == nil {     
      	// t.Fatal("model feature not exist") 
      } 
      
      // get online features 
      features, err := model_feature.GetOnlineFeatures(map[string][]interface{}{"user_id": {"100000676", "100004208"}, "item_id":{"238038872", "264025480"}} )

      Voici un exemple des données renvoyées :

      [     
      {         
      "age":26,         "author":100015828,         "category":"14",         "city":"Shenyang",         "duration":63,         "gender":"male",         "item_id":"238038872",         "user_id":"100000676"    
       },     {         
      "age":23,         "author":100015828,         "category":"15",         "city":"Xi'an",         "duration":22,         "gender":"male",         "item_id":"264025480",         "user_id":"100004208"    
       }
       ]
      

      Vous pouvez également spécifier une entité de fonctionnalité afin de récupérer l'ensemble de ses caractéristiques associées.

      Voici un exemple des données renvoyées :

      [    
       {         
      "age":26,         "city":"Shenyang",         "gender":"male",         "user_id":"100000676"    
       },     {        
       "age":23,         "city":"Xi'an",         "gender":"male",         "user_id":"100004208"    
       } 
      ]

Java SDK

Le SDK FeatureStore Java est open source. Pour plus d'informations, reportez-vous au dépôt aliyun-pai-featurestore-java-sdk.

Cette section prend pour exemple une source de données Hologres.

1. Exécutez le code suivant pour charger les variables d'environnement et initialiser le service.

   public static String accessId = "";
   public static String accessKey = "";
   // Configure the host based on the region
   public static String host = "";
   // Get the accessId and accessKey from the configured local environment variables
   static {
       accessId = System.getenv("ACCESS_KEY_ID");
       accessKey = System.getenv("ACCESS_KEY_SECRET");
   }

2. Créez une classe de configuration qui définit les paramètres regionId, accessId, accessKey ainsi que le nom du projet.

   Configuration cf = new Configuration("cn-hangzhou",Constants.accessId,Constants.accessKey,"ele28");
   cf.setDomain(Constants.host);// Note: The default environment is a VPC environment

3. Initialisez le client.

   ApiClient apiClient = new ApiClient(cf);
   // FS client
   FeatureStoreClient featureStoreClient = new FeatureStoreClient(apiClient);

4. Récupérez le projet. Cet exemple utilise un projet nommé ele28.

   Project project=featureStoreClient.getProject("ele28");
   if(project==null){
       throw new RuntimeException("Project not found");
   }

5. Récupérez la vue de fonctionnalités du projet. Cet exemple utilise une vue de fonctionnalités nommée mc_test.

   FeatureView featureView=project.getFeatureView("mc_test");
   if (featureView == null) {
       throw  new RuntimeException("FeatureView not found");
   }

6. Récupérez les données de fonctionnalités en ligne basées sur la vue de fonctionnalités.

   Map<String,String> m1=new HashMap<>();
   m1.put("gender","gender1"); // Create an alias                                                                                                                                                                                                 user_id='100027781'(FS_INT64) age='28'(FS_INT64) city='null'(FS_STRING) item_cnt='0'(FS_INT64) follow_cnt='0'(FS_INT64) follower_cnt='2'(FS_INT64) register_time='1697641608'(FS_INT64) tags='0'(FS_STRING) gender1='female'(FS_STRING) ---------------

   Pour récupérer les fonctionnalités en ligne, l'utilisation de String[]{"*"} permet d'obtenir toutes les propriétés. Vous avez également la possibilité de spécifier certaines propriétés afin de ne récupérer qu'un sous-ensemble des informations.

   FeatureResult featureResult1=featureView.getOnlineFeatures(new String[]{"100017768","100027781","100072534"},new String[]{"*"},m1);

   Affichez les informations relatives aux fonctionnalités.

   while(featureResult1.next()){
       System.out.println("---------------");
       // Feature name
       for(String m:featureResult1.getFeatureFields()){
           System.out.print(String.format("%s=%s(%s) ",m,featureResult1.getObject(m),featureResult1.getType(m)));
       }
       System.out.println("---------------");
   }   

   Les données suivantes sont renvoyées.

   ---------------
   user_id='100017768'(FS_INT64)  age='28'(FS_INT64)  city='Dongguan'(FS_STRING) item_cnt='1'(FS_INT64)  follow_cnt='1'(FS_INT64)  follower_cnt='0'(FS_INT64) register_time='1697202320'(FS_INT64)  tags='1,2'(FS_STRING)  gender1='female'(FS_STRING) 
   ---------------

7. Récupérez le modèle.

   Model model=project.getModelFeature("model_t1");
   if(model==null){
       throw new RuntimeException("Model not found");
   }

   1. Récupérez les données depuis la fonctionnalité de modèle.

      Cette fonctionnalité de modèle utilise deux ID de jointure : user_id et item_id. Le nombre de valeurs fournies doit correspondre au nombre d'ID de jointure. Cet exemple fournit une valeur pour chaque ID de jointure.

      Map<String, List<String>> m2=new HashMap<>(); 
      m2.put("user_id",Arrays.asList("101683057"));
      m2.put("item_id",Arrays.asList("203665415"));

   2. Récupérez toutes les données de fonctionnalités liées à l'entité de fonctionnalité utilisateur depuis la fonctionnalité de modèle.

      FeatureResult featureResult2 = model.getOnlineFeaturesWithEntity(m2,"user");

      Les données suivantes sont renvoyées.

      ---------------
      user_id='101683057' age='28' city='Shenzhen' follower_cnt='234' follow_cnt='0' gender='male' item_cnt='0' register_time='1696407642' tags='2' item_id='203665415' author='132920407' category='14' click_count='0' duration='18.0' praise_count='10' pub_time='1698218997' title='#Idiom Story' 
      ---------------

Cpp SDK

Le SDK FeatureStore C++ est actuellement intégré au processeur EasyRec. Il est spécifiquement optimisé pour l'extraction de fonctionnalités, la gestion du cache et les opérations de lecture, offrant ainsi une solution haute performance et à faible latence adaptée aux scénarios de recommandation à grande échelle.

• Utilisation de la mémoire : lors du traitement de données de fonctionnalités complexes et volumineuses, la consommation de mémoire est considérablement réduite. Les économies de mémoire sont d'autant plus significatives que la charge de fonctionnalités est élevée.

• Temps d'extraction des fonctionnalités : au lieu de tirer les fonctionnalités depuis des magasins en ligne (tels que FeatureDB et Hologres), le SDK les extrait directement depuis MaxCompute vers le cache du Elastic Algorithm Service (EAS). Cela réduit considérablement le temps de chargement des fonctionnalités. De plus, MaxCompute offre une meilleure stabilité et extensibilité, ce qui diminue la charge imposée aux magasins en ligne lors des opérations de mise à l'échelle.

• Temps de scoring du modèle : l'utilisation de ce SDK améliore la métrique de performance TP100 pour le scoring des modèles, stabilise les temps de réponse et réduit significativement le nombre de requêtes expirées. Ces améliorations renforcent la fiabilité globale et l'expérience utilisateur du service de recommandation.