Använda Llamafiler för att förenkla LLM-exekveringen

Beskrivning

Att köra stora språkmodeller har alltid varit en tråkig process. Man måste ladda ner en uppsättning programvara från tredje part för att ladda dessa LLM:er eller ladda ner Python och skapa en miljö genom att ladda ner många Pytorch- och HuggingFace-bibliotek. Om man går igenom Pythonic Approach måste man gå igenom processen att skriva kod för att ladda ner och köra modellen. Den här guiden kommer att titta på ett enklare sätt att köra dessa LLM:er.

Inlärningsmål

• Förstå utmaningarna med traditionellt LLM-utförande
• Ta tag i det innovativa konceptet med Llamafiles
• Lär dig att ladda ner och köra dina egna körbara Llamafile-filer med lätthet
• Lär dig skapa Llamfiler från kvantiserade LLM:er
• Identifiera begränsningarna för detta tillvägagångssätt

Denna artikel publicerades som en del av Data Science Blogathon.

Problem med stora språkmodeller

Stora språkmodeller (LLM) har revolutionerat hur vi interagerar med datorer, genererar text, översätter språk, skriver olika typer av kreativt innehåll och till och med svarar på dina frågor på ett informativt sätt. Men att köra dessa kraftfulla modeller på din dator har ofta varit utmanande.

För att köra LLM:erna måste vi ladda ner Python och många AI-beroenden, och utöver det måste vi till och med skriva kod för att ladda ner och köra dem. Även när du installerar de färdiga användargränssnitten för stora språkmodeller, involverar det många inställningar, som lätt kan gå fel. Att installera och köra dem som en körbar fil har inte varit en enkel process.

Vad är Llamafiler?

Llamafiler är skapade för att fungera enkelt med populära stora språkmodeller med öppen källkod. Dessa är körbara filer med en enda fil. Det är precis som att ladda ner en LLM och köra den som en körbar fil. Det finns inget behov av en första installation av bibliotek. Allt detta var möjligt tack vare llama.cpp och den kosmopolitiska libc, som gör att LLM:erna körs på olika operativsystem.

llama.cpp utvecklades av Georgi Gerganov för att köra stora språkmodeller i det kvantiserade formatet så att de kan köras på en CPU. llama.cpp är ett C-bibliotek som låter oss köra kvantiserade LLM på konsumenthårdvara. Å andra sidan är det kosmopolitiska libc ett annat C-bibliotek som bygger en binär som kan köras på alla operativsystem (Windows, Mac, Ubuntu) utan att behöva en tolk. Så Llamafilen är byggd ovanpå dessa bibliotek, vilket låter den skapa körbara LLM:er med en fil

De tillgängliga modellerna är i det kvantiserade GGUF-formatet. GGUF är ett filformat för stora språkmodeller utvecklat av Georgi Gerganov, skaparen av llama.cpp. GGUF är ett format för att lagra, dela och ladda stora språkmodeller effektivt och effektivt på CPU:er och GPU:er. GGUF använder en kvantiseringsteknik för att komprimera modellerna från deras ursprungliga 16-bitars flyttal till ett 4-bitars eller 8-bitars heltalsformat. Vikterna för denna kvantiserade modell kan lagras i detta GGUF-format

Detta gör det enklare för 7 Billion Parameter-modeller att köra på en dator med 16 GB VRAM. Vi kan köra de stora språkmodellerna utan att behöva en GPU (även om Llamafile till och med tillåter oss att köra LLM på en GPU). Just nu är lamafilerna för populära stora språkmodeller med öppen källkod som LlaVa, Mistral och WizardCoder lättillgängliga att ladda ner och köra

One Shot körbara filer

I det här avsnittet kommer vi att ladda ner och prova att köra en multimodal LlaVa Llamafile. Här kommer vi inte att arbeta med GPU och köra modellen på CPU. Gå till det officiella Llamafile GitHub-förrådet genom att klicka här. och ladda ner LlaVa 1.5-modellen.

Ladda ner modellen

Bilden ovan visar alla tillgängliga modeller med deras namn, storlekar och nedladdningsbara länkar. LlaVa 1.5 är bara runt 4 GB och är en kraftfull multimodell som kan förstå bilder. Den nedladdade modellen är en modell med 7 miljarder parametrar som är kvantifierad till 4-bitar. När du har laddat ner modellen, gå till mappen där den laddades ner.

Öppna sedan CMD, navigera till mappen där denna modell är nedladdad, skriv namnet på filen vi laddade ner och tryck på enter.

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

För Mac- och Linux-användare

För Mac och Linux är exekveringsbehörigheten avstängd som standard för den här filen. Därför måste vi ge exekveringsbehörigheten för llamafilen, vilket vi kan göra genom att köra kommandot nedan.

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

Detta är för att aktivera exekveringsbehörigheten för llava-v1.5-7b-q4.llamafilen. Lägg också till "./" före filnamnet för att köra filen på Mac och Linux. När du har tryckt på nyckelordet enter, kommer modellen att skjutas till systemets RAM och visa följande utdata.

Då kommer webbläsaren att visas och modellen kommer att köras på URL:en http://127.0.0.1:8080/

Ovanstående bild visar standardprompt, användarnamn, LLM-namn, promptmall och chatthistorikmall. Dessa kan konfigureras, men för tillfället kommer vi att gå med standardvärdena.

Nedan kan vi till och med kontrollera de konfigurerbara LLM-hyperparametrarna som Top P, Top K, Temperature och de andra. Även dessa kommer vi att låta dem vara standard för nu. Låt oss nu skriva in något och klicka på skicka.

På bilden ovan kan vi se att vi har skrivit in ett meddelande och till och med fått ett svar. Under det kan vi kontrollera att vi får runt 6 tokens per sekund, vilket är en bra token/sekund med tanke på att vi kör det helt på CPU. Den här gången ska vi prova med en bild.

Även om det inte är 100% rätt, kunde modellen nästan få det mesta rätt från bilden. Låt oss nu ha en konversation med flera varv med LlaVa för att testa om den kommer ihåg chatthistoriken.

På bilden ovan kan vi se att LlaVa LLM kunde hålla konvot bra. Det kan ta in historikkonversationen och sedan generera svaren. Även om det senaste svaret som genererades inte är riktigt sant, samlade det föregående konvo för att generera det. Så på det här sättet kan vi ladda ner en llamafil och bara köra dem som mjukvara och arbeta med de nedladdade modellerna.

Skapa Llamafiler

Vi har sett en demo av Llamafile som redan fanns på den officiella GitHub. Ofta vill vi inte arbeta med dessa modeller. Istället vill vi skapa enfil körbara filer av våra stora språkmodeller. I det här avsnittet kommer vi att gå igenom processen att skapa körbara filer med en enda fil, dvs lamafiler från kvantiserade LLM:er.

Välj en LLM

Vi börjar först med att välja en stor språkmodell. För denna demo kommer vi att välja en kvantifierad version av TinyLlama. Här kommer vi att ladda ner den 8-bitars kvantiserade GGUF-modellen av TinyLlama (Du kan klicka här. för att gå till HuggingFace och ladda ner modellen)

Ladda ner den senaste Llamfilen

Den senaste llamafilen zip från den officiella GitHub-länken kan laddas ner. Ladda också ner zip-filen och extrahera zip-filen. Den aktuella versionen av denna artikel är lamafil-0.6. Efter lamaextrakteringen kommer bin-mappen med filmappen att innehålla filerna som bilden nedan.

Flytta nu den nedladdade TinyLlama 8-bitars kvantiserade modellen till den här papperskorgen. För att skapa de körbara enfilsfilerna måste vi skapa en .args-fil i bin-mappen i llamafile. Till den här filen måste vi lägga till följande innehåll:

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

• Den första raden indikerar flaggan -m. Detta talar om för lamafilen att vi laddar i vikten av en modell.
• På den andra raden anger vi modellnamnet som vi har laddat ner, som finns i samma katalog som .args-filen finns i, dvs bin-mappen för llamafilen.
• På den tredje raden lägger vi till värdflaggan, vilket indikerar att vi kör den körbara filen och vill ha den till en webbserver.
• Slutligen, på sista raden, nämner vi adressen där vi vill vara värd, vilken mappas till localhost. Följt av detta är de tre prickarna, som anger att vi kan skicka argument till vår lamafil när den väl har skapats.
• Lägg till dessa rader i .args-filen och spara den.

För Windows-användare

Nu är nästa steg för Windows-användarna. Om vi ​​arbetar på Windows behövde vi ha installerat Linux via WSL. Om inte, klicka här. för att gå igenom stegen för att installera Linux via WSL. I Mac och Linux krävs inga ytterligare steg. Öppna nu bin-mappen för mappen llamafile i terminalen (om du arbetar på Windows, öppna den här katalogen i WSL) och skriv in följande kommandon.

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

Här skapar vi en ny fil som heter tinyllama-1.1b-chat-v0.3.Q3_0.llamafile; det vill säga vi skapar en fil med filtillägget .llamafile och flyttar filen llamafile till den här nya filen. Nu, efter detta, kommer vi att skriva in nästa kommando.

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

Här arbetar vi med zipalign-filen som kom när vi laddade ner llamafilen zip från GitHub. Vi arbetar med detta kommando för att skapa lamafilen för vår kvantiserade TinyLlama. Till detta zipalign-kommando skickar vi in ​​tinyllama-1.1b-chat-v0.3.Q8_0.llamafilen som vi skapade i föregående steg, sedan skickar vi tinyllama-1.1b-chat-v0.3.Q8_0.llamafilen modell som vi har i bin-mappen och skickar slutligen in .args-filen som vi har skapat tidigare.

Detta kommer äntligen att producera vår körbara enkelfil tinyllama-1.1b-chat-v0.3.Q8_0.llamafile. För att säkerställa att vi är på samma sida innehåller bin-mappen nu följande filer.

Nu kan vi köra filen tinyllama-1.1b-chat-v0.3.Q8_0.llama på samma sätt som vi gjorde tidigare. I Windows kan du till och med byta namn på .llamafilen till .exe och köra den genom att dubbelklicka på den.

OpenAI-kompatibel server

Det här avsnittet kommer att undersöka hur man serverar LLM:er genom Llamfilen. Vi har märkt att när vi kör lamafilen öppnas webbläsaren och vi kan interagera med LLM via WebUI. Detta är i grunden vad vi kallar värd för den stora språkmodellen.

När vi väl kört Llamafilen kan vi interagera med respektive LLM som en slutpunkt eftersom modellen serveras på den lokala värden vid PORT 8080. Servern följer OpenAI API-protokollet, dvs. liknar OpenAI GPT Endpoint, vilket gör det är enkelt att växla mellan OpenAI GPT-modellen och LLM som körs med Llamafile.

Här kommer vi att köra den tidigare skapade TinyLlama lamafilen. Nu måste detta köras på localhost 8080. Vi kommer nu att testa det genom själva OpenAI API 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)

• Här arbetar vi med OpenAI-biblioteket. Men istället för att ange OpenAI-slutpunkten anger vi URL:en där vår TinyLlama är värd och ger "sk-no-token-required" för api_key
• Sedan kommer klienten att kopplas till vår TinyLlama-slutpunkt
• Nu, i likhet med hur vi arbetar med OpenAI, kan vi använda koden för att chatta med vår TinyLlama.
• För detta arbetar vi med kompletteringar klass av OpenAI. Vi skapar nytt kompletteringar med .skapa() objekt och skicka detaljerna som modellnamnet och meddelandena.
• Meddelanden är i form av en lista med ordböcker, där vi har rollen, som kan vara system, användare eller assistent, och vi har innehållet.
• Slutligen kan vi hämta informationen som genereras genom ovanstående utskriftsutlåtande.

Utgången för ovanstående kan ses nedan.

På så sätt kan vi utnyttja llamafilerna och enkelt ersätta OpenAI API med llamafilen som vi valde att köra.

Llamafiles begränsningar

Även om de är revolutionerande, är lamafiler fortfarande under utveckling. Några begränsningar inkluderar:

• Begränsat modellval: För närvarande är inte alla LLM:er tillgängliga i form av lamafiler. Det nuvarande urvalet av förbyggda Llamafiler växer fortfarande. För närvarande finns Llamafiler tillgängliga för Llama 2, LlaVa, Mistral och Wizard Coder.
• Hårdvarukrav: Att köra LLM, även genom Llamafiler, kräver fortfarande mycket beräkningsresurser. Även om de är lättare att köra än traditionella metoder, kan äldre eller mindre kraftfulla datorer behöva hjälp för att köra dem smidigt.
• Säkerhetsproblem: Att ladda ner och köra körbara filer från opålitliga källor medför inneboende risker. Så det måste finnas en pålitlig plattform där vi kan ladda ner dessa lamafiler.

Llamafiles vs resten

Innan Llamafiles fanns det olika sätt att köra stora språkmodeller. En var genom lama_cpp_python. Detta är Python-versionen av llama.cpp som låter oss köra kvantiserade stora språkmodeller på konsumenthårdvara som bärbara och stationära datorer. Men för att köra det måste vi ladda ner och installera Python och till och med djupinlärningsbibliotek som torch, huggingface, transformatorer och många fler. Och efter det innebar det att skriva många rader kod för att köra modellen.

Även då kan vi ibland stöta på problem på grund av beroendeproblem (det vill säga att vissa bibliotek har lägre eller högre versioner än nödvändigt). Och det finns också CTransformers bibliotek som låter oss köra kvantiserade LLM:er. Även detta kräver samma process som vi har diskuterat för llama_cpp_python

Och så finns det Ollama. Ollama har varit mycket framgångsrik i AI-gemenskapen för sin enkla användning för att enkelt ladda och köra stora språkmodeller, särskilt de kvantiserade. Ollama är ett slags TUI (Terminal User Interface) för LLM. Den enda skillnaden mellan Ollama och Llamafilen är delbarheten. Det vill säga, om jag vill kan jag dela min model.llamafile med vem som helst och de kan köra den utan att ladda ner någon ytterligare programvara. Men när det gäller Ollama måste jag dela filen model.gguf, som den andra personen bara kan köra när de installerar Ollama-programvaran eller genom ovanstående Python-bibliotek.

När det gäller resurserna kräver alla samma mängd resurser eftersom alla dessa metoder använder llama.cpp under för att köra de kvantiserade modellerna. Det handlar bara om användarvänligheten där det finns skillnader mellan dessa.

Slutsats

Llamafiler markerar ett avgörande steg framåt för att göra LLM:er lättkörbara. Deras användarvänlighet och portabilitet öppnar upp en värld av möjligheter för utvecklare, forskare och tillfälliga användare. Även om det finns begränsningar är potentialen för lamafiler att demokratisera LLM-åtkomst uppenbar. Oavsett om du är en expertutvecklare eller en nyfiken nybörjare, öppnar Llamafiles spännande möjligheter för att utforska världen av LLMs. I den här guiden har vi tagit en titt på hur man laddar ner Llamafiles och till och med hur man skapar våra alldeles egna Llamafiles med våra kvantiserade modeller . Vi har till och med tagit en titt på den OpenAI-kompatibla servern som skapas när man kör Llamafiles.

Key Takeaways

• Llamafiler är körbara filer med en enda fil som gör det enklare och mer lättillgängligt att köra stora språkmodeller (LLM).
• De eliminerar behovet av komplexa inställningar och konfigurationer, vilket gör att användare kan ladda ner och köra LLM:er direkt utan Python- eller GPU-krav.
• Llamafiler är just nu tillgängliga för ett begränsat urval av LLM:er med öppen källkod, inklusive LlaVa, Mistral och WizardCoder.
• Även om det är bekvämt, har Llamafiler fortfarande begränsningar, som hårdvarukrav och säkerhetsproblem som är förknippade med nedladdning av körbara filer från opålitliga källor.
• Trots dessa begränsningar representerar Llamafiles ett viktigt steg mot att demokratisera LLM-åtkomst för utvecklare, forskare och till och med tillfälliga användare.

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/using-llamafiles-to-simplify-llm-execution/