TinyLlama 1.1B – Storleken spelar ingen roll

Beskrivning

I det snabbt växande landskapet av artificiell intelligens och maskininlärning framstår TinyLlama 1.1B som en anmärkningsvärd utveckling. I en tid där beräkningsbegränsningar utgör utmaningar för att köra mer komplexa modeller, sticker TinyLlama ut genom att trotsa förväntningarna. Den visar upp den anmärkningsvärda prestandan hos kompakta modeller.

Den här artikeln syftar till att ge en analys av TinyLlama 1.1B, en kompakt stor språkmodell. Vi kommer att fördjupa oss i dess kärnaspekter, som hur den utbildades i prestandabenchmarks och praktisk implementering med Hugging Face-plattformen. Vi kommer till och med att köra den här modellen på det kostnadsfria Google Colab och testa dess matematik- och resonemangsförmåga.

Inlärningsmål

• Få en omfattande förståelse av TinyLlama 1.1B
• Utforska den intrikata utbildningsprocessen som modellen har gått igenom
• Analysera prestanda och benchmarkresultat för att bedöma dess effektivitet
• Lär dig de praktiska stegen för att implementera TinyLlama 1.1B med hjälp av kodningsexempel

Denna artikel publicerades som en del av Data Science Blogathon.

Vad är TinyLlama 1.1B?

TinyLlama 1.1B, en del av det bredare Llama-projektet, är ett bevis på framsteg i språkmodellering. Det är en modell med 1.1 miljarder parametrar, tränad på häpnadsväckande 3 biljoner tokens, vilket sätter den i en unik position i AI-landskapet. Till skillnad från sina större motsvarigheter är TinyLlama 1.1B designad för att vara mer effektiv och hanterbar, vilket gör den till ett bra val för applikationer med begränsade beräkningsresurser.

Denna modell med öppen källkod demokratiserar tillgången till den senaste AI-tekniken, vilket gör att många utvecklare och forskare kan utforska och förnya sig inom området naturlig språkbehandling. Det är en modell som är känd för sin förmåga att balansera prestanda med resursförbrukning, en kritisk faktor i dagens olika beräkningsmiljöer.

Utbildningsprocessen för TinyLlama 1.1B

Träningsprocessen för TinyLlama 1.1B är fascinerande, precis som modellen själv. Träningen av TinyLlama skedde bara under 90 dagar, tränad på de 16 A100-40G GPU:erna. Förträningen gjordes på 3 biljoner tokens, och TinyLlama-teamet har publicerat mellanmodellen mellan varje halv biljon. 

När det gäller data togs Slimpajama och Starcoderdata med en kombinerad datauppsättningsstorlek på 950 miljarder tokens. Det naturliga språk-till-kod-förhållandet hölls på 7:3, dvs 70% av data var naturligt språk och 30% var kod. För att uppnå märket 3 biljoner tokens för finjustering, genomgick TinyLlama tre epoker av träning för denna datauppsättning. 

Det finns till och med en chattversion av TinyLlama som kallas TinyLlama-Chat släppt. Inledningsvis genomgick denna modell finjustering på UltraChat-datauppsättningen, som innehåller olika syntetiska konversationer genererade av ChatGPT. Detta steg var avgörande för att få modellen att hantera olika konversationssammanhang och stilar.

Ytterligare förfining uppnåddes med hjälp av DPOTrainer på datauppsättningen UltraFeedback. Denna utbildningsfas fokuserade på att anpassa modellens svar så att de överensstämmer med mänskliga konversationsmönster. Resultatet är en modell som inte bara förstår information om olika ämnen utan även interagerar på ett naturligt och engagerande sätt.

Du kan också läsa: Komma igång med LlaMA 2: En nybörjarguide

Prestanda och benchmarkresultat

Att utvärdera prestandan för TinyLlama 1.1B avslöjar dess förmåga att leverera högkvalitativa svar snabbt. Dess utbildning har försett den med förmågan att tillgodose flerspråkiga tillämpningar, en viktig egenskap i vår globaliserade värld. Trots sin mindre storlek är TinyLlama 1.1B fortfarande ikapp sina större motsvarigheter när det gäller svarskvalitet och hastighet, vilket gör det till ett potent verktyg i olika AI-applikationer.

Riktmärkena för TinyLlama 1.1B, även om de är mindre omfattande än de för större modeller, visar fortfarande sin skicklighet i att hantera komplexa språkuppgifter. Dess förmåga att generera sammanhängande och kontextuellt relevanta svar på flera språk är särskilt imponerande. Modellen testades på olika riktmärken som HellaSwag, WinoGrande, ARC, MMLU och andra. Den sammanlagda medelpoängen blev 52.99. Detta är mycket bättre än den andra 1 Billion Parameter Model, dvs Pythia 1B, som uppnådde ett genomsnittligt betyg på 48.3. Tabellen visar de individuella poängen för varje benchmark

TinyLlama – Komma igång

Här, i det här avsnittet, kommer vi att ladda ner den kvantiserade versionen av TinyLlama Chat och köra den i Google Colab. Innan vi laddar ner modellen måste vi ladda ner och installera följande Python-paket

!CMAKE_ARGS="-DLLAMA_CUBLAS=on" FORCE_CMAKE=1 pip3 install llama-cpp-python 
!pip3 install huggingface-hub 

• Smakämnen CMAKE_ARGS=”-DLLAMA_CUBLAS=på” och FORCE_CMAKE=1, kommer att tillåta llama_cpp_python att använda Nvidia GPU som är tillgänglig i den kostnadsfria colab-versionen.
• Sedan installerar vi lama_cpp_python packa genom pip3
• Vi laddar till och med ner huggingface-hub, med vilken vi kommer att ladda ner den kvantiserade TinyLlama 1.1B Chat

För att testa TinyLlama 1.1B Chat-modellen måste vi först ladda ner den kvantiserade versionen av den. För att ladda ner den kör vi följande kod

from huggingface_hub import hf_hub_download

# specifying the model name
model_name = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF"
# specifying the type of quantization of the model
model_file = "tinyllama-1.1b-chat-v1.0.Q8_0.gguf"

# download the model by specifying the model name and quantized model name
model_path = hf_hub_download(model_name, filename=model_file)

Här, den hugging_face_hub biblioteket kommer att ta hand om processen att ladda ner den kvantiserade modellen. För detta importerar vi hf_hub_download som tar in följande parametrar:

• modellnamn: Till denna variabel skickar vi modellen som vi vill ladda ner. Här vill vi ladda ner TinyLlama 1.1B Chat GGUF-modellen.
• modell_fil: Här anger vi vilken typ av kvantiserad modell vi vill ladda ner. Här kommer vi att ladda ner den 8-bitars kvantiserade versionen av TinyLlama 1.1B Chat.
• Slutligen skickar vi dessa parametrar till hf_hub_download, som tar in dessa parametrar och laddar ner den angivna modellen. Efter nedladdningen returnerar den sökvägen där modellen laddas ner.
• Den returnerade sökvägen sparas i model_path variabel.

Nu kan vi ladda den här modellen genom lama_cpp_python bibliotek. Koden för att ladda modellen kommer att se ut som den nedan.

from llama_cpp import Llama
llm = Llama(
    model_path=model_path,
    n_ctx=512,  # the number of i/p tokens the model can take
    n_threads=8, # the number of threads to use
    n_gpu_layers=40# how many layers of the model to offload to the GPU
)

Vi importerar Lama klass från lama_cpp, som tar in följande parametrar

• modell_sökväg: Denna variabel tar in vägen där vår modell är lagrad. Vi har fått vägen från föregående steg, som vi kommer att tillhandahålla här
• n_ctx: Här ger vi kontextlängden för modellen. För närvarande tillhandahåller vi 512 tokens som kontextlängd
• n_trådar: Här nämner vi antalet trådar som ska användas av Lama klass
• n_gpu_lager: Vi specificerar detta om vi har en körande GPU, vilket vi gör i fallet med gratis colab. Till detta skickar vi 40, vilket innebär att vi vill ladda ner hela modellen till GPU:n och inte vill att någon del av den ska köras i systemets RAM
• Slutligen skapar vi ett objekt från detta Lama klass och ge den till variabeln llm

Genom att köra den här koden laddas den kvantiserade TinyLlama 1.1B Chat-modellen till GPU:n och ställer in lämplig kontextlängd. Nu är det dags att göra några slutsatser om denna modell. För detta arbetar vi med nedanstående kod

output = llm(
  "<|im_start|>usernWho are you?<|im_end|>n<|im_start|>assistantn", # User Prompt
  max_tokens=512,  # Number of output tokens generated
  stop=["</s>"],   # Token which tells the LLM to stop
)
print(output['choices'][0]['text']) # Model generated text

För att härleda modellen skickar vi följande parametrar till LLM:

• prompt/chattmall: Detta är den promptmall som behövs för att chatta med modellen. Ovan nämnda mall(dvs , ) är den som fungerar för TinyLlama 1.1B Chat-modellen. I mallen är meningen efter Användaren User Prompt, och genereringen kommer att genereras efter Assistant.
• max_tokens: Till denna variabel skickar vi ett värde som definierar det maximala antalet tokens som en stor språkmodell kan mata ut när en prompt ges. För närvarande begränsar vi det till 512 tokens.
• sluta: Till denna variabel skickar vi stopptoken. Stopptoken säger till Large Language Model att sluta generera ytterligare tokens. För TinyLlama 1.1B Chat är stopptoken

Den genererade texten lagras i utdatavariabeln när vi kör detta. Resultatet genereras i ett format som liknar OpenAI API-anropet. Därför kan vi komma åt generationen genom den givna utskriftssatsen, liknande hur vi får tillgång till generationen från OpenAI-svaren. Resultatet som genereras kan ses nedan

För en modell av denna storlek är dess genererade respons förstklassig. Detta är oväntat från en modell av denna storlek; grammatiken och tonen ser helt ok ut, och det finns inga tecken på upprepning av meningar. Låt oss prova att testa modellens resonemangsförmåga

output = llm(
  "<|im_start|>usernIf all students who study hard get good grades, 
  and John got good grades, can we conclude that John studied hard?
  <|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

output = llm(
  "<|im_start|>usernHow fast can a snake fly?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

Än så länge är allt bra. Av de exempel vi har sett genererar modellen bra svar. Men detta kanske inte stämmer i alla fall eftersom vi bara testar det på ett begränsat antal frågor. Låt oss till och med testa modellen på dess matematiska resonemangsförmåga

output = llm(
  "<|im_start|>usernJohn is twice as old as Sarah, and Sarah is three years 
  older than Mary. If Mary is 10 years old, how old is John?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

output = llm(
  "<|im_start|>usernWhat is the missing number in this pattern: 
  1, 4, 9, 16, __, 36?n<|im_end|>n<|im_start|>assistantn",
  max_tokens=512,
  stop=["</s>"],
)


print(output['choices'][0]['text'])

Från de exempel vi har sett är det tydligt att TinyLlamaChat presterar extremt dåligt när det gäller att svara på enkla begåvningsfrågor i matematik. Detta förväntas eftersom modellen inte var förtränad på någon mattedatauppsättning. Kvaliteten på generationen kan förbättras genom att finjustera den på den matematiska datamängden

När det gäller finjustering är TinyLlama ett bra val för dem som har begränsad hårdvara och vill finjustera stora språkmodeller på sin specifika datauppsättning

Potentiella användningsfall och applikationer

Med tanke på den kompakta storleken på Lilla Lama, som har 1.1 miljarder parametrar, är dess applikationer främst lämpade för miljöer där större modeller kanske inte är lika genomförbara på grund av hårdvarubegränsningar eller högre effektivitet. Här är några specifika användningsfall där storleken beaktas:

Mobilapplikationer: TinyLlamas mindre storlek gör den till ett bra val för att integrera i mobilappar där bearbetning på enheten är nödvändig. Detta inkluderar språköversättningsappar, personliga assistentfunktioner och chatbots som kan fungera effektivt på smartphones.

Inbyggda system i IoT-enheter: Inom Internet of Things (IoT)-området är datorresurserna ofta begränsade; TinyLlama kan användas för att lägga till intelligenta språkbehandlingsmöjligheter till olika utrustningar som smarta hemassistenter, bärbar teknik och annan sådan ansluten utrustning.

Edge computing: För applikationer som drar nytta av att behandla data närmare källan snarare än i en centraliserad molnmiljö, kan TinyLlama användas effektivt. Detta inkluderar språkbehandling i realtid i bilsystem, tillverkningsutrustning och andra avancerade enheter.

Språkforskning med låga resurser: På grund av dess mindre storlek och lägre beräkningskrav, kan TinyLlama vara ett värdefullt verktyg i språkforskning, särskilt för språk som inte har några resurser där storskalig modellutbildning inte är genomförbar.

Utbildningsverktyg: I utbildningsmiljöer, särskilt de med begränsad tillgång till avancerade datorresurser, kan TinyLlama användas för att utveckla språkinlärningsappar, interaktiva utbildningsverktyg och andra inlärningshjälpmedel.

Innehållsgenerering för småföretag: Små företag med begränsade resurser kan använda TinyLlama för att generera innehåll, som produktbeskrivningar, marknadsföringsexemplar och kundkorrespondens, utan behov av omfattande datorkraft.

Prototyper och experiment: Utvecklare och forskare som vill experimentera med språkmodeller men saknar tillgång till kraftfulla datorresurser kan använda TinyLlama för att prototyper och utveckla nya NLP-applikationer.

Effektiv dataanalys: TinyLlama kan användas för textanalys och dataextraktion i scenarier där snabb och effektiv bearbetning behövs, som att analysera kundfeedback, enkätsvar eller interaktioner med sociala medier.

Slutsats

TinyLlama 1.1B är ett bevis på framstegen inom området AI och naturlig språkbehandling. Dess utveckling och utbredda tillgänglighet är avgörande för att skapa effektivare, små och snabbare inferensspråksmodeller. Genom att balansera ett mindre parameterfotavtryck med robust prestanda, möter TinyLlama 1.1B det kritiska behovet av kraftfulla och praktiska modeller för ett brett spektrum av applikationer. Dess förmåga att förstå och generera språk på ett mänskligt sätt samtidigt som det är tillräckligt lätt för olika datormiljöer gör det till ett bra val för människor som kämpar för att köra stora språkmodeller på sina maskiner. Modellen kan enkelt finjusteras på en datauppsättning och kan tränas med begränsade datorresurser. 

De viktigaste takeaways från denna artikel inkluderar

• Designad för effektivitet, TinyLlama 1.1B är tillgänglig för en bredare publik, inklusive de med begränsade beräkningsresurser, vilket gör den lämplig för flera applikationer.
• Modellen genomgick en omfattande träningsprocess, inklusive träning på 3 biljoner tokens under 90 dagar med 16 A100-40G GPU:er.
• Trots sin mindre storlek levererar TinyLlama 1.1B högkvalitativa, kontextuellt relevanta svar på flera språk, vilket gör det till en modell att överväga.
• Det är ett bra val för mobila applikationer, IoT-utrustning, utbildningsverktyg och mer, dess kompakta storlek och effektivitet möjliggör breda applikationer.
• Dess lägre beräkningskrav gör det till ett värdefullt verktyg i språkforskning, särskilt för språk som inte har några resurser.
• Modellen är ett bra val för de som experimenterar med språkmodeller eller utvecklar nya NLP-appar, främst i inställningar med begränsad beräkningskraft.

Vanliga frågor

Medierna som visas i den här artikeln ägs inte av Analytics Vidhya och används efter författarens gottfinnande.

Relaterad

• 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. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• Källa: https://www.analyticsvidhya.com/blog/2024/01/tinyllama-1-1b-size-doesnt-matter/