Kör textgenerering med GPT- och Bloom-modeller på Amazon SageMaker JumpStart

I december 2020, AWS meddelade den allmänna tillgängligheten till Amazon SageMaker JumpStart, en förmåga av Amazon SageMaker som hjälper dig att snabbt och enkelt komma igång med maskininlärning (ML). JumpStart tillhandahåller finjustering och distribution med ett klick av en mängd olika förtränade modeller över populära ML-uppgifter, samt ett urval av helhetslösningar som löser vanliga affärsproblem. Dessa funktioner tar bort de tunga lyften från varje steg i ML-processen, vilket gör det lättare att utveckla högkvalitativa modeller och minskar tiden till implementering.

Det här inlägget är det fjärde i en serie om att använda JumpStart för specifika ML-uppgifter. I den första inlägget, visade vi hur man kör användningsfall för bildklassificering på JumpStart. I den andra inlägget, visade vi hur man kör användningsfall för textklassificering. I den tredje inlägget, körde vi användningsfall för bildsegmentering.

I det här inlägget ger vi en steg-för-steg-genomgång om hur man distribuerar förtränade textgenereringsmodeller. Vi utforskar två sätt att få samma resultat: via JumpStarts grafiska gränssnitt på Amazon SageMaker Studio, och programmatiskt igenom JumpStart API:er.

Om du vill hoppa direkt in i JumpStart API-koden som vi går igenom i det här inlägget, kan du hänvisa till följande exempel på Jupyter-anteckningsboken: Introduktion till JumpStart – Textgenerering.

JumpStart översikt

JumpStart hjälper dig att komma igång med ML-modeller för en mängd olika uppgifter utan att skriva en enda rad kod. För närvarande låter JumpStart dig göra följande:

• Distribuera förutbildade modeller för vanliga ML-uppgifter – JumpStart gör att du kan hantera vanliga ML-uppgifter utan utvecklingsansträngning genom att tillhandahålla enkel distribution av modeller som är förutbildade på stora, allmänt tillgängliga datauppsättningar. ML forskarsamhället har lagt ner mycket arbete på att göra en majoritet av de nyligen utvecklade modellerna allmänt tillgängliga för användning. JumpStart är värd för en samling av över 300 modeller som spänner över de 15 mest populära ML-uppgifterna som objektdetektering, textklassificering och textgenerering, vilket gör det enkelt för nybörjare att använda dem. Dessa modeller är hämtade från populära modellnav som TensorFlow, PyTorch, Hugging Face och MXNet.
• Finjustera förtränade modeller – JumpStart låter dig finjustera förtränade modeller utan att behöva skriva din egen träningsalgoritm. I ML kallas förmågan att överföra den kunskap som lärts inom en domän till en annan domän överför lärande. Du kan använda överföringsinlärning för att producera exakta modeller på dina mindre datauppsättningar, med mycket lägre utbildningskostnader än de som är involverade i att träna den ursprungliga modellen. JumpStart innehåller också populära träningsalgoritmer baserade på LightGBM, CatBoost, XGBoost och Scikit-learn, som du kan träna från grunden för tabellregression och klassificering.
• Använd färdigbyggda lösningar – JumpStart tillhandahåller en uppsättning av 17 lösningar för vanliga ML-användningsfall, såsom efterfrågeprognoser och industriella och finansiella applikationer, som du kan implementera med bara några klick. Lösningar är end-to-end ML-applikationer som sammanfogar olika AWS-tjänster för att lösa ett visst affärsanvändningsfall. De använder AWS molnformation mallar och referensarkitekturer för snabb implementering, vilket innebär att de är helt anpassningsbara.
• Se exempel på anteckningsboken för SageMaker-algoritmer – SageMaker tillhandahåller en svit med inbyggda algoritmer för att hjälpa datavetare och ML-utövare att snabbt komma igång med utbildning och implementering av ML-modeller. JumpStart tillhandahåller exempel på anteckningsböcker som du kan använda för att snabbt använda dessa algoritmer.
• Granska träningsvideor och bloggar – JumpStart tillhandahåller också många blogginlägg och videor som lär dig hur du använder olika funktioner inom SageMaker.

JumpStart accepterar anpassade VPC-inställningar och AWS nyckelhanteringstjänst (AWS KMS) krypteringsnycklar, så att du kan använda de tillgängliga modellerna och lösningarna säkert i din företagsmiljö. Du kan skicka dina säkerhetsinställningar till JumpStart i Studio eller via SageMaker Python SDK.

Textgenerering, GPT-2 och Bloom

Textgenerering är uppgiften att generera text som är flytande och som inte kan skiljas från mänskligt skriven text. Det är också känt som naturligt språkgenerering.

GPT-2 är en populär transformatorbaserad textgenereringsmodell. Den är förtränad på en stor korpus av rå engelsk text utan mänsklig märkning. Den är tränad på uppgiften där modellen, givet en delsekvens (mening eller text), behöver förutsäga nästa ord eller token i sekvensen.

Bloom är också en transformatorbaserad textgenereringsmodell och tränad på samma sätt som GPT-2. Bloom är dock förutbildad på 46 olika språk och 13 programmeringsspråk. Följande är ett exempel på att köra textgenerering med Bloom-modellen:

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,"

Lösningsöversikt

Följande avsnitt ger en steg-för-steg-demo för att utföra slutledning, både via Studio UI och via JumpStart API:er. Vi går igenom följande steg:

1. Få åtkomst till JumpStart via Studio UI för att distribuera och köra slutledning på den förtränade modellen.
2. Använd JumpStart programmatiskt med SageMaker Python SDK för att distribuera den förtränade modellen och köra slutledning.

Gå till JumpStart genom Studio UI och kör inferens med en förtränad modell

I det här avsnittet visar vi hur man tränar och distribuerar JumpStart-modeller genom Studio UI.

Följande video visar hur du hittar en förtränad textgenereringsmodell på JumpStart och distribuerar den. Modellsidan innehåller värdefull information om modellen och hur man använder den. Du kan distribuera vilken som helst av de förtränade modellerna som finns tillgängliga i JumpStart. För slutledning väljer vi instanstypen ml.p3.2xlarge, eftersom den ger den GPU-acceleration som behövs för låg slutledningsfördröjning till ett lågt pris. När du har konfigurerat SageMaker-värdinstansen väljer du Distribuera. Det kan ta 20–25 minuter innan ditt ihållande slutpunkt är igång.

När din slutpunkt är operativ är den redo att svara på slutledningsförfrågningar!

För att påskynda din tid till slutledning tillhandahåller JumpStart en exempelanteckningsbok som visar hur du kör inferens på din nyligen distribuerade slutpunkt. Välja Öppna Notebook under Använd Endpoint från Studio.

Använd JumpStart programmatiskt med SageMaker SDK

I det föregående avsnittet visade vi hur du kan använda JumpStart UI för att distribuera en förtränad modell interaktivt, med bara några få klick. Du kan dock också använda JumpStarts modeller programmatiskt genom att använda API:er som är integrerade i SageMaker SDK.

I det här avsnittet går vi igenom ett snabbt exempel på hur du kan replikera den föregående processen med SageMaker SDK. Vi väljer en lämplig förtränad modell i JumpStart, distribuerar denna modell till en SageMaker-slutpunkt och kör slutledning om den distribuerade slutpunkten. Alla steg i denna demo finns i den medföljande anteckningsboken Introduktion till JumpStart – Textgenerering.

Implementera den förtränade modellen

SageMaker är en plattform som i stor utsträckning använder Docker-behållare för bygg- och körningsuppgifter. JumpStart använder den tillgängliga ramspecifika SageMaker Deep Learning Containers (DLC). Vi hämtar först eventuella ytterligare paket, samt skript för att hantera utbildning och slutledning för den valda uppgiften. Slutligen hämtas de förtränade modellartefakterna separat med model_uris, vilket ger flexibilitet till plattformen. Du kan använda valfritt antal modeller förutbildade på samma uppgift med ett enda slutledningsskript. Se följande kod:

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 är en mycket stor modell och kan ta upp till 20–25 minuter att distribuera. Du kan också använda en mindre modell som GPT-2. För att distribuera en förtränad GPT-2-modell kan du ställa in model_id = huggingface-textgeneration-gpt2. För en lista över andra tillgängliga modeller i JumpStart, se JumpStart Tillgänglig modelltabell.

Därefter matar vi resurserna till en SageMaker modell instans och distribuera en slutpunkt:

# 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,
)

Efter att vår modell har implementerats kan vi få förutsägelser från den i realtid!

Kör slutledning

Följande kodavsnitt ger dig en glimt av hur utgångarna ser ut. För att skicka förfrågningar till en utplacerad modell måste inmatningstext anges i en utf-8 kodat format.

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

Endpoint-svaret är ett JSON-objekt som innehåller inmatningstexten följt av den genererade texten:

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)

Vår produktion är som följer:

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

Slutsats

I det här inlägget visade vi hur man distribuerar en förtränad textgenereringsmodell med JumpStart. Du kan åstadkomma detta utan att behöva skriva kod. Prova lösningen på egen hand och skicka oss dina kommentarer. För att lära dig mer om JumpStart och hur du kan använda förtränade modeller med öppen källkod för en mängd andra ML-uppgifter, kolla in följande AWS re:Invent 2020-video.

Om författarna

Dr. Vivek Madan är en tillämpad forskare med Amazon SageMaker JumpStart-teamet. Han tog sin doktorsexamen från University of Illinois i Urbana-Champaign och var postdoktor vid Georgia Tech. Han är en aktiv forskare inom maskininlärning och algoritmdesign och har publicerat artiklar på EMNLP-, ICLR-, COLT-, FOCS- och SODA-konferenser.

Santosh Kulkarni är en Enterprise Solutions Architect på Amazon Web Services som arbetar med sportkunder i Australien. Han brinner för att bygga storskaliga distribuerade applikationer för att lösa affärsproblem med sin kunskap inom AI/ML, big data och mjukvaruutveckling.

Dr Ashish Khetan är en Senior Applied Scientist med Amazon SageMaker inbyggda algoritmer och hjälper till att utveckla maskininlärningsalgoritmer. Han tog sin doktorsexamen från University of Illinois Urbana Champaign. Han är en aktiv forskare inom maskininlärning och statistisk slutledning och har publicerat många artiklar i NeurIPS, ICML, ICLR, JMLR, ACL och EMNLP-konferenser.