Hosten Sie mehrere TensorFlow-Computer-Vision-Modelle mit Amazon SageMaker-Multimodell-Endpunkten

Amazon Sage Maker unterstützt Datenwissenschaftler und Entwickler bei der schnellen Vorbereitung, Erstellung, Schulung und Bereitstellung hochwertiger Machine Learning (ML)-Modelle, indem eine breite Palette von speziell für ML entwickelten Funktionen zusammengeführt wird. SageMaker beschleunigt die Innovation in Ihrem Unternehmen, indem es speziell entwickelte Tools für jeden Schritt der ML-Entwicklung bereitstellt, einschließlich Kennzeichnung, Datenaufbereitung, Feature-Engineering, statistische Verzerrungserkennung, AutoML, Training, Tuning, Hosting, Erklärbarkeit, Überwachung und Workflow-Automatisierung.

Unternehmen trainieren zunehmend ML-Modelle auf Basis individueller Nutzerdaten. Beispielsweise trainiert ein Bildfreigabedienst, der das Auffinden von Informationen im Internet ermöglicht, benutzerdefinierte Modelle basierend auf den hochgeladenen Bildern und dem Browserverlauf jedes Benutzers, um Empfehlungen für diesen Benutzer zu personalisieren. Das Unternehmen kann auch benutzerdefinierte Modelle basierend auf Suchthemen trainieren, um Bilder pro Thema zu empfehlen. Die Erstellung benutzerdefinierter ML-Modelle für jeden Anwendungsfall führt zu einer höheren Inferenzgenauigkeit, erhöht jedoch die Kosten für die Bereitstellung und Verwaltung von Modellen. Diese Herausforderungen werden noch größer, wenn nicht alle Modelle mit der gleichen Rate abgerufen werden, aber dennoch jederzeit verfügbar sein müssen.

SageMaker Endpunkte mit mehreren Modellen bieten eine skalierbare und kostengünstige Möglichkeit, eine große Anzahl von ML-Modellen in der Cloud bereitzustellen. SageMaker-Endpunkte mit mehreren Modellen ermöglichen Ihnen die Bereitstellung mehrerer ML-Modelle hinter einem einzigen Endpunkt und deren Bereitstellung mit einem einzigen Bereitstellungscontainer. Ihre Anwendung muss lediglich einen API-Aufruf mit dem Zielmodell an diesen Endpunkt einschließen, um eine Inferenz mit geringer Latenz und hohem Durchsatz zu erzielen. Anstatt für jedes einzelne Modell einen separaten Endpunkt zu bezahlen, können Sie viele Modelle zum Preis eines einzelnen Endpunkts hosten. Weitere Informationen zu SageMaker-Multimodell-Endpunkten finden Sie unter Sparen Sie Inferenzkosten, indem Sie Amazon SageMaker-Endpunkte mit mehreren Modellen verwenden.

In diesem Beitrag zeigen wir, wie Sie SageMaker-Multimodell-Endpunkte verwenden, um zwei Computer Vision-Modelle mit unterschiedlichen Modellarchitekturen und Datensätzen für die Bildklassifizierung zu hosten. In der Praxis können Sie Zehntausende von Modellen auf Endpunkten mit mehreren Modellen bereitstellen.

Lösungsübersicht

SageMaker-Endpunkte mit mehreren Modellen funktionieren mit mehreren Frameworks wie TensorFlow, PyTorch, MXNet und sklearn, und Sie können Erstellen Sie Ihren eigenen Container mit einem Multi-Model-Server. Endpunkte mit mehreren Modellen werden auch nativ in den folgenden beliebten integrierten SageMaker-Algorithmen unterstützt: XGBoost, Linearer Lerner, Zufällig geschnittener Wald (RCF) und K-Nächste Nachbarn (KNN). Sie können die von SageMaker bereitgestellten Container direkt verwenden, während Sie diese Algorithmen verwenden, ohne Ihren eigenen benutzerdefinierten Container erstellen zu müssen.

Das folgende Diagramm ist eine vereinfachte Darstellung, wie Sie mehrere (für diesen Beitrag sechs) Modelle mit SageMaker-Multimodell-Endpunkten hosten können. In der Praxis können Endpunkte mit mehreren Modellen Hunderte bis Zehntausende von ML-Modellen hinter einem Endpunkt aufnehmen. Wenn wir in unserer Architektur mehr Modelle hosten, indem wir Modellartefakte verwenden, die in Amazon Simple Storage-Service (Amazon S3) entladen Endpunkte mit mehreren Modellen dynamisch einige der am wenigsten verwendeten Modelle, um neuere Modelle zu unterstützen.

In diesem Beitrag zeigen wir, wie Sie zwei mit dem TensorFlow-Framework trainierte Computer Vision-Modelle hinter einem einzigen SageMaker-Multimodell-Endpunkt hosten. Wir benutzen das TensorFlow-Bereitstellung Container, der für Endpunkte mit mehreren Modellen aktiviert ist, um diese Modelle zu hosten. Für unser erstes Modell trainieren wir eine kleinere Version von AlexNet CNN um Bilder aus dem . zu klassifizieren CIFAR-10 Datensatz. Für das zweite Modell verwenden wir a VGG16 CNN-Modell vortrainiert auf dem IMAGEnet Datensatz und verfeinert auf die Gebärdensprach-Ziffern-Datensatz um Handsymbolbilder zu klassifizieren. Wir bieten auch eine voll funktionsfähige Notizbuch um alle Schritte zu demonstrieren.

Modell 1: CIFAR-10-Bildklassifizierung

CIFAR-10 ist ein Benchmark-Datensatz für die Bildklassifizierung in Computer Vision und ML. CIFAR-Bilder sind farbig (drei Kanäle) mit dramatischen Variationen in der Darstellung der Objekte. Es besteht aus 32 × 32 Farbbildern in 10 Klassen mit 6,000 Bildern pro Klasse. Es enthält 50,000 Trainingsbilder und 10,000 Testbilder. Die folgende Abbildung zeigt ein Beispiel der nach den Labels gruppierten Bilder.

Um den Bildklassifikator zu erstellen, verwenden wir eine vereinfachte Version des klassischen AlexNet CNN. Das Netzwerk besteht aus fünf Faltungs- und Pooling-Schichten und drei vollständig verbundenen Schichten. Unsere vereinfachte Architektur stapelt drei Faltungsschichten und zwei vollständig verbundene (dichte) Schichten.

Der erste Schritt besteht darin, den Datensatz in Trainings- und Testobjekte zu laden. Das TensorFlow-Framework stellt den CIFAR-Datensatz bereit, den wir mit der Methode load_data() laden können. Als nächstes skalieren wir die Eingabebilder neu, indem wir die Pixelwerte durch 255 teilen: [0,255] ⇒ [0,1]. Wir müssen auch die Etiketten vorbereiten mit One-Hot-Codierung. Eine heiße Codierung ist ein Prozess, bei dem die kategorialen Variablen in eine numerische Form umgewandelt werden. Das folgende Code-Snippet zeigt diese Schritte in Aktion:

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)

Nachdem das Dataset vorbereitet und für das Training bereit ist, wird es in Amazon S3 gespeichert, um von SageMaker verwendet zu werden. Die Modellarchitektur und der Trainingscode für den Bildklassifikator werden zu einem Trainingsskript (cifar_train.py). Um Stapel von Tensorbilddaten für den Trainingsprozess zu generieren, verwenden wir ImageDataGenerator. Dies ermöglicht es uns, Datenerweiterungstransformationen wie Rotations-, Breiten- und Höhenverschiebungen auf unsere Trainingsdaten anzuwenden.

Im nächsten Schritt verwenden wir das Trainingsskript, um einen TensorFlow-Schätzer mit dem SageMaker SDK zu erstellen (siehe folgenden Code). Wir verwenden den Schätzer, um das CNN-Modell an CIFAR-10-Eingänge anzupassen. Nach Abschluss des Trainings wird das Modell in Amazon S3 gespeichert.

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)

Später demonstrieren wir, wie dieses Modell unter Verwendung des SageMaker-Multimodell-Endpunkts neben unserem zweiten Modell (dem Klassifikator für Gebärdensprachenziffern) gehostet wird.

Modell 2: Klassifikation der Ziffern in Gebärdensprache

Für unser zweites Modell verwenden wir den Datensatz für Gebärdensprachenziffern. Dieser Datensatz unterscheidet die Ziffern der Gebärdensprache von 0–9. Das folgende Bild zeigt ein Beispiel des Datasets.

Der Datensatz enthält 100 x 100 Bilder in RGB-Farbe und hat 10 Klassen (Ziffern 0–9). Das Trainingsset enthält 1,712 Bilder, das Validierungsset 300 und das Testset 50.

Dieser Datensatz ist sehr klein. Das Training eines Netzwerks von Grund auf mit diesem kleinen Datensatz führt zu keinen guten Ergebnissen. Um eine höhere Genauigkeit zu erreichen, verwenden wir privaten Transfer lernen. Transferlernen ist normalerweise der erste Ansatz, wenn Sie ein Klassifizierungsprojekt starten, insbesondere wenn Sie nicht viele Trainingsdaten haben. Es migriert das aus dem Quell-Dataset erlernte Wissen in das Ziel-Dataset, um Trainingszeit und Rechenkosten zu sparen.

Um dieses Modell zu trainieren, verwenden wir ein vortrainiertes VGG16-CNN-Modell, das auf dem ImageNet-Datensatz trainiert wurde, und optimieren es, um mit unserem Gebärdensprach-Ziffern-Datensatz zu arbeiten. Ein vortrainiertes Modell ist ein Netzwerk, das zuvor an einem großen Datensatz trainiert wurde, typischerweise an einer groß angelegten Bildklassifizierungsaufgabe. Die von uns verwendete VGG16-Modellarchitektur hat insgesamt 13 Faltungsschichten. Da sich die Domäne des Gebärdensprach-Datasets von der Quelldomäne des ImageNet-Datasets unterscheidet, verfeinern wir nur die letzten Schichten. Feinabstimmung bezieht sich hier auf das Einfrieren einiger der Netzwerk-Layer, die für die Feature-Extraktion verwendet werden, und das gemeinsame Trainieren sowohl der nicht eingefrorenen Layer als auch der neu hinzugefügten Klassifikator-Layer des vortrainierten Modells.

Das Trainingsskript (sign_lingual_train.py) kapselt die Modellarchitektur und die Trainingslogik für den Klassifikator für Gebärdensprachenziffern. Zuerst laden wir die vortrainierten Gewichte aus dem VGG16-Netzwerk, das auf dem ImageNet-Datensatz trainiert wurde. Als Nächstes frieren wir einen Teil des Feature-Extraktor-Teils ein, gefolgt vom Hinzufügen der neuen Klassifikator-Layer. Schließlich kompilieren wir das Netzwerk und führen den Trainingsprozess durch, um das Modell für den kleineren Datensatz zu optimieren.

Als Nächstes verwenden wir dieses Trainingsskript, um einen TensorFlow-Schätzer mit dem SageMaker SDK zu erstellen. Dieser Schätzer wird verwendet, um den Klassifikator für Gebärdensprachenziffern an die bereitgestellten Eingaben anzupassen. Nach Abschluss der Schulung wird das Modell in Amazon S3 gespeichert, um von SageMaker-Multimodell-Endpunkten gehostet zu werden. Siehe folgenden Code:

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})

Bereitstellen eines Endpunkts mit mehreren Modellen

SageMaker-Endpunkte mit mehreren Modellen bieten eine skalierbare und kostengünstige Lösung für die Bereitstellung einer großen Anzahl von Modellen. Es verwendet einen freigegebenen Bereitstellungscontainer, der zum Hosten mehrerer Modelle aktiviert ist. Dies reduziert die Hosting-Kosten, indem die Endpunktauslastung im Vergleich zur Verwendung von Endpunkten mit einem einzigen Modell verbessert wird. Es reduziert auch den Bereitstellungsaufwand, da SageMaker das Laden von Modellen in den Speicher verwaltet und sie basierend auf den Datenverkehrsmustern zu ihnen skaliert.

Um den Multimodell-Endpunkt zu erstellen, müssen wir zunächst die trainierten Modelle für die einzelnen Schätzer (1 und 2) von ihren gespeicherten S3-Standorten in ein gemeinsames S3-Präfix kopieren, das vom Multimodell-Endpunkt verwendet werden kann:

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}

Nachdem die Modelle an den durch das S3-Präfix angegebenen gemeinsamen Speicherort kopiert wurden, erstellen wir ein Bereitstellungsmodell mithilfe der TensorFlowModel-Klasse aus dem SageMaker SDK. Das Bereitstellungsmodell wird für eines der Modelle erstellt, die unter dem Multi-Modell-Endpunkt gehostet werden sollen. In diesem Fall verwenden wir das erste Modell (den CIFAR-10-Bildklassifikator). Als Nächstes verwenden wir die MultiDataModel-Klasse aus dem SageMaker SDK, um ein Datenmodell mit mehreren Modellen unter Verwendung des Bereitstellungsmodells für model-1 zu erstellen, das wir im vorherigen Schritt erstellt haben:

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)

Schließlich stellen wir das MultiDataModel bereit, indem wir die Methode deploy() aufrufen und die Attribute bereitstellen, die zum Erstellen der Hosting-Infrastruktur erforderlich sind, die für die Unterstützung des Endpunkts mit mehreren Modellen erforderlich ist:

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

Der Bereitstellungsaufruf gibt eine Prädiktorinstanz zurück, mit der wir Rückschlussaufrufe durchführen können. Dies sehen wir im nächsten Abschnitt.

Testen Sie den Multi-Modell-Endpunkt für Echtzeit-Inferenz

Endpunkte mit mehreren Modellen ermöglichen die gemeinsame Nutzung von Speicherressourcen für Ihre Modelle. Wenn das zu referenzierende Modell bereits zwischengespeichert ist, führen Endpunkte mit mehreren Modellen die Inferenz sofort aus. Wenn das bestimmte angeforderte Modell andererseits nicht zwischengespeichert ist, muss SageMaker das Modell herunterladen, was die Latenz für diese erste Anforderung erhöht. Dies dauert jedoch nur einen Bruchteil der Zeit, die benötigt würde, um eine völlig neue Infrastruktur (Instanzen) zu starten, um das Modell einzeln auf SageMaker zu hosten. Nachdem ein Modell im Multimodell-Endpunkt zwischengespeichert wurde, werden nachfolgende Anforderungen in Echtzeit initiiert (es sei denn, das Modell wird entfernt). Dadurch können Sie viele Modelle von einer einzigen Instanz aus ausführen und unsere Modellmenge effektiv von unseren Bereitstellungskosten entkoppeln. Dies erleichtert die Verwaltung von ML-Bereitstellungen in großem Maßstab und senkt die Kosten für die Modellbereitstellung durch eine erhöhte Nutzung des Endpunkts und der zugrunde liegenden Recheninstanzen. Weitere Informationen und eine Demonstration von Kosteneinsparungen von über 90 % für ein 1,000-Modell-Beispiel finden Sie unter Sparen Sie Inferenzkosten mit Amazon SageMaker-Endpunkten mit mehreren Modellen.

Endpunkte mit mehreren Modellen entladen auch nicht verwendete Modelle aus dem Container, wenn die Instanzen, die den Endpunkt unterstützen, die Speicherkapazität erreichen und weitere Modelle in den Container geladen werden müssen. SageMaker löscht ungenutzte Modellartefakte vom Instanzspeichervolume, wenn das Volume seine Kapazität erreicht und neue Modelle heruntergeladen werden müssen. Der erste Aufruf eines neu hinzugefügten Modells dauert länger, da der Endpunkt Zeit braucht, um das Modell von Amazon S3 in den Speicher des Containers der Instances herunterzuladen, die den Multi-Model-Endpunkt unterstützen. Entladene Modelle verbleiben auf dem Speichervolume der Instanz und können später in den Speicher des Containers geladen werden, ohne erneut aus dem S3-Bucket heruntergeladen zu werden.

Sehen wir uns an, wie Sie eine Schlussfolgerung aus dem CIFAR-10-Bildklassifikator (Modell-1) ziehen, der unter dem Multi-Modell-Endpunkt gehostet wird. Zuerst laden wir ein Beispielbild aus einer der Klassen – Flugzeug – und bereiten es mit dem im vorherigen Schritt erstellten Prädiktor für den Versand an den Multi-Modell-Endpunkt vor.

Mit diesem Prädiktor können wir die Methode predict() zusammen mit dem Parameter initial_args aufrufen, der den Namen des aufzurufenden Zielmodells angibt. In diesem Fall ist das Zielmodell cifar.tar.gz. Das folgende Snippet demonstriert diesen Vorgang im Detail:

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}]')

Wenn Sie den vorherigen Code ausführen, wird die Vorhersageausgabe als Label-Flugzeug zurückgegeben, das von unserem bedienten Modell korrekt interpretiert wird:

Predicted Label: [airplane]

Als Nächstes sehen wir uns an, wie Sie den Ziffernklassifizierer für Gebärdensprache (Modell-2) dynamisch in einen Endpunkt mit mehreren Modellen laden, indem Sie den Endpunkt mit sign-language.tar.gz als Zielmodell aufrufen.

Wir verwenden das folgende Beispielbild der Handzeichenziffer 0.

Das folgende Snippet zeigt, wie Sie den Endpunkt mit mehreren Modellen mit dem Beispielbild aufrufen, um die richtige Antwort zurückzubekommen:

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}]')

Der folgende Code ist unsere Antwort mit dem Label 0:

Predicted Label: [0]

Zusammenfassung

In diesem Beitrag haben wir die SageMaker-Funktion demonstriert Endpunkte mit mehreren Modellen Inferenzkosten zu optimieren. Endpunkte mit mehreren Modellen sind nützlich, wenn Sie mit Hunderten bis Zehntausenden von Modellen arbeiten und nicht jedes Modell als einzelnen Endpunkt bereitstellen müssen. Modelle werden dynamisch geladen und entladen, je nach Nutzung und verfügbarer Speichermenge auf dem Endpunkt.

In diesem Beitrag wurde erläutert, wie mehrere mit dem TensorFlow-Framework trainierte Computer Vision-Modelle unter einem SageMaker-Multimodell-Endpunkt gehostet werden. Die Bildklassifizierungsmodelle wiesen unterschiedliche Modellarchitekturen auf und wurden auf unterschiedlichen Datensätzen trainiert. Das Notizbuch der Post beigefügt ist, enthält detaillierte Anweisungen zum Training und Hosting der Models.

Probieren Sie SageMaker-Endpunkte mit mehreren Modellen für Ihren Anwendungsfall aus und hinterlassen Sie Ihr Feedback in den Kommentaren.

Über die Autoren

Arunprasath Shankar ist ein auf AWS spezialisierter Lösungsarchitekt für künstliche Intelligenz und maschinelles Lernen (AI / ML), der globalen Kunden hilft, ihre KI-Lösungen effektiv und effizient in der Cloud zu skalieren. In seiner Freizeit sieht Arun gerne Science-Fiction-Filme und hört klassische Musik.

Markus Roy ist Principal Machine Learning Architect für AWS und hilft AWS-Kunden beim Design und Aufbau von KI/ML-Lösungen. Marks Arbeit deckt ein breites Spektrum von ML-Anwendungsfällen ab, wobei sein Hauptinteresse an Computer Vision, Deep Learning und der Skalierung von ML im gesamten Unternehmen liegt. Er hat Unternehmen in vielen Branchen unterstützt, darunter Versicherungen, Finanzdienstleistungen, Medien und Unterhaltung, Gesundheitswesen, Versorgungsunternehmen und Fertigung. Mark besitzt sechs AWS-Zertifizierungen, darunter die ML-Spezialzertifizierung. Bevor er zu AWS kam, war Mark mehr als 25 Jahre lang Architekt, Entwickler und Technologieführer, davon 19 Jahre im Finanzdienstleistungsbereich.

Quelle: https://aws.amazon.com/blogs/machine-learning/host-multiple-tensorflow-computer-vision-models-using-amazon-sagemaker-multi-model-endpoints/