Présentation de la prédiction hors ligne - Platform For AI

Le composant de prédiction utilise les modèles entraînés par EasyVision pour effectuer des prédictions hors ligne dans Platform for AI (PAI). Cette rubrique décrit les formats de données d'entrée et les paramètres de commande PAI pour la prédiction hors ligne.

Vue d'ensemble

EasyVision lit les données depuis des tables MaxCompute et y écrit les résultats. Il peut également lire des fichiers Object Storage Service pour la prédiction, puis écrire les résultats dans des fichiers OSS. Le processus de prédiction hors ligne s'apparente à une chaîne de montage. Chaque opération atomique est traitée de manière asynchrone et simultanée par plusieurs threads sur chaque nœud worker. Lors des opérations d'E/S, chaque nœud worker obtient les données d'entrée via des shards et écrit les données dans les shards de sortie correspondants. Par exemple, lors de la lecture d'images depuis une table pour la prédiction de modèle, le système divise les données de la table d'entrée en fonction du nombre de nœuds workers. Chaque nœud worker lit ses propres données, décode les données Base64, exécute la prédiction du modèle et écrit les résultats dans la table de sortie. Plusieurs threads effectuent le décodage Base64 et la prédiction du modèle de manière asynchrone. Cette approche exploite pleinement la puissance de calcul du CPU et du GPU pour un traitement simultané. La figure suivante illustre les processus de décodage Base64 et de prédiction du modèle.

EasyVision fournit des modèles de prédiction au niveau vidéo pour traiter les données vidéo. Vous pouvez également appeler des modèles liés aux images pour prédire les trames vidéo. Le framework de traitement hors ligne d'EasyVision décode automatiquement les données vidéo, prédit les images frame par frame et agrège tous les résultats des trames vidéo.

Le code de prédiction par défaut fourni par EasyVision ne permet pas de charger des modèles entraînés pour la prédiction hors ligne. EasyVision vous permet de spécifier un code de prédiction personnalisé et de réutiliser la fonctionnalité d'E/S existante de ev_predict. Effectuez une prédiction hors ligne pour votre modèle en téléchargeant et en décodant les données. EasyVision vous permet également d'insérer un processus personnalisé avant la prédiction. Les données d'entrée sont traitées avant d'être envoyées au prédicteur. Pour plus d'informations, consultez la section Données d'entrée personnalisées.

Formats de données d'entrée

Lecture des données depuis des tables MaxCompute

La table d'entrée peut contenir une ou plusieurs colonnes. Une colonne est destinée aux URL encodées en Base64 ou aux données binaires des images. Les données de cette colonne sont de type string. Schéma d'exemple :

+------------------------------------------------------------------------------------+
| Field           | Type       | Label | Comment                                     |
+------------------------------------------------------------------------------------+
| id              | string     |       |                                             |
| url             | string     |       |                                             |
+------------------------------------------------------------------------------------+

Lecture des données depuis des fichiers OSS
Chaque ligne du fichier d'entrée OSS est une URL ou un endpoint OSS. Exemple :
```
oss://your/path/to/image.jpg
http://your.path/to/image.jpg
```
Données d'entrée personnalisées

Lorsque les données sont lues depuis une table MaxCompute, seule l'URL ou les données encodées en Base64 de l'image sont obtenues. Lorsque les données sont lues depuis un fichier OSS, seule l'URL de l'image est obtenue pour faciliter le téléchargement et le décodage de l'image. Les méthodes précédentes permettent d'obtenir uniquement des tableaux NumPy de l'image. Le format {"image": np.ndarray} est utilisé par divers processus et prédicteurs lors de la prédiction. Avec l'augmentation du nombre d'utilisateurs employant des prédicteurs et des processus personnalisés, le format d'entrée unique ne suffit plus à répondre aux exigences métier. Par conséquent, le mode de lecture OSS a été modifié pour prendre en charge les formats de données personnalisés.

Le format personnalisé peut être le format de fichier OSS original ou un format de chaîne JSON. Chaque ligne des fichiers d'entrée est une chaîne JSON. Saisissez plusieurs paires clé-valeur. Toutes les paires clé-valeur sont enregistrées dans un dictionnaire et transférées aux prédicteurs et processus personnalisés. Obtenez facilement les valeurs correspondantes en fonction des clés personnalisées.

Si la valeur est un chemin OSS ou une URL, le système utilise automatiquement plusieurs threads pour télécharger le contenu du fichier et convertit la valeur en un objet au format Python. Appelez la méthode de fichier telle que read() ou readlines() pour obtenir le contenu du fichier. Si la valeur pointe vers un fichier avec une extension d'image, le système décode automatiquement l'image. Obtenez la valeur à partir du dictionnaire input_data en fonction des clés. La valeur est de type numpy.ndarray.
Exemple de données d'entrée :
```
{"image":"http://your/path/to/image.jpg", "prior":"oss://your/path/to/prior.txt", "config": {"key1":1, "key2":"value2"}}
{"image":"http://your/path/to/image.jpg", "prior":"oss://your/path/to/prior.txt", "config": {"key2":1, "key2":"value2"}}
```
Les données d'entrée précédentes sont converties en données dans le dictionnaire input_data contenant les champs suivants :
- image: les données décodées d'une image.
- prior: l'objet au format fichier.
- config: un dictionnaire de chaînes JSON.
Le dictionnaire input_data est au format suivant. Pour toutes les classes de processus et de prédicteurs personnalisés, interrogez les données d'image en utilisant les clés.
```
input_dict = {
  "image": np.ndarray,
  "prior" : file_like_object,
  "config": {"key1":1, "key2":"value2"}
}
```
Important
Tous les prédicteurs intégrés d'EasyVision utilisent la clé image pour obtenir les images d'entrée. Si vous souhaitez utiliser un format d'entrée personnalisé pour appeler les prédicteurs intégrés d'EasyVision, vous devez utiliser la clé image pour les données d'image.

Paramètres

Paramètre	Obligatoire	Description	Type	Valeur par défaut
model_path	Oui	Le chemin OSS du modèle. Exemple : "oss://your_bucket/your_model_dir".	STRING	S/O
model_type	Oui	Le type de modèle. Valeurs valides : feature_extractor: extraction de caractéristiques classifier: classification d'images multilabel_classifier: classification multi-étiquettes detector: détection d'objets text_detector: détection de texte text_recognizer: reconnaissance de lignes de texte text_detection_recognition: détection et reconnaissance de texte text_spotter: reconnaissance de texte de bout en bout segmentor: segmentation sémantique d'images self_define: prédiction personnalisée Si vous définissez le paramètre model_type sur self_define, la classe de prédicteur spécifiée par le paramètre user_predictor_cls est chargée.	STRING	S/O
buckets	Oui	Les informations sur les buckets OSS. Si vous utilisez un modèle personnalisé, vous devez spécifier les informations du bucket OSS pour stocker le modèle. Exemple : "oss://{bucket_name}.{oss_host}/{path}".	STRING	S/O
arn	Oui	Le nom de ressource Alibaba Cloud (ARN) du rôle RAM disposant des autorisations d'accès aux ressources OSS. Pour plus d'informations sur l'obtention de l'ARN, consultez la section « Paramètres d'E/S » de la rubrique Paramètres des tâches PAI-TensorFlow.	STRING	S/O
feature_name	Non	Le nom de la caractéristique que vous souhaitez extraire. Ce paramètre est requis uniquement si vous définissez le paramètre model_type sur feature_extractor. Exemple : resnet_v1_50/logits.	STRING	Chaîne vide ("")
input_table	Non	Le nom de la table d'entrée. Par exemple, vous pouvez utiliser une table non partitionnée nommée "odps://prj_name/tables/table_name" ou une table partitionnée nommée "odps://prj_name/tables/table_name/pt=xxx".	STRING	Chaîne vide ("")
image_col	Non	Le nom de la colonne contenant les données d'image.	STRING	"image"
image_type	Non	Le format des données d'image. Valeurs valides : base64: indique que la table stocke les données d'image au format Base64. url: indique que la table stocke les URL ou les chemins OSS des images.	STRING	"base64"
reserved_columns	Non	Les noms des colonnes de données réservées. Séparez plusieurs noms par des virgules (,). Exemple : "col1,col2,col3".	STRING	Chaîne vide ("")
result_column	Non	Le nom de la colonne de résultat.	STRING	"prediction_result"
output_table	Non	La table de sortie. Le format de la valeur est identique à celui du paramètre input_table. Si la table n'existe pas, le système crée automatiquement une table de sortie et y crée des partitions. Vous pouvez également créer une table partitionnée comme table de sortie avant d'effectuer la prédiction.	STRING	Chaîne vide ("")
lifecycle	Non	Le cycle de vie de la table de sortie.	INT	10
num_worker	Non	Le nombre de nœuds workers de prédiction. Augmentez le nombre de nœuds workers pour accélérer la prédiction hors ligne.	INT	2
cpuRequired	Non	Le nombre de CPU pour un nœud worker. Une valeur de 100 indique un CPU.	INT	1600
gpuRequired	Non	Le nombre de GPU pour chaque nœud worker. Une valeur de 100 indique un GPU. Vous pouvez utiliser jusqu'à 100 GPU pour un nœud worker. Une valeur de 0 indique qu'un cluster CPU est utilisé.	INT	100
input_oss_file	Non	Le chemin du fichier OSS d'entrée. Chaque ligne du fichier d'entrée peut être dans l'un des formats suivants : Le chemin OSS ou l'URL d'une image que vous souhaitez prédire. Exemple : oss://your_bucket/filelist.txt. Une chaîne JSON. Pour plus d'informations, consultez la section Données d'entrée personnalisées.	STRING	Chaîne vide ("")
output_oss_file	Non	Le chemin du fichier OSS de sortie utilisé pour stocker les résultats de la prédiction. Le système peut générer plusieurs fichiers de résultats et les fusionner en un fichier OSS de sortie. Les fichiers de résultats sont préfixés par le nom du fichier OSS de sortie. Le nombre de fichiers de résultats est identique au nombre de nœuds workers, spécifié par le paramètre num_worker.	STRING	Chaîne vide ("")
output_dir	Non	Le dossier dans lequel les fichiers de sortie sont stockés. Exemple : "oss://your_bucket/dir". Si vous utilisez un format de sortie personnalisé, tous les fichiers image de résultats sont enregistrés dans ce dossier.	STRING	Chaîne vide ("")
user_resource	Non	Le chemin de la ressource téléchargée, qui peut être un fichier TAR.GZ, ZIP ou Python. Les chemins OSS et les URL HTTP sont pris en charge. Exemples : oss://xxx/a.tar.gz et http://example.com/c.zip.	STRING	Chaîne vide ("")
user_predictor_cls	Non	Le chemin du module de la classe de prédicteur personnalisé. Par exemple, si vous implémentez le Prédicteur A dans module.py, le chemin du module du Prédicteur A est module.A.	STRING	Chaîne vide ("")
user_process_config	Non	Les configurations de la classe de processus personnalisé. Utilisez les champs suivants pour configurer la classe de processus. Vous pouvez également configurer d'autres champs personnalisés. job_name: le nom de la classe de processus personnalisé. num_threads: le nombre de threads simultanés utilisés par la classe de processus personnalisé. batch_size: la taille du lot des données que vous souhaitez traiter. user_process_cls: le chemin du module de la classe de processus personnalisé. Par exemple, si vous implémentez le Processus A dans module.py, le chemin du module du Processus A est module.A. Exemple : '{["job_name":"myprocess","user_process_cls": module.ClassA"num_threads":2, "batch_size":1]}'	JSON	Chaîne vide ("")
queue_size	Non	La longueur de la file d'attente de cache.	INT	1024
batch_size	Non	La taille du lot pour la prédiction.	INT	1
preprocess_thread_num	Non	Le nombre de threads simultanés utilisés pour le prétraitement, tel que le décodage et le téléchargement d'images.	INT	4
predict_thread_num	Non	Le nombre de threads simultanés utilisés pour la prédiction.	INT	2
is_input_video	Non	Indique si l'entrée est une vidéo. Valeurs valides : true false	BOOL	false
use_image_predictor	Non	Indique si le prédicteur prend en charge uniquement l'entrée d'image.	BOOL	true
decode_type	Non	La méthode utilisée pour décoder les vidéos. Valeurs valides : 1 : intra uniquement 2 : keyframe uniquement 3 : sans bidirectionnel 4 : tout décoder	INT	4
sample_fps	Non	Le nombre de trames extraites pour l'échantillonnage par seconde.	FLOAT	5
reshape_size	Non	La taille des trames de sortie en pixels. Si vous définissez ce paramètre sur -1, les trames ne sont pas redimensionnées.	INT	-1
decode_batch_size	Non	Le nombre de trames décodées simultanément.	INT	10
decode_keep_size	Non	Le nombre de trames chevauchées dans différents lots.	INT	0
enableDynamicCluster	Non	Indique s'il faut activer la fonctionnalité de cluster dynamique. Si la fonctionnalité est activée, le basculement d'un seul nœud worker est autorisé. Si des exceptions de tâche se produisent fréquemment, nous vous recommandons d'activer la fonctionnalité de cluster dynamique. Valeurs valides : true false	BOOL	false
useSparseClusterSchema	Non	Si vous définissez le paramètre enableDynamicCluster sur true, vous devez également définir le paramètre useSparseClusterSchema sur true. Valeurs valides : true false	BOOL	false