Domænetilpasning Finjustering af fundamentmodeller i Amazon SageMaker JumpStart på finansielle data

Store sprogmodeller (LLM'er) med milliarder af parametre er i øjeblikket på forkant med naturlig sprogbehandling (NLP). Disse modeller ryster op i feltet med deres utrolige evner til at generere tekst, analysere følelser, oversætte sprog og meget mere. Med adgang til enorme mængder data har LLM'er potentialet til at revolutionere den måde, vi interagerer med sprog på. Selvom LLM'er er i stand til at udføre forskellige NLP-opgaver, betragtes de som generalister og ikke specialister. For at uddanne en LLM til at blive en ekspert inden for et bestemt domæne, er finjustering normalt påkrævet.

En af de store udfordringer ved træning og implementering af LLM'er med milliarder af parametre er deres størrelse, hvilket kan gøre det vanskeligt at passe dem ind i enkelte GPU'er, den hardware, der almindeligvis bruges til dyb læring. Den store skala af disse modeller kræver højtydende computerressourcer, såsom specialiserede GPU'er med store mængder hukommelse. Derudover kan størrelsen af ​​disse modeller gøre dem beregningsmæssigt dyre, hvilket kan øge trænings- og inferenstider markant.

I dette indlæg viser vi, hvordan vi kan bruge Amazon SageMaker JumpStart for nemt at finjustere en storsproget tekstgenereringsmodel på et domænespecifikt datasæt på samme måde, som du ville træne og implementere enhver model på Amazon SageMaker. Vi viser især, hvordan du kan finjustere GPT-J 6B sprogmodellen til generering af finansiel tekst ved hjælp af både JumpStart SDK og Amazon SageMaker Studio UI på et offentligt tilgængeligt datasæt af SEC-arkiveringer.

JumpStart hjælper dig hurtigt og nemt med at komme i gang med maskinlæring (ML) og giver et sæt løsninger til de mest almindelige use cases, som nemt kan trænes og implementeres med blot et par trin. Alle trinene i denne demo er tilgængelige i den medfølgende notesbog Finjustering af tekstgenerering GPT-J 6B-model på et domænespecifikt datasæt.

Løsningsoversigt

I de følgende afsnit giver vi en trin-for-trin demonstration til finjustering af en LLM til tekstgenereringsopgaver via både JumpStart Studio UI og Python SDK. Vi diskuterer især følgende emner:

• En oversigt over SEC-arkiveringsdata i det finansielle domæne, som modellen er finjusteret på
• En oversigt over LLM GPT-J 6B modellen, vi har valgt at finjustere
• En demonstration af to forskellige måder, vi kan finjustere LLM ved hjælp af JumpStart:
  • Brug JumpStart programmatisk med SageMaker Python SDK
  • Få adgang til JumpStart ved hjælp af Studio UI
• En evaluering af den finjusterede model ved at sammenligne den med den fortrænede model uden finjustering

Finjustering refererer til processen med at tage en fortrænet sprogmodel og træne den til en anden, men relateret opgave ved hjælp af specifikke data. Denne tilgang er også kendt som overføre læring, som går ud på at overføre den lærte viden fra en opgave til en anden. LLM'er som GPT-J 6B trænes på enorme mængder umærkede data og kan finjusteres på mindre datasæt, hvilket får modellen til at yde bedre i et specifikt domæne.

Som et eksempel på, hvordan ydeevnen forbedres, når modellen finjusteres, kan du overveje at stille den følgende spørgsmål:

"Hvad driver salgsvæksten hos Amazon?"

Uden finjustering ville svaret være:

“Amazon er verdens største online forhandler. Det er også verdens største online markedsplads. Det er også verden”

Med finjustering er svaret:

"Salgsvækst hos Amazon er primært drevet af øget kundebrug, herunder øget udvalg, lavere priser og øget bekvemmelighed og øget salg fra andre sælgere på vores hjemmesider."

Forbedringen fra finjustering er tydelig.

Vi bruger finansiel tekst fra SEC-arkiver til at finjustere en GPT-J 6B LLM til finansielle applikationer. I de næste afsnit introducerer vi dataene og LLM, der vil blive finjusteret.

SEC-arkiveringsdatasæt

SEC-ansøgninger er afgørende for regulering og offentliggørelse i finanssektoren. Arkiver informerer investorsamfundet om virksomhedernes forretningsforhold og virksomhedernes fremtidsudsigter. Teksten i SEC-ansøgninger dækker hele spektret af en virksomheds drift og forretningsbetingelser. På grund af deres potentielle forudsigelige værdi er disse ansøgninger gode informationskilder for investorer. Selvom disse SEC ansøgninger er offentligt tilgængelige for alle er det en tidskrævende øvelse at downloade analyserede filer og konstruere et rent datasæt med tilføjede funktioner. Vi gør dette muligt i nogle få API-kald i JumpStart Industri SDK.

Ved at bruge SageMaker API downloadede vi årsrapporter (10-K ansøgninger; se Sådan læser du en 10-K for mere information) for et stort antal virksomheder. Vi vælger Amazons SEC-arkiveringsrapporter for årene 2021-2022 som træningsdata for at finjustere GPT-J 6B-modellen. Især sammenkæder vi virksomhedens SEC-indberetningsrapporter i forskellige år i en enkelt tekstfil med undtagelse af afsnittet "Management Diskussion and Analysis", som indeholder fremadrettede udsagn fra virksomhedens ledelse og bruges som valideringsdata.

Forventningen er, at efter finjustering af GPT-J 6B-tekstgenereringsmodellen på de finansielle SEC-dokumenter, er modellen i stand til at generere indsigtsfuldt finansielt relateret tekstoutput og kan derfor bruges til at løse flere domænespecifikke NLP-opgaver.

GPT-J 6B stor sprogmodel

GPT-J 6B er en open source model med 6 milliarder parametre frigivet af Eleuther AI. GPT-J 6B er blevet trænet i et stort korpus af tekstdata og er i stand til at udføre forskellige NLP-opgaver såsom tekstgenerering, tekstklassificering og tekstresumé. Selvom denne model er imponerende på en række NLP-opgaver uden behov for nogen finjustering, bliver du i mange tilfælde nødt til at finjustere modellen på et specifikt datasæt og NLP-opgaver, du forsøger at løse. Brugstilfælde omfatter tilpassede chatbots, idégenerering, enhedsudtrækning, klassificering og sentimentanalyse.

Få adgang til LLM'er på SageMaker

Nu hvor vi har identificeret datasættet og modellen, vi skal finjustere på, giver JumpStart to muligheder for at komme i gang med at bruge finjustering af tekstgenerering: SageMaker SDK og Studio.

Brug JumpStart programmatisk med SageMaker SDK

Vi gennemgår nu et eksempel på, hvordan du kan bruge SageMaker JumpStart SDK til at få adgang til en LLM (GPT-J 6B) og finjustere den på SEC-arkiveringsdatasættet. Når finjusteringen er afsluttet, vil vi implementere den finjusterede model og drage konklusioner imod den. Alle trinene i dette indlæg er tilgængelige i den medfølgende notesbog: Finjustering af tekstgenerering GPT-J 6B-model på domænespecifikt datasæt.

I dette eksempel bruger JumpStart SageMaker Hugging Face Deep Learning Container (DLC) og DeepSpeed bibliotek for at finjustere modellen. DeepSpeed-biblioteket er designet til at reducere computerkraft og hukommelsesbrug og til at træne store distribuerede modeller med bedre parallelitet på eksisterende computerhardware. Den understøtter single node-distribueret træning, ved at bruge gradient checkpointing og modelparallelisme til at træne store modeller på en enkelt SageMaker-træningsinstans med flere GPU'er. Med JumpStart integrerer vi DeepSpeed-biblioteket med SageMaker Hugging Face DLC for dig og tager os af alt under motorhjelmen. Du kan nemt finjustere modellen på dit domænespecifikke datasæt uden at konfigurere det manuelt.

Finjuster den fortrænede model på domænespecifikke data

For at finjustere en udvalgt model skal vi få den models URI samt træningsscriptet og containerbilledet, der bruges til træning. For at gøre tingene nemmere afhænger disse tre input udelukkende af modelnavnet, versionen (for en liste over de tilgængelige modeller, se Indbyggede algoritmer med fortrænet modelbord), og den type instans, du vil træne på. Dette er demonstreret i følgende kodestykke:

from sagemaker import image_uris, model_uris, script_uris, hyperparameters model_id, model_version = "huggingface-textgeneration1-gpt-j-6b", "*"
training_instance_type = "ml.g5.12xlarge" # Retrieve the docker image
train_image_uri = image_uris.retrieve( region=None, framework=None, model_id=model_id, model_version=model_version, image_scope="training", instance_type=training_instance_type,
) # Retrieve the training script
train_source_uri = script_uris.retrieve( model_id=model_id, model_version=model_version, script_scope="training"
) # Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve( model_id=model_id, model_version=model_version, model_scope="training"
)

Vi henter model_id svarende til den samme model, vi ønsker at bruge. I dette tilfælde finjusterer vi huggingface-textgeneration1-gpt-j-6b.

At definere hyperparametre involverer indstilling af værdierne for forskellige parametre, der bruges under træningsprocessen for en ML-model. Disse parametre kan påvirke modellens ydeevne og nøjagtighed. I det følgende trin etablerer vi hyperparametrene ved at bruge standardindstillingerne og angive brugerdefinerede værdier for parametre som f.eks. epochs , learning_rate:

from sagemaker import hyperparameters # Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version) # [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "6" hyperparameters["learning_rate"] = "2e-04"
print(hyperparameters)

JumpStart giver en omfattende liste over hyperparametre, der er tilgængelige for tuning. Den følgende liste giver et overblik over en del af de vigtigste hyperparametre, der bruges til at finjustere modellen. For en komplet liste over hyperparametre, se notesbogen Finjustering af tekstgenerering GPT-J 6B-model på domænespecifikt datasæt.

• epoker – Angiver højst, hvor mange epoker af det originale datasæt, der vil blive itereret.
• learning_rate – Styrer trinstørrelsen eller indlæringshastigheden for optimeringsalgoritmen under træning.
• eval_trin – Angiver, hvor mange trin, der skal køres, før modellen evalueres på valideringssættet under træning. Valideringssættet er en delmængde af dataene, der ikke bruges til træning, men i stedet bruges til at kontrollere modellens ydeevne på usete data.
• vægt_henfald – Styrer regulariseringsstyrken under modeltræning. Regularisering er en teknik, der hjælper med at forhindre modellen i at overfitte træningsdataene, hvilket kan resultere i bedre præstationer på usete data.
• fp16 – Styrer, om der skal bruges fp16 16-bit (blandet) præcisionstræning i stedet for 32-bit træning.
• evalueringsstrategi – Evalueringsstrategien brugt under uddannelsen.
• gradient_akkumulation_trin – Antallet af opdateringstrin, der skal akkumuleres gradienterne for, før der udføres et tilbage-/opdateringspass.

For yderligere detaljer vedrørende hyperparametre henvises til embedsmanden Kram Face Trainer dokumentation.

Du kan nu finjustere denne JumpStart-model på dit eget brugerdefinerede datasæt ved hjælp af SageMaker SDK. Vi bruger SEC-arkiveringsdataene, vi beskrev tidligere. Tog- og valideringsdataene er hostet under train_dataset_s3_path , validation_dataset_s3_path. Det understøttede format af data inkluderer CSV, JSON og TXT. For CSV- og JSON-dataene bruges tekstdataene fra den kaldede kolonne text eller den første kolonne, hvis der ikke findes en kolonne kaldet tekst. Fordi dette er til finjustering af tekstgenerering, kræves der ingen grundsandhedsetiketter. Følgende kode er et SDK-eksempel på, hvordan man finjusterer modellen:

from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
from sagemaker.tuner import HyperparameterTuner
from sagemaker.huggingface import HuggingFace train_dataset_s3_path = "s3://jumpstart-cache-prod-us-west-2/training-datasets/tc/data.csv"
validation_dataset_s3_path = "s3://jumpstart-cache-prod-us-west-2/training-datasets/tc/data.csv" training_job_name = name_from_base(f"jumpstart-example-{model_id}") metric_definitions=[ {'Name': 'train:loss', 'Regex': "'loss': ([0-9]+.[0-9]+)"}, {'Name': 'eval:loss', 'Regex': "'eval_loss': ([0-9]+.[0-9]+)"}, {'Name': 'eval:runtime', 'Regex': "'eval_runtime': ([0-9]+.[0-9]+)"}, {'Name': 'eval:samples_per_second', 'Regex': "'eval_samples_per_second': ([0-9]+.[0-9]+)"}, {'Name': 'eval:eval_steps_per_second', 'Regex': "'eval_steps_per_second': ([0-9]+.[0-9]+)"},
] # # Create SageMaker Estimator instance
tg_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", instance_count=1, instance_type=training_instance_type, hyperparameters=hyperparameters, output_path=s3_output_location, base_job_name=training_job_name, enable_network_isolation=True, metric_definitions=metric_definitions
) # Launch a SageMaker Training job by passing s3 path of the training data
tg_estimator.fit({"train": train_dataset_s3_path, "validation": validation_dataset_s3_path}, logs=True)

Efter at vi har konfigureret SageMaker Estimator med de nødvendige hyperparametre, instansierer vi en SageMaker Estimator og kalder .fit metode til at begynde at finjustere vores model ved at give den videre Amazon Simple Storage Service (Amazon S3) URI for vores træningsdata. Som du kan se, er entry_point det angivne script er navngivet transfer_learning.py (det samme for andre opgaver og modeller), og inputdatakanalen videregivet til .fit skal benævnes tog og validering.

JumpStart understøtter også hyperparameteroptimering med SageMaker automatisk model tuning. For detaljer, se eksemplet notesbog.

Implementer den finjusterede model

Når træningen er færdig, kan du implementere din finjusterede model. For at gøre det, er alt, hvad vi behøver at opnå, inferensscript-URI (koden, der bestemmer, hvordan modellen bruges til inferens, når den først er installeret) og inferenscontainerbillede-URI, som inkluderer en passende modelserver til at være vært for den model, vi valgte. Se følgende kode:

from sagemaker.predictor import Predictor
from sagemaker import image_uris
from sagemaker.utils import name_from_base
import boto3 sagemaker_session = sagemaker.Session(boto_session=boto3.Session(region_name="us-west-2")) #Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve( region=None, framework=None, image_scope="inference", model_id=model_id, model_version=model_version, instance_type=inference_instance_type,
) endpoint_name = name_from_base(f"jumpstart-example-{model_id}") # Use the estimator from the previous step to deploy to a SageMaker endpoint
finetuned_predictor = tg_estimator.deploy( initial_instance_count=1, instance_type="ml.g5.12xlarge", image_uri=image_uri, endpoint_name=endpoint_name,
)

Efter et par minutter er vores model implementeret, og vi kan få forudsigelser fra den i realtid!

Få adgang til JumpStart gennem Studio UI

En anden måde at finjustere og implementere JumpStart-modeller er gennem Studio UI. Denne brugergrænseflade giver en lav-kode/ingen kode løsning til finjustering af LLM'er.

På Studio-konsollen skal du vælge Modeller, notesbøger, løsninger under SageMaker JumpStart i navigationsruden.

I søgelinjen skal du søge efter den model, du vil finjustere og implementere.

I vores tilfælde valgte vi modelkortet GPT-J 6B. Her kan vi direkte finjustere eller implementere LLM.

Modelvurdering

Når vi evaluerer en LLM, kan vi bruge perplexity (PPL). PPL er et fælles mål for, hvor godt en sprogmodel er i stand til at forudsige det næste ord i en sekvens. I enklere vendinger er det en måde at måle, hvor godt modellen kan forstå og generere menneskelignende sprog.

En lavere perplexity-score betyder, at modellen viser sig at præstere bedre til at forudsige det næste ord. Rent praktisk kan vi bruge forvirring til at sammenligne forskellige sprogmodeller og afgøre, hvilken der klarer sig bedst på en given opgave. Vi kan også bruge det til at spore en enkelt models ydeevne over tid. For flere detaljer, se Forvirring af modeller med fast længde.

Vi evaluerer modellens ydeevne gennem en sammenligning af dens præ- og post-finjusteringsydelse. PPL udsendes i træningsjobbet amazoncloudwatch logs. Derudover ser vi på output genereret af modellen som svar på specifikke test-prompter.

Modellens forbedrede ydeevne demonstreres af to eksperimenter:

• Tekstgenerering – Vi viser, at outputtet af den finjusterede GPT-J genererer tekst, der ligner SEC-datasættet, hvilket indikerer, at det har lært at efterligne sprogmønstrene og konventionerne i det finansielle regulatoriske domæne
• Zero-shot læring – Vi demonstrerer, at den finjusterede GPT-J viser væsentligt bedre ydeevne end den ikke-finjusterede GPT-J på nul-shot spørgsmålssvar

Til tekstgenereringseksperimentet bruger vi følgende inferensparametre for at opnå vores resultater: max_length på 400 (antal returnerede poletter), num_return_sequences af 1 (antal svarteksteksempler), top_k af 250 (vælg fra en af ​​de øverste 250 mulige fortsættelser), top_p på 0.8 (vælg kun fra fortsættelser, der er mindst 80 % sandsynlige), do_sample is True (prøveudtagning), og temperature på 1 (høj temperatur er større tilfældighed i svar). For flere detaljer om parametrene, se GenerationConfig. Følgende tabel sammenligner den finjusterede GPT-J og den ikke-finjusterede på en tekstfuldførelsesopgave.

Til det andet eksperiment med en opgave med nul-skudsspørgsmål satte vi max_length at være en anden værdi (henholdsvis 40, 200 og 40) baseret på det output, vi forventer fra hvert spørgsmål. Parametrene for top_k, top_p, do_sample, temperature er indstillet til 250, 0.8, Falsehenholdsvis 0 og 0. Vi indstiller temperaturen tæt på 1 for at kontrollere outputtet tilfældigt, mens vi i tekstgenereringsopgaven sætter den tæt på XNUMX for at gøre modellen mere kreativ. Følgende tabel sammenligner resultaterne. For hvert spørgsmål er outputtet fra finjusteret GPT-J mere nøjagtigt end det ikke-finjusterede.

Ryd op

For at undgå løbende opkrævninger skal du slette SageMaker-slutpunkterne. Du kan slette endepunkterne via SageMaker-konsollen eller fra notesbogen ved at bruge følgende kommandoer:

# Delete the SageMaker endpoint and the attached resources
finetuned_predictor.delete_model()
finetuned_predictor.delete_endpoint()

Konklusion

JumpStart er en funktion i SageMaker, der giver dig mulighed for hurtigt at komme i gang med ML. JumpStart bruger open source, forudtrænede modeller til at løse almindelige ML-problemer som billedklassificering, objektgenkendelse, tekstklassificering, sætningsparklassificering og besvarelse af spørgsmål.

I dette indlæg viste vi dig, hvordan du finjusterer og implementerer en forudtrænet LLM (GPT-J 6B) til tekstgenerering baseret på SEC-fyldningsdatasættet. Vi demonstrerede, hvordan modellen forvandlede sig til en finansdomæneekspert ved at gennemgå finjusteringsprocessen på blot to årsrapporter fra virksomheden. Denne finjustering gjorde det muligt for modellen at generere indhold med en forståelse af økonomiske emner og større præcision. Prøv løsningen på egen hånd, og lad os vide, hvordan det går i kommentarerne.

Vigtigt: Dette indlæg er kun til demonstrationsformål. Det er ikke finansiel rådgivning og bør ikke påberåbes som finansiel eller investeringsrådgivning. Posten brugte modeller, der var forudtrænede på data hentet fra SEC EDGAR-databasen. Du er ansvarlig for at overholde EDGARs adgangsvilkår og -betingelser, hvis du bruger SEC-data.

For at lære mere om JumpStart, tjek følgende indlæg:

Om forfatterne

Dr. Xin Huang er en Senior Applied Scientist for Amazon SageMaker JumpStart og Amazon SageMaker indbyggede algoritmer. Han fokuserer på at udvikle skalerbare maskinlæringsalgoritmer. Hans forskningsinteresser er inden for området naturlig sprogbehandling, forklarlig dyb læring på tabeldata og robust analyse af ikke-parametrisk rum-tid-klynger. Han har udgivet mange artikler i ACL, ICDM, KDD-konferencer og Royal Statistical Society: Series A.

Marc Karp er en ML-arkitekt hos Amazon SageMaker Service-teamet. Han fokuserer på at hjælpe kunder med at designe, implementere og administrere ML-arbejdsbelastninger i stor skala. I sin fritid nyder han at rejse og udforske nye steder.

Dr. Sanjiv Das er Amazon Scholar og Terry-professor i finans- og datavidenskab ved Santa Clara University. Han har post-graduate grader i finans (M.Phil og PhD fra New York University) og Computer Science (MS fra UC Berkeley) og en MBA fra Indian Institute of Management, Ahmedabad. Før han blev akademiker, arbejdede han i derivatbranchen i Asien-Stillehavsområdet som Vice President hos Citibank. Han arbejder med multimodal maskinlæring inden for finansielle applikationer.

Arun Kumar Lokanatha er senior ML Solutions Architect hos Amazon SageMaker Service-teamet. Han fokuserer på at hjælpe kunder med at opbygge, træne og migrere ML-produktionsarbejdsbelastninger til SageMaker i stor skala. Han har specialiseret sig i deep learning, især inden for NLP og CV. Uden for arbejdet nyder han at løbe og vandre.

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• Platoblokkæde. Web3 Metaverse Intelligence. Viden forstærket. Adgang her.
• Udmøntning af fremtiden med Adryenn Ashley. Adgang her.
• Kilde: https://aws.amazon.com/blogs/machine-learning/domain-adaptation-fine-tuning-of-foundation-models-in-amazon-sagemaker-jumpstart-on-financial-data/