Host meerdere TensorFlow computervisie-modellen met behulp van Amazon SageMaker-eindpunten met meerdere modellen

Amazon Sage Maker helpt datawetenschappers en ontwikkelaars om snel hoogwaardige modellen voor machine learning (ML) voor te bereiden, te bouwen, te trainen en te implementeren door een brede reeks mogelijkheden samen te brengen die speciaal zijn ontwikkeld voor ML. SageMaker versnelt innovatie binnen uw organisatie door speciaal ontwikkelde tools te bieden voor elke stap van ML-ontwikkeling, inclusief labeling, gegevensvoorbereiding, feature-engineering, statistische biasdetectie, AutoML, training, afstemming, hosting, uitlegbaarheid, monitoring en workflowautomatisering.

Bedrijven trainen steeds vaker ML-modellen op basis van individuele gebruikersgegevens. Een service voor het delen van afbeeldingen die is ontworpen om het ontdekken van informatie op internet mogelijk te maken, traint bijvoorbeeld aangepaste modellen op basis van de geüploade afbeeldingen en browsegeschiedenis van elke gebruiker om aanbevelingen voor die gebruiker te personaliseren. Het bedrijf kan ook aangepaste modellen trainen op basis van zoekonderwerpen om afbeeldingen per onderwerp aan te bevelen. Het bouwen van aangepaste ML-modellen voor elke use case leidt tot een hogere nauwkeurigheid van gevolgtrekkingen, maar verhoogt de kosten van het implementeren en beheren van modellen. Deze uitdagingen worden groter wanneer niet alle modellen in hetzelfde tempo worden gebruikt, maar toch altijd beschikbaar moeten zijn.

SageMaker eindpunten met meerdere modellen bieden een schaalbare en kosteneffectieve manier om grote aantallen ML-modellen in de cloud te implementeren. Met SageMaker-eindpunten met meerdere modellen kunt u meerdere ML-modellen achter een enkel eindpunt implementeren en deze bedienen met een enkele servercontainer. Uw toepassing hoeft alleen maar een API-aanroep met het doelmodel naar dit eindpunt op te nemen om inferentie met lage latentie en hoge doorvoer te bereiken. In plaats van te betalen voor een afzonderlijk eindpunt voor elk afzonderlijk model, kunt u veel modellen hosten voor de prijs van een enkel eindpunt. Voor meer informatie over SageMaker multi-model endpoints, zie: Bespaar op interferentiekosten met behulp van Amazon SageMaker multi-model eindpunten.

In dit bericht laten we zien hoe u SageMaker-eindpunten met meerdere modellen kunt gebruiken om twee computervisiemodellen te hosten met verschillende modelarchitecturen en datasets voor beeldclassificatie. In de praktijk kunt u tienduizenden modellen implementeren op multi-model endpoints.

Overzicht van de oplossing

SageMaker-eindpunten met meerdere modellen werken met verschillende frameworks, zoals TensorFlow, PyTorch, MXNet en sklearn, en u kunt bouw uw eigen container met een server met meerdere modellen. Eindpunten met meerdere modellen worden ook standaard ondersteund in de volgende populaire ingebouwde algoritmen van SageMaker: XGBoost, Lineaire leerling, Willekeurig gekapt bos (RCF), en K-dichtstbijzijnde buren (KNN). U kunt de door SageMaker geleverde containers direct gebruiken terwijl u deze algoritmen gebruikt zonder dat u uw eigen aangepaste container hoeft te bouwen.

Het volgende diagram is een vereenvoudigde illustratie van hoe u meerdere (voor dit bericht zes) modellen kunt hosten met behulp van SageMaker-eindpunten met meerdere modellen. In de praktijk kunnen multi-model endpoints honderden tot tienduizenden ML-modellen achter een endpoint accommoderen. Als we in onze architectuur meer modellen hosten met behulp van modelartefacten die zijn opgeslagen in Amazon eenvoudige opslagservice (Amazon S3), multi-model endpoints ontladen dynamisch enkele van de minst gebruikte modellen om plaats te bieden aan nieuwere modellen.

In dit bericht laten we zien hoe u twee computervisiemodellen kunt hosten die zijn getraind met behulp van het TensorFlow-framework achter een enkel SageMaker-eindpunt met meerdere modellen. Wij gebruiken de TensorFlow-serveren container ingeschakeld voor eindpunten met meerdere modellen om deze modellen te hosten. Voor ons eerste model trainen we een kleinere versie van AlexNet CNN om afbeeldingen van de . te classificeren CIFAR-10 gegevensset. Voor het tweede model gebruiken we a VGG16 CNN-model vooraf getraind op de on IMAGEnet dataset en verfijnd op de Gegevensset gebarentaalcijfers om afbeeldingen van handsymbolen te classificeren. We bieden ook een volledig functionele notitieboekje om alle stappen te demonstreren.

Model 1: CIFAR-10 beeldclassificatie

CIFAR-10 is een benchmark dataset voor beeldclassificatie in computer vision en ML. CIFAR-afbeeldingen zijn gekleurd (drie kanalen) met dramatische variatie in hoe de objecten verschijnen. Het bestaat uit 32 × 32 kleurenafbeeldingen in 10 klassen, met 6,000 afbeeldingen per klas. Het bevat 50,000 trainingsbeelden en 10,000 testbeelden. De volgende afbeelding toont een voorbeeld van de afbeeldingen gegroepeerd op de labels.

Om de afbeeldingsclassificatie te bouwen, gebruiken we een vereenvoudigde versie van de klassieke AlexNet CNN. Het netwerk bestaat uit vijf convolutionele en pooling-lagen en drie volledig verbonden lagen. Onze vereenvoudigde architectuur stapelt drie convolutionele lagen en twee volledig verbonden (dichte) lagen.

De eerste stap is het laden van de dataset in trein- en testobjecten. Het TensorFlow-framework biedt de CIFAR-gegevensset die we kunnen laden met behulp van de methode load_data(). Vervolgens herschalen we de invoerafbeeldingen door de pixelwaarden te delen door 255: [0,255] ⇒ [0,1]. We moeten ook de labels voorbereiden met: een-hot codering. Een hete codering is een proces waarbij de categorische variabelen worden omgezet in een numerieke vorm. Het volgende codefragment toont deze stappen in actie:

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)

Nadat de dataset is voorbereid en klaar is voor training, wordt deze opgeslagen op Amazon S3 om te worden gebruikt door SageMaker. De modelarchitectuur en de trainingscode voor de beeldclassificator worden samengevoegd tot een trainingsscript (cifar_train.py). Om batches met tensorbeeldgegevens voor het trainingsproces te genereren, gebruiken we ImageDataGenerator. Dit stelt ons in staat om gegevensvergrotingstransformaties zoals rotatie-, breedte- en hoogteverschuivingen toe te passen op onze trainingsgegevens.

In de volgende stap gebruiken we het trainingsscript om een ​​TensorFlow-schatter te maken met behulp van de SageMaker SDK (zie de volgende code). We gebruiken de schatter om het CNN-model op CIFAR-10-ingangen te passen. Wanneer de training is voltooid, wordt het model opgeslagen op 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)

Later laten we zien hoe we dit model kunnen hosten met behulp van SageMaker multi-model endpoint naast ons tweede model (de classificatie van gebarentaalcijfers).

Model 2: Classificatie van gebarentaalcijfers

Voor ons tweede model gebruiken we de dataset gebarentaalcijfers. Deze dataset onderscheidt de gebarentaalcijfers van 0–9. In de volgende afbeelding ziet u een voorbeeld van de gegevensset.

De dataset bevat 100 x 100 afbeeldingen in RGB-kleur en heeft 10 klassen (cijfers 0–9). De trainingsset bevat 1,712 afbeeldingen, de validatieset 300 en de testset 50.

Deze dataset is erg klein. Het trainen van een netwerk vanaf het begin op deze kleine dataset levert geen goede resultaten op. Om een ​​hogere nauwkeurigheid te bereiken, gebruiken we: overdracht leren. Overdracht van leren is meestal de beste aanpak bij het starten van een classificatieproject, vooral als je niet veel trainingsgegevens hebt. Het migreert de opgedane kennis van de brondataset naar de doeldataset, om trainingstijd en rekenkosten te besparen.

Om dit model te trainen, gebruiken we een vooraf getraind VGG16 CNN-model dat is getraind op de ImageNet-dataset en finetunen we het om te werken aan onze gebarentaalcijfers-dataset. Een vooraf getraind model is een netwerk dat eerder is getraind op een grote dataset, meestal op een grootschalige afbeeldingsclassificatietaak. De VGG16-modelarchitectuur die we gebruiken, heeft in totaal 13 convolutionele lagen. Omdat het domein van de gebarentaaldataset verschilt van het brondomein van de ImageNet-dataset, finetunen we alleen de laatste paar lagen. Verfijning verwijst hier naar het bevriezen van enkele netwerklagen die worden gebruikt voor het extraheren van kenmerken, en het gezamenlijk trainen van zowel de niet-bevroren lagen als de nieuw toegevoegde classificatielagen van het vooraf getrainde model.

Het trainingsscript (sign_taal_train.py) omvat de modelarchitectuur en de trainingslogica voor de classificatie van gebarentaalcijfers. Eerst laden we de vooraf getrainde gewichten van het VGG16-netwerk dat is getraind op de ImageNet-dataset. Vervolgens bevriezen we een deel van het feature-extractorgedeelte, gevolgd door het toevoegen van de nieuwe classificatielagen. Ten slotte compileren we het netwerk en voeren we het trainingsproces uit om het model voor de kleinere dataset te optimaliseren.

Vervolgens gebruiken we dit trainingsscript om een ​​TensorFlow-schatter te maken met behulp van de SageMaker SDK. Deze schatter wordt gebruikt om de classificatie van gebarentaalcijfers op de geleverde inputs te passen. Wanneer de training is voltooid, wordt het model opgeslagen op Amazon S3 om te worden gehost door SageMaker-eindpunten met meerdere modellen. Zie de volgende 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})

Een eindpunt met meerdere modellen implementeren

SageMaker multi-model endpoints bieden een schaalbare en kosteneffectieve oplossing om grote aantallen modellen te implementeren. Het maakt gebruik van een gedeelde servercontainer die is ingeschakeld om meerdere modellen te hosten. Dit verlaagt de hostingkosten door het gebruik van endpoints te verbeteren in vergelijking met het gebruik van endpoints met één model. Het vermindert ook de implementatieoverhead omdat SageMaker het laden van modellen in het geheugen beheert en ze schaalt op basis van de verkeerspatronen ernaartoe.

Om het eindpunt met meerdere modellen te maken, moeten we eerst de getrainde modellen voor de individuele schatters (1 en 2) kopiëren van hun opgeslagen S3-locaties naar een algemeen S3-voorvoegsel dat door het eindpunt met meerdere modellen kan worden gebruikt:

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}

Nadat de modellen zijn gekopieerd naar de algemene locatie die is aangewezen door het voorvoegsel S3, maken we een weergavemodel met behulp van de klasse TensorFlowModel uit de SageMaker SDK. Het weergavemodel wordt gemaakt voor een van de modellen die onder het eindpunt met meerdere modellen moeten worden gehost. In dit geval gebruiken we het eerste model (de CIFAR-10 beeldclassificator). Vervolgens gebruiken we de klasse MultiDataModel van de SageMaker SDK om een ​​gegevensmodel met meerdere modellen te maken met behulp van het weergavemodel voor model-1, dat we in de vorige stap hebben gemaakt:

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)

Ten slotte implementeren we het MultiDataModel door de methode deploy() aan te roepen, die de attributen levert die nodig zijn om de hostinginfrastructuur te creëren die nodig is om het multimodel-eindpunt te ondersteunen:

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

De deploy-aanroep retourneert een voorspellingsinstantie, die we kunnen gebruiken om gevolgtrekkingen te maken. Dit zien we in de volgende paragraaf.

Test het eindpunt met meerdere modellen voor realtime gevolgtrekking

Met eindpunten voor meerdere modellen kunt u geheugenbronnen delen tussen uw modellen. Als het model waarnaar moet worden verwezen al in de cache is opgeslagen, wordt inferentie voor meerdere modellen onmiddellijk uitgevoerd. Aan de andere kant, als het specifieke aangevraagde model niet in de cache is opgeslagen, moet SageMaker het model downloaden, wat de latentie voor dat eerste verzoek verhoogt. Dit kost echter slechts een fractie van de tijd die nodig is om een ​​geheel nieuwe infrastructuur (instances) te lanceren om het model afzonderlijk op SageMaker te hosten. Nadat een model in het cachegeheugen is opgeslagen in het eindpunt met meerdere modellen, worden volgende aanvragen in realtime gestart (tenzij het model wordt verwijderd). Als gevolg hiervan kunt u veel modellen uitvoeren vanuit één exemplaar, waardoor onze hoeveelheid modellen effectief wordt losgekoppeld van onze implementatiekosten. Dit maakt het eenvoudig om ML-implementaties op schaal te beheren en verlaagt de kosten van uw modelimplementatie door meer gebruik van het eindpunt en de onderliggende rekeninstances. Voor meer informatie en een demonstratie van kostenbesparingen van meer dan 90% voor een voorbeeld van 1,000 modellen, zie: Bespaar op gevolgtrekkingskosten met Amazon SageMaker-eindpunten voor meerdere modellen.

Eindpunten met meerdere modellen halen ook ongebruikte modellen uit de container wanneer de instanties die het eindpunt ondersteunen de geheugencapaciteit bereiken en er meer modellen in de container moeten worden geladen. SageMaker verwijdert ongebruikte modelartefacten van het instantieopslagvolume wanneer het volume de capaciteit bereikt en nieuwe modellen moeten worden gedownload. De eerste aanroep van een nieuw toegevoegd model duurt langer omdat het eindpunt tijd nodig heeft om het model van Amazon S3 te downloaden naar het containergeheugen van de instanties die het eindpunt met meerdere modellen ondersteunen. Modellen die worden verwijderd, blijven op het opslagvolume van de instantie staan ​​en kunnen later in het geheugen van de container worden geladen zonder opnieuw te worden gedownload van de S3-bucket.

Laten we eens kijken hoe we een gevolgtrekking kunnen maken uit de CIFAR-10-beeldclassificatie (model-1) die wordt gehost onder het eindpunt met meerdere modellen. Eerst laden we een voorbeeldafbeelding van een van de klassen - vliegtuig - en bereiden deze voor om naar het eindpunt met meerdere modellen te worden verzonden met behulp van de voorspeller die we in de vorige stap hebben gemaakt.

Met deze voorspeller kunnen we de methode predict() samen met de parameter initial_args aanroepen, die de naam specificeert van het aan te roepen doelmodel. In dit geval is het doelmodel cifar.tar.gz. Het volgende fragment demonstreert dit proces in 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}]')

Het uitvoeren van de voorgaande code retourneert de voorspellingsuitvoer als het label vliegtuig, wat correct wordt geïnterpreteerd door ons geserveerde model:

Predicted Label: [airplane]

Laten we vervolgens kijken hoe we de gebarentaalclassificatie (model-2) dynamisch kunnen laden in een eindpunt met meerdere modellen door het eindpunt aan te roepen met gebarentaal.tar.gz als het doelmodel.

We gebruiken de volgende voorbeeldafbeelding van het handtekencijfer 0.

Het volgende fragment laat zien hoe u het eindpunt met meerdere modellen kunt aanroepen met de voorbeeldafbeelding om het juiste antwoord terug te krijgen:

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

De volgende code is ons antwoord, met het label 0:

Predicted Label: [0]

Conclusie

In dit bericht hebben we de SageMaker-functie gedemonstreerd eindpunten met meerdere modellen om de inferentiekosten te optimaliseren. Eindpunten met meerdere modellen zijn handig wanneer u te maken hebt met honderden tot tienduizenden modellen en waarbij u niet elk model als afzonderlijk eindpunt hoeft te implementeren. Modellen worden dynamisch geladen en gelost, afhankelijk van het gebruik en de hoeveelheid geheugen die beschikbaar is op het eindpunt.

In dit bericht werd besproken hoe u meerdere computervisiemodellen kunt hosten die zijn getraind met behulp van het TensorFlow-framework onder één SageMaker-eindpunt met meerdere modellen. De beeldclassificatiemodellen waren van verschillende modelarchitecturen en getraind op verschillende datasets. De notitieboekje meegeleverd met de post biedt gedetailleerde instructies over het trainen en hosten van de modellen.

Geef SageMaker multi-model endpoints een kans voor uw use case en laat uw feedback achter in de opmerkingen.

Over de auteurs

Arunprasath Shankar is een Artificial Intelligence en Machine Learning (AI / ML) Specialist Solutions Architect met AWS, die wereldwijde klanten helpt hun AI-oplossingen effectief en efficiënt in de cloud te schalen. In zijn vrije tijd kijkt Arun graag naar scifi-films en luistert hij naar klassieke muziek.

Marc Roy is een Principal Machine Learning Architect voor AWS en helpt AWS-klanten bij het ontwerpen en bouwen van AI/ML-oplossingen. Marks werk omvat een breed scala aan ML-gebruiksscenario's, met een primaire interesse in computervisie, deep learning en het opschalen van ML in de hele onderneming. Hij heeft bedrijven in vele sectoren geholpen, waaronder verzekeringen, financiële diensten, media en entertainment, gezondheidszorg, nutsbedrijven en productie. Mark heeft zes AWS-certificeringen, waaronder de ML Specialty-certificering. Voordat hij bij AWS kwam, was Mark meer dan 25 jaar architect, ontwikkelaar en technologieleider, waarvan 19 jaar in de financiële dienstverlening.

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