Meta LLaMa och alpackor lös i labbet! Kör stora språkmodeller lokalt

Under de senaste månaderna har stora språkmodeller varit föremål för omfattande forskning och utveckling, med toppmoderna modeller som GPT-4, Meta LLaMa och Alpaca som tänjer på gränserna för naturlig språkbehandling och den hårdvara som krävs för att köra dem . Att köra slutsatser om dessa modeller kan vara beräkningsmässigt utmanande, eftersom det kräver kraftfull hårdvara för att leverera resultat i realtid.

Under de senaste månaderna har stora språkmodeller varit föremål för omfattande forskning och utveckling, med toppmoderna modeller som GPT-4, Meta LLaMa och Alpaca som tänjer på gränserna för naturlig språkbehandling och den hårdvara som krävs för att köra dem . Att köra slutsatser om dessa modeller kan vara beräkningsmässigt utmanande, eftersom det kräver kraftfull hårdvara för att leverera resultat i realtid.

I Storage Review-labbet satte vi två NVIDIA RTX 8000 GPU:er på jobbet med att köra Metas LLaMa-modell för att se hur de presterade när de körde inferens på stora språkmodeller. Vi använde lenovo P920 som värd för korten, vilket minimerar flaskhalsar. RTX 8000 är ett avancerat grafikkort som kan användas i AI- och djupinlärningsapplikationer, och vi valde dessa specifikt ur stacken tack vare 48 GB GDDR6-minne och 4608 CUDA-kärnor på varje kort, och även Kevin hamstrar alla A6000'S.

Meta LLaMA är en storskalig språkmodell som tränas på en mångsidig uppsättning internettext. Det är allmänt tillgängligt och ger toppmoderna resultat i olika bearbetningsuppgifter för naturligt språk. I den här artikeln kommer vi att ge en steg-för-steg-guide om hur vi ställer in och körde LLaMA-inferens på NVIDIA GPU:er, detta är inte garanterat att det fungerar för alla.

Meta LLaMa-krav

Innan vi börjar måste vi se till att vi har följande krav installerade:

• NVIDIA GPU(s) med minst 16 GB VRAM
• NVIDIA-drivrutiner installerade (minst version 440.33)
• CUDA Toolkit installerat (minst version 10.1)
• Anaconda installerad
• PyTorch installerad (minst version 1.7.1)
• Disk utrymme; hela uppsättningen av LLaMa-kontrollpunkter pressar över 200TB.

Obs: Det rekommenderas att ha en dedikerad Anaconda-miljö för LLaMA, vi har några på testbänken så att vi kan bråka med paket och parametrar och inte slanga basinstallationen.

Skapa en dedikerad miljö eller två i Anaconda

Steg för att köra Meta LLaMA Inference på NVIDIA GPU:er

1. Ladda ner LLaMA-förvaret: Det första steget är att klona LLaMA-förvaret från GitHub.

2. Skaffa LLaMA checkpoint och tokenizer: Besök GitHub-sidan och fyll i det länkade Google-formuläret för att komma åt nedladdningen. Andra LLM är tillgängliga, såsom Alpaca. För detta ändamål kommer vi att anta att det finns tillgång till LLaMa-filerna.

3. Lista och installera de program som krävs för LLaMa genom att köra följande kommando från den klonade förvarskatalogen:

4. Ställ in slutledningsskript: Smakämnen example.py skript som tillhandahålls i LLaMA-förvaret kan användas för att köra LLaMA-inferens. Skriptet kan köras på en enkel- eller multi-gpu-nod med torchrun och kommer att mata ut slutföranden för två fördefinierade uppmaningar.

Öppen example.py och ställ in följande parametrar baserat på dina önskemål. Beskrivningar för varje parameter och vad de gör listas nedan.

• --max_seq_len: maximal sekvenslängd (standard är 2048)
• --max_batch_size: maximal batchstorlek (standard är 8)
• --gen_length: generationslängd (standard är 512)
• --temperature: Generationstemperatur (standard är 1.0)
• --top_p: top-p sampling (standard är 0.9)

Till exempel att köra LLaMA-inferens på en enda GPU med checkpoint- och tokenizer-filer i katalogen /path/to/files, använd följande kommando:

Obs: nproc_per_node argument beror på storleken på modellen och antalet GPU:er som krävs för standardkontrollpunkterna för LLaMa. Se följande tabell för att ställa in lämpligt värde för ditt system och din modell du kör:

I exemplet nedan använde vi standardprompterna i exempelfilen men spelade med temperature och top_p variabler, vilket ger några intressanta resultat. Vi ökade också svarslängden.

Var försiktig när du leker med termostaten!

Dela upp filen example.py och variabler du behöver veta

De flesta av dessa är förinställda i modellen och behöver inte justeras; men om du börjar använda LLM:er och slutledning, här är lite praktisk information som bryter ner vad flaggorna och switcharna gör.

1. local_rank: Rangen för den nuvarande GPU (processen) i gruppen GPU:er som används för modellparallellism. Detta ställs in automatiskt.
2. world_size: Det totala antalet GPU:er som används för modellparallellism. Detta ställs in automatiskt.
3. ckpt_dir: Katalogen som innehåller modellkontrollpunkterna. Detta ställs in vid körning.
4. tokenizer_path: Sökvägen till tokenizern som används för att förbehandla texten. Detta ställs in vid körning.
5. temperature: En parameter som styr slumpmässigheten i den genererade texten (högre värden gör utdata mer slumpmässigt och lägre värden gör den mer fokuserad).
6. top_p: En parameter som styr kärnsamplingsstrategin, vilket är en metod för att generera text som endast väljer de mest sannolika tokens med en kumulativ sannolikhet på högst top_p.
7. max_seq_len: Den maximala sekvenslängden för in- och utmatning av modellen. Du kan justera detta för att minska ditt VRAM-behov.
8. max_batch_size: Det maximala antalet ingångssekvenser som modellen kan bearbeta parallellt. Du kan justera detta för att minska ditt VRAM-behov.
9. prompts: En lista med indatameddelanden som modellen ska generera text baserat på.
10. results: En lista med genererad text som motsvarar varje inmatningsprompt.

Avslutande tankar

Våra tester visade att RTX 8000 GPU:erna kunde leverera imponerande prestanda, med slutledningstider som sträcker sig från några sekunder till ungefär en minut, beroende på modellparametrar och ingångsstorlek. GPU:erna kunde hantera stora batchstorlekar och köra inferens på flera modeller samtidigt utan någon märkbar nedgång.

En av fördelarna med att använda GPU:er för slutledning är att de enkelt kan skalas upp genom att lägga till fler GPU:er i systemet. Detta gör att ännu större modeller kan köras i realtid, vilket möjliggör nya applikationer inom områden som chatbots, frågesvarssystem och sentimentanalys.

Alpaca är en kompakt AI-språkmodell skapad av ett team av datavetare vid Stanford University. Den är byggd på Metas LLaMA 7B-modell, som har 7 miljarder parametrar och har tränats med en stor mängd text från webben. För att finjustera Alpaca genererades 52,000 003 instruktionsföljande demonstrationer med OpenAI:s text-davinci-600-modell, en mångsidig modell som kan utföra olika uppgifter baserade på naturliga språkinstruktioner. Alpaca är bättre på att följa instruktioner och producera text för en rad olika syften, inklusive att skriva sammanfattningar, berättelser och skämt. Med en träningskostnad under XNUMX USD är Alpaca designad för att vara både kostnadseffektiv och lätt att replikera. Mycket imponerande är det värt att nämna att Alpaca kan köras på bara en bärbar dator. Vi tränar en modell som liknar Alpaca med de metoder som Stanford gjorde, men med vår egen twist.

Det här är bara ett sätt vi arbetar med de senaste tekniska framstegen i labbet, och tack vare några kraftfulla NVIDIA GPU:er kan vi göra ännu mer än bara slutsatser; vi tränar. Håll utkik efter nästa artikel snart om finjustering av modeller som Meta LLaMa.

Engagera dig med StorageReview 

Nyhetsbrev | Youtube | Podcast iTunes/Spotify | Instagram | Twitter | TikTok | Rssflöde