Voer tekstgeneratie uit met GPT- en Bloom-modellen op Amazon SageMaker JumpStart

In december 2020, AWS aangekondigd de algemene beschikbaarheid van 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.

Dit bericht is het vierde in een serie over het gebruik van JumpStart voor specifieke ML-taken. In de eerste bericht, hebben we laten zien hoe u gebruiksscenario's voor afbeeldingsclassificatie kunt uitvoeren op JumpStart. In de tweede bericht, hebben we laten zien hoe u gebruiksgevallen voor tekstclassificatie kunt uitvoeren. In de derde bericht, hebben we use cases voor beeldsegmentatie uitgevoerd.

In dit bericht bieden we een stapsgewijze uitleg over het implementeren van vooraf getrainde modellen voor het genereren van tekst. We onderzoeken twee manieren om hetzelfde resultaat te verkrijgen: via de grafische interface van JumpStart Amazon SageMaker Studio, en programmatisch door JumpStart-API's.

Als je direct in de JumpStart API-code wilt springen die we in dit bericht doornemen, kun je het volgende voorbeeld Jupyter-notebook raadplegen: Inleiding tot JumpStart – Tekstgeneratie.

JumpStart-overzicht

JumpStart helpt u aan de slag te gaan met ML-modellen voor verschillende taken zonder ook maar één regel code te hoeven schrijven. Momenteel kunt u met JumpStart het volgende doen:

• Vooraf getrainde modellen implementeren voor veelvoorkomende ML-taken – JumpStart stelt u in staat om veelvoorkomende ML-taken aan te pakken zonder ontwikkelingsinspanningen door eenvoudige implementatie te bieden van modellen die vooraf zijn getraind op grote, openbaar beschikbare datasets. De ML-onderzoeksgemeenschap heeft veel moeite gedaan om de meeste recent ontwikkelde modellen openbaar beschikbaar te maken 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.
• Vooraf getrainde modellen afstemmen - Met JumpStart kunt u vooraf getrainde modellen verfijnen zonder uw eigen trainingsalgoritme te hoeven 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 de kosten voor het trainen van het originele model. JumpStart bevat ook populaire trainingsalgoritmen op basis van LightGBM, CatBoost, XGBoost en Scikit-learn, die u helemaal opnieuw kunt trainen voor tabelregressie en classificatie.
• Gebruik kant-en-klare oplossingen – JumpStart biedt een set van 17 oplossingen voor veelvoorkomende ML-gebruiksscenario's, zoals vraagvoorspelling en industriële en financiële toepassingen, die u met slechts een paar klikken kunt implementeren. 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.
• Raadpleeg notebookvoorbeelden voor SageMaker-algoritmen – SageMaker biedt een reeks 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.
• Bekijk 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 AWS Sleutelbeheerservice (AWS KMS) encryptiesleutels, zodat u de beschikbare modellen en oplossingen veilig kunt gebruiken binnen uw bedrijfsomgeving. U kunt uw beveiligingsinstellingen doorgeven aan JumpStart in Studio of via de SageMaker Python SDK.

Tekstgeneratie, GPT-2 en Bloom

Tekstgeneratie is de taak om tekst te genereren die vloeiend is en niet te onderscheiden lijkt van door mensen geschreven tekst. Het is ook bekend als natuurlijke taalgeneratie.

GPT-2 is een populair op transformatoren gebaseerd model voor het genereren van tekst. Het is vooraf getraind op een groot corpus onbewerkte Engelse tekst zonder menselijke labels. Het is getraind op de taak waarbij het model, gegeven een gedeeltelijke reeks (zin of stuk tekst), het volgende woord of token in de reeks moet voorspellen.

Bloom is ook een op een transformator gebaseerd model voor het genereren van tekst en is op dezelfde manier getraind als GPT-2. Bloom is echter vooraf getraind in 46 verschillende talen en 13 programmeertalen. Het volgende is een voorbeeld van het genereren van tekst met het Bloom-model:

Input: "Some people like dogs, some people like cats"
Output: "Some people like dogs, some people like cats some people like birds, some people like fish,"

Overzicht oplossingen

De volgende secties bieden een stapsgewijze demo om gevolgtrekkingen uit te voeren, zowel via de Studio UI als via JumpStart API's. We doorlopen de volgende stappen:

1. Open JumpStart via de Studio UI om het vooraf getrainde model te implementeren en inferentie uit te voeren.
2. Gebruik JumpStart programmatisch met de SageMaker Python SDK om het vooraf getrainde model te implementeren en inferentie uit te voeren.

Open JumpStart via de gebruikersinterface van Studio en voer inferentie uit met een vooraf getraind model

In deze sectie laten we zien hoe u JumpStart-modellen kunt trainen en implementeren via de Studio UI.

De volgende video laat zien hoe u een vooraf getraind model voor het genereren van tekst op JumpStart kunt vinden en implementeren. De modelpagina bevat waardevolle informatie over het model en het gebruik ervan. U kunt elk van de vooraf getrainde modellen implementeren die beschikbaar zijn in JumpStart. Voor gevolgtrekking kiezen we het instantietype ml.p3.2xlarge, omdat dit de GPU-versnelling biedt die nodig is voor lage gevolgtrekkingslatentie tegen een lage prijs. Nadat u de SageMaker-hostinginstantie hebt geconfigureerd, kiest u Implementeren. Het kan 20-25 minuten duren voordat uw permanente eindpunt actief is.

Zodra uw eindpunt operationeel is, is het klaar om te reageren op deductieverzoeken!

Om uw tijd tot gevolgtrekking te versnellen, biedt JumpStart een voorbeeldnotitieblok dat u laat zien hoe u inferentie uitvoert op uw pas geïmplementeerde eindpunt. Kiezen Notitieblok openen voor Eindpunt van Studio gebruiken.

Gebruik JumpStart programmatisch met de SageMaker SDK

In het vorige gedeelte hebben we laten zien hoe u de JumpStart UI kunt gebruiken om een ​​vooraf getraind model interactief te implementeren, in een kwestie van een paar klikken. U kunt de modellen van JumpStart echter ook programmatisch gebruiken door API's te gebruiken die zijn geïntegreerd in de SageMaker SDK.

In deze sectie bespreken we een snel voorbeeld van hoe u het voorgaande proces kunt repliceren met de SageMaker SDK. We kiezen een geschikt vooraf getraind model in JumpStart, implementeren dit model op een SageMaker-eindpunt en voeren gevolgtrekkingen uit op het geïmplementeerde eindpunt. Alle stappen in deze demo zijn beschikbaar in het bijbehorende notitieboek Inleiding tot JumpStart – Tekstgeneratie.

Het vooraf getrainde model implementeren

SageMaker is een platform dat uitgebreid gebruik maakt van Docker-containers voor build- en runtime-taken. JumpStart gebruikt de beschikbare framework-specifieke SageMaker Deep Learning-containers (DLC's). We halen eerst 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, die het platform flexibiliteit biedt. U kunt een willekeurig aantal modellen gebruiken die vooraf zijn getraind op dezelfde taak met een enkel inferentiescript. Zie de volgende code:

model_id, model_version = "huggingface-textgeneration-bloom-560m", "*"

# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve(
    region=None,
    framework=None,  # automatically inferred from model_id
    image_scope="inference",
    model_id=model_id,
    model_version=model_version,
    instance_type=inference_instance_type,
)

# Retrieve the inference script uri
deploy_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="inference")

base_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="inference")

Bloom is een zeer groot model en het kan tot 20-25 minuten duren om te implementeren. U kunt ook een kleiner model gebruiken, zoals GPT-2. Om een ​​vooraf getraind GPT-2-model te implementeren, kunt u instellen model_id = huggingface-textgeneration-gpt2. Raadpleeg voor een lijst met andere beschikbare modellen in JumpStart Tabel met beschikbare JumpStart-modellen.

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",  # entry point file in source_dir and present in deploy_source_uri
    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,
)

Nadat ons model is geïmplementeerd, kunnen we er in realtime voorspellingen van krijgen!

Voer gevolgtrekking uit

Het volgende codefragment geeft u een glimp van hoe de uitvoer eruit ziet. Om verzoeken naar een geïmplementeerd model te sturen, moet invoertekst worden opgegeven in een utf-8 gecodeerd formaat.

def query(model_predictor, text):
    """Query the model predictor."""

    encoded_text = json.dumps(text).encode("utf-8")

    query_response = model_predictor.predict(
        encoded_text,
        {
            "ContentType": "application/x-text",
            "Accept": "application/json",
        },
    )
    return query_response

Het eindpuntantwoord is een JSON-object dat de invoertekst bevat, gevolgd door de gegenereerde tekst:

def parse_response(query_response):
    """Parse response and return the generated text."""

    model_predictions = json.loads(query_response)
    generated_text = model_predictions["generated_text"]
    return generated_text
    
text = "Some people like dogs, some people like cats"
query_response = query(model_predictor, text)
parse_response(query_response)

Onze output is als volgt:

"Some people like dogs, some people like cats some people like birds, some people like fish,"

Conclusie

In dit bericht hebben we laten zien hoe u een vooraf getraind model voor het genereren van tekst kunt implementeren met behulp van JumpStart. U kunt dit bereiken zonder dat u code hoeft te schrijven. Probeer de oplossing zelf uit en stuur ons uw opmerkingen. Bekijk het volgende voor meer informatie over JumpStart en hoe u voorgetrainde open-sourcemodellen kunt gebruiken voor tal van andere ML-taken AWS re:Invent 2020-video.

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 algoritmeontwerp en heeft artikelen gepubliceerd op EMNLP-, ICLR-, COLT-, FOCS- en SODA-conferenties.

Santosh Kulkarni is een Enterprise Solutions Architect bij Amazon Web Services die werkt met sportklanten in Australië. Hij is gepassioneerd door het bouwen van grootschalige gedistribueerde applicaties om zakelijke problemen op te lossen met behulp van zijn kennis van AI/ML, big data en softwareontwikkeling.

Dr Ashish Khetan is een Senior Applied Scientist met ingebouwde algoritmen van Amazon SageMaker en helpt bij het ontwikkelen van algoritmen voor machine learning. Hij promoveerde aan de Universiteit van Illinois, Urbana Champaign. Hij is een actief onderzoeker op het gebied van machine learning en statistische inferentie en heeft veel artikelen gepubliceerd op NeurIPS-, ICML-, ICLR-, JMLR-, ACL- en EMNLP-conferenties.