batch inference

Boîte à outils d'inférence par lots

Batch Inference Toolkit (batch-inference) est un package Python qui regroupe dynamiquement les tenseurs d'entrée du modèle provenant de plusieurs requêtes, exécute le modèle, dégroupe les tenseurs de sortie, puis les renvoie respectivement à chaque requête. Cela améliorera le débit du système grâce à un meilleur parallélisme de calcul et une meilleure localisation du cache. L'ensemble du processus est transparent pour les développeurs.

Quand utiliser

Lorsque vous souhaitez héberger l'inférence de modèle Deep Learning sur des serveurs Cloud, notamment sur GPU

Pourquoi utiliser

Il peut améliorer le débit de votre serveur jusqu'à plusieurs fois

Avantage de l'inférence par lots

• Bibliothèque Python légère indépendante de la plate-forme
• Seules quelques modifications de code de lignes sont nécessaires pour l'intégration à l'aide d'algorithmes de traitement par lots intégrés
• API flexibles pour prendre en charge des algorithmes de traitement par lots et des types d'entrée personnalisés
• Prise en charge du mode distant multi-processus pour éviter le goulot d'étranglement de Python GIL
• Tutoriels et benchmarks sur des modèles populaires :

Modèle	Débit par rapport à la ligne de base	Links
Bert Intégration	4,7x	Tutoriel
Achèvement des GPT	16x	Tutoriel

Installation

Installer depuis Pip

python -m pip install batch-inference --upgrade

Construire et installer à partir de la source (pour les développeurs)

git clone https://github.com/microsoft/batch-inference.git
python -m pip install -e .[docs,testing]

# if you want to format the code before commit
pip install pre-commit
pre-commit install

# run unittests
python -m unittest discover tests

Exemple

Commençons par un modèle jouet pour apprendre les API. Tout d'abord, vous devez définir une méthode Predict_batch dans votre classe de modèle, puis ajouter le décorateur de traitement par lots à votre classe de modèle.

Le décorateur par lots ajoute la méthode host() pour créer un objet ModelHost . La méthode prédictive de ModelHost prend une seule requête en entrée et fusionnera plusieurs requêtes en un lot avant d'appeler la méthode prédict_batch . La méthode prédictive divise également les sorties de la méthode prédict_batch avant de renvoyer le résultat.

 import numpy as np
from batch_inference import batching
from batch_inference . batcher . concat_batcher import ConcatBatcher

@ batching ( batcher = ConcatBatcher (), max_batch_size = 32 )
class MyModel :
    def __init__ ( self , k , n ):
        self . weights = np . random . randn ( k , n ). astype ( "f" )

    # shape of x: [batch_size, m, k]
    def predict_batch ( self , x ):
        y = np . matmul ( x , self . weights )
        return y

# initialize MyModel with k=3 and n=3
host = MyModel . host ( 3 , 3 )
host . start ()

# shape of x: [1, 3, 3]
def process_request ( x ):
    y = host . predict ( x )
    return y

host . stop ()

Batcher est chargé de fusionner les requêtes et de diviser les sorties. Dans ce cas, ConcatBatcher concaténera les tenseurs d'entrée en tenseurs groupés en première dimension. Nous fournissons un ensemble de Batchers intégrés pour les scénarios courants, et vous pouvez également implémenter votre propre Batcher. Voir Qu'est-ce que Batcher pour plus d'informations.