Zephyrnet-logo

Amazon SageMaker JumpStart-modellen en algoritmen nu beschikbaar via API

Datum:

In december 2020, AWS heeft de algemene beschikbaarheid aangekondigd of Amazon SageMaker JumpStart, een vermogen van Amazon Sage Maker waarmee je snel en eenvoudig aan de slag gaat met machine learning (ML). JumpStart biedt fijnafstemming en implementatie met één klik van een breed scala aan vooraf getrainde modellen voor populaire ML-taken, evenals een selectie van end-to-end-oplossingen die veelvoorkomende zakelijke problemen oplossen. Deze functies verwijderen het zware werk van elke stap van het ML-proces, waardoor het gemakkelijker wordt om hoogwaardige modellen te ontwikkelen en de implementatietijd te verkorten.

Voorheen was alle JumpStart-inhoud alleen beschikbaar via Amazon SageMaker Studio, wat zorgt voor een gebruiksvriendelijke grafische interface om te communiceren met de functie. Vandaag kondigen we met trots de lancering aan van de gebruiksvriendelijke JumpStart-API's als een uitbreiding van de SageMaker Python SDK. Met deze API's kunt u een uitgebreide selectie van door JumpStart ondersteunde, vooraf getrainde modellen programmatisch implementeren en afstemmen op uw eigen datasets. Deze lancering ontgrendelt het gebruik van JumpStart-mogelijkheden in uw codeworkflows, MLOps-pipelines en overal waar u via SDK met SageMaker communiceert.

In dit bericht geven we een update over de huidige staat van de mogelijkheden van JumpStart en begeleiden we u door de gebruiksstroom van de JumpStart API met een voorbeeld van een use-case.

JumpStart-overzicht

JumpStart is een veelzijdig product met verschillende mogelijkheden om u snel op weg te helpen met ML op SageMaker. Op het moment van schrijven kunt u met JumpStart het volgende doen:

  • Vooraf getrainde modellen implementeren voor veelvoorkomende ML-taken – JumpStart stelt u in staat om veelvoorkomende ML-taken op te lossen zonder ontwikkelingsinspanningen door eenvoudige implementatie te bieden van modellen die vooraf zijn getraind op openbaar beschikbare grote datasets. De ML-onderzoeksgemeenschap heeft veel energie gestoken in het openbaar maken van de meeste recent ontwikkelde modellen voor gebruik. JumpStart host een verzameling van meer dan 300 modellen, verspreid over de 15 meest populaire ML-taken, zoals objectdetectie, tekstclassificatie en tekstgeneratie, waardoor het voor beginners gemakkelijk is om ze te gebruiken. Deze modellen zijn afkomstig van populaire modelhubs, zoals TensorFlow, PyTorch, Hugging Face en MXNet Hub.
  • Vooraf getrainde modellen afstemmen - Met JumpStart kunt u vooraf getrainde modellen verfijnen zonder dat u uw eigen trainingsalgoritme hoeft te schrijven. In ML wordt het vermogen om de kennis die in het ene domein is geleerd over te dragen naar een ander domein genoemd overdracht leren. U kunt transfer learning gebruiken om nauwkeurige modellen te produceren op uw kleinere datasets, met veel lagere trainingskosten dan die welke nodig zijn om het originele model helemaal opnieuw te trainen. JumpStart bevat ook populaire trainingsalgoritmen op basis van LightGBM, CatBoost, XGBoost en Scikit-learn waarmee u helemaal opnieuw kunt trainen voor regressie en classificatie van gegevens in tabelvorm.
  • Gebruik kant-en-klare oplossingen – JumpStart biedt een set van 17 kant-en-klare oplossingen voor veelvoorkomende ML-gebruiksscenario's, zoals vraagvoorspelling en industriële en financiële toepassingen, die u met slechts een paar klikken kunt implementeren. De oplossingen zijn end-to-end ML-applicaties die verschillende AWS-services aaneenrijgen om een ​​bepaalde zakelijke use-case op te lossen. Ze gebruiken AWS CloudFormatie sjablonen en referentiearchitecturen voor snelle implementatie, wat betekent dat ze volledig aanpasbaar zijn.
  • Gebruik notebookvoorbeelden voor SageMaker-algoritmen – SageMaker biedt een suite van ingebouwde algoritmen om datawetenschappers en ML-beoefenaars te helpen snel aan de slag te gaan met het trainen en implementeren van ML-modellen. JumpStart biedt voorbeeldnotitieblokken die u kunt gebruiken om deze algoritmen snel te gebruiken.
  • Profiteer van trainingsvideo's en blogs – JumpStart biedt ook tal van blogberichten en video's die u leren hoe u verschillende functionaliteiten binnen SageMaker kunt gebruiken.

JumpStart accepteert aangepaste VPC-instellingen en KMS-coderingssleutels, zodat u de beschikbare modellen en oplossingen veilig kunt gebruiken binnen uw bedrijfsomgeving. U kunt uw beveiligingsinstellingen doorgeven aan JumpStart in SageMaker Studio of via de SageMaker Python SDK.

JumpStart-ondersteunde ML-taken en API-voorbeeld Notebooks

JumpStart ondersteunt momenteel 15 van de meest populaire ML-taken; 13 daarvan zijn op visie en NLP gebaseerde taken, waarvan 8 no-code fine-tuning ondersteunen. Het ondersteunt ook vier populaire algoritmen voor gegevensmodellering in tabelvorm. De taken en koppelingen naar hun voorbeeldnotitieblokken zijn samengevat in de volgende tabel.

Taak Inferentie met vooraf getrainde modellen Training op aangepaste dataset Ondersteunde frameworks Voorbeeld notebooks
Afbeeldingsclassificatie ja ja PyTorch, TensorFlow Inleiding tot JumpStart – Beeldclassificatie
Objectdetectie ja ja PyTorch, TensorFlow, MXNet Inleiding tot JumpStart – Objectdetectie
Semantische segmentatie ja ja MXNet Inleiding tot JumpStart – Semantische segmentatie
Instantiesegmentatie ja geen MXNet Inleiding tot JumpStart – instantiesegmentatie
Afbeelding insluiten ja geen TensorFlow, MXNet Inleiding tot JumpStart – Inbedding van afbeeldingen
Tekstclassificatie ja ja TensorFlow Inleiding tot JumpStart – Tekstclassificatie
Classificatie van zinsparen ja ja TensorFlow, knuffelend gezicht Inleiding tot JumpStart – Classificatie van zinsparen
Vraag beantwoorden ja ja PyTorch Inleiding tot JumpStart - Vragen beantwoorden
Erkende entiteitsherkenning ja geen Gezicht knuffelen Inleiding tot JumpStart – benoemde entiteitsherkenning
Tekstsamenvatting ja geen Gezicht knuffelen Inleiding tot JumpStart – Tekstsamenvatting
Tekst genereren ja geen Gezicht knuffelen Inleiding tot JumpStart – Tekstgeneratie
Machine vertaling ja geen Gezicht knuffelen Inleiding tot JumpStart – Machinevertaling
Tekst insluiten ja geen TensorFlow, MXNet Inleiding tot JumpStart – Tekst insluiten
Classificatie in tabelvorm ja ja LightGBM, CatBoost, XGBoost, Lineaire leerling Inleiding tot JumpStart – Classificatie in tabelvorm – LightGBM, CatBoost
Inleiding tot JumpStart – Classificatie in tabelvorm – XGBoost, lineaire leerling
Tabelregressie ja ja LightGBM, CatBoost, XGBoost, Lineaire leerling Inleiding tot JumpStart - Tabelregressie - LightGBM, CatBoost
Inleiding tot JumpStart - Tabelregressie - XGBoost, lineaire leerling

Afhankelijk van de taak kunnen de voorbeeldnotitieblokken die in de voorgaande tabel zijn gekoppeld, u begeleiden bij alle of een subset van de volgende processen:

  • Selecteer een door JumpStart ondersteund, vooraf getraind model voor uw specifieke taak.
  • Host een vooraf getraind model, ontvang er in realtime voorspellingen van en geef de resultaten adequaat weer.
  • Verfijn een vooraf getraind model met uw eigen selectie van hyperparameters en implementeer het voor gevolgtrekking.

Verfijn en implementeer een objectdetectiemodel met JumpStart API's

In de volgende secties bieden we een stapsgewijze uitleg over het gebruik van de nieuwe JumpStart-API's voor de representatieve taak van objectdetectie. We laten zien hoe u een vooraf getraind objectdetectiemodel kunt gebruiken om objecten uit een vooraf gedefinieerde reeks klassen in een afbeelding met begrenzingsvakken te identificeren. Ten slotte laten we zien hoe u een vooraf getraind model op uw eigen dataset kunt verfijnen om objecten in afbeeldingen te detecteren die specifiek zijn voor uw zakelijke behoeften, simpelweg door uw eigen gegevens mee te nemen. Wij bieden een bijbehorend notitieboekje voor deze walkthrough.

We doorlopen de volgende stappen op hoog niveau:

  1. Voer gevolgtrekkingen uit op het vooraf getrainde model.
    1. Haal JumpStart-artefacten op en implementeer een eindpunt.
    2. Voer een query uit op het eindpunt, parseer het antwoord en geef modelvoorspellingen weer.
  2. Stem het vooraf getrainde model af op uw eigen dataset.
    1. Trainingsartefacten ophalen.
    2. Loop training.

Voer gevolgtrekkingen uit op het vooraf getrainde model

In deze sectie kiezen we een geschikt vooraf getraind model in JumpStart, implementeren we dit model op een SageMaker-eindpunt en laten we zien hoe u gevolgtrekkingen uitvoert op het geïmplementeerde eindpunt. Alle stappen zijn beschikbaar in de bijbehorende Jupyter-notitieboek.

Haal JumpStart-artefacten op en implementeer een eindpunt

SageMaker is een platform gebaseerd op Docker-containers. JumpStart gebruikt de beschikbare framework-specifieke SageMaker Deep Learning-containers (DLC's). We halen eventuele aanvullende pakketten op, evenals scripts om training en gevolgtrekking voor de geselecteerde taak af te handelen. Ten slotte worden de vooraf getrainde modelartefacten afzonderlijk opgehaald met model_uris, wat het platform flexibiliteit biedt. U kunt een willekeurig aantal modellen gebruiken die vooraf zijn getraind voor dezelfde taak met een enkel trainings- of inferentiescript. Zie de volgende code:

infer_model_id, infer_model_version = "pytorch-od-nvidia-ssd", "*" # Retrieve the inference docker container uri. This is the base container PyTorch image for the model selected above. deploy_image_uri = image_uris.retrieve(region=None, framework=None, image_scope="inference",model_id=infer_model_id, model_version=infer_model_version, instance_type=inference_instance_type) # Retrieve the inference script uri. This includes all dependencies and scripts for model loading, inference handling etc.
deploy_source_uri = script_uris.retrieve(model_id=infer_model_id, model_version=infer_model_version, script_scope="inference") # Retrieve the base model uri. This includes the pre-trained nvidia-ssd model and parameters.
base_model_uri = model_uris.retrieve(model_id=infer_model_id, model_version=infer_model_version, model_scope="inference")

Vervolgens voeren we de middelen in a SageMaker-model instantie en implementeer een eindpunt:

# Create the SageMaker model instance
model = Model(image_uri=deploy_image_uri, source_dir=deploy_source_uri, model_data=base_model_uri, entry_point="inference.py", role=aws_role, predictor_cls=Predictor, name=endpoint_name) # deploy the Model. Note that we need to pass Predictor class when we deploy model through Model class for being able to run inference through the sagemaker API.
base_model_predictor = model.deploy(initial_instance_count=1, instance_type=inference_instance_type, predictor_cls=Predictor, endpoint_name=endpoint_name)

De implementatie van het eindpunt kan enkele minuten duren.

Het eindpunt opvragen, het antwoord ontleden en voorspellingen weergeven

Om gevolgtrekkingen van een geïmplementeerd model te krijgen, moet een invoerafbeelding in binair formaat worden aangeleverd, samen met een acceptatietype. In JumpStart kunt u het aantal geretourneerde selectiekaders definiëren. In het volgende codefragment voorspellen we tien begrenzingsvakken per afbeelding door toe te voegen ;n_predictions=10 naar Accept. Om xx dozen te voorspellen, kun je dit veranderen in ;n_predictions=xx , of verkrijg alle voorspelde vakken door weg te laten ;n_predictions=xx geheel.

def query(model_predictor, image_file_name): with open(image_file_name, "rb") as file: input_img_rb = file.read() return model_predictor.predict(input_img_rb,{ "ContentType": "application/x-image", "Accept": "application/json;verbose;n_predictions=10"}) query_response = query(base_model_predictor, Naxos_Taverna)

Het volgende codefragment geeft u een idee van hoe objectdetectie eruitziet. De voorspelde waarschijnlijkheid voor elke objectklasse wordt gevisualiseerd, samen met het bijbehorende selectiekader. Wij gebruiken de parse_response en display_predictions helperfuncties, die zijn gedefinieerd in de bijgevoegde notitieboekje.

normalized_boxes, classes_names, confidences = parse_response(query_response)
display_predictions(Naxos_Taverna, normalized_boxes, classes_names, confidences)

De volgende schermafbeelding toont de uitvoer van een afbeelding met voorspellingslabels en selectiekaders.

Stem een ​​vooraf getraind model af op uw eigen dataset

Bestaande objectdetectiemodellen in JumpStart zijn vooraf getraind op de COCO- of de VOC-datasets. Als u echter objectklassen moet identificeren die niet voorkomen in de oorspronkelijke pre-trainingsgegevensset, moet u het model verfijnen op een nieuwe gegevensset die deze nieuwe objecttypen bevat. Als u bijvoorbeeld keukengerei moet identificeren en gevolgtrekkingen moet uitvoeren op een ingezet, vooraf getraind SSD-model, herkent het model geen kenmerken van de nieuwe afbeeldingstypen en is de uitvoer daarom onjuist.

In deze sectie laten we zien hoe eenvoudig het is om een ​​vooraf getraind model te verfijnen om nieuwe objectklassen te detecteren met behulp van JumpStart API's. Het volledige codevoorbeeld met meer details is beschikbaar in de bijbehorende notebook.

Trainingsartefacten ophalen

Trainingsartefacten zijn vergelijkbaar met de inferentieartefacten die in de vorige sectie zijn besproken. Voor training is een basis Docker-container vereist, namelijk de MXNet-container in de volgende voorbeeldcode. Eventuele aanvullende pakketten die nodig zijn voor training zijn opgenomen in de trainingsscripts in train_sourcer_uri. Het voorgetrainde model en zijn parameters zijn apart verpakt.

train_model_id, train_model_version, train_scope = "mxnet-od-ssd-512-vgg16-atrous-coco","*","training"
training_instance_type = "ml.p2.xlarge" # Retrieve the docker image. This is the base container MXNet image for the model selected above. train_image_uri = image_uris.retrieve(region=None, framework=None, model_id=train_model_id, model_version=train_model_version, image_scope=train_scope,instance_type=training_instance_type) # Retrieve the training script and dependencies. This contains all the necessary files including data processing, model training etc.
train_source_uri = script_uris.retrieve(model_id=train_model_id, model_version=train_model_version, script_scope=train_scope) # Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope)

Run training

Om de training uit te voeren, voeren we eenvoudig de vereiste artefacten samen met enkele aanvullende parameters naar een SageMaker-schatter en bel de .fit functie:

# Create SageMaker Estimator instance
od_estimator = Estimator( role=aws_role, image_uri=train_image_uri, source_dir=train_source_uri, model_uri=train_model_uri, entry_point="transfer_learning.py", # Entry-point file in source_dir and present in train_source_uri. instance_count=1, instance_type=training_instance_type, max_run=360000, hyperparameters=hyperparameters, output_path=s3_output_location,
) # Launch a SageMaker Training job by passing s3 path of the training data
od_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Terwijl het algoritme traint, kunt u de voortgang ervan volgen in de SageMaker-notebook waar u de code zelf uitvoert, of op Amazon Cloud Watch. Wanneer de training is voltooid, worden de verfijnde modelartefacten geüpload naar de Amazon eenvoudige opslagservice (Amazon S3) uitvoerlocatie gespecificeerd in de trainingsconfiguratie. U kunt het model nu op dezelfde manier implementeren als het vooraf getrainde model. U kunt de rest van het proces volgen in de bijbehorende notebook.

Conclusie

In dit bericht hebben we de waarde beschreven van de nieuw uitgebrachte JumpStart API's en hoe ze te gebruiken. We hebben links gegeven naar 17 voorbeeldnotitieblokken voor de verschillende ML-taken die in JumpStart worden ondersteund, en hebben u door het objectdetectienotitieblok geleid.

We horen graag van je terwijl je experimenteert met JumpStart.


Over de auteurs

Dr Vivek Madan is een Applied Scientist bij het Amazon SageMaker JumpStart-team. Hij promoveerde aan de Universiteit van Illinois in Urbana-Champaign en was een postdoctoraal onderzoeker bij Georgia Tech. Hij is een actief onderzoeker op het gebied van machine learning en het ontwerpen van algoritmen, en heeft papers gepubliceerd op EMNLP-, ICLR-, COLT-, FOCS- en SODA-conferenties.

Joao Moura is een AI/ML Specialist Solutions Architect bij Amazon Web Services. Hij is vooral gericht op NLP-use-cases en helpt klanten bij het optimaliseren van de training en implementatie van Deep Learning-modellen.

Dr Ashish Khetan is een Senior Applied Scientist met Amazon SageMaker JumpStart en Ingebouwde algoritmen van Amazon SageMaker en helpt bij het ontwikkelen van algoritmen voor machine learning. Hij is een actief onderzoeker op het gebied van machine learning en statistische inferentie en heeft veel artikelen gepubliceerd op NeurIPS-, ICML-, ICLR-, JMLR- en ACL-conferenties.

spot_img

Laatste intelligentie

spot_img