Găzduiește mai multe modele de viziune computerizată TensorFlow utilizând punctele finale cu mai multe modele Amazon SageMaker

Amazon SageMaker ajută oamenii de știință și dezvoltatorii de date să pregătească, să construiască, să antreneze și să implementeze rapid modele de învățare automată (ML) de înaltă calitate, prin reunirea unui set larg de capabilități concepute special pentru ML. SageMaker accelerează inovația în cadrul organizației dumneavoastră, oferind instrumente special concepute pentru fiecare pas al dezvoltării ML, inclusiv etichetarea, pregătirea datelor, ingineria caracteristicilor, detectarea părtinirii statistice, AutoML, instruire, reglare, găzduire, explicabilitate, monitorizare și automatizare a fluxului de lucru.

Companiile antrenează din ce în ce mai mult modele ML bazate pe datele individuale ale utilizatorilor. De exemplu, un serviciu de partajare a imaginilor conceput pentru a permite descoperirea de informații pe internet antrenează modele personalizate pe baza imaginilor încărcate de fiecare utilizator și a istoricului de navigare pentru a personaliza recomandările pentru acel utilizator. De asemenea, compania poate antrena modele personalizate pe baza subiectelor de căutare pentru a recomanda imagini pe subiect. Construirea modelelor personalizate ML pentru fiecare caz de utilizare duce la o precizie mai mare a inferenței, dar crește costul implementării și gestionării modelelor. Aceste provocări devin mai pronunțate atunci când nu toate modelele sunt accesate la aceeași frecvență, dar trebuie totuși să fie disponibile în orice moment.

SageMaker puncte finale multi-model oferă o modalitate scalabilă și rentabilă de a implementa un număr mare de modele ML în cloud. Punctele finale cu mai multe modele SageMaker vă permit să implementați mai multe modele ML în spatele unui singur punct final și să le serviți folosind un singur container de servire. Aplicația dvs. trebuie pur și simplu să includă un apel API cu modelul țintă către acest punct final pentru a obține o inferență cu latență scăzută și debit mare. În loc să plătiți pentru un punct final separat pentru fiecare model, puteți găzdui multe modele la prețul unui singur punct final. Pentru mai multe informații despre punctele finale cu mai multe modele SageMaker, consultați Economisiți costurile de inferență utilizând punctele finale multimodel Amazon SageMaker.

În această postare, demonstrăm cum să folosiți punctele finale multi-model SageMaker pentru a găzdui două modele de viziune computerizată cu arhitecturi de model și seturi de date diferite pentru clasificarea imaginilor. În practică, puteți implementa zeci de mii de modele pe terminale cu mai multe modele.

Prezentare generală a soluției

Punctele finale cu mai multe modele SageMaker funcționează cu mai multe cadre, cum ar fi TensorFlow, PyTorch, MXNet și sklearn și puteți construiește-ți propriul container cu un server cu mai multe modele. Punctele finale cu mai multe modele sunt, de asemenea, acceptate nativ în următorii algoritmi populari încorporați SageMaker: XGBoost, Învățător liniar, Pădure tăiată aleatoriu (RCF) și K-Cei mai apropiati vecini (KNN). Puteți utiliza direct containerele furnizate de SageMaker în timp ce utilizați acești algoritmi, fără a fi nevoie să vă construiți propriul container personalizat.

Următoarea diagramă este o ilustrare simplificată a modului în care puteți găzdui mai multe modele (pentru această postare, șase) folosind punctele finale cu mai multe modele SageMaker. În practică, punctele finale cu mai multe modele pot găzdui sute până la zeci de mii de modele ML în spatele unui punct final. În arhitectura noastră, dacă găzduim mai multe modele folosind artefacte de model stocate în Serviciul Amazon de stocare simplă (Amazon S3), punctele finale cu mai multe modele descarcă dinamic unele dintre modelele cel mai puțin utilizate pentru a se adapta modelelor mai noi.

În această postare, arătăm cum să găzduim două modele de viziune computerizată antrenate folosind cadrul TensorFlow în spatele unui singur punct final multi-model SageMaker. Noi folosim Servire TensorFlow container activat pentru punctele finale cu mai multe modele pentru a găzdui aceste modele. Pentru primul nostru model, antrenăm o versiune mai mică a AlexNet CNN pentru a clasifica imaginile din CIFAR-10 set de date. Pentru al doilea model, folosim a VGG16 Modelul CNN pre-antrenat pe IMAGEnet set de date și reglat fin pe Setul de date cu cifre din limbajul semnelor pentru a clasifica imaginile cu simbolul mâinii. Oferim, de asemenea, un complet funcțional caiet pentru a demonstra toți pașii.

Model 1: Clasificare imagini CIFAR-10

CIFAR-10 este un set de date de referință pentru clasificarea imaginilor în viziunea computerizată și ML. Imaginile CIFAR sunt colorate (trei canale) cu variații dramatice în modul în care apar obiectele. Este format din 32 × 32 de imagini color în 10 clase, cu 6,000 de imagini pe clasă. Conține 50,000 de imagini de antrenament și 10,000 de imagini de testare. Următoarea imagine prezintă o mostră de imagini grupate după etichete.

Pentru a construi clasificatorul de imagini, folosim o versiune simplificată a clasicului AlexNet CNN. Rețeaua este compusă din cinci straturi convoluționale și de grupare și trei straturi complet conectate. Arhitectura noastră simplificată stivuiește trei straturi convoluționale și două straturi complet conectate (dense).

Primul pas este să încărcați setul de date în obiecte de tren și testare. Cadrul TensorFlow oferă setul de date CIFAR pe care să îl încărcăm folosind metoda load_data(). În continuare, redimensionăm imaginile de intrare împărțind valorile pixelilor la 255: [0,255] ⇒ [0,1]. De asemenea, trebuie să pregătim etichetele folosind codificare one-hot. O codificare fierbinte este un proces prin care variabilele categoriale sunt convertite într-o formă numerică. Următorul fragment de cod arată acești pași în acțiune:

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)

După ce setul de date este pregătit și pregătit pentru antrenament, acesta este salvat pe Amazon S3 pentru a fi utilizat de SageMaker. Arhitectura modelului și codul de antrenament pentru clasificatorul de imagini sunt asamblate într-un script de antrenament (cifar_train.py). Pentru a genera loturi de date de imagine tensor pentru procesul de antrenament, folosim ImageDataGenerator. Acest lucru ne permite să aplicăm transformări de creștere a datelor, cum ar fi schimbările de rotație, lățime și înălțime, la datele noastre de antrenament.

În pasul următor, folosim scriptul de antrenament pentru a crea un estimator TensorFlow folosind SDK-ul SageMaker (vezi următorul cod). Folosim estimatorul pentru a se potrivi modelului CNN pe intrările CIFAR-10. Când antrenamentul este finalizat, modelul este salvat pe 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)

Mai târziu, demonstrăm cum să găzduim acest model folosind punctul final multi-model SageMaker alături de cel de-al doilea model (clasificatorul de cifre în limbajul semnelor).

Model 2: Clasificarea cifrelor din limbajul semnelor

Pentru al doilea model, folosim setul de date cu cifre în limbajul semnelor. Acest set de date distinge cifrele limbajului semnelor de la 0 la 9. Următoarea imagine prezintă un eșantion al setului de date.

Setul de date conține 100 x 100 de imagini în culoare RGB și are 10 clase (cifre de la 0 la 9). Setul de antrenament conține 1,712 imagini, setul de validare 300 și setul de testare 50.

Acest set de date este foarte mic. Antrenarea unei rețele de la zero pe acest set de date mic nu obține rezultate bune. Pentru a obține o precizie mai mare, folosim transfer învăţare. Învățarea prin transfer este de obicei abordarea de bază atunci când începeți un proiect de clasificare, mai ales când nu aveți multe date de antrenament. Acesta migrează cunoștințele învățate din setul de date sursă în setul de date țintă, pentru a economisi timp de instruire și costuri de calcul.

Pentru a antrena acest model, folosim un model CNN VGG16 preantrenat, antrenat pe setul de date ImageNet și îl reglam fin pentru a funcționa pe setul nostru de date cu cifre în limbajul semnelor. Un model preantrenat este o rețea care a fost pregătită anterior pe un set de date mare, de obicei pe o sarcină de clasificare a imaginilor la scară largă. Arhitectura modelului VGG16 pe care o folosim are 13 straturi convoluționale în total. Pentru setul de date în limbajul semnelor, deoarece domeniul său este diferit de domeniul sursă al setului de date ImageNet, reglam doar ultimele câteva straturi. Reglarea fină se referă aici la înghețarea câtorva dintre straturile de rețea care sunt utilizate pentru extragerea caracteristicilor și antrenarea în comun atât a straturilor neînghețate, cât și a straturilor de clasificare nou adăugate ale modelului preantrenat.

Scriptul de antrenament (sign_language_train.py) încapsulează arhitectura modelului și logica de antrenament pentru clasificatorul de cifre în limbajul semnelor. În primul rând, încărcăm greutățile preantrenate din rețeaua VGG16 antrenată pe setul de date ImageNet. Apoi, înghețăm o parte din partea extractor de caracteristici, urmată de adăugarea noilor straturi de clasificare. În cele din urmă, compilam rețeaua și rulăm procesul de instruire pentru a optimiza modelul pentru setul de date mai mic.

Apoi, folosim acest script de instruire pentru a crea un estimator TensorFlow folosind SDK-ul SageMaker. Acest estimator este utilizat pentru a potrivi clasificatorul de cifre în limbajul semnelor pe intrările furnizate. Când instruirea este finalizată, modelul este salvat în Amazon S3 pentru a fi găzduit de punctele finale cu mai multe modele SageMaker. Vezi următorul cod:

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

Implementați un punct final cu mai multe modele

Punctele finale cu mai multe modele SageMaker oferă o soluție scalabilă și rentabilă pentru implementarea unui număr mare de modele. Utilizează un container de servire partajat care este activat pentru a găzdui mai multe modele. Acest lucru reduce costurile de găzduire prin îmbunătățirea utilizării punctelor finale în comparație cu utilizarea punctelor finale cu un singur model. De asemenea, reduce costul general de implementare, deoarece SageMaker gestionează încărcarea modelelor în memorie și scalarea acestora în funcție de tiparele de trafic către acestea.

Pentru a crea punctul final cu mai multe modele, mai întâi trebuie să copiem modelele antrenate pentru estimatorii individuali (1 și 2) din locațiile lor S3 salvate într-un prefix comun S3 care poate fi utilizat de punctul final cu mai multe modele:

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}

După ce modelele sunt copiate în locația comună desemnată de prefixul S3, creăm un model de servire folosind clasa TensorFlowModel din SDK-ul SageMaker. Modelul de servire este creat pentru unul dintre modele care urmează să fie găzduit sub punctul final cu mai multe modele. În acest caz, folosim primul model (clasificatorul de imagini CIFAR-10). Apoi, folosim clasa MultiDataModel din SDK-ul SageMaker pentru a crea un model de date cu mai multe modele folosind modelul de servire pentru modelul-1, pe care l-am creat în pasul anterior:

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)

În cele din urmă, implementăm MultiDataModel apelând metoda deploy(), furnizând atributele necesare pentru a crea infrastructura de găzduire necesară pentru a susține punctul final cu mai multe modele:

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

Apelul de implementare returnează o instanță de predictor, pe care o putem folosi pentru a efectua apeluri de inferență. Vedem acest lucru în secțiunea următoare.

Testați punctul final cu mai multe modele pentru inferență în timp real

Punctele finale cu mai multe modele permit partajarea resurselor de memorie între modelele dvs. Dacă modelul care trebuie referit este deja memorat în cache, punctele finale cu mai multe modele rulează imediat inferența. Pe de altă parte, dacă modelul solicitat particular nu este stocat în cache, SageMaker trebuie să descarce modelul, ceea ce crește latența pentru cererea inițială. Cu toate acestea, acest lucru durează doar o fracțiune din timpul necesar pentru a lansa o infrastructură (instanțe) complet nouă pentru a găzdui modelul individual pe SageMaker. După ce un model este stocat în cache în punctul final cu mai multe modele, solicitările ulterioare sunt inițiate în timp real (cu excepția cazului în care modelul este eliminat). Ca rezultat, puteți rula multe modele dintr-o singură instanță, decuplând efectiv cantitatea noastră de modele de costul nostru de implementare. Acest lucru facilitează gestionarea implementărilor ML la scară și reduce costurile de implementare a modelului prin utilizarea sporită a punctului final și a instanțelor de calcul subiacente. Pentru mai multe informații și o demonstrație a economiilor de costuri de peste 90% pentru un exemplu de 1,000 de modele, consultați Economisiți costurile de inferență folosind punctele finale multimodel Amazon SageMaker.

Punctele terminale cu mai multe modele descarcă, de asemenea, modelele neutilizate din container atunci când instanțele care sprijină punctul final ating capacitatea de memorie și mai multe modele trebuie încărcate în containerul său. SageMaker șterge artefactele de model neutilizate din volumul de stocare a instanței atunci când volumul atinge capacitatea și modelele noi trebuie descărcate. Prima invocare la un model nou adăugat durează mai mult, deoarece punctul final necesită timp pentru a descărca modelul de pe Amazon S3 în memoria containerului a instanțelor care susțin punctul final cu mai multe modele. Modelele care sunt descărcate rămân pe volumul de stocare al instanței și pot fi încărcate ulterior în memoria containerului, fără a fi descărcate din nou din bucket-ul S3.

Să vedem cum să facem o inferență din clasificatorul de imagini CIFAR-10 (model-1) găzduit sub punctul final cu mai multe modele. În primul rând, încărcăm o imagine eșantion de la una dintre clase — avion — și o pregătim pentru a fi trimisă la punctul final cu mai multe modele folosind predictorul creat la pasul anterior.

Cu acest predictor, putem apela metoda predict() împreună cu parametrul initial_args, care specifică numele modelului țintă de invocat. În acest caz, modelul țintă este cifar.tar.gz. Următorul fragment demonstrează acest proces în detaliu:

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

Rularea codului precedent returnează rezultatul de predicție ca avion etichetă, care este interpretat corect de modelul nostru deservit:

Predicted Label: [airplane]

În continuare, să vedem cum să încărcăm în mod dinamic clasificatorul de cifre în limbajul semnelor (model-2) într-un punct final cu mai multe modele, invocând punctul final cu semn-language.tar.gz ca model țintă.

Folosim următoarea imagine exemplu a cifrei semnului mâinii 0.

Următorul fragment arată cum să invocați punctul final cu mai multe modele cu imaginea eșantion pentru a obține răspunsul corect:

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

Următorul cod este răspunsul nostru, cu eticheta 0:

Predicted Label: [0]

Concluzie

În această postare, am demonstrat caracteristica SageMaker puncte finale multi-model pentru a optimiza costurile de inferență. Punctele finale cu mai multe modele sunt utile atunci când aveți de-a face cu sute până la zeci de mii de modele și în care nu trebuie să implementați fiecare model ca punct final individual. Modelele sunt încărcate și descărcate dinamic, în funcție de utilizare și de cantitatea de memorie disponibilă la punctul final.

Această postare a discutat cum să găzduiți mai multe modele de viziune computerizată instruite folosind cadrul TensorFlow sub un punct final multimodel SageMaker. Modelele de clasificare a imaginilor au avut arhitecturi de model diferite și au fost instruite pe diferite seturi de date. The caiet inclus cu postarea oferă instrucțiuni detaliate despre formarea și găzduirea modelelor.

Încercați punctele finale cu mai multe modele SageMaker pentru cazul dvs. de utilizare și lăsați-vă feedback în comentarii.

Despre Autori

Arunprasath Shankar este un arhitect specializat în soluții de inteligență artificială și învățare automată (AI / ML) cu AWS, ajutând clienții globali să își scaleze soluțiile de AI în mod eficient și eficient în cloud. În timpul liber, lui Arun îi place să urmărească filme SF și să asculte muzică clasică.

Mark Roy este arhitect principal de învățare automată pentru AWS, ajutând clienții AWS să proiecteze și să construiască soluții AI/ML. Lucrarea lui Mark acoperă o gamă largă de cazuri de utilizare ML, cu un interes principal în viziunea computerizată, învățarea profundă și scalarea ML în întreaga întreprindere. El a ajutat companii din multe industrii, inclusiv asigurări, servicii financiare, media și divertisment, asistență medicală, utilități și producție. Mark deține șase certificări AWS, inclusiv certificarea de specialitate ML. Înainte de a se alătura AWS, Mark a fost arhitect, dezvoltator și lider tehnologic timp de peste 25 de ani, inclusiv 19 ani în servicii financiare.

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