Unslot är ett fantastiskt verktyg som gör det möjligt att effektivt finslipa LLAMA-3-modellen på din egen datamängd. Här är en steg-för-steg-guide om hur du gör det:

1. Installera nödvändiga paket: Börja med att klona Unslot GitHub-databasen och installera de nödvändiga paketen baserat på din maskinvara.

2. Ställ in träningsparametrar: Definiera dina träningsparametrar, som maximal sekvenslängd, datatyper och kvantiseringsmetod. Unslot använder Lora-adaptrar för att möjliggöra effektiv finslipning.

3. Formatera din träningsdata: Se till att din data är strukturerad i rätt format, med kolumner för instruktion, indata och utdata. Unslot ger exempel med Alpaca-datauppsättningen, men du kan anpassa den till din egen data.

4. Ställ in SFT-tränaren: Skapa ett SFT (Supervised Fine-Tuning) Trainer-objekt från Hugging Face Transformers-biblioteket, och ange modell, tokeniserare, dataset och andra träningsparametrar.

5. Träna modellen: Anropa train()-funktionen på SFT Trainer-objektet för att starta finslipningsprocessen. Unslots optimerade minnesanvändning och hastighet säkerställer effektiv träning, även med begränsade GPU-resurser.

6. Utför inferens: Efter träningen kan du använda Unslot-specifika FastLanguageModel-klassen för att generera svar från din finslipade modell. Unslot ger också alternativ för att spara modellen och ladda Lora-adaptrar för framtida användning.

7. Utforska ytterligare funktioner: Unslot erbjuder avancerade funktioner, som möjligheten att använda modellen med andra ramverk som PyTorch Lightning och alternativet att konvertera modellen till GGML-format för användning med LLAMA-CPP eller GoLLAMA.

Unslots tillvägagångssätt för att finslipa LLAMA-3 är mycket effektivt, med optimerad minnesanvändning och hastighet. Det ger en användarvänlig och omfattande lösning, vilket gör det till ett utmärkt val för att finslipa stora språkmodeller på din egen data.

Först måste vi importera de nödvändiga klasserna från unslot-biblioteket:

from unslot.models.fast_language_model import FastLanguageModel

Nästa steg är att ställa in träningsparametrarna:

• max_sequence_length: Den maximala sekvenslängden för indata. Vi ställer in den på 248 tokens, eftersom datauppsättningen vi använder har relativt kort text.
• data_type: Vi använder 4-bitars kvantisering för effektiv träning.

max_sequence_length = 248
data_type = "4bit"

Unslot använder Lora-adaptrar för att möjliggöra effektiv finslipning. Det finns två alternativ:

1. Använd en förindladdad modell från unslot Hugging Face-databasen, som redan har Lora-adaptrarna sammanfogade.
2. Använd en modell från Hugging Face-databasen och lägg till Lora-adaptrarna själv.

I det här fallet kommer vi att använda den förindladdade modellen, så vi behöver inte göra några ytterligare steg.

model = FastLanguageModel.from_pretrained("unslot/alpaca-7b")

Om du behöver använda en annan modell och lägga till Lora-adaptrarna själv, kan du avkommentera följande avsnitt och ange de nödvändiga parametrarna.

# model_id = "your-hugging-face-model-id"
# model = FastLanguageModel.from_pretrained(model_id)
# model.add_lora_adapters()

Nu är vi redo att gå vidare till nästa steg: formatera träningsdatan.

För att finslipa Lama 3-modellen med Unslot måste du formatera din träningsdata på ett särskilt sätt. Datauppsättningen som används i exemplet har tre kolumner: instruktion, indata och utdata.

Instruktionskolumnen innehåller uppgiftsbeskrivningen som modellen ska slutföra. Indatakolumnen ger ytterligare kontext för uppgiften, och utdatakolumnen innehåller det förväntade svaret från modellen.

När du formaterar din egen data, se till att strukturera den på samma sätt, med kolumnerna instruktion, indata och utdata. Om indata saknas för ett visst exempel är det inget problem, eftersom instruktionen ensam kan ge den nödvändiga informationen för modellen att generera utdata.

Efter att ha laddat ner data måste du omvandla de tre kolumnerna till en enda textsträng som följer ett särskilt format. Detta format innehåller specialtecken för instruktion, indata och svar. Koden i exemplet visar hur du utför denna omvandling och skapar en enda kolumn som kan användas för att träna modellen.

Observera att medan exemplet använder den standardmässiga Alpaca-datauppsättningen kan du också strukturera din data med hjälp av andra promptmallar, som ChatML-formatet som introducerats av OpenAI. Se bara till att korrekt formatera dina indataexempel, eftersom de kommer att matas in i språkmodellen under träningen.

Först måste vi ställa in träningsparametrarna. Vi kommer att importera FastLanguageModel-klassen från Unslot och definiera maximal sekvenslängd, datatyper och kvantiseringsmetod.

Därefter kommer vi att hantera fallet där vi behöver lägga till Lora-adaptrar till modellen. Om vi använder en modell från Hugging Face-databasen kanske vi behöver ange en token för att acceptera användarvillkoren.

Nu måste vi formatera träningsdatan. Datauppsättningen bör ha tre kolumner: instruktion, indata och utdata. Vi kommer att ladda ner data från Hugging Face och mappa den till detta format.

Vi kommer sedan att ställa in Supervised Fine-Tuning Trainer från Hugging Face Transformers-biblioteket. Denna tränare kommer att acceptera modellobjektet, tokeniseraren, datauppsättningen och andra parametrar som optimerare, inlärningshastighetsschema och utdatakatalog.

Avslutningsvis kommer vi att anropa train()-funktionen på tränarobjektet. Vi kommer att observera att träningsförlusten minskar, vilket indikerar att modellen lär sig. Observera att vi endast kör en liten delmängd av data i det här exemplet, men du vill köra det i minst en epok eller två för att få bättre resultat.

Efter träningen kan vi spara modellen och ladda Lora-adaptrarna för inferens. Unslot ger också alternativ för att använda modellen med andra ramverk som PyTorch Lightning och TensorFlow.

När modellen är tränad kan du använda den för inferens. Unslot ger ett enkelt gränssnitt för detta:

1. Importera FastLanguageModel-klassen från Unslot.
2. Ange den tränade modellen och berätta för den att utföra inferens.
3. Tokenisera indata med hjälp av Alpaca-formatet (instruktion, indata och förväntat utdata).
4. Flytta indata till GPU:n för att utnyttja de tillgängliga resurserna.
5. Anropa generate-funktionen och ange de tokeniserade indata, det maximala antalet tokens som ska genereras och om cachelagring ska användas.

Modellen kommer sedan att generera ett svar baserat på den angivna indata. Du kan också använda TextStreamer-klassen för att strömma textsvaret.

Efter träningen kan du spara modellen på olika sätt:

• Skicka modellen till Hugging Face Hub, vilket sparar Lora-adaptrarna separat.
• Spara modellen lokalt, igen genom att spara Lora-adaptrarna separat.

För att ladda den sparade modellen för inferens kan du ange ett flagg för att sammanfoga Lora-adaptrarna med modellen.

Unslot ger också alternativa alternativ för inferens, som att använda AutoModelForCausalLM-klassen från Hugging Face Transformers-biblioteket, vilket kan vara långsammare men låter dig använda modellen med andra verktyg som LLaMA-CPP eller GoLLaMA.

När modellen är tränad kan du spara den på olika sätt för att använda den för inferens senare. Unslot ger flera alternativ för att spara och ladda den finslipade modellen:

1. Spara till Hugging Face Hub: Du kan skicka den finslipade modellen till Hugging Face Hub, vilket låter dig dela och använda modellen med andra. För att göra detta behöver du ange din Hugging Face-token.

model.push_to_hub("your-model-name")

2. Spara lokalt: Du kan också spara modellen lokalt, vilket endast sparar Lora-adaptrarna, inte hela modellen. Detta gör det enkelt att senare ladda Lora-adaptrarna och sammanfoga dem med basmodellen.

model.save_pretrained("path/to/save/model")

3. Ladda sparade Lora-adaptrar: När du vill använda den finslipade modellen för inferens kan du ladda de sparade Lora-adaptrarna och sammanfoga dem med basmodellen.

model = FastLLamaForCausalLM.from_pretrained("path/to/base/model")
model.load_adapter("path/to/saved/model")

4. Konvertera till GGML-format: Unslot ger också möjlighet att konvertera den finslipade modellen till GGML-format, vilket kan användas med verktyg som Llama-CPP eller GoLlama. Detta låter dig använda modellen i CPU-endast miljöer.

model.save_pretrained("path/to/save/model", quantization_method="nf16")

Genom att utnyttja dessa alternativ kan du enkelt spara, ladda och använda den finslipade modellen för olika användningsfall, inklusive distribution i olika miljöer och delning med gemenskapen.

Artikel ger en omfattande guide om hur man finsliper Lama 3-modellen med hjälp av Unslot-paketet. De viktigaste punkterna som täcks i avsnittet är:

1. Unslot erbjuder ett effektivt och optimerat sätt att finslipa Lama 3 och andra språkmodeller, med funktioner som minskad minnesanvändning och snabbare träning.
2. Artikeln går igenom stegen för att ställa in träningsmiljön, formatera data och träna modellen med hjälp av Unslot-specifika klasser och metoder.
3. Den visar också hur man utför inferens med den finslipade modellen, både genom Unslot-gränssnittet och genom att konvertera modellen till andra format som ONNX för användning med andra inferensverktyg.
4. Författaren lyfter fram fördelarna med Unslot, som dess förmåga att hantera GPU-begränsningar och den enkla användningen jämfört med andra finslipningsalternativ som AutoTrain.
5. Artikeln avslutas med att uppmuntra läsarna att utforska Unslot och andra finslipningsverktyg, och inbjuder dem att höra av sig med eventuella frågor eller problem de stöter på.