PyTorch's torchchat-tutorial: lokaal instellen met Python

Mogelijkheden van Torchchat

Torchchat biedt vier primaire functionaliteiten:

1. LLM’s draaien met Python en PyTorch.
2. Zelfstandige modellen uitvoeren op een desktopapplicatie of server zonder Python.
3. Modellen draaien op een mobiel apparaat.
4. De prestaties van een model evalueren.

LLM’s draaien met Python en PyTorch

In deze modus kun je een LLM draaien op een machine waarop Python en PyTorch zijn geïnstalleerd. Je kunt rechtstreeks in de terminal met het model werken of een server opzetten met een REST API. Dit is waar we ons in dit artikel op richten.

Zelfstandige modellen draaien

Torchchat gebruikt AOT Inductor (Ahead-of-Time Inductor) om een zelfstandige, distribueerbare executable te maken voor PyTorch-inferenceprogramma’s, specifiek in de vorm van een dynamische bibliotheek zonder afhankelijkheid van Python en PyTorch.

Deze aanpak speelt in op de behoefte om modellen in een productieomgeving te deployen met stabiele runtime over updates en wijzigingen in de serveeromgeving, zodat modellen operationeel blijven zonder hercompilatie. 

AOT Inductor richt zich op het optimaliseren van modeldeployments door efficiënte binaire distributieformaten te bieden die snel laden en meteen uitvoerbaar zijn. Zo worden de beperkingen en overhead van tekstformaten zoals TorchScript omzeild. Het maakt gebruik van codegeneratie en optimalisatietechnieken voor zowel CPU- als GPU-prestaties om overhead te verminderen en de uitvoersnelheid te verhogen. 

Uitvoeren op mobiele apparaten

Voor uitvoering op mobiele apparaten maakt Torchchat gebruik van ExecuTorch. Net als AOT Inductor optimaliseert ExecuTorch het model voor uitvoering op een mobiel of embedded apparaat. Het produceert een PTE-artifact dat later gebruikt kan worden om het model uit te voeren.

Een model evalueren

De evaluatiemodus van Torchchat kan worden gebruikt om de prestaties van een LLM te beoordelen op verschillende taken die beschikbaar zijn in lm_eval. Dit is een belangrijke functie voor onderzoekers die hun nieuwe modellen willen toetsen op gangbare benchmarks.

Waarom Torchchat gebruiken

Een LLM lokaal draaien in plaats van te vertrouwen op een externe cloud-API zoals de API van OpenAI biedt uiteenlopende use-cases en voordelen voor verschillende behoeften en scenario’s. 

• Privacygevoelige toepassingen: Voor sectoren die met gevoelige data werken, zoals zorg, financiën en juridisch, zorgt lokaal draaien ervoor dat vertrouwelijke informatie de infrastructuur van de organisatie niet verlaat, in lijn met regels rond gegevensbescherming.
• Realtime-toepassingen: Toepassingen die lage latentie vereisen, zoals interactieve chatbots, realtime contentgeneratie en live monitoringsystemen, profiteren van lokaal draaien doordat de netwerkvertraging van en naar een cloud-API vervalt.
• Offline of beperkte connectiviteit: In omgevingen met slechte of geen internetverbinding maakt lokale deployment het gebruik van LLM-toepassingen mogelijk, zoals bij veldonderzoek, afstandsonderwijs en entertainmentsystemen in vliegtuigen.
• Kostenbeheersing en optimalisatie: Voor hoge volumes of continu gebruik kan lokale deployment kostenefficiënter zijn: je vermijdt prijsmodellen per request van cloud-API’s en benut mogelijk bestaande rekenmiddelen.

Wil je meer weten over het lokaal draaien van een AI-model op een apparaat in plaats van in de cloud? Dan raad ik deze blogpost over Edge AI aan.

Lokaal instellen met Python

Laten we Torchchat stap voor stap lokaal instellen. We beginnen met het clonen van de Torchchat-repository.

Code clonen of downloaden

De eerste stap bij het lokaal instellen van Torchchat is het clonen van de Torchchat-repository. Met Git geïnstalleerd klonen we de repository door een terminal te openen en het volgende commando uit te voeren:

git clone git@github.com:pytorch/torchchat.git

Je kunt de repository ook downloaden via de GitHub-interface.

Installatie

We gaan ervan uit dat Python 3.10 al is geïnstalleerd. Voor een handleiding over het installeren van Python, bekijk dit artikel.

Om Torchchat te installeren, open je een terminal in de Torchchat-map. We beginnen met het aanmaken van een virtual environment:

python -m venv .venv

Kort gezegd is een virtual environment een afgebakende projectmap met daarin de installatiemapjes voor Python-bibliotheken en -packages, en soms zelfs een specifieke Python-versie. Dit zorgt ervoor dat elk project precies de softwareversies heeft die het nodig heeft, zonder interferentie door andere projecten en hun afhankelijkheden.

Na het aanmaken moeten we de virtual environment activeren. Dat kan met:

source .venv/bin/activate

Tot slot richten we de omgeving in door alle vereiste dependencies voor Torchchat te installeren. Torchchat levert een installatiescript, install_requirements.sh, dat je kunt draaien met:

./install_requirements.sh

Torchchat zou nu geïnstalleerd en klaar voor gebruik moeten zijn. We kunnen de installatie controleren door de beschikbare Torchchat-commando’s op te sommen, zo:

python torchchat.py --help

Torchchat lokaal gebruiken met Python

Met Torchchat geïnstalleerd kunnen we LLM’s op onze lokale machine draaien.

Alle ondersteunde modellen weergeven

Torchchat ondersteunt een brede waaier aan LLM’s. We kunnen de ondersteunde modellen tonen met het list-commando:

python torchchat.py list

De volledige lijst met modellen is te vinden in hun GitHub-repository. 

De sectie “Notes” geeft nuttige informatie over het model, zoals de beste use-case en de alias die je gebruikt om het model aan te duiden in Torchchat-commando’s.

Een model downloaden

Torchchat gebruikt Hugging Face als distributiekanaal voor de modellen. Hugging Face is een samenwerkingsplatform met tools waarmee iedereen NLP- en ML-modellen kan maken, trainen en deployen met open-sourcecode. Wil je er meer over weten, bekijk dan deze blogpost over Wat is Hugging Face.

Voor we een model downloaden, moeten we:

1. De Hugging Face command line interface installeren
2. Een account aanmaken op Hugging Face
3. Een access token aanmaken
4. Inloggen via de Hugging Face command line interface

Om de Hugging Face CLI te installeren, gebruiken we pip:

pip install huggingface_hub

Vervolgens gaan we naar de Hugging Face-website om een account aan te maken. Na het aanmaken kunnen we een access token genereren via de profielinstellingen:

In het profiel kunnen we het menu “Access Tokens” openen om een nieuw token te maken:

Wat betreft de tokenrechten: leesrechten zijn voldoende voor dit artikel. Let op: zodra het token is aangemaakt, moet je het kopiëren naar je klembord, want later kun je het niet meer bekijken. 

Met het token kunnen we inloggen met het volgende commando:

huggingface-cli login

Zodra we zijn ingelogd, kunnen we een model downloaden met het download-commando. Let op dat sommige modellen behoorlijk groot zijn; zorg dus voor voldoende schijfruimte. Ter illustratie gebruiken we het stories15M-model, een klein model voor verhaal­generatie. Dit is een goed startmodel omdat het snel downloadt en geen speciale rechten vereist.

Om het te downloaden, doen we:

python torchchat.py download stories15M

Een model draaien

Na het downloaden kunnen we de commando’s chat of generate gebruiken. Om tekst te genereren geven we een prompt mee met het argument --prompt. Bijvoorbeeld:

python torchchat.py generate stories15M --prompt “Once upon a time”

Bovenstaand commando laat Torchchat tekst genereren met het stories15M-model op basis van de prompt ”Once upon a time”.

Om het model in chatmodus uit te voeren, gebruiken we het chat-commando zonder prompt.

python torchchat.py chat stories15M 

Het chat-commando start een interactieve chat in de terminal, waarin je heen en weer kunt praten met de LLM. Let op: sommige modellen werken beter met de modus generate, andere weer met chat. Deze informatie vind je in de sectie “Notes” van de modeldocumentatie.

Toegang tot een model aanvragen

Sommige modellen, zoals llama3, vereisen speciale toegang om te kunnen worden gedownload. Als we zo’n model proberen te downloaden, krijgen we een foutmelding:

Access to model meta-llama/Meta-Llama-3-8B-Instruct is restricted and you are not in the authorized list. Visit https://huggingface.co/meta-llama/Meta-Llama-3-8B-Instruct to ask for access.

We kunnen toegang aanvragen via de URL in de foutmelding. Je vult een kort formulier in met persoonlijke gegevens en gaat akkoord met de gebruiksvoorwaarden. Je ontvangt een e-mail zodra de toegang is verleend.

Geavanceerd gebruik

Torchchat biedt nog enkele extra opties bij het lokaal draaien van LLM’s, zodat je ze kunt afstemmen op je behoeften en hardware. Laten we er een paar bekijken.

De precisie sturen

LLM’s leunen zwaar op matrixvermenigvuldiging, waarbij veel drijvendekommagetallen worden vermenigvuldigd. Er bestaan verschillende datatypes om drijvendekommagetallen in de computer met uiteenlopende precisie te representeren. 

Hogere precisie kan ervoor zorgen dat de nuances die tijdens training zijn vastgelegd, ook tijdens inference behouden blijven, zeker bij complexe taken of subtiel taalbegrip. Maar hoge precisie kan inference aanzienlijk vertragen. Het juiste datatype hangt af van de afweging tussen snelheid en nauwkeurigheid.

Om het datatype in te stellen bij het draaien van de LLM, gebruiken we de parameter --dtype, bijvoorbeeld:

python torchchat.py chat --dtype fast stories15M

Just-In-Time-compilatie

De vlag --compile schakelt Just-In-Time (JIT)-compilatie van het model in. JIT is een techniek om de inferenceprestaties te optimaliseren door delen van het model tijdens runtime dynamisch naar machinecode te compileren, in plaats van ze telkens te interpreteren. Dit kan de efficiëntie en snelheid op diverse hardwareplatforms aanzienlijk verbeteren.

Met JIT duurt het opstarten langer door de extra compilatiestap, maar inference draait sneller. Zo gebruik je chat samen met JIT:

python torchchat.py chat --compile stories15M

Let op: deze optie wordt mogelijk niet op alle hardware ondersteund. In dat geval negeert Torchchat de compilatiestap en draait de LLM zonder.

Kwantisatie

Kwantisatie is een techniek om de modelgrootte te verkleinen en de inference­snelheid te verhogen zonder de prestaties of nauwkeurigheid noemenswaardig te beïnvloeden. Dit is vooral belangrijk bij het deployen van LLM’s op edge-apparaten of in omgevingen met beperkte rekenkracht, geheugen en bandbreedte.

Kort gezegd houdt kwantisatie in dat je de gewichten en activaties van een neuraal netwerk omzet van drijvendekommarepresentaties (meestal 32-bit floats) naar lagere bitrepresentaties, zoals 16-bit of 8-bit integers, of in sommige gevallen zelfs binaire representaties. 

Dit verschilt van het instellen van de precisie met --dtype. Kwantisatie werkt direct op de modelgewichten en creëert zo een kleiner model, terwijl het datatype het type gegevens specificeert dat wordt gebruikt bij de inferentieberekeningen.

Kwantisatie in Torchchat vereist een JSON-configuratiebestand en kun je zo gebruiken:

python torchchat.py chat --quantize config.json stories15M

Voor meer details over het formaat van het config.json-configuratiebestand of over hoe kwantisatie in Torchchat werkt, bekijk de pagina met kwantisatiedocumentatie.

Apparaatspecificatie

We kunnen het apparaat waarop de LLM draait specificeren met de optie --device. Om het bijvoorbeeld op CUDA te draaien, gebruiken we:

python torchchat.py chat --device cuda stories15M

Conclusie

Torchchat is een grote stap in de democratisering van LLM-inference. Het maakt het eenvoudig voor iedereen om LLM’s efficiënt te draaien op een breed scala aan apparaten.

Torchchat biedt veel meer mogelijkheden dan we in dit artikel hebben besproken. We hebben de nodige uitleg gegeven zodat iedereen aan de slag kan met het lokaal draaien van LLM’s op zijn of haar computer met Python en PyTorch. Ik raad je sterk aan Torchchat verder te verkennen.