Platform For AI:Développer un processeur personnalisé à l'aide de Python

Flux de travail

Développez un processeur Python personnalisé en suivant les étapes ci-dessous :

1. Étape 1 : Configurer l'environnement de développement

   Le SDK Python d'EAS prend en charge divers frameworks d'apprentissage automatique Python et s'intègre à des frameworks de traitement de données tels que Pandas. Configurez un environnement Python local, développez des processeurs personnalisés, puis empaquetez et téléchargez l'environnement.

2. Étape 2 : Écrire la logique de prédiction

   Le SDK Python d'EAS fournit un framework RPC haute performance et des interfaces internes pour interagir avec le cluster EAS. Écrivez la logique de prédiction et implémentez une interface simple pour déployer votre service de modèle sur EAS.

3. Étape 3 : Tester le service localement

   Testez le service localement afin de vérifier que la logique de prédiction est correcte et que le service fonctionne comme prévu après le déploiement.

4. Étape 4 : Empaqueter le code et l'environnement Python

   Empaquetez le code et l'environnement pour le déploiement du service.

5. Étape 5 : Télécharger le package du processeur et le fichier de modèle

   Téléchargez séparément le package et les fichiers de modèle vers Object Storage Service (OSS).

6. Étape 6 : Déployer et tester le service

   Déployez votre processeur personnalisé en tant que service de modèle et vérifiez son bon fonctionnement.

Prérequis

Préparez un fichier de modèle.

Étape 1 : Configurer l'environnement de développement

Utilisez des outils de gestion de packages Python tels que Pyenv pour configurer un environnement de développement. EAS met à disposition l'outil client EASCMD, qui encapsule le processus d'initialisation du SDK Python. Après avoir téléchargé l'outil, exécutez une seule commande pour initialiser l'environnement du SDK Python et générer des modèles de fichiers. EASCMD est compatible uniquement avec Linux. Exemple :

# Install and initialize EASCMD. This example shows how to install the EASCMD client for Linux.
$ wget https://eas-data.oss-cn-shanghai.aliyuncs.com/tools/eascmd/v2/eascmd64
# After the download is complete, modify the access permissions and configure your Alibaba Cloud AccessKey pair.
$ chmod +x eascmd64
$ ./eascmd64 config -i <access_id> -k <access_key>

# Initialize the environment.
$ ./eascmd64 pysdk init ./pysdk_demo

Lorsque vous y êtes invité, saisissez une version de Python (par défaut : 3,6). Le système crée alors un répertoire d'environnement Python nommé ENV, un modèle de code de service de prédiction nommé app.py et un modèle de déploiement de service nommé app.json dans le répertoire ./pysdk_demo.

Étape 2 : Écrire la logique de prédiction

# -*- coding: utf-8 -*-
import allspark

class MyProcessor(allspark.BaseProcessor):
    """ MyProcessor is an example
        you can send mesage like this to predict
        curl -v http://127.0.0.1:8080/api/predict/service_name -d '2 105'
    """
    def initialize(self):
        """ load module, executed once at the start of the service
             do service initialization and load models in this function.
        """
        self.module = {'w0': 100, 'w1': 2}
        # model_dir = self.get_model_path().decode()
        # You must implement the load_model function yourself. For example, to load a model.pt file, you can implement it as torch.load(model_dir + "/model.pt").
        # self.model = load_model(model_dir)

    def pre_process(self, data):
        """ data format pre process
        """
        x, y = data.split(b' ')
        return int(x), int(y)

    def post_process(self, data):
        """ process after process
        """
        return bytes(data, encoding='utf8')

    def process(self, data):
        """ process the request data
        """
        x, y = self.pre_process(data)
        w0 = self.module['w0']
        w1 = self.module['w1']
        y1 = w1 * x + w0
        if y1 >= y:
            return self.post_process("True"), 200
        else:
            return self.post_process("False"), 400

if __name__ == '__main__':
    # allspark.default_properties().put('rpc.keepalive', '10000')
    # Set the service timeout to 10s. The default is 5s.
    # The worker_threads parameter indicates the processing concurrency.
    runner = MyProcessor(worker_threads=10)
    runner.run()

model_dir = self.get_model_path().decode()
    self.model = load_model(model_dir)

Étape 3 : Tester le service localement

1. Dans le répertoire contenant app.py, exécutez la commande suivante pour démarrer l'application.

   ./ENV/bin/python app.py

   Sortie attendue en cas de succès :

   [INFO] waiting for service initialization to complete...
   [INFO] service initialization complete
   [INFO] create service
   [INFO] rpc binds to predefined port 8080
   [INFO] install builtin handler call to /api/builtin/call
   [INFO] install builtin handler eastool to /api/builtin/eastool
   [INFO] install builtin handler monitor to /api/builtin/monitor
   [INFO] install builtin handler ping to /api/builtin/ping
   [INFO] install builtin handler prop to /api/builtin/prop
   [INFO] install builtin handler realtime_metrics to /api/builtin/realtime_metrics
   [INFO] install builtin handler tell to /api/builtin/tell
   [INFO] install builtin handler term to /api/builtin/term
   [INFO] Service start successfully

2. Ouvrez un nouveau terminal et exécutez la commande suivante pour tester l'application.

   Sur la base de l'exemple de code de l'Étape 2, envoyez les données de requête à l'application. Le résultat renvoyé reflète la logique du code.

   curl http://127.0.0.1:8080/test  -d '10 20'

Étape 4 : Empaqueter le code et l'environnement

EASCMD propose une commande d'empaquetage en une seule étape. Si vous n'utilisez pas EASCMD, empaquetez l'environnement manuellement. Les deux méthodes sont décrites ci-dessous.

Étape 5 : Télécharger le package et les fichiers de modèle

Téléchargez séparément le fichier de package (.zip ou .tar.gz) et le fichier de modèle vers OSS pour leur montage lors du déploiement du service. Pour plus d'informations, consultez la rubrique Démarrage rapide pour ossutil.

Étape 6 : Déployer et tester le service

Déployez le service de modèle à l'aide de la console PAI ou d'EASCMD.

1. Déployez le service.

   Console PAI

   1. Connectez-vous à la console PAI. Sélectionnez une région en haut de la page. Ensuite, sélectionnez l'espace de travail souhaité et cliquez sur Enter Elastic Algorithm Service (EAS).

   2. Cliquez sur Deploy Service. Dans la section Custom Model Deployment, cliquez sur Custom Deployment.

   3. Sur la page Custom Deployment, configurez les paramètres suivants. Pour les autres paramètres, consultez la rubrique Déploiement personnalisé.

      Paramètre	Description
      Deployment Method	Sélectionnez Processor-based Deployment.
      Model Settings	Pour Type, sélectionnez OSS et sélectionnez le chemin OSS du fichier de modèle.
      Processor Type	Sélectionnez Custom Processor.
      Processor Language	Sélectionnez python.
      Processor Package	Pour Type, sélectionnez OSS et sélectionnez le chemin OSS du fichier de package de l'étape précédente.
      Processor Main File	Saisissez ./app.py.

   4. (Facultatif) Dans la section Service Configurations, ajoutez le paramètre data_image et définissez-le sur le chemin de l'image configuré lors de l'empaquetage.

      Remarque

      Ce paramètre est requis uniquement si vous avez utilisé une image pour empaqueter l'environnement à l'Étape 4.

   5. Cliquez sur Deploy.

   EASCMD

   Déployez le service sous Linux :

   1. Téléchargez et authentifiez EASCMD. Pour plus d'informations, consultez la rubrique Télécharger et authentifier le client.

   2. Dans le répertoire EASCMD, créez un fichier JSON nommé app.json. Exemple :

      {
        "name": "pysdk_demo",
        "processor_entry": "./app.py",
        "processor_type": "python",
        "processor_path": "oss://examplebucket/exampledirectory/pysdk_demo.tar.gz",
        "model_path": "oss://examplebucket/exampledirectory/model",
        "cloud": {
              "computing": {
                  "instance_type": "ecs.c7.large"
              }
        },
        "metadata": {
          "instance": 1,
          }
      }

   3. Dans le répertoire contenant app.json, exécutez la commande suivante pour déployer le service.

      $ ./eascmd64 create app.json

      Sortie attendue en cas de succès :

      [RequestId]: 1202D427-8187-4BCB-8D32-D7096E95B5CA
      +-------------------+-------------------------------------------------------------------+
      | Intranet Endpoint | http://182848887922****.vpc.cn-beijing.pai-eas.aliyuncs.com/api/predict/pysdk_demo |
      |             Token | ZTBhZTY3ZjgwMmMyMTQ5OTgyMTQ5YmM0NjdiMmNiNmJkY2M5ODI0****          |
      +-------------------+-------------------------------------------------------------------+
      [OK] Waiting task server to be ready
      [OK] Fetching processor from [oss://eas-model-beijing/195557026392****/pysdk_demo.tar.gz]
      [OK] Building image [registry-vpc.cn-beijing.aliyuncs.com/eas/pysdk_demo_cn-beijing:v0.0.1-20190806082810]
      [OK] Pushing image [registry-vpc.cn-beijing.aliyuncs.com/eas/pysdk_demo_cn-beijing:v0.0.1-20190806082810]
      [OK] Waiting [Total: 1, Pending: 1, Running: 0]
      [OK] Service is running

2. Testez le service.

   1. Connectez-vous à la console PAI. Sélectionnez une région en haut de la page. Ensuite, sélectionnez l'espace de travail souhaité et cliquez sur Enter Elastic Algorithm Service (EAS).

   2. Recherchez le service cible et cliquez sur Invocation Information dans la colonne Service Type pour obtenir l'endpoint public et le Token.

   3. Exécutez la commande suivante pour appeler le service avec l'endpoint et le token de l'étape précédente.

      $ curl <service_url> -H 'Authorization: <token>' -d '10 20'

      Paramètres :

      • <service_url> : Endpoint public de l'étape précédente. Exemple : http://182848887922****.vpc.cn-beijing.pai-eas.aliyuncs.com/api/predict/pysdk_demo.

      • <token> : Token de l'étape précédente. Exemple : ZTBhZTY3ZjgwMmMyMTQ5OTgyMTQ5YmM0NjdiMmNiNmJkY2M5ODI0****.

      • -d : Données d'entrée pour le service.

Références

• Problèmes de développement courants : FAQ

• Développement de processeurs personnalisés en Java : Développer un processeur personnalisé à l'aide de Java