Finjustera Llama 2 för textgenerering på Amazon SageMaker JumpStart | Amazon webbtjänster

Idag är vi glada över att kunna tillkännage möjligheten att finjustera Llama 2-modeller av Meta med Amazon SageMaker JumpStart. Llama 2-familjen av stora språkmodeller (LLM) är en samling förtränade och finjusterade generativa textmodeller som sträcker sig i skala från 7 miljarder till 70 miljarder parametrar. Finjusterade LLM:er, kallade Llama-2-chat, är optimerade för dialoganvändningsfall. Du kan enkelt prova dessa modeller och använda dem med SageMaker JumpStart, som är ett nav för maskininlärning (ML) som ger tillgång till algoritmer, modeller och ML-lösningar så att du snabbt kan komma igång med ML. Nu kan du också finjustera 7 miljarder, 13 miljarder och 70 miljarder parametrar Llama 2-textgenereringsmodeller på SageMaker JumpStart med hjälp av Amazon SageMaker Studio UI med några få klick eller med SageMaker Python SDK.

Generativa AI-grundmodeller har varit i fokus för det mesta av ML och artificiell intelligens forskning och användningsfall i över ett år nu. Dessa grundmodeller fungerar mycket bra med generativa uppgifter, såsom textgenerering, sammanfattning, frågesvar, bild- och videogenerering, med mera, på grund av sin stora storlek och även för att de tränas på flera stora datamängder och hundratals uppgifter. Trots de stora generaliseringsmöjligheterna hos dessa modeller finns det ofta användningsfall som har mycket specifika domändata (som sjukvård eller finansiella tjänster), på grund av vilka dessa modeller kanske inte kan ge bra resultat för dessa användningsfall. Detta resulterar i ett behov av ytterligare finjustering av dessa generativa AI-modeller över användningsfallsspecifika och domänspecifika data.

I det här inlägget går vi igenom hur man finjusterar Llama 2 förtränade textgenereringsmodeller via SageMaker JumpStart.

Vad är Llama 2

Llama 2 är en autoregressiv språkmodell som använder en optimerad transformatorarkitektur. Llama 2 är avsedd för kommersiell och forskningsanvändning på engelska. Den finns i en rad parameterstorlekar – 7 miljarder, 13 miljarder och 70 miljarder – såväl som förtränade och finjusterade varianter. Enligt Meta använder de avstämda versionerna övervakad finjustering (SFT) och förstärkningsinlärning med mänsklig feedback (RLHF) för att anpassa sig till mänskliga preferenser för hjälpsamhet och säkerhet. Llama 2 var förtränad på 2 biljoner tokens data från allmänt tillgängliga källor. De avstämda modellerna är avsedda för assistentliknande chatt, medan förtränade modeller kan anpassas för en mängd olika naturliga språkgenereringsuppgifter. Oavsett vilken version av modellen en utvecklare använder, guide för ansvarsfull användning från Meta kan hjälpa till att vägleda ytterligare finjusteringar som kan vara nödvändiga för att anpassa och optimera modellerna med lämpliga säkerhetsbegränsningar.

För närvarande är Llama 2 tillgänglig i följande regioner:

• Distribuera förtränad modell tillgänglig: "us-west-2", "us-east-1", "us-east-2", "eu-west-1", "ap-southeast-1", "ap-southeast-2"
• Finjustera och distribuera den finjusterade modellen: “us-east-1”, “us-west-2”,“eu-west-1”

Vad är SageMaker JumpStart

Med SageMaker JumpStart kan ML-utövare välja från ett brett urval av allmänt tillgängliga grundmodeller. ML-utövare kan distribuera grundmodeller till dedikerade Amazon SageMaker instanser från en nätverksisolerad miljö och anpassa modeller med SageMaker för modellträning och implementering. Du kan nu upptäcka och distribuera Llama 2 med några få klick i SageMaker Studio eller programmatiskt genom SageMaker Python SDK, vilket gör att du kan härleda modellprestanda och MLOps-kontroller med SageMaker-funktioner som t.ex. Amazon SageMaker-rörledningar, Amazon SageMaker Debugger, eller behållarloggar. Modellen distribueras i en AWS säker miljö och under dina VPC-kontroller, vilket hjälper till att säkerställa datasäkerhet. Dessutom kan du finjustera Llama2 7B, 13B och 70B förtränade textgenereringsmodeller via SageMaker JumpStart.

Finjustera Llama2-modeller

Du kan finjustera modellerna med antingen SageMaker Studio UI eller SageMaker Python SDK. Vi diskuterar båda metoderna i detta avsnitt.

Finjustering utan kod via SageMaker Studio UI

I SageMaker Studio kan du komma åt Llama 2-modeller via SageMaker JumpStart under Modeller, anteckningsböcker och lösningar, som visas i följande skärmdump.

Om du inte ser Llama 2-modeller, uppdatera din SageMaker Studio-version genom att stänga av och starta om. För mer information om versionsuppdateringar, se Stäng av och uppdatera Studio-appar.

Du kan även hitta andra fyra modellvarianter genom att välja Utforska alla textgenereringsmodeller eller söker efter lama i sökrutan.

På den här sidan kan du peka på Amazon enkel lagringstjänst (Amazon S3) hink som innehåller tränings- och valideringsdataset för finjustering. Dessutom kan du konfigurera distributionskonfiguration, hyperparametrar och säkerhetsinställningar för finjustering. Du kan sedan välja Tåg att starta utbildningsjobbet på en SageMaker ML-instans. Den föregående skärmdumpen visar finjusteringssidan för Llama-2 7B-modellen; du kan dock finjustera 13B och 70B Llama 2 textgenereringsmodeller med hjälp av deras respektive modellsidor på liknande sätt. För att använda Llama 2-modeller måste du acceptera slutanvändarlicensavtalet (EULA). Det kommer att dyka upp när du väljer Tåg, som visas i följande skärmdump. Välja Jag har läst och accepterar EULA och AUP för att påbörja finjusteringsjobbet.

Distribuera modellen

Efter att modellen har finjusterats kan du distribuera den med hjälp av modellsidan på SageMaker JumpStart. Alternativet att distribuera den finjusterade modellen visas när finjusteringen är klar, som visas i följande skärmdump.

Finjustera via SageMaker Python SDK

Du kan också finjustera Llama 2-modeller med SageMaker Python SDK. Följande är en exempelkod för att finjustera Llama 2 7B på din datauppsättning:

import os
import boto3
from sagemaker.session import Session
from sagemaker.jumpstart.estimator import JumpStartEstimator # To fine-tune the 13B/70B model, please change model_id to `meta-textgeneration-llama-2-13b`/`meta-textgeneration-llama-2-70b`.
model_id = "meta-textgeneration-llama-2-7b" estimator = JumpStartEstimator( model_id=model_id, environment={"accept_eula": "true"}
)
# By default, instruction tuning is set to false. Thus, to use instruction tuning dataset you use
estimator.set_hyperparameters(instruction_tuned="True", epoch="5")
estimator.fit({"training": train_data_location})

Du kan distribuera den finjusterade modellen direkt från skattaren:

finetuned_predictor = estimator.deploy()

Du kan också hitta koden i Finjustera LLaMA 2-modeller på SageMaker JumpStart. Det inkluderar förberedelse av dataset, utbildning i din anpassade datauppsättning och implementering av den finjusterade modellen. Den demonstrerar finjustering av en delmängd av Dolly-datauppsättningen med exempel från sammanfattningsuppgiften. Följande är exempelinmatningen med svar från finjusterade och icke-finjusterade tillsammans med grundsanningssvaret:

Indata till modellen:

Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.nn### Instruction:nWhen did Felix Luna die?nn### Input:nFélix César Luna (30 September 1925 – 5 November 2009) was an Argentine writer, lyricist and historian.nnnn### Response:n

Ground Truth-svar:

Felix Luna died on November 5th, 2009

Svar från den icke finjusterade modellen:

Félix César Luna (30 September 1925 – 5 November 2009) was an ArgentinennWhen did Luna die?nnn### Explanation:nWe answer the question with the input's date of birth and the date of death.nnn### Solution: 1102n

Svar från den finjusterade modellen:

Félix Luna died on November 5th, 2009.nn

För prestandabenchmarking av olika modeller på Dolly och Dialogsum dataset, se Prestandabenchmarking avsnitt i bilagan i slutet av detta inlägg.

Finjusteringsteknik

Språkmodeller som Llama är mer än 10 GB eller till och med 100 GB stora. Att finjustera så stora modeller kräver instanser med avsevärt högt CUDA-minne. Dessutom kan träningen av dessa modeller vara mycket långsam på grund av modellens storlek. Därför använder vi följande optimeringar för effektiv finjustering:

• Lågrankad anpassning (LoRA) – Detta är en typ av parametereffektiv finjustering (PEFT) för effektiv finjustering av stora modeller. I detta fryser vi hela modellen och lägger bara till en liten uppsättning justerbara parametrar eller lager i modellen. Till exempel, istället för att träna alla 7 miljarder parametrar för Llama 2 7B, kan vi finjustera mindre än 1 % av parametrarna. Detta bidrar till en betydande minskning av minneskravet eftersom vi bara behöver lagra gradienter, optimerartillstånd och annan träningsrelaterad information för endast 1% av parametrarna. Dessutom hjälper detta till att minska träningstiden såväl som kostnaden. För mer information om denna metod, se LoRA: Lågrankad anpassning av stora språkmodeller.
• Int8 kvantisering – Även med optimeringar som LoRA är modeller som Llama 70B fortfarande för stora för att träna. För att minska minnesavtrycket under träning kan vi använda Int8-kvantisering under träning. Kvantisering minskar vanligtvis precisionen för flyttalsdatatyperna. Även om detta minskar minnet som krävs för att lagra modellvikter, försämrar det prestandan på grund av förlust av information. Int8-kvantisering använder bara en kvarts precision men medför ingen försämring av prestanda eftersom den inte bara tappar bitarna. Den rundar data från en typ till en annan. För att lära dig om Int8-kvantisering, se LLM.int8(): 8-bitars matrismultiplikation för transformatorer i skala.
• Fullständigt delad data parallell (FSDP) – Det här är en typ av dataparallell träningsalgoritm som skär modellens parametrar över dataparallellarbetare och som valfritt kan överföra en del av träningsberäkningen till CPU:erna. Även om parametrarna är delade över olika GPU:er, är beräkningen av varje mikrobatch lokal för GPU-arbetaren. Det skär parametrar mer enhetligt och uppnår optimerad prestanda via kommunikation och beräkningsöverlappning under träning.

Följande tabell jämför olika metoder med de tre Llama 2-modellerna.

Observera att finjustering av Llama-modeller baseras på skript som tillhandahålls av följande GitHub repo.

Utbildningsdatauppsättningsformat

SageMaker JumpStart stöder för närvarande datauppsättningar i både domänanpassningsformat och instruktionsjusteringsformat. I det här avsnittet specificerar vi ett exempel på datauppsättning i båda formaten. För mer information, se Datauppsättningsformatering avsnitt i bilagan.

Domänanpassningsformat

Textgenereringsmodellen Llama 2 kan finjusteras på vilken domänspecifik datauppsättning som helst. Efter att den har finjusterats på den domänspecifika datamängden förväntas modellen generera domänspecifik text och lösa olika NLP-uppgifter i den specifika domänen med få-shot prompt. Med denna datauppsättning består indata av en CSV-, JSON- eller TXT-fil. Till exempel kan indata vara SEC-filer från Amazon som en textfil:

This report includes estimates, projections, statements relating to our
business plans, objectives, and expected operating results that are “forward-
looking statements” within the meaning of the Private Securities Litigation
Reform Act of 1995, Section 27A of the Securities Act of 1933, and Section 21E
of the Securities Exchange Act of 1934. Forward-looking statements may appear
throughout this report, including the following sections: “Business” (Part I,
Item 1 of this Form 10-K), “Risk Factors” (Part I, Item 1A of this Form 10-K),
and “Management’s Discussion and Analysis of Financial Condition and Results
of Operations” (Part II, Item 7 of this Form 10-K). These forward-looking
statements generally are identified by the words “believe,” “project,”
“expect,” “anticipate,” “estimate,” “intend,” “strategy,” “future,”
“opportunity,” “plan,” “may,” “should,” “will,” “would,” “will be,” “will
continue,” “will likely result,” and similar expressions.

Instruktionsjusteringsformat

Vid instruktionsfinjustering är modellen finjusterad för en uppsättning NLP-uppgifter (natural language processing) som beskrivs med hjälp av instruktioner. Detta hjälper till att förbättra modellens prestanda för osynliga uppgifter med noll-shot-uppmaningar. I formatet för instruktionsinställningsdatauppsättning anger du template.json fil som beskriver inmatnings- och utdataformaten. Till exempel varje rad i filen train.jsonl ser ut som följande:

{"instruction": "What is a dispersive prism?", "context": "In optics, a dispersive prism is an optical prism that is used to disperse light, that is, to separate light into its spectral components (the colors of the rainbow). Different wavelengths (colors) of light will be deflected by the prism at different angles. This is a result of the prism material's index of refraction varying with wavelength (dispersion). Generally, longer wavelengths (red) undergo a smaller deviation than shorter wavelengths (blue). The dispersion of white light into colors by a prism led Sir Isaac Newton to conclude that white light consisted of a mixture of different colors.", "response": "A dispersive prism is an optical prism that disperses the light's different wavelengths at different angles. When white light is shined through a dispersive prism it will separate into the different colors of the rainbow."}

Den extra filen template.json ser ut som följande:

{ "prompt": "Below is an instruction that describes a task, paired with an input that provides further context. " "Write a response that appropriately completes the request.nn" "### Instruction:n{instruction}nn### Input:n{context}nn", "completion": " {response}",
}

Hyperparametrar som stöds för träning

Finjustering av Llama 2 stöder ett antal hyperparametrar, som var och en kan påverka minneskravet, träningshastigheten och prestandan för den finjusterade modellen:

• epok – Antalet pass som finjusteringsalgoritmen tar genom träningsdatauppsättningen. Måste vara ett heltal större än 1. Standard är 5.
• learning_rate – Den hastighet med vilken modellvikterna uppdateras efter att man har arbetat igenom varje grupp med träningsexempel. Måste vara en positiv float större än 0. Standard är 1e-4.
• instruktion_avstämd – Om man ska instruera-träna modellen eller inte. Måste vara 'True"eller"False'. Standard är 'False".
• per_device_train_batch_size – Batchstorleken per GPU-kärna/CPU för träning. Måste vara ett positivt heltal. Standard är 4.
• per_device_eval_batch_size – Batchstorleken per GPU-kärna/CPU för utvärdering. Måste vara ett positivt heltal. Standard är 1.
• max_train_samples – För felsökningsändamål eller snabbare träning, trunkera antalet träningsexempel till detta värde. Värde -1 betyder att man använder alla träningsprover. Måste vara ett positivt heltal eller -1. Standard är -1.
• max_val_samples – För felsökningsändamål eller snabbare utbildning, trunkera antalet valideringsexempel till detta värde. Värde -1 betyder att alla valideringsprover används. Måste vara ett positivt heltal eller -1. Standard är -1.
• max_input_length – Maximal total ingångssekvenslängd efter tokenisering. Sekvenser längre än detta kommer att trunkeras. Om -1, max_input_length är inställd på minimum 1024 och den maximala modelllängden som definieras av tokenizern. Om inställt på ett positivt värde, max_input_length är inställd på minimum av det angivna värdet och model_max_length definieras av tokenizern. Måste vara ett positivt heltal eller -1. Standard är -1.
• validation_split_ratio – Om valideringskanalen är none, förhållandet mellan tågvalideringsdelning från tågdata måste vara mellan 0–1. Standard är 0.2.
• train_data_split_seed – Om valideringsdata inte finns, fixar detta den slumpmässiga uppdelningen av ingående träningsdata till tränings- och valideringsdata som används av algoritmen. Måste vara ett heltal. Standard är 0.
• förbearbetning_antal_arbetare – Antalet processer som ska användas för förbearbetning. Om None, används huvudprocessen för förbearbetning. Standard är None.
• lora_r – Lora R. Måste vara ett positivt heltal. Standard är 8.
• lora_alpha – Lora Alpha. Måste vara ett positivt heltal. Standard är 32
• lora_avhopp – Lora Dropout. måste vara ett positivt flytande mellan 0 och 1. Standard är 0.05.
• int8_kvantisering - Om True, modellen är laddad med 8-bitars precision för träning. Standard för 7B och 13B är False. Standard för 70B är True.
• aktivera_fsdp - Om True, utbildning använder FSDP. Standard för 7B och 13B är True. Standard för 70B är False. Anteckna det int8_quantization stöds inte med FSDP.

Instanstyper och kompatibla hyperparametrar

Minneskravet under finjustering kan variera beroende på flera faktorer:

• Modell typ – 7B-modellen har minst GPU-minneskrav och 70B har det största minnesbehovet
• Max ingångslängd – Ett högre värde på ingångslängden leder till att fler tokens behandlas åt gången och kräver därför mer CUDA-minne
• Satsstorlek – En större batchstorlek kräver större CUDA-minne och kräver därför större instanstyper
• Int8 kvantisering – Om du använder Int8-kvantisering laddas modellen till låg precision och kräver därför mindre CUDA-minne

För att hjälpa dig komma igång tillhandahåller vi en uppsättning kombinationer av olika instanstyper, hyperparametrar och modelltyper som framgångsrikt kan finjusteras. Du kan välja en konfiguration enligt dina krav och tillgänglighet av instanstyper. Vi finjusterar alla tre modellerna på en mängd olika inställningar med tre epoker på en delmängd av Dolly-datauppsättningen med sammanfattningsexempel.

7B modell

Följande tabell sammanfattar finjusteringsalternativen på 7B-modellen.

13B

Följande tabell sammanfattar finjusteringsalternativen på 13B-modellen.

70B

Följande tabell sammanfattar finjusteringsalternativen på 70B-modellen.

Rekommendationer om instanstyper och hyperparametrar

Tänk på följande när du finjusterar modellens noggrannhet:

• Större modeller som 70B ger bättre prestanda än 7B
• Prestanda utan Int8-kvantisering är bättre än prestanda med INT8-kvantisering

Observera följande krav på träningstid och CUDA-minne:

• Att lägga plattor int8_quantization=True minskar minnesbehovet och leder till snabbare träning.
• minskande per_device_train_batch_size och max_input_length minskar minneskravet och kan därför köras på mindre instanser. Att ställa in mycket låga värden kan dock öka träningstiden.
• Om du inte använder Int8 kvantisering (int8_quantization=False), använd FSDP (enable_fsdp=True) för snabbare och effektiv träning.

Tänk på följande när du väljer instanstyp:

• G5-instanser ger den mest effektiva utbildningen bland de instanstyper som stöds. Därför, om du har tillgängliga G5-instanser, bör du använda dem.
• Träningstiden beror till stor del på mängden av antalet GPU:er och CUDA-minnet som är tillgängligt. Därför är träning på instanser med samma antal GPU:er (till exempel ml.g5.2xlarge och ml.g5.4xlarge) ungefär densamma. Därför kan du använda den billigare instansen för träning (ml.g5.2xlarge).
• När du använder p3-instanser kommer träning att göras med 32-bitars precision eftersom bfloat16 inte stöds på dessa instanser. Därför kommer träningsjobbet att förbruka dubbelt så mycket CUDA-minne när man tränar på p3-instanser jämfört med g5-instanser.

För att lära dig mer om kostnaden för utbildning per instans, se Amazon EC2 G5-instanser.

Om datamängden är i instruktionsjusteringsformat och inmatnings-+slutförandesekvenserna är små (som 50–100 ord), då är ett högt värde på max_input_length leder till mycket dålig prestanda. Standardvärdet för denna parameter är -1, vilket motsvarar max_input_length av 2048 för Llama-modeller. Därför rekommenderar vi att om din datauppsättning innehåller små prov, använder du ett litet värde för max_input_length (som 200–400).

Slutligen, på grund av stor efterfrågan på G5-instanserna, kan du uppleva att dessa instanser inte är tillgängliga i din region med felet “CapacityError: Unable to provision requested ML compute capacity. Please retry using a different ML instance type.” Om du upplever det här felet, försök med träningsjobbet igen eller prova en annan region.

Problem vid finjustering av mycket stora modeller

I det här avsnittet diskuterar vi två frågor vid finjustering av mycket stora modeller.

Inaktivera utdatakomprimering

Som standard är resultatet av ett träningsjobb en tränad modell som komprimeras i ett .tar.gz-format innan den laddas upp till Amazon S3. Men på grund av modellens stora storlek kan detta steg ta lång tid. Till exempel kan komprimering och uppladdning av 70B-modellen ta mer än 4 timmar. För att undvika det här problemet kan du använda funktionen inaktivera utdatakomprimering som stöds av SageMaker-utbildningsplattformen. I det här fallet laddas modellen upp utan någon komprimering, som vidare används för distribution:

estimator = JumpStartEstimator(
model_id=model_id, environment={"accept_eula": "true"}, disable_output_compression=True
)

SageMaker Studio kärnan timeout problem

På grund av storleken på Llama 70B-modellen kan träningsjobbet ta flera timmar och SageMaker Studio-kärnan kan dö under träningsfasen. Men under denna tid pågår träning fortfarande i SageMaker. Om detta händer kan du fortfarande distribuera slutpunkten med hjälp av utbildningsjobbets namn med följande kod:

from sagemaker.jumpstart.estimator import JumpStartEstimator
training_job_name = <<<INSERT_TRAINING_JOB_NAME>>> attached_estimator = JumpStartEstimator.attach(training_job_name, model_id)
attached_estimator.logs()
attached_estimator.deploy()

För att hitta utbildningsjobbets namn, navigera till SageMaker-konsolen och under Utbildning välj i navigeringsfönstret Träningsjobb. Identifiera utbildningsjobbets namn och ersätt det i föregående kod.

Slutsats

I det här inlägget diskuterade vi finjustering av Metas Llama 2-modeller med SageMaker JumpStart. Vi visade att du kan använda SageMaker JumpStart-konsolen i SageMaker Studio eller SageMaker Python SDK för att finjustera och distribuera dessa modeller. Vi diskuterade också finjusteringstekniken, instanstyper och stödda hyperparametrar. Dessutom skisserade vi rekommendationer för optimerad träning utifrån olika tester vi genomfört. Resultaten för att finjustera de tre modellerna över två datamängder visas i bilagan i slutet av detta inlägg. Som vi kan se av dessa resultat förbättrar finjustering sammanfattningen jämfört med icke finjusterade modeller. Som ett nästa steg kan du prova att finjustera dessa modeller på din egen datauppsättning med hjälp av koden som tillhandahålls i GitHub-förvaret för att testa och jämföra resultaten för dina användningsfall.

Författarna vill erkänna de tekniska bidragen från Christopher Whitten, Xin Huang, Kyle Ulrich, Sifei Li, Amy You, Adam Kozdrowicz, Evan Kravitz, Benjamin Crabtree, Haotian An, Manan Shah, Tony Cruz, Ernev Sharma, Jonathan Guinegagne och June Vann.

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.

Dr Farooq Sabir är Senior Artificiell Intelligens och Machine Learning Specialist Solutions Architect på AWS. Han har doktorsexamen och MS-examen i elektroteknik från University of Texas i Austin och en MS i datavetenskap från Georgia Institute of Technology. Han har över 15 års arbetslivserfarenhet och gillar även att undervisa och mentor studenter. På AWS hjälper han kunder att formulera och lösa sina affärsproblem inom datavetenskap, maskininlärning, datorseende, artificiell intelligens, numerisk optimering och relaterade domäner. Baserad i Dallas, Texas, älskar han och hans familj att resa och åka på långa vägresor.

Dr Ashish Khetan är en Senior Applied Scientist med Amazon SageMaker JumpStart 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.

Appendix

Den här bilagan ger ytterligare information om prestandabenchmarking och datauppsättningsformatering.

Prestandabenchmarking

I det här avsnittet ger vi resultat för att finjustera de tre Llama 2-modellerna (7B, 13B och 70B) på två olika datamängder: Dolly och Dialogsum. För Dolly-dataset är vår uppgift att sammanfatta ett stycke text, medan vi för Dialogsum finjusterar modellen för att sammanfatta en diskussion mellan två personer. I följande tabeller visar vi input till modellen (uppmaning och instruktioner), grundsannhet (sammanfattning), svar från den förtränade Llama 2-modellen och svar från den finjusterade Llama 2-modellen för var och en av de tre lamaerna 2 modeller. Vi visar slutledningsresultat för fem datapunkter. Du kan märka från följande tabeller att sammanfattningarna förbättras för båda datamängderna när vi finjusterar modellerna.

• Resultat för finjustering av Llama 2 7B-textgenereringsmodellen på Dolly-dataset:

• Resultat för finjustering av Llama 2 13B-textgenereringsmodellen på Dolly-dataset:

• Resultat för finjustering av Llama 2 70B-textgenereringsmodellen på Dolly-dataset:

• Resultat för finjustering av Llama 2 7B-textgenereringsmodellen på Dialogsum-datauppsättningen:

• Resultat för finjustering av Llama-2 13B-modellen på Dialogsum-datauppsättningen:

• Resultat för finjustering av Llama 2 70B-modellen på Dialogsum-datauppsättningen:

Datauppsättningsformatering

Vi erbjuder för närvarande två typer av finjustering: instruktionsfinjustering och finjustering av domänanpassning. Du kan enkelt växla till en av träningsmetoderna genom att ange parametern instruction_tuned som 'True"eller"False".

Domänanpassningsformat

Textgenereringsmodellen kan också finjusteras på vilken domänspecifik datauppsättning som helst. Efter att den har finjusterats på den domänspecifika datamängden förväntas modellen generera domänspecifik text och lösa olika NLP-uppgifter i den specifika domänen med få-shot prompt.

För input till modellen, använd en utbildnings- och valfri valideringskatalog. Varje katalog innehåller en CSV-, JSON- eller TXT-fil. För CSV- och JSON-filer används tåg- eller valideringsdata från kolumnen som kallas text eller den första kolumnen om ingen kolumn anropas text är hittad. Antalet filer under tåg och validering (om tillhandahållet) bör vara 1 respektive.

Utgången är en tränad modell som kan användas för slutledning.

Följande är ett exempel på en TXT-fil för finjustering av textgenereringsmodellen. TXT-filen är SEC-anmälningar från Amazon från 2021–2022:

This report includes estimates, projections, statements relating to our
business plans, objectives, and expected operating results that are “forward-
looking statements” within the meaning of the Private Securities Litigation
Reform Act of 1995, Section 27A of the Securities Act of 1933, and Section 21E
of the Securities Exchange Act of 1934. Forward-looking statements may appear
throughout this report, including the following sections: “Business” (Part I,
Item 1 of this Form 10-K), “Risk Factors” (Part I, Item 1A of this Form 10-K),
and “Management’s Discussion and Analysis of Financial Condition and Results
of Operations” (Part II, Item 7 of this Form 10-K). These forward-looking
statements generally are identified by the words “believe,” “project,”
“expect,” “anticipate,” “estimate,” “intend,” “strategy,” “future,”
“opportunity,” “plan,” “may,” “should,” “will,” “would,” “will be,” “will
continue,” “will likely result,” and similar expressions. Forward-looking
statements are based on current expectations and assumptions that are subject
to risks and uncertainties that may cause actual results to differ materially.
We describe risks and uncertainties that could cause actual results and events
to differ materially in “Risk Factors,” “Management’s Discussion and Analysis
of Financial Condition and Results of Operations,” and “Quantitative and
Qualitative Disclosures about Market Risk” (Part II, Item 7A of this Form
10-K). Readers are cautioned not to place undue reliance on forward-looking
statements, which speak only as of the date they are made. We undertake no
obligation to update or revise publicly any forward-looking statements,
whether because of new information, future events, or otherwise. GENERAL Embracing Our Future ...

Instruktionsfinjustering

Textgenereringsmodellen kan instruktionsjusteras på vilken textdata som helst förutsatt att data är i det förväntade formatet. Den instruktionsinställda modellen kan vidareutvecklas för slutledning.

För input, använd en utbildnings- och valfri valideringskatalog. Tåg- och valideringskatalogerna bör innehålla en eller flera JSON-rader (.jsonl) formaterade filer. I synnerhet kan tågkatalogen också innehålla en valfri *.json-fil som beskriver inmatnings- och utdataformaten.

Den bästa modellen väljs enligt valideringsförlusten, beräknad i slutet av varje epok. Om en valideringsuppsättning inte ges delas en (justerbar) procentandel av träningsdata automatiskt och används för validering.

Träningsdatan måste formateras i ett JSON-rader (.jsonl)-format, där varje rad är en ordbok som representerar ett enda dataprov. All träningsdata måste finnas i en enda mapp; den kan dock sparas i flera .jsonl-filer. Filtillägget .jsonl är obligatoriskt. Utbildningsfoldern kan även innehålla en template.json fil som beskriver in- och utdataformaten. Om ingen mallfil anges kommer följande mall att användas:

{ "prompt": "Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.nn### Instruction:n{instruction}nn### Input:n{context}`, "completion": "{response}",
}

I det här fallet måste data i JSON-radposterna inkludera prompt och completion fält. Om en anpassad mall tillhandahålls måste den också användas prompt och completion för att definiera inmatnings- och utmatningsmallarna. Följande är ett exempel på en anpassad mall:

{ "prompt": "question: {question} context: {context}", "completion": "{answer}"
}

Här måste data i JSON-radposterna inkludera question, contextoch answer fält.

Utgången är en tränad modell som kan användas för slutledning.

Vi tillhandahåller en delmängd av SEC-anmälningsdata från Amazon. Den laddas ner från allmänt tillgänglig Edgar. För instruktioner om hur du kommer åt data, se Åtkomst till EDGAR-data.

Licens: Creative Commons Erkännande-Dela Lika-licens (CC BY-SA 4.0)

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Fordon / elbilar, Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• ChartPrime. Höj ditt handelsspel med ChartPrime. Tillgång här.
• BlockOffsets. Modernisera miljökompensation ägande. Tillgång här.
• Källa: https://aws.amazon.com/blogs/machine-learning/fine-tune-llama-2-for-text-generation-on-amazon-sagemaker-jumpstart/