Bruke Llamafiler for å forenkle LLM-utførelse

Publisert av Platon

Følgere: 0

Introduksjon

Å kjøre store språkmodeller har alltid vært en kjedelig prosess. Man må laste ned et sett med tredjepartsprogramvare for å laste disse LLM-ene eller laste ned Python og lage et miljø ved å laste ned mange Pytorch- og HuggingFace-biblioteker. Hvis man går gjennom Pythonic Approach, må man gå gjennom prosessen med å skrive kode for å laste ned og kjøre modellen. Denne veiledningen vil se på en enklere tilnærming til å kjøre disse LLM-ene.

Læringsmål

Forstå utfordringene med tradisjonell LLM-utførelse
Ta tak i det innovative konseptet til Llamafiles
Lær å laste ned og kjøre dine egne kjørbare Llamafile-filer med letthet
Lære å lage Llam-filer fra kvantiserte LLM-er
Identifiser begrensningene ved denne tilnærmingen

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

Innholdsfortegnelse

Problemer med store språkmodeller

Store språkmodeller (LLM) har revolusjonert hvordan vi samhandler med datamaskiner, genererer tekst, oversetter språk, skriver ulike typer kreativt innhold og til og med svarer på spørsmålene dine på en informativ måte. Det har imidlertid ofte vært utfordrende å kjøre disse kraftige modellene på datamaskinen.

For å kjøre LLM-ene må vi laste ned Python og mange AI-avhengigheter, og på toppen av det må vi til og med skrive kode for å laste ned og kjøre dem. Selv når du installerer de ferdige brukergrensesnittene for store språkmodeller, involverer det mange oppsett, som lett kan gå galt. Å installere og kjøre dem som en kjørbar fil har ikke vært en enkel prosess.

Hva er Llamafiler?

Llamafiler er laget for å fungere enkelt med populære åpen kildekode store språkmodeller. Dette er kjørbare filer med én fil. Det er akkurat som å laste ned en LLM og kjøre den som en kjørbar fil. Det er ikke behov for en første installasjon av biblioteker. Alt dette var mulig på grunn av llama.cpp og den kosmopolitiske libc, som gjør at LLM-ene kjører på forskjellige OSer.

llama.cpp ble utviklet av Georgi Gerganov for å kjøre store språkmodeller i det kvantiserte formatet slik at de kan kjøre på en CPU. llama.cpp er et C-bibliotek som lar oss kjøre kvantiserte LLM-er på forbrukermaskinvare. På den annen side er det kosmopolitiske libc et annet C-bibliotek som bygger en binær som kan kjøres på alle operativsystemer (Windows, Mac, Ubuntu) uten å trenge en tolk. Så Llamafile er bygget på toppen av disse bibliotekene, som lar den lage enkeltfil kjørbare LLMer

De tilgjengelige modellene er i GGUF-kvantisert format. GGUF er et filformat for store språkmodeller utviklet av Georgi Gerganov, skaperen av llama.cpp. GGUF er et format for lagring, deling og lasting av store språkmodeller effektivt og effektivt på CPUer og GPUer. GGUF bruker en kvantiseringsteknikk for å komprimere modellene fra deres opprinnelige 16-bit flytepunkt til et 4-bit eller 8-bit heltallsformat. Vektene til denne kvantiserte modellen kan lagres i dette GGUF-formatet

Dette gjør det enklere for 7 Billion Parameter-modeller å kjøre på en datamaskin med 16 GB VRAM. Vi kan kjøre de store språkmodellene uten å kreve en GPU (selv om Llamafile til og med lar oss kjøre LLM-ene på en GPU). Akkurat nå er lamafilene til populære store språkmodeller med åpen kildekode som LlaVa, Mistral og WizardCoder lett tilgjengelig for nedlasting og kjøring

One Shot kjørbare filer

I denne delen vil vi laste ned og prøve å kjøre en multimodal LlaVa Llamafile. Her vil vi ikke jobbe med GPU og kjøre modellen på CPU. Gå til det offisielle Llamafile GitHub-depotet ved å klikke her. og laster ned LlaVa 1.5-modellen.

Last ned modellen

Bildet ovenfor viser alle tilgjengelige modeller med navn, størrelser og nedlastbare lenker. LlaVa 1.5 er på bare rundt 4 GB og er en kraftig multimodell som kan forstå bilder. Den nedlastede modellen er en 7 milliarder parametermodell som er kvantisert til 4-bits. Etter å ha lastet ned modellen, gå til mappen der den ble lastet ned.

Åpne deretter CMD, naviger til mappen der denne modellen er lastet ned, skriv inn navnet på filen vi lastet ned, og trykk enter.

llava-v1.5-7b-q4.llamafile

For Mac- og Linux-brukere

For Mac og Linux er kjøringstillatelsen av for denne filen som standard. Derfor må vi gi utførelsestillatelsen for llamafilen, noe vi kan gjøre ved å kjøre kommandoen nedenfor.

chmod +x llava-v1.5-7b-q4.llamafile

Dette er for å aktivere kjøringstillatelsen for llava-v1.5-7b-q4.llamafilen. Legg også til "./" før filnavnet for å kjøre filen på Mac og Linux. Etter at du har trykket på enter-nøkkelordet, vil modellen skyves til system-RAM og vise følgende utgang.

Deretter vil nettleseren komme opp og modellen kjører på URLen http://127.0.0.1:8080/

Bildet ovenfor viser standard ledetekst, brukernavn, LLM-navn, ledetekstmal og mal for chattehistorikk. Disse kan konfigureres, men foreløpig vil vi gå med standardverdiene.

Nedenfor kan vi til og med sjekke de konfigurerbare LLM-hyperparametrene som Top P, Top K, Temperature og de andre. Selv disse vil vi la dem være standard for nå. La oss nå skrive inn noe og klikke på send.

På bildet ovenfor kan vi se at vi har skrevet inn en melding og til og med mottatt et svar. Under det kan vi sjekke at vi får rundt 6 tokens per sekund, som er en god token/sekund med tanke på at vi kjører den utelukkende på CPU. Denne gangen, la oss prøve det med et bilde.

Selv om den ikke er 100 % riktig, kan modellen nesten få det meste rett fra bildet. La oss nå ha en samtale med flere svinger med LlaVa for å teste om den husker chat-historikken.

På bildet ovenfor kan vi se at LlaVa LLM var i stand til å holde konvoen godt oppe. Den kan ta inn historiesamtalen og deretter generere svarene. Selv om det siste svaret som ble generert ikke er helt sant, samlet det forrige konvo for å generere det. Så på denne måten kan vi laste ned en lamafil og bare kjøre dem som programvare og jobbe med de nedlastede modellene.

Opprette Llamafiler

Vi har sett en demo av Llamafile som allerede var til stede på den offisielle GitHub. Ofte ønsker vi ikke å jobbe med disse modellene. I stedet ønsker vi å lage kjørbare enkeltfiler av våre store språkmodeller. I denne delen vil vi gå gjennom prosessen med å lage kjørbare enkeltfiler, dvs. lama-filer fra kvantiserte LLM-er.

Velg en LLM

Vi starter først med å velge en stor språkmodell. For denne demoen vil vi velge en kvantisert versjon av TinyLlama. Her vil vi laste ned den 8-bits kvantiserte GGUF-modellen til TinyLlama (Du kan klikke her. for å gå til HuggingFace og laste ned modellen)

Last ned den nyeste Llam-filen

Den siste llamafilen zip fra den offisielle GitHub-lenken kan lastes ned. Last også ned zip-filen og pakk ut zip-filen. Den gjeldende versjonen av denne artikkelen er lamafil-0.6. Etter lamautvinningen vil bin-mappen med filmappen inneholde filene som bildet nedenfor.

Flytt nå den nedlastede TinyLlama 8-bits kvantiserte modellen til denne bin-mappen. For å lage kjørbare enkeltfiler, må vi lage en .args-fil i bin-mappen til llamafile. Til denne filen må vi legge til følgende innhold:

-m
tinyllama-1.1b-chat-v0.3.Q8_0.gguf
--host
0.0.0.0
...

Den første linjen indikerer flagget -m. Dette forteller lamafilen at vi laster inn vektene til en modell.
I den andre linjen spesifiserer vi modellnavnet som vi har lastet ned, som finnes i samme katalog som .args-filen er til stede i, dvs. bin-mappen til llamafilen.
I den tredje linjen legger vi til vertsflagget, som indikerer at vi kjører den kjørbare filen og ønsker å være vert for en webserver.
Til slutt, i den siste linjen, nevner vi adressen der vi ønsker å være vert, som tilordnes lokalvert. Etterfulgt av dette er de tre prikkene, som spesifiserer at vi kan sende argumenter til lamafilen vår når den er opprettet.
Legg til disse linjene i .args-filen og lagre den.

For Windows-brukere

Nå er neste trinn for Windows-brukerne. Hvis vi jobber på Windows, måtte vi ha installert Linux via WSL. Hvis ikke, klikk her. for å gå gjennom trinnene for å installere Linux gjennom WSL. I Mac og Linux er ingen ekstra trinn nødvendig. Åpne nå bin-mappen til llamafile-mappen i terminalen (hvis du jobber på Windows, åpne denne katalogen i WSL) og skriv inn følgende kommandoer.

cp llamafile tinyllama-1.1b-chat-v0.3.Q8_0.llamafile

Her lager vi en ny fil kalt tinyllama-1.1b-chat-v0.3.Q3_0.llamafile; det vil si at vi lager en fil med filtypen .llamafile og flytter filen llamafile inn i denne nye filen. Nå, etter dette, vil vi skrive inn denne neste kommandoen.

./zipalign -j0 tinyllama-1.1b-chat-v0.3.Q8_0.llamafile tinyllama-1.1b-chat-v0.3.Q8_0.gguf .args

Her jobber vi med zipalign-filen som kom da vi lastet ned lamafilen zip fra GitHub. Vi jobber med denne kommandoen for å lage lamafilen for vår kvantiserte TinyLlama. Til denne zipalign-kommandoen sender vi inn tinyllama-1.1b-chat-v0.3.Q8_0.llamafilen som vi har opprettet i forrige trinn, deretter sender vi tinyllama-1.1b-chat-v0.3.Q8_0.llamafilen modell som vi har i bin-mappen og sender til slutt inn .args-filen som vi har laget tidligere.

Dette vil til slutt produsere vår enkeltfil kjørbare tinyllama-1.1b-chat-v0.3.Q8_0.llamafile. For å sikre at vi er på samme side, inneholder bin-mappen nå følgende filer.

Nå kan vi kjøre tinyllama-1.1b-chat-v0.3.Q8_0.llama-filen på samme måte som vi gjorde før. I Windows kan du til og med gi nytt navn til .llamafilen til .exe og kjøre den ved å dobbeltklikke på den.

OpenAI-kompatibel server

Denne delen vil se på hvordan du serverer LLM-er gjennom Llamfilen. Vi har lagt merke til at når vi kjører lamafilen, åpnes nettleseren, og vi kan samhandle med LLM gjennom WebUI. Dette er i utgangspunktet det vi kaller å være vertskap for den store språkmodellen.

Når vi kjører Llamafile, kan vi samhandle med den respektive LLM som et endepunkt fordi modellen blir servert hos den lokale verten på PORT 8080. Serveren følger OpenAI API Protocol, dvs. ligner på OpenAI GPT Endpoint, og gjør dermed det er enkelt å bytte mellom OpenAI GPT-modellen og LLM som kjører med Llamafile.

Her vil vi kjøre den tidligere opprettede TinyLlama lamafilen. Nå må dette kjøres på localhost 8080. Vi vil nå teste det gjennom OpenAI API selv i Python

from openai import OpenAI
client = OpenAI(
    base_url="http://localhost:8080/v1", 
    api_key = "sk-no-key-required"
)
completion = client.chat.completions.create(
    model="TinyLlama",
    messages=[
        {"role": "system", "content": "You are a usefull AI 
        Assistant who helps answering user questions"},
        {"role": "user", "content": "Distance between earth to moon?"}
    ]
)
print(completion.choices[0].message.content)

Her jobber vi med OpenAI-biblioteket. Men i stedet for å spesifisere OpenAI-endepunktet, spesifiserer vi URL-en der TinyLlamaen vår er vert og gir "sk-no-token-required" for api_key
Deretter vil klienten koble seg til vårt TinyLlama-endepunkt
Nå, i likhet med hvordan vi jobber med OpenAI, kan vi bruke koden til å chatte med vår TinyLlama.
For dette jobber vi med komplettering klasse av OpenAI. Vi skaper nytt komplettering med .skape() objekt og send detaljene som modellnavnet og meldingene.
Meldingene er i form av en liste med ordbøker, der vi har rollen, som kan være system, bruker eller assistent, og vi har innholdet.
Til slutt kan vi hente informasjonen generert gjennom utskriftserklæringen ovenfor.

Utgangen for ovennevnte kan sees nedenfor.

På denne måten kan vi utnytte llamafilene og enkelt erstatte OpenAI API med llamafilen vi valgte å kjøre.

Llamafiles begrensninger

Mens de er revolusjonerende, er lamafiler fortsatt under utvikling. Noen begrensninger inkluderer:

Begrenset modellutvalg: Foreløpig er ikke alle LLM-er tilgjengelige i form av lamafiler. Det nåværende utvalget av forhåndsbygde Llamafiles vokser fortsatt. For øyeblikket er Llamafiler tilgjengelig for Llama 2, LlaVa, Mistral og Wizard Coder.
Maskinvarekrav: Å kjøre LLM-er, selv gjennom Llamafiles, krever fortsatt mye beregningsressurser. Selv om de er enklere å kjøre enn tradisjonelle metoder, kan eldre eller mindre kraftige datamaskiner trenge hjelp til å kjøre dem jevnt.
Sikkerhetsproblemer: Nedlasting og kjøring av kjørbare filer fra upålitelige kilder medfører iboende risikoer. Så det må være en pålitelig plattform der vi kan laste ned disse lamafilene.

Llamafiles vs resten

Før Llamafiles var det forskjellige måter å kjøre store språkmodeller på. Den ene var gjennom lama_cpp_python. Dette er Python-versjonen av llama.cpp som lar oss kjøre kvantiserte store språkmodeller på forbrukermaskinvare som bærbare og stasjonære PC-er. Men for å kjøre det, må vi laste ned og installere Python og til og med dyplæringsbiblioteker som fakkel, huggingface, transformatorer og mange flere. Og etter det innebar det å skrive mange linjer med kode for å kjøre modellen.

Selv da, noen ganger, kan vi møte problemer på grunn av avhengighetsproblemer (det vil si at noen biblioteker har lavere eller høyere versjoner enn nødvendig). Og det er også CTransformers bibliotek som lar oss kjøre kvantiserte LLM-er. Selv dette krever den samme prosessen som vi har diskutert for llama_cpp_python

Og så er det det Ollama. Ollama har vært svært vellykket i AI-fellesskapet for sin brukervennlighet for enkelt å laste og kjøre store språkmodeller, spesielt de kvantiserte. Ollama er en slags TUI (Terminal User Interface) for LLM-er. Den eneste forskjellen mellom Ollama og Llamafilen er delbarheten. Det vil si at hvis jeg vil, kan jeg dele min model.llamafile med hvem som helst, og de kan kjøre den uten å laste ned noen ekstra programvare. Men når det gjelder Ollama, må jeg dele model.gguf-filen, som den andre personen bare kan kjøre når de installerer Ollama-programvaren eller gjennom Python-bibliotekene ovenfor.

Når det gjelder ressursene, krever alle samme mengde ressurser fordi alle disse metodene bruker llama.cpp under for å kjøre de kvantiserte modellene. Det handler kun om brukervennligheten der det er forskjeller mellom disse.

konklusjonen

Llamafiler markerer et avgjørende skritt fremover for å gjøre LLM-er lett kjørbare. Deres brukervennlighet og portabilitet åpner for en verden av muligheter for utviklere, forskere og tilfeldige brukere. Selv om det er begrensninger, er potensialet til lamafiler for å demokratisere LLM-tilgang åpenbart. Enten du er en ekspertutvikler eller en nysgjerrig nybegynner, åpner Llamafiles spennende muligheter for å utforske verden av LLM-er. I denne guiden har vi tatt en titt på hvordan du laster ned Llamafiles og til og med hvordan du lager våre helt egne Llamafiles med våre kvantiserte modeller . Vi har til og med tatt en titt på den OpenAI-kompatible serveren som opprettes når du kjører Llamafiles.

Nøkkelfunksjoner

Llamafiler er kjørbare enkeltfiler som gjør det enklere og lettere å kjøre store språkmodeller (LLM).
De eliminerer behovet for komplekse oppsett og konfigurasjoner, slik at brukere kan laste ned og kjøre LLM-er direkte uten Python- eller GPU-krav.
Llamafiler er akkurat nå tilgjengelige for et begrenset utvalg av åpen kildekode LLM-er, inkludert LlaVa, Mistral og WizardCoder.
Selv om det er praktisk, har Llamafiles fortsatt begrensninger, som maskinvarekravene og sikkerhetsproblemer knyttet til nedlasting av kjørbare filer fra ikke-klarerte kilder.
Til tross for disse begrensningene representerer Llamafiles et viktig skritt mot å demokratisere LLM-tilgang for utviklere, forskere og til og med tilfeldige brukere.

Ofte Stilte Spørsmål

Q1. Hva er fordelene med å bruke Llamafiles?

A. Llamafiler gir flere fordeler i forhold til tradisjonelle LLM-konfigurasjonsmetoder. De gjør LLM-er enklere og raskere å sette opp og kjøre fordi du ikke trenger å installere Python eller ha en GPU. Dette gjør LLM-er lettere tilgjengelig for et bredere publikum. I tillegg kan Llamafiles kjøre på tvers av forskjellige operativsystemer.

Q2. Hva er begrensningene til Llamafiles?

A. Mens Llamafiler gir mange fordeler, har de også noen begrensninger. Utvalget av LLM-er tilgjengelig i Llamafiles er begrenset sammenlignet med tradisjonelle metoder. I tillegg krever det fortsatt en god mengde maskinvareressurser å kjøre LLM-er gjennom Llamafiles, og eldre eller mindre kraftige datamaskiner støtter det kanskje ikke. Til slutt er sikkerhetsproblemer forbundet med nedlasting og kjøring av kjørbare filer fra ikke-klarerte kilder.

Q3. Hvordan kan jeg komme i gang med Llamafiles?

A. For å komme i gang med Llamafiles, kan du besøke det offisielle Llamafile GitHub-depotet. Der kan du laste ned Llamafile for LLM-modellen du vil bruke. Når du har lastet ned filen, kan du kjøre den direkte som en kjørbar fil.

Q4. Kan jeg bruke min egen LLM-modell med Llamafiles?

A. Nei. Foreløpig støtter Llamafiles kun spesifikke forhåndsbygde modeller. Det er planlagt å lage våre egne Llamafiles for fremtidige versjoner.

Q5. Hva er utsiktene til Llamafiles?

A. Utviklerne av Llamafiles jobber med å utvide utvalget av tilgjengelige LLM-modeller, kjøre dem mer effektivt og implementere sikkerhetstiltak. Disse fremskrittene tar sikte på å gjøre Llamafiles enda mer tilgjengelig og sikker for flere mennesker som har liten teknisk bakgrunn.

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