Héberger plusieurs modèles de vision par ordinateur TensorFlow à l'aide de points de terminaison multimodèles Amazon SageMaker

Republié par Platon

Suiveurs: 0

Amazon Sage Maker aide les data scientists et les développeurs à préparer, créer, former et déployer rapidement des modèles de machine learning (ML) de haute qualité en rassemblant un large éventail de fonctionnalités spécialement conçues pour le ML. SageMaker accélère l'innovation au sein de votre organisation en fournissant des outils spécialement conçus pour chaque étape du développement ML, y compris l'étiquetage, la préparation des données, l'ingénierie des fonctionnalités, la détection des biais statistiques, AutoML, la formation, le réglage, l'hébergement, l'explicabilité, la surveillance et l'automatisation du workflow.

Les entreprises forment de plus en plus des modèles de ML basés sur les données des utilisateurs individuels. Par exemple, un service de partage d'images conçu pour permettre la découverte d'informations sur Internet forme des modèles personnalisés basés sur les images téléchargées et l'historique de navigation de chaque utilisateur afin de personnaliser les recommandations pour cet utilisateur. L'entreprise peut également former des modèles personnalisés basés sur des sujets de recherche pour recommander des images par sujet. La création de modèles de ML personnalisés pour chaque cas d'utilisation conduit à une plus grande précision d'inférence, mais augmente le coût de déploiement et de gestion des modèles. Ces défis deviennent plus prononcés lorsque tous les modèles ne sont pas accessibles au même rythme mais doivent toujours être disponibles à tout moment.

SageMaker points de terminaison multimodèle fournir un moyen évolutif et rentable de déployer un grand nombre de modèles de ML dans le cloud. Les points de terminaison multi-modèles SageMaker vous permettent de déployer plusieurs modèles de ML derrière un seul point de terminaison et de les servir à l'aide d'un conteneur de diffusion unique. Votre application doit simplement inclure un appel d'API avec le modèle cible vers ce point de terminaison pour obtenir une inférence à faible latence et à haut débit. Au lieu de payer pour un point de terminaison distinct pour chaque modèle, vous pouvez héberger de nombreux modèles pour le prix d'un seul point de terminaison. Pour plus d'informations sur les points de terminaison multi-modèles SageMaker, consultez Économisez sur les coûts d'inférence en utilisant des points de terminaison multimodèles Amazon SageMaker.

Dans cet article, nous montrons comment utiliser les points de terminaison multi-modèles SageMaker pour héberger deux modèles de vision par ordinateur avec des architectures de modèles et des ensembles de données différents pour la classification d'images. En pratique, vous pouvez déployer des dizaines de milliers de modèles sur des points de terminaison multi-modèles.

Présentation de la solution

Les points de terminaison multi-modèles SageMaker fonctionnent avec plusieurs frameworks, tels que TensorFlow, PyTorch, MXNet et sklearn, et vous pouvez construisez votre propre conteneur avec un serveur multi-modèle. Les points de terminaison multi-modèles sont également pris en charge de manière native dans les algorithmes intégrés SageMaker populaires suivants : XGBoost, Apprenant linéaire, Forêt coupée au hasard (RCF), et Les voisins les plus proches (KNN). Vous pouvez utiliser directement les conteneurs fournis par SageMaker tout en utilisant ces algorithmes sans avoir à créer votre propre conteneur personnalisé.

Le diagramme suivant est une illustration simplifiée de la façon dont vous pouvez héberger plusieurs (pour cet article, six) modèles à l'aide des points de terminaison multi-modèles SageMaker. En pratique, les points de terminaison multi-modèles peuvent accueillir des centaines à des dizaines de milliers de modèles de ML derrière un point de terminaison. Dans notre architecture, si nous hébergeons plus de modèles en utilisant des artefacts de modèle stockés dans Service de stockage simple Amazon (Amazon S3), les points de terminaison multi-modèles déchargent dynamiquement certains des modèles les moins utilisés pour s'adapter aux modèles plus récents.

Dans cet article, nous montrons comment héberger deux modèles de vision par ordinateur formés à l'aide du framework TensorFlow derrière un seul point de terminaison multi-modèle SageMaker. Nous utilisons le Servir TensorFlow conteneur activé pour les points de terminaison multi-modèles pour héberger ces modèles. Pour notre premier modèle, nous formons une version plus petite de AlexNet CNN pour classer les images de la CIFAR-10 base de données. Pour le deuxième modèle, nous utilisons un VGG16 Modèle CNN pré-entraîné sur le ImageNet ensemble de données et affiné sur le Ensemble de données sur les chiffres de la langue des signes pour classer les images de symboles de main. Nous fournissons également un entièrement fonctionnel cahier pour montrer toutes les étapes.

Modèle 1 : Classification des images CIFAR-10

CIFAR-10 est un ensemble de données de référence pour la classification d'images en vision par ordinateur et en ML. Les images de l'ICRA sont colorées (trois canaux) avec une variation dramatique dans la façon dont les objets apparaissent. Il se compose de 32 × 32 images couleur dans 10 classes, avec 6,000 50,000 images par classe. Il contient 10,000 XNUMX images d'entraînement et XNUMX XNUMX images de test. L'image suivante montre un échantillon des images regroupées par les étiquettes.

Pour construire le classificateur d'images, nous utilisons une version simplifiée du classique AlexNet CNN. Le réseau est composé de cinq couches convolutives et de mise en commun, et de trois couches entièrement connectées. Notre architecture simplifiée empile trois couches convolutives et deux couches entièrement connectées (denses).

La première étape consiste à charger l'ensemble de données dans des objets d'apprentissage et de test. Le framework TensorFlow fournit l'ensemble de données CIFAR que nous pouvons charger à l'aide de la méthode load_data(). Ensuite, nous redimensionnons les images d'entrée en divisant les valeurs de pixels par 255 : [0,255] ⇒ [0,1]. Nous devons également préparer les étiquettes en utilisant encodage à chaud. Un encodage à chaud est un processus par lequel les variables catégorielles sont converties en une forme numérique. L'extrait de code suivant montre ces étapes en action :

from tensorflow.keras.datasets import cifar10 # load dataset
(X_train, y_train), (X_test, y_test) = cifar10.load_data() # rescale input images
X_train = X_train.astype('float32')/255
X_test = X_test.astype('float32')/255 # one hot encode target labels
num_classes = len(np.unique(y_train))
y_train = utils.to_categorical(y_train, num_classes)
y_test = utils.to_categorical(y_test, num_classes)

Une fois l'ensemble de données préparé et prêt pour la formation, il est enregistré sur Amazon S3 pour être utilisé par SageMaker. L'architecture du modèle et le code d'apprentissage du classificateur d'images sont assemblés dans un script d'apprentissage (cifar_train.py). Pour générer des lots de données d'images de tenseurs pour le processus d'apprentissage, nous utilisons ImageDataGenerator. Cela nous permet d'appliquer des transformations d'augmentation de données telles que des changements de rotation, de largeur et de hauteur à nos données d'entraînement.

Dans l'étape suivante, nous utilisons le script de formation pour créer un estimateur TensorFlow à l'aide du SDK SageMaker (voir le code suivant). Nous utilisons l'estimateur pour ajuster le modèle CNN sur les entrées CIFAR-10. Une fois la formation terminée, le modèle est enregistré sur Amazon S3.

from sagemaker.tensorflow import TensorFlow model_name = 'cifar-10' hyperparameters = {'epochs': 50} estimator_parameters = {'entry_point':'cifar_train.py', 'instance_type': 'ml.m5.2xlarge', 'instance_count': 2, 'model_dir': f'/opt/ml/model', 'role': role, 'hyperparameters': hyperparameters, 'output_path': f's3://{BUCKET}/{PREFIX}/cifar_10/out', 'base_job_name': f'mme-cv-{model_name}', 'framework_version': TF_FRAMEWORK_VERSION, 'py_version': 'py37', 'script_mode': True} estimator_1 = TensorFlow(**estimator_parameters) estimator_1.fit(inputs)

Plus tard, nous montrons comment héberger ce modèle à l'aide du point de terminaison multi-modèle SageMaker aux côtés de notre deuxième modèle (le classificateur de chiffres en langue des signes).

Modèle 2 : Classification des chiffres de la langue des signes

Pour notre deuxième modèle, nous utilisons l'ensemble de données des chiffres de la langue des signes. Cet ensemble de données distingue les chiffres de la langue des signes de 0 à 9. L'image suivante montre un exemple de l'ensemble de données.

L'ensemble de données contient 100 x 100 images en couleur RVB et comporte 10 classes (chiffres 0-9). L'ensemble d'apprentissage contient 1,712 images, l'ensemble de validation 300 et l'ensemble de test 50.

Cet ensemble de données est très petit. Former un réseau à partir de zéro sur ce petit ensemble de données ne donne pas de bons résultats. Pour obtenir une plus grande précision, nous utilisons transférer apprentissage. L'apprentissage par transfert est généralement l'approche privilégiée lors du démarrage d'un projet de classification, en particulier lorsque vous n'avez pas beaucoup de données de formation. Il migre les connaissances acquises de l'ensemble de données source vers l'ensemble de données cible, pour économiser du temps de formation et des coûts de calcul.

Pour entraîner ce modèle, nous utilisons un modèle CNN VGG16 pré-entraîné formé sur l'ensemble de données ImageNet et l'affinons pour qu'il fonctionne sur notre ensemble de données de chiffres en langue des signes. Un modèle pré-entraîné est un réseau qui a été préalablement formé sur un grand ensemble de données, généralement sur une tâche de classification d'images à grande échelle. L'architecture du modèle VGG16 que nous utilisons comporte 13 couches convolutives au total. Pour l'ensemble de données en langue des signes, comme son domaine est différent du domaine source de l'ensemble de données ImageNet, nous n'affinons que les dernières couches. Le réglage précis ici fait référence au gel de quelques-unes des couches réseau utilisées pour l'extraction de caractéristiques et à l'entraînement conjoint des couches non gelées et des couches de classificateur nouvellement ajoutées du modèle pré-entraîné.

Le script de formation (train_langue_des_signes.py) encapsule l'architecture du modèle et la logique d'apprentissage pour le classificateur de chiffres en langue des signes. Tout d'abord, nous chargeons les poids pré-entraînés du réseau VGG16 entraînés sur l'ensemble de données ImageNet. Ensuite, nous gelons une partie de la partie extracteur de caractéristiques, puis nous ajoutons les nouvelles couches de classificateur. Enfin, nous compilons le réseau et exécutons le processus de formation pour optimiser le modèle pour le plus petit ensemble de données.

Ensuite, nous utilisons ce script de formation pour créer un estimateur TensorFlow à l'aide du SDK SageMaker. Cet estimateur est utilisé pour ajuster le classificateur de chiffres de la langue des signes sur les entrées fournies. Une fois la formation terminée, le modèle est enregistré sur Amazon S3 pour être hébergé par les points de terminaison multi-modèles SageMaker. Voir le code suivant :

model_name = 'sign-language' hyperparameters = {'epochs': 50} estimator_parameters = {'entry_point':'sign_language_train.py', 'instance_type': 'ml.m5.2xlarge', 'instance_count': 2, 'hyperparameters': hyperparameters, 'model_dir': f'/opt/ml/model', 'role': role, 'output_path': f's3://{BUCKET}/{PREFIX}/sign_language/out', 'base_job_name': f'cv-{model_name}', 'framework_version': TF_FRAMEWORK_VERSION, 'py_version': 'py37', 'script_mode': True} estimator_2 = TensorFlow(**estimator_parameters) estimator_2.fit({'train': train_input, 'val': val_input})

Déployer un point de terminaison multi-modèle

Les points de terminaison multi-modèles SageMaker offrent une solution évolutive et rentable pour déployer un grand nombre de modèles. Il utilise un conteneur de diffusion partagé qui est activé pour héberger plusieurs modèles. Cela réduit les coûts d'hébergement en améliorant l'utilisation des points de terminaison par rapport à l'utilisation de points de terminaison à modèle unique. Cela réduit également la surcharge de déploiement car SageMaker gère le chargement des modèles en mémoire et leur mise à l'échelle en fonction des modèles de trafic vers eux.

Pour créer le point de terminaison multi-modèle, nous devons d'abord copier les modèles entraînés pour les estimateurs individuels (1 et 2) de leurs emplacements S3 enregistrés vers un préfixe S3 commun qui peut être utilisé par le point de terminaison multi-modèle :

tf_model_1 = estimator_1.model_data
output_1 = f's3://{BUCKET}/{PREFIX}/mme/cifar.tar.gz' tf_model_2 = estimator_2.model_data
output_2 = f's3://{BUCKET}/{PREFIX}/mme/sign-language.tar.gz' !aws s3 cp {tf_model_1} {output_1}
!aws s3 cp {tf_model_2} {output_2}

Une fois les modèles copiés vers l'emplacement commun désigné par le préfixe S3, nous créons un modèle de diffusion à l'aide de la classe TensorFlowModel du SDK SageMaker. Le modèle de diffusion est créé pour l'un des modèles à héberger sous le point de terminaison multi-modèle. Dans ce cas, nous utilisons le premier modèle (le classificateur d'images CIFAR-10). Ensuite, nous utilisons la classe MultiDataModel du SDK SageMaker pour créer un modèle de données multi-modèle à l'aide du modèle de service pour le modèle-1, que nous avons créé à l'étape précédente :

from sagemaker.tensorflow.serving import TensorFlowModel
from sagemaker.multidatamodel import MultiDataModel model_1 = TensorFlowModel(model_data=output_1, role=role, image_uri=IMAGE_URI) mme = MultiDataModel(name=f'mme-tensorflow-{current_time}', model_data_prefix=model_data_prefix, model=model_1, sagemaker_session=sagemaker_session)

Enfin, nous déployons le MultiDataModel en appelant la méthode deploy(), en fournissant les attributs nécessaires pour créer l'infrastructure d'hébergement requise pour sauvegarder le point de terminaison multi-modèle :

predictor = mme.deploy(initial_instance_count=2, instance_type='ml.m5.2xlarge', endpoint_name=f'mme-tensorflow-{current_time}')

L'appel de déploiement renvoie une instance de prédicteur, que nous pouvons utiliser pour effectuer des appels d'inférence. Nous le voyons dans la section suivante.

Tester le point de terminaison multi-modèle pour l'inférence en temps réel

Les points de terminaison multi-modèles permettent de partager les ressources mémoire entre vos modèles. Si le modèle à référencer est déjà mis en cache, les points de terminaison multi-modèles exécutent immédiatement l'inférence. D'un autre côté, si le modèle demandé particulier n'est pas mis en cache, SageMaker doit télécharger le modèle, ce qui augmente la latence pour cette demande initiale. Cependant, cela ne prend qu'une fraction du temps qu'il faudrait pour lancer une toute nouvelle infrastructure (instances) pour héberger le modèle individuellement sur SageMaker. Une fois qu'un modèle est mis en cache dans le point de terminaison multi-modèle, les demandes suivantes sont lancées en temps réel (sauf si le modèle est supprimé). En conséquence, vous pouvez exécuter de nombreux modèles à partir d'une seule instance, en découplant efficacement notre quantité de modèles de notre coût de déploiement. Cela facilite la gestion des déploiements de ML à grande échelle et réduit les coûts de déploiement de votre modèle grâce à une utilisation accrue du point de terminaison et de ses instances de calcul sous-jacentes. Pour plus d'informations et une démonstration des économies de coûts de plus de 90 % pour un exemple de 1,000 XNUMX modèles, voir Économisez sur les coûts d'inférence à l'aide des points de terminaison multi-modèles Amazon SageMaker.

Les points de terminaison multi-modèles déchargent également les modèles inutilisés du conteneur lorsque les instances qui soutiennent le point de terminaison atteignent la capacité de mémoire et que davantage de modèles doivent être chargés dans son conteneur. SageMaker supprime les artefacts de modèle inutilisés du volume de stockage d'instance lorsque le volume atteint sa capacité et que de nouveaux modèles doivent être téléchargés. Le premier appel à un modèle nouvellement ajouté prend plus de temps car le point de terminaison met du temps à télécharger le modèle depuis Amazon S3 vers la mémoire du conteneur des instances qui soutiennent le point de terminaison multi-modèle. Les modèles déchargés restent sur le volume de stockage de l'instance et peuvent être chargés ultérieurement dans la mémoire du conteneur sans être à nouveau téléchargés à partir du compartiment S3.

Voyons comment faire une inférence à partir du classificateur d'images CIFAR-10 (modèle-1) hébergé sous le point de terminaison multi-modèle. Tout d'abord, nous chargeons un exemple d'image de l'une des classes (avion) et la préparons à être envoyée au point de terminaison multimodèle à l'aide du prédicteur que nous avons créé à l'étape précédente.

Avec ce prédicteur, nous pouvons appeler la méthode predict() avec le paramètre initial_args, qui spécifie le nom du modèle cible à invoquer. Dans ce cas, le modèle cible est cifar.tar.gz. L'extrait suivant illustre ce processus en détail :

img = load_img('./data/cifar_10/raw_images/airplane.png', target_size=(32, 32))
data = img_to_array(img)
data = data.astype('float32')
data = data / 255.0
data = data.reshape(1, 32, 32, 3)
payload = {'instances': data}
y_pred = predictor.predict(data=payload, initial_args={'TargetModel': 'cifar.tar.gz'})
predicted_label = CIFAR10_LABELS[np.argmax(y_pred)]
print(f'Predicted Label: [{predicted_label}]')

L'exécution du code précédent renvoie la sortie de prédiction en tant qu'étiquette avion, qui est correctement interprétée par notre modèle servi :

Predicted Label: [airplane]

Voyons ensuite comment charger dynamiquement le classificateur de chiffres en langue des signes (model-2) dans un point de terminaison multi-modèle en appelant le point de terminaison avec sign-language.tar.gz comme modèle cible.

Nous utilisons l'exemple d'image suivant du chiffre 0 du signe de la main.

L'extrait de code suivant montre comment appeler le point de terminaison multi-modèle avec l'exemple d'image pour obtenir la réponse correcte :

test_path = './data/sign_language/test'
img = mpimg.imread(f'{test_path}/0/IMG_4159.JPG') def path_to_tensor(img_path): # loads RGB image as PIL.Image.Image type img = image.load_img(img_path, target_size=(224, 224)) # convert PIL.Image.Image type to 3D tensor with shape (224, 224, 3) x = image.img_to_array(img) # convert 3D tensor to 4D tensor with shape (1, 224, 224, 3) and return 4D tensor return np.expand_dims(x, axis=0) data = path_to_tensor(f'{test_path}/0/IMG_4159.JPG')
payload = {'instances': data}
y_pred = predictor.predict(data=payload, initial_args={'TargetModel': 'sign-language.tar.gz'})predicted_label = np.argmax(y_pred)
print(f'Predicted Label: [{predicted_label}]')

Le code suivant est notre réponse, avec l'étiquette 0 :

Predicted Label: [0]

Conclusion

Dans cet article, nous avons présenté la fonctionnalité SageMaker points de terminaison multimodèle pour optimiser les coûts d'inférence. Les points de terminaison multi-modèles sont utiles lorsque vous traitez des centaines à des dizaines de milliers de modèles et lorsque vous n'avez pas besoin de déployer chaque modèle en tant que point de terminaison individuel. Les modèles sont chargés et déchargés dynamiquement, en fonction de l'utilisation et de la quantité de mémoire disponible sur le point de terminaison.

Cet article a expliqué comment héberger plusieurs modèles de vision par ordinateur formés à l'aide du framework TensorFlow sous un point de terminaison multi-modèle SageMaker. Les modèles de classification d'images étaient d'architectures de modèles différentes et entraînés sur différents ensembles de données. le cahier inclus avec le message fournit des instructions détaillées sur la formation et l'hébergement des modèles.

Essayez les points de terminaison multi-modèles SageMaker pour votre cas d'utilisation et laissez vos commentaires dans les commentaires.

À propos des auteurs

Arunprasath Shankar est un architecte de solutions spécialisé en intelligence artificielle et apprentissage automatique (AI / ML) avec AWS, qui aide les clients du monde entier à faire évoluer leurs solutions d'IA de manière efficace et efficiente dans le cloud. Dans ses temps libres, Arun aime regarder des films de science-fiction et écouter de la musique classique.

Marc Roy est un architecte principal d'apprentissage automatique pour AWS, aidant les clients AWS à concevoir et à créer des solutions d'IA/ML. Le travail de Mark couvre un large éventail de cas d'utilisation du ML, avec un intérêt principal pour la vision par ordinateur, l'apprentissage en profondeur et la mise à l'échelle du ML dans toute l'entreprise. Il a aidé des entreprises dans de nombreux secteurs, notamment les assurances, les services financiers, les médias et le divertissement, les soins de santé, les services publics et la fabrication. Mark détient six certifications AWS, dont la certification de spécialité ML. Avant de rejoindre AWS, Mark a été architecte, développeur et leader technologique pendant plus de 25 ans, dont 19 ans dans les services financiers.