Grote taalmodellen (LLM's) met miljarden parameters lopen momenteel voorop in natuurlijke taalverwerking (NLP). Deze modellen schudden het veld wakker met hun ongelooflijke mogelijkheden om tekst te genereren, sentiment te analyseren, talen te vertalen en nog veel meer. Met toegang tot enorme hoeveelheden gegevens hebben LLM's het potentieel om een ​​revolutie teweeg te brengen in de manier waarop we omgaan met taal. Hoewel LLM's in staat zijn om verschillende NLP-taken uit te voeren, worden ze beschouwd als generalisten en niet als specialisten. Om een ​​LLM op te leiden tot een expert in een bepaald domein, is meestal afstemming vereist.

Een van de grootste uitdagingen bij het trainen en implementeren van LLM's met miljarden parameters is hun omvang, waardoor het moeilijk kan zijn om ze in afzonderlijke GPU's in te passen, de hardware die gewoonlijk wordt gebruikt voor diep leren. De enorme schaal van deze modellen vereist krachtige computerbronnen, zoals gespecialiseerde GPU's met grote hoeveelheden geheugen. Bovendien kan de grootte van deze modellen ze rekenkundig duur maken, wat de trainings- en inferentietijden aanzienlijk kan verlengen.

In dit bericht laten we zien hoe we kunnen gebruiken Amazon SageMaker JumpStart om eenvoudig een model voor het genereren van grote taalteksten te verfijnen op een domeinspecifieke dataset, op dezelfde manier waarop u elk model zou trainen en implementeren op Amazon Sage Maker. We laten met name zien hoe u het GPT-J 6B-taalmodel voor het genereren van financiële teksten kunt verfijnen met behulp van zowel de JumpStart SDK als Amazon SageMaker Studio UI op een openbaar beschikbare dataset van SEC-deponeringen.

JumpStart helpt u snel en eenvoudig aan de slag te gaan met machine learning (ML) en biedt een reeks oplossingen voor de meest voorkomende use cases die in slechts enkele stappen kunnen worden getraind en geïmplementeerd. Alle stappen in deze demo zijn beschikbaar in het bijbehorende notitieboekje Verfijning van het GPT-J 6B-model voor het genereren van tekst op een domeinspecifieke dataset.

Overzicht oplossingen

In de volgende secties geven we een stapsgewijze demonstratie voor het verfijnen van een LLM voor taken voor het genereren van tekst via zowel de gebruikersinterface van JumpStart Studio als de Python SDK. In het bijzonder bespreken we de volgende onderwerpen:

• Een overzicht van de SEC-archiveringsgegevens in het financiële domein waarop het model is afgestemd
• Een overzicht van het LLM GPT-J 6B-model dat we hebben gekozen om te verfijnen
• Een demonstratie van twee verschillende manieren waarop we de LLM kunnen verfijnen met behulp van JumpStart:
  • Gebruik JumpStart programmatisch met de SageMaker Python SDK
  • Open JumpStart met behulp van de gebruikersinterface van Studio
• Een evaluatie van het verfijnde model door het te vergelijken met het vooraf getrainde model zonder fijnafstemming

Fine-tuning verwijst naar het proces van het nemen van een vooraf getraind taalmodel en het trainen voor een andere maar gerelateerde taak met behulp van specifieke gegevens. Deze aanpak wordt ook wel genoemd overdracht leren, wat inhoudt dat de geleerde kennis van de ene taak naar de andere wordt overgedragen. LLM's zoals GPT-J 6B zijn getraind op enorme hoeveelheden niet-gelabelde data en kunnen worden verfijnd op kleinere datasets, waardoor het model beter presteert in een specifiek domein.

Als voorbeeld van hoe de prestaties verbeteren wanneer het model wordt verfijnd, kunt u overwegen het de volgende vraag te stellen:

"Wat drijft de omzetgroei bij Amazon?"

Zonder fijnafstemming zou het antwoord zijn:

“Amazon is 's werelds grootste online retailer. Het is ook 's werelds grootste online marktplaats. Het is ook de wereld”

Met fijnafstemming is de respons:

"De omzetgroei bij Amazon wordt voornamelijk gedreven door een groter gebruik door klanten, waaronder meer keuze, lagere prijzen en meer gemak, en meer verkopen door andere verkopers op onze websites."

De verbetering van fine-tuning is duidelijk.

We gebruiken financiële tekst van SEC-deponeringen om een ​​GPT-J 6B LLM te verfijnen voor financiële toepassingen. In de volgende secties introduceren we de gegevens en de LLM die zullen worden verfijnd.

SEC archivering dataset

SEC-deponeringen zijn van cruciaal belang voor regulering en openbaarmaking in de financiële wereld. Deponeringen stellen de beleggersgemeenschap op de hoogte van de zakelijke omstandigheden van bedrijven en de toekomstige vooruitzichten van de bedrijven. De tekst in SEC-deponeringen bestrijkt het hele scala van de activiteiten en bedrijfsomstandigheden van een bedrijf. Vanwege hun potentiële voorspellende waarde zijn deze deponeringen goede informatiebronnen voor beleggers. Hoewel deze SEC-deponeringen dat wel zijn publiekelijk verkrijgbaar voor iedereen is het downloaden van geparseerde bestanden en het samenstellen van een schone dataset met toegevoegde functies een tijdrovende bezigheid. We maken dit mogelijk in een paar API-aanroepen in de JumpStart Industrie-SDK.

Met behulp van de SageMaker API hebben we jaarverslagen gedownload (10-K deponeringen; zien Hoe een 10-K te lezen voor meer informatie) voor een groot aantal bedrijven. We selecteren de SEC-archiveringsrapporten van Amazon voor de jaren 2021–2022 als trainingsgegevens om het GPT-J 6B-model te verfijnen. In het bijzonder voegen we de SEC-rapporten van het bedrijf over verschillende jaren samen in één enkel tekstbestand, met uitzondering van het gedeelte 'Managementdiscussie en -analyse', dat toekomstgerichte verklaringen van het management van het bedrijf bevat en wordt gebruikt als validatiegegevens.

De verwachting is dat na het verfijnen van het GPT-J 6B-tekstgeneratiemodel op de financiële SEC-documenten, het model in staat is om inzichtelijke financieel gerelateerde tekstuele output te genereren, en daarom kan worden gebruikt om meerdere domeinspecifieke NLP-taken op te lossen.

GPT-J 6B groot taalmodel

GPT-J 6B is een open-source model met 6 miljard parameters dat is uitgebracht door Eleuther AI. GPT-J 6B is getraind op een groot corpus aan tekstgegevens en is in staat om verschillende NLP-taken uit te voeren, zoals het genereren van tekst, tekstclassificatie en tekstsamenvatting. Hoewel dit model indrukwekkend is voor een aantal NLP-taken zonder enige fijnafstemming, zult u in veel gevallen het model moeten afstemmen op een specifieke dataset en NLP-taken die u probeert op te lossen. Gebruiksvoorbeelden zijn onder meer aangepaste chatbots, het genereren van ideeën, extractie van entiteiten, classificatie en sentimentanalyse.

Toegang tot LLM's op SageMaker

Nu we de dataset en het model waarop we gaan verfijnen hebben geïdentificeerd, biedt JumpStart twee mogelijkheden om aan de slag te gaan met het verfijnen van tekstgeneratie: de SageMaker SDK en Studio.

Gebruik JumpStart programmatisch met de SageMaker SDK

We bespreken nu een voorbeeld van hoe u de SageMaker JumpStart SDK kunt gebruiken om toegang te krijgen tot een LLM (GPT-J 6B) en deze te verfijnen op de SEC-archiveringsdataset. Na voltooiing van de fijnafstemming zullen we het verfijnde model inzetten en hier conclusies aan verbinden. Alle stappen in dit bericht zijn beschikbaar in het bijbehorende notitieboekje: Verfijning van GPT-J 6B-model voor tekstgeneratie op domeinspecifieke dataset.

In dit voorbeeld gebruikt JumpStart de SageMaker Hugging Face Deep Learning-container (DLC) en diepe snelheid bibliotheek om het model te verfijnen. De DeepSpeed-bibliotheek is ontworpen om de rekenkracht en het geheugengebruik te verminderen en om grote gedistribueerde modellen te trainen met betere parallelliteit op bestaande computerhardware. Het ondersteunt gedistribueerde training met één knooppunt, waarbij gebruik wordt gemaakt van gradiëntcontrolepunten en modelparallelisme om grote modellen te trainen op één enkele SageMaker-trainingsinstantie met meerdere GPU's. Met JumpStart integreren we de DeepSpeed-bibliotheek met de SageMaker Hugging Face DLC voor jou en regelen we alles onder de motorkap. U kunt het model eenvoudig afstemmen op uw domeinspecifieke dataset zonder het handmatig in te stellen.

Verfijn het vooraf getrainde model op domeinspecifieke gegevens

Om een ​​geselecteerd model te verfijnen, hebben we de URI van dat model nodig, evenals het trainingsscript en de containerimage die voor training wordt gebruikt. Om het u gemakkelijk te maken, zijn deze drie invoergegevens uitsluitend afhankelijk van de modelnaam, versie (voor een lijst met beschikbare modellen, zie Ingebouwde algoritmen met vooraf getrainde modeltabel), en het type instantie waarop u wilt trainen. Dit wordt gedemonstreerd in het volgende codefragment:

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

We halen de model_id overeenkomend met hetzelfde model dat we willen gebruiken. In dit geval stemmen we af huggingface-textgeneration1-gpt-j-6b.

Het definiëren van hyperparameters omvat het instellen van de waarden voor verschillende parameters die worden gebruikt tijdens het trainingsproces van een ML-model. Deze parameters kunnen de prestaties en nauwkeurigheid van het model beïnvloeden. In de volgende stap stellen we de hyperparameters vast door de standaardinstellingen te gebruiken en aangepaste waarden op te geven voor parameters zoals epochs en 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 biedt een uitgebreide lijst met hyperparameters die beschikbaar zijn om af te stemmen. De volgende lijst geeft een overzicht van een deel van de belangrijkste hyperparameters die worden gebruikt bij het verfijnen van het model. Zie de notebook voor een volledige lijst met hyperparameters Verfijning van GPT-J 6B-model voor tekstgeneratie op domeinspecifieke dataset.

• tijdperken – Specificeert maximaal hoeveel tijdperken van de originele dataset zullen worden herhaald.
• leertempo – Regelt de stapgrootte of leersnelheid van het optimalisatie-algoritme tijdens de training.
• evaluatie_stappen – Geeft aan hoeveel stappen er moeten worden uitgevoerd voordat het model tijdens de training op de validatieset wordt geëvalueerd. De validatieset is een subset van de gegevens die niet wordt gebruikt voor training, maar wordt gebruikt om de prestaties van het model op ongeziene gegevens te controleren.
• gewicht_verval - Regelt de regularisatiekracht tijdens modeltraining. Regularisatie is een techniek die helpt voorkomen dat het model de trainingsgegevens overfit, wat kan resulteren in betere prestaties op ongeziene gegevens.
• fp16 – Bepaalt of fp16 16-bits (gemengde) precisietraining moet worden gebruikt in plaats van 32-bits training.
• evaluatie_strategie – De evaluatiestrategie die tijdens de training wordt gebruikt.
• gradiënt_accumulatie_stappen – Het aantal update-stappen waarvoor de hellingen moeten worden verzameld, voordat een achterwaartse/update-pass wordt uitgevoerd.

Raadpleeg de ambtenaar voor meer informatie over hyperparameters Hugging Face Trainer-documentatie.

U kunt dit JumpStart-model nu verfijnen op uw eigen aangepaste dataset met behulp van de SageMaker SDK. We gebruiken de SEC-archiveringsgegevens die we eerder hebben beschreven. De trein- en validatiegegevens worden gehost onder train_dataset_s3_path en validation_dataset_s3_path. Het ondersteunde formaat van de gegevens omvat CSV, JSON en TXT. Voor de CSV- en JSON-gegevens worden de tekstgegevens uit de aangeroepen kolom gebruikt text of de eerste kolom als er geen kolom met de naam tekst is gevonden. Omdat dit voor de fijnafstemming van het genereren van tekst is, zijn er geen Ground Truth-labels vereist. De volgende code is een SDK-voorbeeld van het verfijnen van het model:

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)

Nadat we de SageMaker Estimator met de vereiste hyperparameters hebben ingesteld, instantiëren we een SageMaker Estimator en roepen we de .fit methode om te beginnen met het verfijnen van ons model, het doorgeven aan de Amazon eenvoudige opslagservice (Amazon S3) URI voor onze trainingsgegevens. Zoals je kunt zien, de entry_point het opgegeven script heeft een naam transfer_learning.py (hetzelfde voor andere taken en modellen), en het invoergegevenskanaal doorgegeven aan .fit moet trein en validatie heten.

JumpStart ondersteunt ook hyperparameteroptimalisatie met Automatische afstemming van SageMaker-modellen. Zie het voorbeeld voor details notitieboekje.

Het verfijnde model implementeren

Wanneer de training is voltooid, kunt u uw verfijnde model implementeren. Om dit te doen, hebben we alleen de URI van het inferentiescript nodig (de code die bepaalt hoe het model wordt gebruikt voor inferentie zodra het is geïmplementeerd) en de URI van de inferentiecontainer, die een geschikte modelserver bevat om het door ons gekozen model te hosten. Zie de volgende code:

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

Na een paar minuten is ons model geïmplementeerd en kunnen we er in realtime voorspellingen van krijgen!

Toegang tot JumpStart via de Studio UI

Een andere manier om JumpStart-modellen te verfijnen en te implementeren is via de gebruikersinterface van Studio. Deze gebruikersinterface biedt een low-code/no-code-oplossing voor het verfijnen van LLM's.

Kies op de Studio-console Modellen, notebooks, oplossingen voor SageMaker JumpStart in het navigatievenster.

Zoek in de zoekbalk naar het model dat u wilt verfijnen en implementeren.

In ons geval hebben we gekozen voor de GPT-J 6B-modelkaart. Hier kunnen we de LLM direct finetunen of inzetten.

Modelevaluatie

Bij het evalueren van een LLM kunnen we perplexiteit (PPL) gebruiken. PPL is een gebruikelijke maatstaf voor hoe goed een taalmodel het volgende woord in een reeks kan voorspellen. In eenvoudiger bewoordingen is het een manier om te meten hoe goed het model mensachtige taal kan begrijpen en genereren.

Een lagere perplexiteitsscore betekent dat het model beter blijkt te presteren in het voorspellen van het volgende woord. In praktische termen kunnen we perplexiteit gebruiken om verschillende taalmodellen te vergelijken en te bepalen welke beter presteert op een bepaalde taak. We kunnen het ook gebruiken om de prestaties van een enkel model in de loop van de tijd te volgen. Voor meer details, zie Perplexiteit van modellen met een vaste lengte.

We evalueren de prestaties van het model door een vergelijking van de pre- en post-finetuningprestaties. PPL wordt afgegeven in de opleidingsfuncties Amazon Cloud Watch logboeken. Daarnaast kijken we naar de output die het model genereert als reactie op specifieke testprompts.

De verbeterde prestaties van het model worden aangetoond door twee experimenten:

• Tekstgeneratie – We laten zien dat de uitvoer van de verfijnde GPT-J tekst genereert die lijkt op de SEC-dataset, wat aangeeft dat het heeft geleerd om de taalpatronen en conventies van het domein van financiële regelgeving na te bootsen
• Zero-shot leren – We tonen aan dat de nauwkeurig afgestelde GPT-J aanzienlijk betere prestaties laat zien dan de niet-afgestelde GPT-J bij het beantwoorden van vragen met nul schoten

Voor het tekstgeneratie-experiment gebruiken we de volgende inferentieparameters om onze resultaten te bereiken: max_length van 400 (aantal geretourneerde tokens), num_return_sequences van 1 (aantal reactietekstvoorbeelden), top_k van 250 (kies uit een van de 250 beste mogelijke voortzettingen), top_p van 0.8 (selecteer alleen voortzettingen die ten minste 80% waarschijnlijk zijn), do_sample is True (bemonstering), en temperature van 1 (hoge temperatuur is grotere willekeur in reacties). Voor meer details over de parameters, zie GeneratieConfig. De volgende tabel vergelijkt de nauwkeurig afgestelde GPT-J en de niet-afgestemde GPT-J op een tekstaanvullingstaak.

Voor het tweede experiment met een zero-shot vraagantwoordtaak hebben we de max_length een andere waarde zijn (respectievelijk 40, 200 en 40) op basis van de uitvoer die we van elke vraag verwachten. De parameters van top_k, top_p, do_sample, temperature zijn ingesteld als 250, 0.8, Falserespectievelijk , en 0. We hebben de temperatuur dicht bij 0 gezet om de willekeur van de uitvoer te regelen, terwijl we bij het genereren van tekst de temperatuur dicht bij 1 hebben gezet om het model creatiever te maken. De volgende tabel vergelijkt de resultaten. Voor elke vraag is de uitvoer van nauwkeurig afgestelde GPT-J nauwkeuriger dan de niet-afgestemde GPT-J.

Opruimen

Verwijder de SageMaker-inferentie-eindpunten om doorlopende kosten te voorkomen. U kunt de eindpunten verwijderen via de SageMaker-console of vanaf de notebook met behulp van de volgende opdrachten:

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

Conclusie

JumpStart is een mogelijkheid in SageMaker waarmee u snel aan de slag kunt met ML. JumpStart gebruikt open-source, vooraf getrainde modellen om veelvoorkomende ML-problemen op te lossen, zoals beeldclassificatie, objectdetectie, tekstclassificatie, zinpaarclassificatie en het beantwoorden van vragen.

In dit bericht hebben we u laten zien hoe u een vooraf getrainde LLM (GPT-J 6B) kunt verfijnen en implementeren voor het genereren van tekst op basis van de SEC-vullende dataset. We hebben laten zien hoe het model transformeerde tot een expert op het gebied van financiën door het finetuningproces te ondergaan op slechts twee jaarverslagen van het bedrijf. Door deze verfijning kon het model inhoud genereren met inzicht in financiële onderwerpen en met grotere precisie. Probeer de oplossing zelf uit en laat ons in de reacties weten hoe het gaat.

Belangrijk: dit bericht is alleen voor demonstratieve doeleinden. Het is geen financieel advies en mag niet worden gebruikt als financieel of beleggingsadvies. De post gebruikte modellen die vooraf waren getraind op gegevens die waren verkregen uit de SEC EDGAR-database. U bent verantwoordelijk voor het naleven van de toegangsvoorwaarden van EDGAR als u SEC-gegevens gebruikt.

Bekijk de volgende berichten voor meer informatie over JumpStart:

Over de auteurs

Dr Xin Huang is een Senior Applied Scientist voor Amazon SageMaker JumpStart en Amazon SageMaker ingebouwde algoritmen. Hij richt zich op het ontwikkelen van schaalbare machine learning-algoritmen. Zijn onderzoeksinteresses liggen op het gebied van natuurlijke taalverwerking, verklaarbaar diep leren op tabelgegevens en robuuste analyse van niet-parametrische ruimte-tijd clustering. Hij heeft veel artikelen gepubliceerd in ACL-, ICDM-, KDD-conferenties en Royal Statistical Society: Series A.

Marc Karp is een ML-architect bij het Amazon SageMaker Service-team. Hij richt zich op het helpen van klanten bij het ontwerpen, implementeren en beheren van ML-workloads op schaal. In zijn vrije tijd houdt hij van reizen en nieuwe plekken ontdekken.

Dr Sanjiv Das is een Amazon Scholar en de Terry Professor of Finance and Data Science aan de Santa Clara University. Hij heeft postdoctorale diploma's in Finance (M.Phil en PhD van New York University) en Computer Science (MS van UC Berkeley), en een MBA van het Indian Institute of Management, Ahmedabad. Voordat hij academicus werd, werkte hij in de derivatenhandel in de regio Azië-Pacific als Vice President bij Citibank. Hij werkt aan multimodaal machine learning op het gebied van financiële toepassingen.

Arun Kumar Lokanatha is een Senior ML Solutions Architect bij het Amazon SageMaker Service-team. Hij richt zich op het helpen van klanten bij het op grote schaal bouwen, trainen en migreren van ML-productieworkloads naar SageMaker. Hij is gespecialiseerd in deep learning, met name op het gebied van NLP en CV. Naast zijn werk houdt hij van hardlopen en wandelen.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• Platoblockchain. Web3 Metaverse Intelligentie. Kennis versterkt. Toegang hier.
• De toekomst slaan met Adryenn Ashley. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/financial-text-generation-using-a-domain-adapted-fine-tuned-large-language-model-in-amazon-sagemaker-jumpstart/