Det finns vanligtvis tre olika stadier av träning för stora språkmodeller:

1. Förträning: I det här stadiet tränas modellen på en stor mängd rå textdata för att lära sig förutsäga nästa token eller ord. Resultatet är en basmodell som har förvärvat mycket allmän kunskap från texten, men som ännu inte är särskilt användbar för specifika uppgifter.

2. Övervakad finslipning: För att göra basmodellen mer användbar är det andra stadiet övervakad finslipning. I det här stadiet tränas modellen på fråga-svar-par eller instruktion-svar-par. Indata är en fråga eller instruktion, och utdata är önskat svar. Det här stadiet gör det möjligt för modellen att lära sig uppgiftsspecifik kunskap och förmågor.

3. Preferensanpassning: Det tredje, valfria stadiet är preferensanpassning, där modellen tränas för att lära sig vad användaren föredrar när det gäller svar, eller för att anpassa modellen till vissa principer. Detta görs ofta med tekniker som Reinforcement Learning from Human Feedback (RLHF) eller Debate Policy Optimization (DPO).

Syftet med den här videon är att fokusera på det övervakade finslipningsstadiet, särskilt hur man finsliper Llama 3.1-modellen med hjälp av Unsloth-biblioteket. Videon kommer att täcka olika finslipningstekniker, som fullständig finslipning, LoRA och QLoRA, och diskutera avvägningarna mellan dem när det gäller prestanda och minneskrav.

Det finns tre populära alternativ för övervakad finslipning:

1. Fullständig finslipning: I den här metoden tar du den ursprungliga modellen och uppdaterar vikterna med instruktionsfinjusteringsdatauppsättningen. Detta ger dig den bästa prestandan, men VRAM-kravet kommer att vara högt.

2. LoRA (Low-Rank Adaptation): Istället för att direkt uppdatera vikterna lägger du till externa adaptrar till modellen. Antalet parametrar i dessa externa adaptrar kan kontrolleras. Viktuppdateringarna för dessa adaptrar görs med 16-bitars precision och slås sedan samman med de ursprungliga modellvikterna. Den här metoden ger snabb träning, men är fortfarande kostsam på grund av 16-bitarsoperationerna.

3. QLoRA (Quantized LoRA): Detta liknar LoRA, men viktuppdateringarna görs med 4-bitars precision, och modellvikterna hålls också i 4-bitars format. Detta kräver mindre VRAM, men prestandan kanske inte är lika bra som LoRA eller fullständig finslipning.

För att ställa in LoRA-adaptrarna finns det några viktiga hyperparametrar att ta hänsyn till:

1. Rank: Ranken för LoRA-adaptrarna styr antalet parametrar som kommer att uppdateras under finslipningen. En lägre rank innebär färre parametrar, vilket minskar VRAM-kraven men också kan begränsa modellens förmåga att anpassa sig. Å andra sidan möjliggör en högre rank mer flexibilitet men kräver mer VRAM.

2. LoRA Alpha: Den här parametern styr LoRA-adapternas bidrag till de slutliga modellvikterna. Ett högre LoRA Alpha-värde innebär att LoRA-adaptrarna kommer att ha en starkare inverkan, medan ett lägre värde innebär att de kommer att ha en svagare inverkan.

3. LoRA Dropout: Den här parametern styr dropoutsatsen som tillämpas på LoRA-adaptrarna under träningen. Att öka dropoutsatsen kan hjälpa till att förhindra överanpassning, men kan också minska modellens prestanda.

För att förbereda data för finslipning måste vi ställa in promptmallen och ange slut-på-sekvens-token.

Promptmallen är avgörande, eftersom den definierar formatet på indata som modellen kommer att tränas på. För Llama 3.1-familjen kommer vi att använda Alpaca-promptmallen, som innehåller en instruktion och en indata som ger ytterligare kontext. Modellen förväntas sedan generera ett lämpligt svar.

# Alpaca-promptmall
prompt_template = "Nedan finns en instruktion som beskriver en uppgift tillsammans med en indata som ger ytterligare kontext. Svara med ett relevant utdata.\n\nInstruktion: {instruction}\nIndata: {input}\nUtdata:"

Dessutom måste vi ange slut-på-sekvens-token för att förhindra att modellen genererar text i oändlighet. Det här är ett viktigt steg som många har stött på problem med när de använder de kvantiserade versionerna av modellerna med LamaCPP.

# Ange slut-på-sekvens-token
end_token = "</s>"

Genom att ställa in promptmallen och slut-på-sekvens-token säkerställer vi att data är korrekt formaterade för finslipningsprocessen, vilket är ett avgörande steg för att uppnå goda resultat.

För att träna modellen kommer vi att använda SFT (Supervised Fine-Tuning) Trainer från TRL-paketet, som skapats och underhålls av Hugging Face.

Först ger vi vår modell, tokeniserare och datauppsättning till SFT Trainer. I det här fallet använder vi text-kolumnen från datauppsättningen, eftersom vi har ställt in vår promptmall för att använda det här fältet.

Vi ställer också in den maximala sekvenslängden, som bör baseras på exemplen i din träningsdata. Tänk på att en högre sekvenslängd kommer att öka VRAM-kraven.

Därefter konfigurerar vi träningsargumenten, som enhet (i det här fallet en T4-GPU på Google Colab med cirka 15 GB VRAM) och antalet träningssteg.

Till sist kör vi tränaren, och du kan observera den minskande förlusten, vilket är ett bra tecken på träningsförloppet.

Träningen tog cirka 8 minuter, och den högsta reserverade minnet var runt 8 GB, vilket är cirka 53 % av den tillgängliga VRAM på T4-GPU:n. Detta visar på effektiviteten i Unsloth-metoden, som möjliggör finslipning med relativt låga VRAM-krav.

För att göra inferens kan vi använda for_inference-klassen eller -metoden på FastLanguageModel-klassen. Vi måste ange den tränade modellen och inmatningsprompt i Alpaca-format. Vi kan också ange det maximala antalet token som ska genereras.

# Utför inferens
input_prompt = alpaca_prompt(instruction, input)
output = model.for_inference(input_prompt, max_new_tokens=256)
print(output)

För att aktivera strömning kan vi skapa ett Streamer-objekt och skicka det till for_inference-metoden. Detta kommer att visa svaren en token i taget.

# Aktivera strömning
streamer = Streamer()
output = model.for_inference(input_prompt, max_new_tokens=256, streamer=streamer)

Med detta kan du nu utföra inferens på din finslipade modell och till och med aktivera strömning för en mer interaktiv upplevelse.

För att spara den finslipade modellen och tokeniseraren kan du använda save_pretrained()-funktionen på modellen och tokeniseraren:

model.save_pretrained("sökväg/att/spara/modell")
tokenizer.save_pretrained("sökväg/att/spara/tokeniserare")

Detta kommer att spara modellvikterna och tokeniseraren till de angivna katalogerna som en uppsättning JSON-filer.

För att läsa in den sparade modellen och tokeniseraren kan du använda samma FastLanguageModel-klass och ange de lokala katalogerna:

model = FastLanguageModel.from_pretrained("sökväg/att/spara/modell")
tokenizer = FastLanguageModel.from_pretrained("sökväg/att/spara/tokeniserare")

Detta kommer att läsa in modellen och tokeniseraren från de sparade filerna.

En annan bra funktion i Unsloth är möjligheten att spara modellerna i olika format, som 16-bitars flyttalsformat för VLLM eller direkt i GGUF-format för LamaCPP. Detta möjliggör enkel distribution och integrering med olika plattformar och ramverk.

Unsloth introducerar också ett nytt användargränssnitt baserat på Gradio, som låter dig köra de modeller som tränats med Unsloth och delta i interaktiva chattsamtal. Du kan klona Unsloth Studio-databasen och köra den tillhandahållna Colab-anteckningsboken för att uppleva den här funktionen.

Unsloth har introducerat ett nytt chattgränssnitt baserat på Radish-biblioteket, vilket gör det enkelt att interagera med de språkmodeller som tränats med Unsloth. Det här chattgränssnittet ger en användarvänlig miljö för att chatta med modellerna och utforska deras möjligheter.

För att använda chattgränssnittet kan du klona Unsloth studio-databasen och köra den tillhandahållna Google Colab-anteckningsboken. Detta kommer att ställa in den nödvändiga miljön och starta chattgränssnittet, där du kan börja konversera med språkmodellen.

Chattgränssnittet stöder funktioner som strömning av svar, vilket låter dig se modellens utdata allteftersom den genereras. Detta kan vara användbart för att observera modellens tankegång och hur den genererar svar.

Dessutom möjliggör Unsloth's chattgränssnitt att du kan spara och läsa in dina finslipade modeller, vilket gör det enkelt att fortsätta arbeta med dina anpassade språkmodeller. Du kan också exportera dina modeller i olika format, som 16-bitars flyttalsformat för VLLM eller GGUF-format för LamaCPP, vilket ger flexibilitet i hur du använder och distribuerar dina modeller.

Sammanfattningsvis är Unsloth's nya chattgränssnitt ett värdefullt verktyg för att interagera med och utforska möjligheterna hos språkmodeller som tränats med Unsloth-ramverket.