Kør tekstgenerering med GPT- og Bloom-modeller på Amazon SageMaker JumpStart

I december 2020, AWS annonceret den generelle tilgængelighed af Amazon SageMaker JumpStart, en evne til Amazon SageMaker der hjælper dig hurtigt og nemt at komme i gang med maskinlæring (ML). JumpStart giver et-klik finjustering og implementering af en lang række præ-trænede modeller på tværs af populære ML-opgaver, samt et udvalg af end-to-end-løsninger, der løser almindelige forretningsproblemer. Disse funktioner fjerner de tunge løft fra hvert trin i ML-processen, hvilket gør det nemmere at udvikle højkvalitetsmodeller og reducerer tiden til implementering.

Dette indlæg er det fjerde i en serie om brug af JumpStart til specifikke ML-opgaver. I den første indlæg, viste vi, hvordan man kører brugssager til billedklassificering på JumpStart. I den andet indlæg, viste vi, hvordan man kører tekstklassificering use cases. I den tredje indlæg, kørte vi billedsegmentering use cases.

I dette indlæg giver vi en trin-for-trin gennemgang af, hvordan man implementerer forudtrænede tekstgenereringsmodeller. Vi udforsker to måder at opnå det samme resultat på: via JumpStarts grafiske interface på Amazon SageMaker Studio, og programmæssigt igennem JumpStart API'er.

Hvis du vil springe direkte ind i JumpStart API-koden, vi gennemgår i dette indlæg, kan du henvise til følgende eksempel på Jupyter-notebook: Introduktion til JumpStart – Tekstgenerering.

JumpStart oversigt

JumpStart hjælper dig med at komme i gang med ML-modeller til en række forskellige opgaver uden at skrive en enkelt linje kode. I øjeblikket giver JumpStart dig mulighed for at gøre følgende:

• Implementer forudtrænede modeller til almindelige ML-opgaver – JumpStart giver dig mulighed for at løse almindelige ML-opgaver uden udviklingsindsats ved at give nem implementering af modeller, der er forudtrænede på store, offentligt tilgængelige datasæt. ML-forskningsmiljøet har lagt en stor indsats i at gøre et flertal af nyligt udviklede modeller offentligt tilgængelige til brug. JumpStart er vært for en samling af over 300 modeller, der spænder over de 15 mest populære ML-opgaver såsom objektgenkendelse, tekstklassificering og tekstgenerering, hvilket gør det nemt for begyndere at bruge dem. Disse modeller er hentet fra populære modelhubs som TensorFlow, PyTorch, Hugging Face og MXNet.
• Finjuster fortrænede modeller – JumpStart giver dig mulighed for at finjustere fortrænede modeller uden at skulle skrive din egen træningsalgoritme. I ML kaldes evnen til at overføre den lærte viden i et domæne til et andet domæne overføre læring. Du kan bruge transfer learning til at producere nøjagtige modeller på dine mindre datasæt med meget lavere uddannelsesomkostninger end dem, der er involveret i træning af den originale model. JumpStart inkluderer også populære træningsalgoritmer baseret på LightGBM, CatBoost, XGBoost og Scikit-learn, som du kan træne fra bunden til tabelregression og klassificering.
• Brug færdigbyggede løsninger – JumpStart leverer et sæt af 17 løsninger til almindelige ML-brugssager, såsom behovsprognose og industrielle og finansielle applikationer, som du kan implementere med blot et par klik. Løsninger er end-to-end ML-applikationer, der samler forskellige AWS-tjenester for at løse en bestemt forretningsbrugssag. De bruger AWS CloudFormation skabeloner og referencearkitekturer til hurtig implementering, hvilket betyder, at de kan tilpasses fuldt ud.
• Se notebook-eksempler for SageMaker-algoritmer – SageMaker leverer en suite af indbyggede algoritmer til at hjælpe dataforskere og ML-praktikere hurtigt i gang med træning og implementering af ML-modeller. JumpStart giver eksempler på notesbøger, som du kan bruge til hurtigt at bruge disse algoritmer.
• Gennemgå træningsvideoer og blogs – JumpStart giver også adskillige blogindlæg og videoer, der lærer dig, hvordan du bruger forskellige funktioner i SageMaker.

JumpStart accepterer brugerdefinerede VPC-indstillinger og AWS Key Management Service (AWS KMS) krypteringsnøgler, så du kan bruge de tilgængelige modeller og løsninger sikkert i dit virksomhedsmiljø. Du kan videregive dine sikkerhedsindstillinger til JumpStart i Studio eller gennem SageMaker Python SDK.

Tekstgenerering, GPT-2 og Bloom

Tekstgenerering er opgaven med at generere tekst, der er flydende og som ikke kan skelnes fra menneskeskreven tekst. Det er også kendt som generering af naturligt sprog.

GPT-2 er en populær transformer-baseret tekstgenereringsmodel. Det er fortrænet på et stort korpus af rå engelsk tekst uden menneskelig mærkning. Den er trænet i opgaven, hvor modellen, givet en delvis sekvens (sætning eller et stykke tekst), skal forudsige det næste ord eller token i sekvensen.

Bloom er også en transformer-baseret tekstgenereringsmodel og trænet på samme måde som GPT-2. Bloom er dog fortrænet på 46 forskellige sprog og 13 programmeringssprog. Følgende er et eksempel på at køre tekstgenerering 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øsningsoversigt

De følgende sektioner giver en trin-for-trin demo til at udføre inferens, både via Studio UI og via JumpStart API'er. Vi gennemgår følgende trin:

1. Få adgang til JumpStart gennem Studio UI for at implementere og køre inferens på den forudtrænede model.
2. Brug JumpStart programmatisk med SageMaker Python SDK til at implementere den forudtrænede model og køre inferens.

Få adgang til JumpStart gennem Studio UI, og kør inferens med en forudtrænet model

I dette afsnit demonstrerer vi, hvordan man træner og implementerer JumpStart-modeller gennem Studio UI.

Den følgende video viser dig, hvordan du finder en forudtrænet tekstgenereringsmodel på JumpStart og implementerer den. Modelsiden indeholder værdifuld information om modellen og hvordan den bruges. Du kan implementere enhver af de fortrænede modeller, der er tilgængelige i JumpStart. Til slutninger vælger vi instanstypen ml.p3.2xlarge, fordi den giver den GPU-acceleration, der er nødvendig for lav slutningsforsinkelse til en lav pris. Når du har konfigureret SageMaker-hostingforekomsten, skal du vælge Implementer. Det kan tage 20-25 minutter, før dit vedvarende endepunkt er oppe at køre.

Når dit endepunkt er operationelt, er det klar til at svare på anmodninger om slutninger!

For at fremskynde din tid til inferens, giver JumpStart en eksempelnotesbog, der viser dig, hvordan du kører inferens på dit nyligt implementerede slutpunkt. Vælge Åbn Notesbog under Brug Endpoint fra Studio.

Brug JumpStart programmatisk med SageMaker SDK

I det foregående afsnit viste vi, hvordan du kan bruge JumpStart UI til at implementere en forudtrænet model interaktivt med få klik. Du kan dog også bruge JumpStarts modeller programmatisk ved at bruge API'er, der er integreret i SageMaker SDK.

I dette afsnit gennemgår vi et hurtigt eksempel på, hvordan du kan replikere den foregående proces med SageMaker SDK. Vi vælger en passende præ-trænet model i JumpStart, implementerer denne model til et SageMaker-slutpunkt og kører konklusioner om det implementerede slutpunkt. Alle trinene i denne demo er tilgængelige i den medfølgende notesbog Introduktion til JumpStart – Tekstgenerering.

Implementer den fortrænede model

SageMaker er en platform, der gør udstrakt brug af Docker-containere til build- og runtime-opgaver. JumpStart bruger den tilgængelige rammespecifikke SageMaker Deep Learning Containere (DLC'er). Vi henter først eventuelle yderligere pakker, samt scripts til at håndtere træning og slutninger til den valgte opgave. Til sidst hentes de fortrænede modelartefakter separat med model_uris, hvilket giver fleksibilitet til platformen. Du kan bruge et hvilket som helst antal modeller, der er forudtrænet til den samme opgave med et enkelt inferensscript. Se følgende kode:

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 er en meget stor model og kan tage op til 20-25 minutter at implementere. Du kan også bruge en mindre model såsom GPT-2. For at implementere en forudtrænet GPT-2-model kan du indstille model_id = huggingface-textgeneration-gpt2. For en liste over andre tilgængelige modeller i JumpStart, se JumpStart tilgængelig model tabel.

Dernæst tilfører vi ressourcerne til en SageMaker model instans og implementer et 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 vores model er implementeret, kan vi få forudsigelser fra den i realtid!

Kør inferens

Følgende kodestykke giver dig et glimt af, hvordan udgangene ser ud. For at sende anmodninger til en implementeret model skal inputtekst angives i en utf-8 kodet 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

Slutpunktsvaret er et JSON-objekt, der indeholder inputteksten efterfulgt af den genererede 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)

Vores output er som følger:

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

Konklusion

I dette indlæg viste vi, hvordan man implementerer en forudtrænet tekstgenereringsmodel ved hjælp af JumpStart. Du kan opnå dette uden at skulle skrive kode. Prøv løsningen på egen hånd og send os dine kommentarer. For at lære mere om JumpStart og hvordan du kan bruge open source-foruddannede modeller til en række andre ML-opgaver, tjek følgende AWS re: Invent 2020-video.

Om forfatterne

Dr. Vivek Madan er en anvendt videnskabsmand hos Amazon SageMaker JumpStart-teamet. Han fik sin ph.d. fra University of Illinois i Urbana-Champaign og var postdoktor ved Georgia Tech. Han er en aktiv forsker i maskinlæring og algoritmedesign og har publiceret artikler i EMNLP, ICLR, COLT, FOCS og SODA konferencer.

Santosh Kulkarni er en Enterprise Solutions Architect hos Amazon Web Services, der arbejder med sportskunder i Australien. Han brænder for at bygge store distribuerede applikationer til at løse forretningsproblemer ved at bruge sin viden inden for AI/ML, big data og softwareudvikling.

Dr. Ashish Khetan er en Senior Applied Scientist med Amazon SageMaker indbyggede algoritmer og hjælper med at udvikle machine learning algoritmer. Han fik sin ph.d. fra University of Illinois Urbana Champaign. Han er en aktiv forsker i maskinlæring og statistisk inferens og har publiceret mange artikler i NeurIPS, ICML, ICLR, JMLR, ACL og EMNLP konferencer.