Värd för flera TensorFlow-datorvisionsmodeller med Amazon SageMaker flermodell-slutpunkter

Amazon SageMaker hjälper datavetare och utvecklare att förbereda, bygga, utbilda och distribuera högkvalitativa modeller för maskininlärning (ML) genom att sammanföra en bred uppsättning funktioner som är specialbyggda för ML. SageMaker påskyndar innovation inom din organisation genom att tillhandahålla specialbyggda verktyg för varje steg i ML-utveckling, inklusive märkning, dataförberedelse, funktionsteknik, statistisk biasdetektering, AutoML, utbildning, inställning, värd, förklarbarhet, övervakning och automatisering av arbetsflöden.

Företag utbildar alltmer ML-modeller baserat på individuell användardata. Till exempel, en bilddelningstjänst utformad för att möjliggöra upptäckt av information på internet tränar anpassade modeller baserat på varje användares uppladdade bilder och webbhistorik för att anpassa rekommendationer för den användaren. Företaget kan också träna anpassade modeller baserat på sökämnen för att rekommendera bilder per ämne. Att bygga anpassade ML-modeller för varje användningsfall leder till högre inferensnoggrannhet, men ökar kostnaden för att distribuera och hantera modeller. Dessa utmaningar blir mer uttalade när inte alla modeller nås i samma takt men fortfarande måste vara tillgängliga hela tiden.

SageMaker flermodell slutpunkter ge ett skalbart och kostnadseffektivt sätt att distribuera ett stort antal ML-modeller i molnet. SageMaker slutmodeller med flera modeller gör att du kan distribuera flera ML-modeller bakom en enda slutpunkt och betjäna dem med en enda serveringsbehållare. Din applikation behöver helt enkelt inkludera ett API-samtal med målmodellen till denna slutpunkt för att uppnå låg latens, hög genomströmningsinferens. Istället för att betala för en separat slutpunkt för varje enskild modell kan du vara värd för många modeller till priset av en enda slutpunkt. Mer information om SageMaker-slutmodeller för flera modeller finns i Spara på slutkostnader genom att använda Amazon SageMaker multimodell slutpunkter.

I det här inlägget visar vi hur man använder SageMaker-endpoints för flera modeller för att vara värd för två datorvisionsmodeller med olika modellarkitekturer och datamängder för bildklassificering. I praktiken kan du distribuera tiotusentals modeller på slutmodeller med flera modeller.

Översikt över lösningen

SageMaker slutmodeller med flera modeller fungerar med flera ramar, som TensorFlow, PyTorch, MXNet och sklearn, och du kan bygg din egen behållare med en server med flera modeller. Flera modelländpunkter stöds också inbyggt i följande populära inbyggda SageMaker-algoritmer: XGBoost, Linjär elev, Slumpmässigt klippt skog (RCF) och K-närmaste grannar (KNN). Du kan använda behållarna som tillhandahålls av SageMaker direkt medan du använder dessa algoritmer utan att behöva bygga din egen anpassade behållare.

Följande diagram är en förenklad illustration av hur du kan vara värd för flera (för det här inlägget, sex) modeller med SageMaker flermodell slutpunkter. I praktiken kan flera slutmodeller rymma hundratals till tiotusentals ML-modeller bakom en slutpunkt. I vår arkitektur, om vi är värd för fler modeller med hjälp av modellartefakter lagrade i Amazon enkel lagringstjänst (Amazon S3), slutmodeller med flera modeller lossar dynamiskt några av de minst använda modellerna för att rymma nyare modeller.

I det här inlägget visar vi hur du kan vara värd för två datorvisionsmodeller utbildade med TensorFlow-ramverket bakom en enda SageMaker-slutmodell för flera modeller. Vi använder TensorFlow-servering container aktiverad för slutmodeller med flera modeller för att vara värd för dessa modeller. För vår första modell tränar vi en mindre version av AlexNet CNN för att klassificera bilder från CIFAR-10 dataset. För den andra modellen använder vi en VGG16 CNN-modell förtränad på IMAGEnet dataset och finjusteras på Dataset för siffror med siffror för att klassificera handsymbolbilder. Vi erbjuder också en fullt fungerande anteckningsbok för att visa alla steg.

Modell 1: CIFAR-10 bildklassificering

CIFAR-10 är ett riktmärke för bildklassificering i datorvision och ML. CIFAR-bilder är färgade (tre kanaler) med dramatisk variation i hur objekten ser ut. Den består av 32 × 32 färgbilder i 10 klasser, med 6,000 bilder per klass. Den innehåller 50,000 10,000 träningsbilder och XNUMX XNUMX testbilder. Följande bild visar ett exempel på bilderna grupperade efter etiketterna.

För att bygga bildklassificeringen använder vi en förenklad version av det klassiska AlexNet CNN. Nätverket består av fem fack- och poolskikt och tre helt anslutna lager. Vår förenklade arkitektur staplar tre fällningsskikt och två helt anslutna (täta) lager.

Det första steget är att ladda datauppsättningen i tåg- och testobjekt. TensorFlow-ramverket tillhandahåller CIFAR-datasetet som vi kan ladda med metoden load_data (). Därefter skalar vi in ​​de inmatade bilderna genom att dela pixelvärdena med 255: [0,255] ⇒ [0,1]. Vi måste också förbereda etiketterna med en het kodning. En het kodning är en process genom vilken de kategoriska variablerna omvandlas till en numerisk form. Följande kodavsnitt visar dessa steg i handling:

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)

När datauppsättningen är förberedd och redo för träning sparas den på Amazon S3 för att användas av SageMaker. Modellarkitekturen och utbildningskoden för bildklassificeraren samlas i ett träningsskript (cifar_train.py). För att generera satser av tensorbilddata för träningsprocessen använder vi ImageDataGenerator. Detta gör det möjligt för oss att tillämpa dataförstärkningstransformationer som rotation, bredd och höjdförskjutningar på vår träningsdata.

I nästa steg använder vi träningsskriptet för att skapa en TensorFlow-estimator med hjälp av SageMaker SDK (se följande kod). Vi använder estimatorn för att passa CNN-modellen på CIFAR-10-ingångar. När träningen är klar sparas modellen på 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)

Senare demonstrerar vi hur vi kan vara värd för den här modellen med SageMaker-multimodell-slutpunkt tillsammans med vår andra modell (teckenspråkens siffraklassificering).

Modell 2: Klassificering av teckenspråkssiffror

För vår andra modell använder vi teckenspråkens siffror. Denna dataset skiljer siffrorna för teckenspråk från 0–9. Följande bild visar ett exempel på datasetet.

Datauppsättningen innehåller 100 x 100 bilder i RGB-färg och har 10 klasser (siffror 0–9). Träningssatsen innehåller 1,712 bilder, valideringsuppsättningen 300 och testuppsättningen 50.

Denna dataset är väldigt liten. Att träna ett nätverk från grunden på denna lilla datamängd ger inte bra resultat. För att uppnå högre noggrannhet använder vi överföring inlärning. Överföringsinlärning är vanligtvis det bästa sättet att starta ett klassificeringsprojekt, särskilt när du inte har mycket träningsdata. Den migrerar kunskapen från källdatasetet till måldatasetet för att spara utbildningstid och beräkningskostnad.

För att utbilda den här modellen använder vi en förutbildad VGG16 CNN-modell utbildad i ImageNet-datasetet och finjusterar den för att arbeta med vår teckenspråkssiffraset. En förutbildad modell är ett nätverk som tidigare har utbildats i en stor dataset, vanligtvis i en storskalig bildklassificeringsuppgift. VGG16-modellarkitekturen som vi använder har totalt 13 facklager. För teckenspråkens dataset, eftersom dess domän skiljer sig från källdomänen för ImageNet-datasetet, finjusterar vi bara de sista lagren. Finjustering här avser frysning av några av nätverkslagren som används för extraktion av funktioner och gemensam träning av både de icke-frysta lagren och de nyligen tillagda klassificeringslagren av den förtränade modellen.

Träningsmanuset (sign_language_train.py) inkapslar modellarkitekturen och träningslogiken för teckenspråkens klassificering. Först laddar vi de förspända vikterna från VGG16-nätverket som tränats i ImageNet-datasetet. Därefter fryser vi en del av funktionen extraheringsdel, följt av att lägga till de nya klassificeringslagren. Slutligen sammanställer vi nätverket och kör utbildningsprocessen för att optimera modellen för den mindre datasetet.

Därefter använder vi det här träningsskriptet för att skapa en TensorFlow-estimator med SageMaker SDK. Denna uppskattare används för att passa teckenspråkens siffraklassificering på de medföljande ingångarna. När träningen är klar sparas modellen på Amazon S3 för att vara värd för SageMaker flermodell slutpunkter. Se följande kod:

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

Distribuera en slutmodell för flera modeller

SageMaker slutmodeller med flera modeller ger en skalbar och kostnadseffektiv lösning för att distribuera ett stort antal modeller. Den använder en delad serverbehållare som är aktiverad för att vara värd för flera modeller. Detta minskar värdkostnaderna genom att förbättra slutpunktsanvändningen jämfört med att använda slutmodeller för en modell. Det minskar också distributionskostnaderna eftersom SageMaker hanterar inläsning av modeller i minnet och skalar dem baserat på trafikmönstren till dem.

För att skapa slutmodellen för flera modeller måste vi först kopiera de utbildade modellerna för de enskilda beräknarna (1 och 2) från deras sparade S3-platser till ett gemensamt S3-prefix som kan användas av multimodelländpunkten:

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}

Efter att modellerna har kopierats till den gemensamma platsen som anges av S3-prefixet skapar vi en serveringsmodell med klassen TensorFlowModel från SageMaker SDK. Serveringsmodellen skapas för att en av modellerna ska vara värd under slutmodellen för flera modeller. I det här fallet använder vi den första modellen (bildklassificeraren CIFAR-10). Därefter använder vi klassen MultiDataModel från SageMaker SDK för att skapa en datamodell med flera modeller med hjälp av serveringsmodellen för modell 1, som vi skapade i föregående steg:

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)

Slutligen distribuerar vi MultiDataModel genom att anropa deploy () -metoden och tillhandahålla de attribut som behövs för att skapa den värdinfrastruktur som krävs för att backa multimodell-slutpunkten:

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

Distribuera samtalet returnerar en prediktorinstans, som vi kan använda för att ringa slutsamtal. Vi ser detta i nästa avsnitt.

Testa flermodellens slutpunkt för inferens i realtid

Flera-modell slutpunkter möjliggör delning av minnesresurser mellan dina modeller. Om modellen som ska refereras redan är cachad, kör slutmodeller för flera modeller omedelbart. Å andra sidan, om den specifika begärda modellen inte cachas, måste SageMaker ladda ner modellen, vilket ökar latensen för den första begäran. Det tar dock bara en bråkdel av den tid det tar att starta en helt ny infrastruktur (instanser) för att vara värd för modellen individuellt på SageMaker. Efter att en modell har cachelagrats i slutmodellen för flera modeller initieras efterfrågan i realtid (såvida inte modellen tas bort). Som ett resultat kan du köra många modeller från en enda instans och effektivt koppla bort vår mängd modeller från våra distributionskostnader. Detta gör det enkelt att hantera ML-distributioner i stor skala och sänker dina modelldistributionskostnader genom ökad användning av slutpunkten och dess underliggande beräkningsinstanser. För mer information och en demonstration av kostnadsbesparingar på över 90% för ett 1,000-modellsexempel, se Spara på slutsatserna med Amazon SageMaker slutmodeller för flera modeller.

Flera modelländpunkter laddar också bort oanvända modeller från behållaren när de instanser som backar slutpunkten når minneskapacitet och fler modeller behöver laddas i behållaren. SageMaker tar bort oanvända modellartefakter från instanslagringsvolymen när volymen når kapacitet och nya modeller måste laddas ner. Den första anropet till en nyligen tillagd modell tar längre tid eftersom slutpunkten tar tid att ladda ner modellen från Amazon S3 till behållarens minne av de instanser som stöder multimodelländpunkten. Modeller som lossas finns kvar på instansens lagringsvolym och kan laddas in i behållarens minne senare utan att laddas ner igen från S3-skopan.

Låt oss se hur man gör en slutsats från CIFAR-10-bildklassificatorn (modell-1) som är värd under multimodell-slutpunkten. Först laddar vi en provbild från en av klasserna - flygplan - och förbereder den för att skickas till flermodellens slutpunkt med hjälp av prediktorn vi skapade i föregående steg.

Med den här prediktorn kan vi anropa predict () -metoden tillsammans med parametern initial_args, som specificerar namnet på målmodellen som ska åberopas. I det här fallet är målmodellen cifar.tar.gz. Följande utdrag visar denna process i detalj:

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

Att köra den föregående koden returnerar prediktionsutgången som etikettflygplan, vilket tolkas korrekt av vår serverade modell:

Predicted Label: [airplane]

Låt oss sedan se hur man dynamiskt laddar teckenspråkssiffran (modell-2) i en slutmodell med flera modeller genom att anropa slutpunkten med teckenspråk.tar.gz som målmodell.

Vi använder följande exempelbild av handteckensiffran 0.

Följande kodavsnitt visar hur man åberopar slutmodellen för flera modeller med exempelbilden för att få tillbaka rätt svar:

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

Följande kod är vårt svar med etiketten 0:

Predicted Label: [0]

Slutsats

I det här inlägget demonstrerade vi SageMaker-funktionen flermodell slutpunkter för att optimera slutsatserna. Flera modelländpunkter är användbara när du har att göra med hundratals till tiotusentals modeller och där du inte behöver distribuera varje modell som en enskild slutpunkt. Modeller laddas och lossas dynamiskt, beroende på användning och mängden tillgängligt minne på slutpunkten.

Det här inlägget diskuterade hur man kan vara värd för flera datorsynmodeller utbildade med TensorFlow-ramverk under en SageMaker-multimodell-slutpunkt. Bildklassificeringsmodellerna var av olika modellarkitekturer och utbildade i olika datamängder. De anteckningsbok ingår i inlägget ger detaljerade instruktioner om utbildning och värd för modellerna.

Ge SageMaker slutmodeller för flera modeller ett försök till ditt användningsfall och lämna din feedback i kommentarerna.

Om författarna

Arunprasath Shankar är en artificiell intelligens och maskininlärning (AI / ML) specialistlösningsarkitekt med AWS, som hjälper globala kunder att skala sina AI-lösningar effektivt och effektivt i molnet. På fritiden tycker Arun om att titta på sci-fi-filmer och lyssna på klassisk musik.

Mark Roy är en huvudsaklig maskininlärningsarkitekt för AWS, som hjälper AWS-kunder att designa och bygga AI / ML-lösningar. Marks arbete täcker ett brett spektrum av ML-användningsfall, med ett primärt intresse för datorsyn, djupinlärning och skalning av ML över hela företaget. Han har hjälpt företag i många branscher, inklusive försäkringar, finansiella tjänster, media och underhållning, sjukvård, verktyg och tillverkning. Mark har sex AWS-certifieringar, inklusive ML-specialcertifiering. Innan Mark började på AWS var han arkitekt, utvecklare och teknologiledare i över 25 år, inklusive 19 år inom finansiella tjänster.

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