TinyLlama 1.1B – Størrelsen spiller ingen rolle

Introduksjon

I det raskt voksende landskapet med kunstig intelligens og maskinlæring, fremstår TinyLlama 1.1B som en bemerkelsesverdig utvikling. I en tid der beregningsmessige begrensninger utgjør utfordringer for å kjøre mer komplekse modeller, skiller TinyLlama seg ut ved å trosse forventningene. Den viser frem den bemerkelsesverdige ytelsen til kompakte modeller.

Denne artikkelen tar sikte på å gi en analyse av TinyLlama 1.1B, en kompakt stor språkmodell. Vi vil fordype oss i kjerneaspektene, som hvordan den ble opplært i ytelsesbenchmarks og praktisk implementering ved hjelp av Hugging Face-plattformen. Vi vil til og med kjøre denne modellen på gratis Google Colab og teste dens matematikk- og resonneringsevner.

Læringsmål

• Få en omfattende forståelse av TinyLlama 1.1B
• Utforsk den intrikate treningsprosessen som modellen har gått gjennom
• Analyser ytelsen og benchmark-resultatene for å vurdere effektiviteten
• Lær de praktiske trinnene for å implementere TinyLlama 1.1B ved å bruke kodeeksempler

Denne artikkelen ble publisert som en del av Data Science Blogathon.

Hva er TinyLlama 1.1B?

TinyLlama 1.1B, en del av det bredere Llama-prosjektet, er et bevis på fremskritt i språkmodellering. Det er en modell med 1.1 milliarder parametere, trent på svimlende 3 billioner tokens, som setter den i en unik posisjon i AI-landskapet. I motsetning til sine større motparter, er TinyLlama 1.1B designet for å være mer effektiv og håndterlig, noe som gjør den til et godt valg for applikasjoner med begrensede beregningsressurser.

Denne åpen kildekode-modellen demokratiserer tilgang til toppmoderne AI-teknologi, og lar mange utviklere og forskere utforske og innovere innen naturlig språkbehandling. Det er en modell kjent for sin evne til å balansere ytelse med ressursforbruk, en kritisk vurdering i dagens mangfoldige beregningsmiljøer.

Opplæringsprosess for TinyLlama 1.1B

Treningsprosessen til TinyLlama 1.1B er fascinerende, som selve modellen. Treningen av TinyLlama fant sted bare i 90 dager, trent på de 16 A100-40G GPUene. Foropplæringen ble utført på 3 billioner tokens, og TinyLlama-teamet har publisert mellommodellen mellom hver halv billion. 

Når det gjelder dataene, ble Slimpajama og Starcoderdata tatt med en samlet datasettstørrelse på 950 milliarder tokens. Det naturlige språk-til-kode-forholdet ble holdt på 7:3, dvs. 70 % av dataene var naturlig språk, og 30 % var kode. For å oppnå 3 Trillion Tokens-merket for finjustering, gjennomgikk TinyLlama tre epoker med trening for dette datasettet. 

Det er til og med en chatversjon av TinyLlama kalt TinyLlama-Chat utgitt. Opprinnelig gjennomgikk denne modellen finjustering på UltraChat-datasettet, som inneholder forskjellige syntetiske samtaler generert av ChatGPT. Dette trinnet var avgjørende for å få modellen til å håndtere ulike samtalekontekster og stiler.

Ytterligere forfining ble oppnådd ved å bruke DPOTrainer på UltraFeedback-datasettet. Denne treningsfasen fokuserte på å justere modellens svar for å tilpasse seg menneskelignende samtalemønstre. Resultatet er en modell som ikke bare tar tak i informasjon om forskjellige emner, men til og med samhandler på en naturlig og engasjerende måte.

Du kan også lese: Komme i gang med LlaMA 2: En nybegynnerveiledning

Ytelse og benchmark-resultater

Evaluering av ytelsen til TinyLlama 1.1B avslører evnen til å levere høykvalitetssvar raskt. Opplæringen har gitt den muligheten til å imøtekomme flerspråklige applikasjoner, en viktig funksjon i vår globaliserte verden. Til tross for sin mindre størrelse, tar TinyLlama 1.1B fortsatt opp til sine større motparter når det gjelder responskvalitet og hastighet, noe som gjør den til et potent verktøy i forskjellige AI-applikasjoner.

Referansemålene for TinyLlama 1.1B, selv om de er mindre omfattende enn de for større modeller, viser fortsatt dens ferdigheter i å håndtere komplekse språkoppgaver. Dens evne til å generere sammenhengende og kontekstuelt relevante svar på flere språk er spesielt imponerende. Modellen ble testet på forskjellige benchmarks som HellaSwag, WinoGrande, ARC, MMLU og andre. Den samlede gjennomsnittlige poengsummen kom ut til å være 52.99. Dette er mye bedre enn den andre 1 Billion Parameter Model, dvs. Pythia 1B, som oppnådde en gjennomsnittlig poengsum på 48.3. Tabellen viser de individuelle poengsummene for hver benchmark

TinyLlama – Komme i gang

Her, i denne delen, vil vi laste ned den kvantiserte versjonen av TinyLlama Chat og kjøre den i Google Colab. Før du laster ned modellen, må vi laste ned og installere følgende Python-pakker

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

• De CMAKE_ARGS=”-DLLAMA_CUBLAS=på” og FORCE_CMAKE=1, vil tillate llama_cpp_python å bruke Nvidia GPU som er tilgjengelig i den gratis colab-versjonen.
• Deretter installerer vi lama_cpp_python pakke gjennom pip3
• Vi laster til og med ned huggingface-hub, som vi skal laste ned den kvantiserte TinyLlama 1.1B Chat

For å teste TinyLlama 1.1B Chat-modellen, må vi først laste ned den kvantiserte versjonen av den. For å laste den ned, kjører vi følgende kode

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)

Her, den hugging_face_hub biblioteket vil ta seg av prosessen med å laste ned den kvantiserte modellen. For dette importerer vi hf_hub_download som tar inn følgende parametere:

• modell navn: Til denne variabelen sender vi modellen vi ønsker å laste ned. Her ønsker vi å laste ned TinyLlama 1.1B Chat GGUF-modellen.
• modell_fil: Her spesifiserer vi hvilken type kvantisert modell vi ønsker å laste ned. Her vil vi laste ned den 8-biters kvantiserte versjonen av TinyLlama 1.1B Chat.
• Til slutt sender vi disse parametrene til hf_hub_download, som tar inn disse parameterne og laster ned den angitte modellen. Etter nedlasting returnerer den banen der modellen er lastet ned.
• Denne returnerte banen blir lagret i model_path variabel.

Nå kan vi laste denne modellen gjennom lama_cpp_python bibliotek. Koden for å laste modellen vil være som den nedenfor.

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 importerer Llama klasse fra lama_cpp, som tar inn følgende parametere

• modellbane: Denne variabelen tar inn banen der modellen vår er lagret. Vi har fått veien fra forrige trinn, som vi vil gi her
• n_ctx: Her gir vi kontekstlengden for modellen. Foreløpig gir vi 512 tokens som kontekstlengde
• n_tråder: Her nevner vi antall tråder som skal brukes av Llama klasse
• n_gpu_lag: Vi spesifiserer dette hvis vi har en kjørende GPU, noe vi gjør i tilfelle gratis colab. Til dette sender vi 40, som innebærer at vi ønsker å laste hele modellen inn i GPUen og ikke vil at noen del av den skal kjøre i system-RAM
• Til slutt lager vi et objekt fra dette Llama klasse og gi den til variabelen llm

Kjøring av denne koden vil laste den kvantiserte TinyLlama 1.1B Chat-modellen inn på GPUen og angi riktig kontekstlengde. Nå er det på tide å gjøre noen slutninger om denne modellen. For dette jobber vi med koden nedenfor

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

For å utlede modellen sender vi følgende parametere til LLM:

• ledetekst/chatmal: Dette er ledetekstmalen som trengs for å chatte med modellen. Den ovennevnte malen(dvs , ) er den som fungerer for TinyLlama 1.1B Chat-modellen. I malen er setningen etter brukeren brukermeldingen, og generasjonen vil bli generert etter assistenten.
• max_tokens: Til denne variabelen sender vi en verdi som definerer det maksimale antallet tokens en stor språkmodell kan sende ut når en ledetekst gis. Foreløpig begrenser vi det til 512 tokens.
• Stoppe: Til denne variabelen sender vi stopptokenet. Stopptokenet forteller den store språkmodellen å slutte å generere flere tokens. For TinyLlama 1.1B Chat er stopptokenet

Den genererte teksten lagres i utdatavariabelen når vi kjører denne. Resultatet genereres i et format som ligner på OpenAI API-kallet. Derfor kan vi få tilgang til generasjonen gjennom den gitte utskriftserklæringen, på samme måte som vi får tilgang til generasjonen fra OpenAI-svarene. Utgangen som genereres kan sees nedenfor

For en modell av denne størrelsen er den genererte responsen førsteklasses. Dette er uventet fra en modell av denne størrelsen; grammatikken og tonen ser helt grei ut, og det er ingen tegn til gjentakelse av setninger. La oss prøve å teste modellens resonneringsevner

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'])

Så langt så bra. Fra eksemplene vi har sett, genererer modellen gode svar. Men dette er kanskje ikke sant i alle tilfeller fordi vi bare tester det på et begrenset antall spørsmål. La oss til og med teste modellen på dens matematiske resonneringsevner

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'])

Fra eksemplene vi har sett, er det klart at TinyLlamaChat yter ekstremt dårlig når det gjelder å svare på enkle egnethetsspørsmål i matematikk. Dette er forventet fordi modellen ikke ble forhåndsopplært på noe matematisk datasett. Kvaliteten på generasjonen kan forbedres ved å finjustere den på mattedatasettet

Når det gjelder finjustering, er TinyLlama et godt valg for de som er begrenset med begrenset maskinvare og ønsker å finjustere store språkmodeller på deres spesifikke datasett

Potensielle brukstilfeller og applikasjoner

Gitt den kompakte størrelsen på Lille Lama, som har 1.1 milliarder parametere, er applikasjonene hovedsakelig egnet for miljøer der større modeller kanskje ikke er like gjennomførbare på grunn av maskinvarebegrensninger eller større effektivitet. Her er noen spesifikke brukstilfeller som tar hensyn til størrelsen:

Mobilapplikasjoner: TinyLlamas mindre størrelse gjør den til et godt valg for integrering i mobilapper der behandling på enheten er nødvendig. Dette inkluderer språkoversettelsesapper, personlige assistentfunksjoner og chatbots som kan fungere effektivt på smarttelefoner.

Innebygde systemer i IoT-enheter: I feltet Internet of Things (IoT) er dataressursene ofte begrensede; TinyLlama kan brukes til å legge til intelligente språkbehandlingsfunksjoner til forskjellig utstyr som smarte hjemmeassistenter, bærbar teknologi og annet slikt tilkoblet utstyr.

Edge Computing: For applikasjoner som drar nytte av å behandle data nærmere kilden i stedet for i et sentralisert skymiljø, kan TinyLlama brukes effektivt. Dette inkluderer sanntids språkbehandling i bilsystemer, produksjonsutstyr og andre avanserte enheter.

Språkforskning med lav ressurser: På grunn av sin mindre størrelse og lavere beregningskrav, kan TinyLlama være et verdifullt verktøy i språkforskning, spesielt for språk med lite ressurser der storskala modelltrening ikke er mulig.

Pedagogiske verktøy: I utdanningsmiljøer, spesielt de med begrenset tilgang til avanserte dataressurser, kan TinyLlama brukes til å utvikle språkopplæringsapper, interaktive pedagogiske verktøy og andre læremidler.

Innholdsgenerering for små bedrifter: Små bedrifter med begrensede ressurser kan bruke TinyLlama til å generere innhold, som produktbeskrivelser, markedsføringstekst og kundekorrespondanse, uten behov for omfattende datakraft.

Prototyping og eksperimentering: Utviklere og forskere som ønsker å eksperimentere med språkmodeller, men mangler tilgang til kraftige dataressurser, kan bruke TinyLlama til å prototyper og utvikle nye NLP-applikasjoner.

Effektiv dataanalyse: TinyLlama kan brukes til tekstanalyse og datautvinning i scenarier der rask og effektiv behandling er nødvendig, som å analysere tilbakemeldinger fra kunder, spørreundersøkelser eller interaksjoner på sosiale medier.

konklusjonen

TinyLlama 1.1B er et bevis på fremskritt innen AI og naturlig språkbehandling. Dens utvikling og utbredte tilgjengelighet er avgjørende for å skape mer effektive, små og raske inferensspråkmodeller. Ved å balansere et mindre parameter fotavtrykk med robust ytelse, imøtekommer TinyLlama 1.1B det kritiske behovet for kraftige og praktiske modeller for et bredt spekter av applikasjoner. Dens evne til å forstå og generere språk på en menneskelignende måte samtidig som den er lett nok for forskjellige datamiljøer, gjør det til et godt valg for folk som sliter med å kjøre store språkmodeller på maskinene sine. Modellen kan enkelt finjusteres på et datasett og kan trenes med begrensede dataressurser. 

Nøkkelpakkene fra denne artikkelen inkluderer

• Designet for effektivitet, er TinyLlama 1.1B tilgjengelig for et bredere publikum, inkludert de med begrensede beregningsressurser, noe som gjør den egnet for flere applikasjoner.
• Modellen gjennomgikk en omfattende opplæringsprosess, inkludert trening på 3 billioner tokens over 90 dager ved bruk av 16 A100-40G GPUer.
• Til tross for sin mindre størrelse, leverer TinyLlama 1.1B høykvalitets, kontekstuelt relevante svar på flere språk, noe som gjør den til en modell å vurdere.
• Det er et godt valg for mobile applikasjoner, IoT-utstyr, pedagogiske verktøy og mer, dens kompakte størrelse og effektivitet tillater brede applikasjoner.
• Dens lavere beregningskrav gjør det til et verdifullt verktøy i språkforskning, spesielt for språk med lite ressurser.
• Modellen er et godt valg for de som eksperimenterer med språkmodeller eller utvikler nye NLP-apper, hovedsakelig i innstillinger med begrenset beregningskraft.

Ofte Stilte Spørsmål

Mediene vist i denne artikkelen eies ikke av Analytics Vidhya og brukes etter forfatterens skjønn.

I slekt

• SEO-drevet innhold og PR-distribusjon. Bli forsterket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk deg selv. Tilgang her.
• PlatoAiStream. Web3 Intelligence. Kunnskap forsterket. Tilgang her.
• PlatoESG. Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
• PlatoHelse. Bioteknologisk og klinisk etterretning. Tilgang her.
• kilde: https://www.analyticsvidhya.com/blog/2024/01/tinyllama-1-1b-size-doesnt-matter/