Utiliser cube studio pour développer un pipeline de modélisation d'apprentissage automatique

(Auteur : Chen Yujue)

Cube Studio comprend actuellement des modèles d'apprentissage automatique traditionnels, plus de 400 modèles d'IA, bienvenue dans un message privé pour en savoir plus !

Dans le processus d'utilisation de Cube Studio pour la formation ou le raisonnement de modèles, nous constatons parfois qu'aucun modèle ne répond à nos exigences. Pour le moment, nous devons créer des modèles et créer des pipelines pour une utilisation directe dans des scénarios de modélisation ou de surveillance similaires à l'avenir. ., pour faciliter la réutilisation et la planification.

Voici un exemple de création d'un pipeline pour la modélisation de forêt aléatoire afin d'enregistrer comment utiliser Cube Studio pour créer un pipeline.

1. Constitution du code

La différence entre l'écriture du code de modélisation de forêt aléatoire et la modélisation habituelle est que le code ici doit avoir des paramètres d'entrée.Ceci doit être connecté à notre modèle, car le modèle a besoin de paramètres d'entrée pour mieux fonctionner. Le code n'est pas montré ici, tout le monde les connaît, montrez juste les paramètres d'entrée qui sont différents de la modélisation habituelle.

if __name__ == "__main__":
    arg_parser = argparse.ArgumentParser("train lr launcher")
    arg_parser.add_argument('--train_dataset', type=str, help="训练数据集来源", default='')
    arg_parser.add_argument('--val_dataset', type=str, help="评估数据集名称", default='')
    arg_parser.add_argument('--feature_columns', type=str, help="特征列", default='')
    arg_parser.add_argument('--label_columns', type=str, help="标签列", default='')
    arg_parser.add_argument('--save_model_dir', type=str, help="模型地址", default='')
    arg_parser.add_argument('--save_val_dir', type=str, help="模型训练集和测试集评估结果地址", default='')
    arg_parser.add_argument('--inference_dataset', type=str, help="推理数据集名称", default='')
    arg_parser.add_argument('--result_path', type=str, help="推理结果保存地址", default='')

Comment faire le processus de formation, la clé est ces paramètres d'entrée, qui doivent être pris en compte clairement au début de la conception du modèle, quels paramètres doivent être transmis au modèle et quels résultats doivent être produits.

Après avoir exécuté le notebook, vous pouvez passer à l'étape suivante.

2. Création d'images

1. projet de studio git clone cube;

2. Sous le dossier cube-studio/job-template/job/, créez un nouveau dossier randomforest, placez le fichier py dans ce dossier et nommez-le launcher.py ;

3. Sous le même dossier que ci-dessus, créez trois autres fichiers, build.sh, Dockerfile, README.md. 

Où build.sh doit construire et pousser l'image

#!/bin/bash

set -ex

docker build -t ccr.ccs.tencentyun.com/cube-studio/lightgbm:20230428 -f job/lightgbm/Dockerfile .
docker push ccr.ccs.tencentyun.com/cube-studio/lightgbm:20230428

Dockerfile varie également d'une personne à l'autre. La principale chose à changer est les packages que vous devez installer et le dossier à utiliser launcher.py

FROM python:3.9

ENV TZ Asia/Shanghai
ENV DEBIAN_FRONTEND noninteractive

RUN /usr/local/bin/python -m pip install --upgrade pip

RUN pip install pysnooper psutil requests numpy scikit-learn pandas pyinstaller tinyaes joblib argparse 
#-i https://pypi.tuna.tsinghua.edu.cn/simple/
#http://pypi.douban.com/simple/ --trusted-host pypi.douban.com



COPY job/random_forest/launcher.py /app/

WORKDIR /app
ENV PYTHONPATH=/app:$PYTHONPATH

RUN pyinstaller --onefile --key=kaiqiao launcher.py && cp dist/launcher ./ && rm -rf launcher.py launcher.spec build dist

ENTRYPOINT ["./launcher"]

README.md est utilisé pour écrire les paramètres d'entrée, qui sont utilisés pour définir l'affichage frontal du modèle

# randomforest 模板
镜像：ccr.ccs.tencentyun.com/cube-studio/randomforest:20230427

参数
```bash
{
    "训练相关参数": {
      "--train_dataset": {
        "type": "str",
        "item_type": "str",
        "label": "训练数据集",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "训练数据集",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      },
      "--save_val_dir": {
        "type": "str",
        "item_type": "str",
        "label": "训练集和测试集acc输出文件地址",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "训练集和测试集acc输出文件地址,txt文件",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      },
      "--label_columns": {
        "type": "str",
        "item_type": "str",
        "label": "标签列",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "标签列，逗号分割",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      },
      "--save_model_dir": {
        "type": "str",
        "item_type": "str",
        "label": "模型保存目录",
        "require": 1,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "模型保存目录",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      } ,
      "--feature_columns": {
        "type": "str",
        "item_type": "str",
        "label": "特征列，逗号分隔",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "特征列，逗号分隔",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      }
    },
    "推理相关参数": {
      "--result_path": {
        "type": "str",
        "item_type": "str",
        "label": "推理结果保存路径",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "推理结果保存路径",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      },
      "--inference_dataset": {
        "type": "str",
        "item_type": "str",
        "label": "推理数据集",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "推理数据集",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      },
      "--save_model_dir": {
        "type": "str",
        "item_type": "str",
        "label": "模型保存目录",
        "require": 1,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "模型保存目录",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      },
      "--label_columns": {
        "type": "str",
        "item_type": "str",
        "label": "标签列",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "标签列，逗号分割",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      },
      "--feature_columns": {
        "type": "str",
        "item_type": "str",
        "label": "特征列，逗号分隔",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "特征列，逗号分隔",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      }
    },
    "验证相关参数": {
      "--val_dataset": {
        "type": "str",
        "item_type": "str",
        "label": "验证数据集",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "验证数据集",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      },
      "--save_model_dir": {
        "type": "str",
        "item_type": "str",
        "label": "模型保存目录",
        "require": 1,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "模型保存目录",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      },
      "--label_columns": {
        "type": "str",
        "item_type": "str",
        "label": "标签列",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "标签列，逗号分割",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      },
      "--feature_columns": {
        "type": "str",
        "item_type": "str",
        "label": "特征列，逗号分隔",
        "require": 0,
        "choice": [],
        "range": "",
        "default": "",
        "placeholder": "",
        "describe": "特征列，逗号分隔",
        "editable": 1,
        "condition": "",
        "sub_args": {}
      }
    }
}
```

4. Installez Docker et procédez comme suit

cd /data/k8s/kubeflow/pipeline/workspace/admin/cube-studio/job-template
sh job/random_forest/build.sh

3. Gestion des images

Ajoutez l'image générée avec succès tout à l'heure à la gestion des images, et le nom de l'image est le nom de l'image dans build.sh. 

4. Ajout de modèle

Ajouter des modèles de tâche dans la formation de modèle 

Il s'agit principalement de sélectionner l'image et de définir les paramètres de démarrage du modèle, c'est-à-dire le groupe de paramètres définis dans README.md

5. Créer un pipeline 

Accédez à la page d'accueil de la page et sélectionnez Nouveau pipeline

 Pour le modèle de gauche, faites glisser et déposez en fonction des besoins, cliquez sur le nœud de la tâche, définissez les paramètres d'exécution et vous pouvez l'exécuter

Ça marche comme ça

S'il y a un bogue, cliquez sur le nœud pour afficher le journal et résoudre le problème

C'est ça!