True ML Talks #23 - MLOps en LLM-toepassingen @ GitLab

We zijn terug met een nieuwe aflevering van  True ML Talks. Hierin duiken we opnieuw diep in MLOps en LLM-toepassingen bij GitLab en spreken we met Monmayuri Ray.

Monmayuri leidt de AI-researchvertical bij GitLab met het afgelopen jaar een sterke focus op LLMs. Daarvoor was ze engineering manager in de ModelOps-divisie bij GitLab. Ze heeft ook gewerkt bij andere bedrijven zoals Microsoft en eBay.

📌

Onze gesprekken met Monmayuri behandelen de volgende aspecten:
- ML- en LLM-use cases bij GitLab
- De evolutie van GitLab's ML-infrastructuur ter ondersteuning van large language models (LLMs)
- GitLab's reis met LLMs: van open-source tot fine-tuning
- Het trainen van Large Language Models bij GitLab
- Triton vs. PyTorch, geënsembleerde GPU's en dynamic batching voor LLM-inference
- Uitdagingen en onderzoek bij het evalueren van LLMs bij GitLab
- GitLab's LLM-architectuur en de toekomst van LLMs

Bekijk de volledige aflevering hieronder:

ML- en LLM-use cases @ GitLab

Machine learning (ML) transformeert de softwareontwikkelingslevenscyclus, en GitLab loopt voorop bij deze innovatie. GitLab gebruikt ML om ontwikkelaars te ondersteunen gedurende hun gehele traject, van het aanmaken van issues tot merge requests en het deployen van apps.

Een van de meest veelbelovende use cases voor ML bij GitLab is het gebruik van large language models (LLMs). GitLab gebruikt LLMs en GenAI om nieuwe functies voor haar producten te ontwikkelen, zoals code completion en het samenvatten van issues.

Voordelen van ML voor GitLab-gebruikers

1. Verhoogde productiviteit: ML kan ontwikkelaars helpen productiever te zijn door taken zoals code completion en het samenvatten van issues te automatiseren.
2. Verbeterde codekwaliteit: ML kan ontwikkelaars helpen betere code te schrijven door potentiële fouten te identificeren en verbeteringen voor te stellen.
3. Kortere ontwikkeltijd: ML kan ontwikkelaars helpen de tijd die nodig is om software te ontwikkelen te verkorten door taken te automatiseren en hen te helpen problemen sneller te identificeren en op te lossen.
4. Verbeterde developer experience: ML kan helpen de ontwikkelaarservaring te verbeteren door het gebruik van GitLab-producten eenvoudiger te maken en ondersteuning en begeleiding te bieden.

Hoe de ML-infrastructuur van GitLab evolueerde om large language models (LLMs) te ondersteunen

GitLab loopt voorop bij het inzetten van large language models (LLMs) om ontwikkelaars te versterken. Als gevolg hiervan heeft GitLab haar ML-infrastructuur moeten laten evolueren om deze complexe modellen te ondersteunen.

Uitdagingen

1. Omvang en complexiteit: LLMs zijn veel groter en complexer dan traditionele ML-modellen, wat betekent dat ze krachtigere hardware en software vereisen om te trainen en te deployen.
2. Integratie: De producten van GitLab zijn geschreven in Ruby on Rails en JavaScript. Dit betekent dat GitLab manieren heeft moeten vinden om haar ML-infrastructuur met deze technologieën te integreren.
3. Gedistribueerde infrastructuur: De ML-infrastructuur van GitLab is verdeeld over meerdere verschillende cloudproviders. Dit betekent dat GitLab manieren heeft moeten ontwikkelen om haar ML-infrastructuur op een consistente en efficiënte manier te beheren.

Oplossingen

Om de hierboven genoemde uitdagingen aan te pakken, heeft GitLab een reeks wijzigingen aangebracht in haar ML-infrastructuur. Deze wijzigingen kunnen worden gecategoriseerd in de volgende gebieden:

1. Hardware: GitLab heeft geïnvesteerd in nieuwe hardware, zoals GPU's en TPU's, om de training en deployment van LLMs te ondersteunen.
2. Software: GitLab heeft nieuwe trainings- en deployment-pipelines voor LLMs ontwikkeld. GitLab heeft ook een aantal integratieoplossingen ontwikkeld om haar ML-infrastructuur te laten samenwerken met haar Ruby on Rails- en JavaScript-applicaties.
3. Beheer: GitLab heeft verschillende tools en processen ontwikkeld om haar gedistribueerde ML-infrastructuur te helpen beheren.

GitLab's reis met LLMs: Van open-source tot fine-tuning

GitLab loopt voorop bij het inzetten van large language models (LLMs) om ontwikkelaars te versterken. In het begin startte GitLab met het gebruik van open-source LLMs, zoals Salesforce code gen. Naarmate het landschap veranderde en LLMs krachtiger werden, is GitLab echter overgestapt op het fine-tunen van haar eigen LLMs voor specifieke use cases, zoals codegeneratie.

Het fine-tunen van LLMs vereist een aanzienlijke investering in infrastructuur, aangezien deze modellen zeer groot en complex zijn. GitLab heeft nieuwe trainings- en deployment-pipelines voor LLMs moeten ontwikkelen, evenals nieuwe manieren om haar ML-infrastructuur te beheren in een gedistribueerde omgeving.

Een van de belangrijkste uitdagingen waarmee GitLab te maken kreeg bij het fine-tunen van LLMs, was het vinden van de juiste balans tussen kosten en latency. LLMs kunnen erg duur zijn om te trainen en te deployen, en ze kunnen ook traag zijn in het genereren van resultaten. GitLab heeft moeten experimenteren met verschillende clustergroottes, GPU-configuraties en batchingtechnieken om de juiste balans te vinden voor haar behoeften.

Een andere uitdaging voor GitLab was het waarborgen van de nauwkeurigheid en betrouwbaarheid van haar LLMs. LLMs kunnen worden getraind op gigantische datasets van tekst en code, maar deze datasets kunnen ook fouten en biases bevatten. GitLab heeft nieuwe technieken moeten ontwikkelen om haar LLMs te evalueren en te debiasen.

Ondanks de uitdagingen heeft GitLab aanzienlijke vooruitgang geboekt in het inzetten van LLMs om ontwikkelaars te versterken. GitLab is nu in staat om LLMs op schaal te trainen en te deployen, en gebruikt deze modellen om nieuwe functies en producten te ontwikkelen die het softwareontwikkelingsproces efficiënter en prettiger maken.

Training van Large Language Models bij GitLab

Het trainen van large language models (LLMs) is een uitdagende taak die een aanzienlijke investering in infrastructuur en middelen vereist. GitLab loopt voorop bij het inzetten van LLMs om ontwikkelaars te versterken, en het bedrijf heeft onderweg veel geleerd.

Hier zijn enkele inzichten en lessen uit de ervaring van GitLab met het trainen van LLMs:

1. Begin klein en schaal op. Bij het inschatten van de hoeveelheid GPU-resources die nodig is voor training, kunt u het beste klein beginnen en geleidelijk opschalen. Dit helpt u te voorkomen dat resources worden verspild en helpt potentiële knelpunten vroegtijdig te identificeren.
2. Gebruik dynamic batching. Dynamic batching kan u helpen uw trainingsproces te optimaliseren door vergelijkbare invoer te groeperen. Dit kan leiden tot aanzienlijke prestatieverbeteringen, vooral bij grote datasets.
3. Kies de juiste parameters om voor te optimaliseren. Er is geen universele aanpak voor het kiezen van de juiste parameters om voor te optimaliseren bij het fine-tunen van LLMs. De beste parameters variëren afhankelijk van het specifieke LLM, de trainingsdata en het gewenste resultaat. Het is echter belangrijk om te experimenteren met verschillende parameters om de beste combinatie voor uw specifieke behoeften te vinden.
4. Overweeg het gebruik van gedistribueerde training. Gedistribueerde training kan u helpen het trainingsproces te versnellen door de werklast te verdelen over meerdere GPU's of machines. Dit kan vooral voordelig zijn voor het trainen van grote LLMs op grote datasets.
5. Experimenteer met low rank adaptation mode. Low rank adaptation mode is een techniek die kan worden gebruikt om LLMs te fine-tunen met een kleiner aantal parameters. Dit kan nuttig zijn voor gevallen waarin u niet over voldoende resources beschikt om het gehele model te fine-tunen.

Naast de bovenstaande inzichten heeft GitLab ook een aantal waardevolle lessen geleerd over het belang van een goed begrip van het basismodel en de trainingsdata. GitLab heeft bijvoorbeeld ondervonden dat het belangrijk is om de structuur van het basismodel te kennen en te weten hoe de trainingsdata samengesteld moet worden om te optimaliseren voor de gewenste use case.

Triton vs. PyTorch, geënsembleerde GPU's en Dynamic Batching voor LLM-inference

GitLab gebruikt Triton voor LLM-inference omdat het beter geschikt is voor het schalen naar het hoge volume aan requests dat GitLab ontvangt. Triton is ook gemakkelijker te wrappen en te schalen dan andere model servers, zoals PyTorch servers.

GitLab heeft nog niet geëxperimenteerd met Hugging Face's TGI of VLLM model servers, aangezien deze zich nog in de beginfase van ontwikkeling bevonden toen GitLab haar LLM-inferencepipeline voor het eerst deployde.

Als het gaat om dynamic batching, is de strategie van GitLab om te optimaliseren voor de specifieke use case, belasting, queryniveau, volume en het aantal beschikbare GPU's. Als GitLab bijvoorbeeld 500 GPU's heeft voor een 7B-model, kan het een andere batchingstrategie gebruiken dan wanneer het slechts enkele GPU's heeft voor een kleiner model.

GitLab gebruikt ook een ensemble van GPU's om requests te verwerken. Dit betekent dat GitLab een mix gebruikt van verschillende typen GPU's, waaronder krachtige GPU's en GPU's met lagere prestaties. GitLab verdeelt de belasting van requests over het ensemble van GPU's om te optimaliseren voor prestaties en kosten.

Hier zijn enkele tips voor het ontwerpen van een architectuur om GPU's te ensembleren en load balancing te optimaliseren:

1. Begrijp uw verkeerspatronen. Wanneer zijn uw piekuren? Welke typen requests ontvangt u het vaakst?
2. Gebruik A/B-testing om te experimenteren met verschillende GPU-configuraties en load balancing-strategieën.
3. Monitor uw prestaties en latency om er zeker van te zijn dat uw architectuur aan uw behoeften voldoet.

Hier zijn enkele specifieke voorbeelden van hoe GitLab haar architectuur heeft geoptimaliseerd voor geënsembleerde GPU's en dynamic batching:

1. GitLab gebruikt een dynamisch orchestratiesysteem om requests toe te wijzen aan GPU's op basis van hun type, prestaties en beschikbaarheid.
2. GitLab gebruikt een techniek genaamd "GPU warm-up" om ervoor te zorgen dat GPU's klaar zijn om requests te verwerken wanneer ze nodig zijn.
3. GitLab gebruikt quantisatie om de omvang van haar modellen te verkleinen zonder dat dit ten koste gaat van de nauwkeurigheid.

Door deze tips te volgen, kunt u een architectuur ontwerpen die efficiënt grote volumes LLM-inference-requests kan verwerken.

We hebben streaming ook geprobeerd, en ik denk dat we streaming ook onderzoeken voor onze derde partijen - Monmayuri

Uitdagingen en onderzoek bij het evalueren van LLMs bij GitLab

Het evalueren van de prestaties van large language models (LLMs) is een uitdagende taak. GitLab heeft aan dit probleem gewerkt en heeft te maken gehad met verschillende uitdagingen, waaronder:

1. Verschillende use cases hebben verschillende behoeften. Verschillende LLM-use cases, zoals chat, code suggestion en vulnerability explanation, hebben verschillende behoeften en vereisen verschillende evaluatiemetrieken.
2. Het is moeilijk te bepalen welk model het beste werkt voor een gegeven query. Het is lastig vast te stellen welke LLM het beste zal presteren op een specifieke query, vooral in productie.
3. Het is lastig om nauwkeurigheid en acceptatiegraad in balans te brengen. Het is belangrijk om een balans te vinden tussen de nauwkeurigheid van de resultaten van het LLM en de acceptatiegraad van deze resultaten door gebruikers.

GitLab pakt deze uitdagingen aan door:

1. Een goede dataset samen te stellen voor elke use case. GitLab stelt voor elke LLM-use case een dataset samen die representatief is voor de typen queries die gebruikers in productie zullen indienen.
2. Historische gegevens te analyseren. GitLab analyseert historische gegevens om te begrijpen hoe LLMs in het verleden op verschillende typen queries hebben gepresteerd.
3. Nieuwe evaluatiemetrieken te ontwikkelen. GitLab ontwikkelt nieuwe evaluatiemetrieken die zijn afgestemd op specifieke LLM-use cases.
4. Data te gebruiken voor besluitvorming. GitLab gebruikt data om beslissingen te nemen over welke LLMs moeten worden ingezet voor verschillende use cases en hoe de parameters van deze LLMs moeten worden afgesteld.

Het doel van GitLab is het ontwikkelen van een schaalbare en datagedreven aanpak voor het evalueren van LLMs. Deze aanpak helpt GitLab ervoor te zorgen dat haar LLMs goed presteren in productie en voldoen aan de behoeften van haar gebruikers.

Onderzoeksrichtingen

GitLab doet ook onderzoek naar nieuwe manieren om LLMs te evalueren. Enkele onderzoeksrichtingen die GitLab verkent zijn:

1. Het gebruiken van mens-computerinteractie (HCI)-data om LLMs te evalueren. HCI-data kan inzicht bieden in hoe gebruikers omgaan met LLMs en hoe zij de resultaten van deze interacties ervaren. Deze data kan worden gebruikt om nieuwe evaluatiemetrieken voor LLMs te ontwikkelen.
2. Het gebruiken van adversarial-methoden om LLMs te evalueren. Adversarial-methoden kunnen worden gebruikt om invoer te genereren die is ontworpen om LLMs tot fouten te verleiden. Deze data kan worden gebruikt om de robuustheid van LLMs tegen verschillende soorten fouten te evalueren.
3. Het gebruiken van transfer learning om LLMs te evalueren. Transfer learning kan worden gebruikt om LLMs te evalueren op nieuwe taken zonder voor elke taak een nieuwe dataset te hoeven verzamelen. Dit kan nuttig zijn voor het evalueren van LLMs op taken waarvoor het verzamelen van data moeilijk of kostbaar is.

Het onderzoek van GitLab naar het evalueren van LLMs is doorlopend. GitLab zet zich in om nieuwe en innovatieve manieren te ontwikkelen om LLMs te evalueren, om er zo voor te zorgen dat haar LLMs blijven voldoen aan de behoeften van haar gebruikers.

GitLab's LLM-architectuur en de toekomst van LLMs

GitLab's LLM-architectuur is een omvattende benadering van het trainen, evalueren en deployen van LLMs. De architectuur is ontworpen om flexibel en schaalbaar te zijn, zodat GitLab eenvoudig nieuwe technologieën kan adopteren en kan voldoen aan de behoeften van haar gebruikers.

De architectuur bestaat uit een aantal belangrijke componenten:

1. Datapreprocessing en tokenisatie: GitLab's LLM-architectuur begint met het voorbewerken en tokeniseren van de data die gebruikt zal worden om het LLM te trainen. Dit proces omvat het opschonen van de data, het verwijderen van ruis en het omzetten van de tekst naar een formaat dat het LLM kan begrijpen.
2. Sampling en inkorten: Zodra de data is voorbewerkt en getokeniseerd, voert GitLab's LLM-architectuur sampling en inkorting van de data uit. Dit wordt gedaan om de rekenkosten van het trainen van het LLM te verminderen.
3. GPU-suites: GitLab's LLM-architectuur maakt gebruik van GPU-suites om het LLM te trainen. GPU's zijn gespecialiseerde processoren die uiterst geschikt zijn voor het trainen van LLMs.
4. Evaluatiesuite: GitLab's LLM-architectuur bevat een evaluatiesuite om de prestaties van het LLM te evalueren. De evaluatiesuite bevat een verscheidenheid aan metrieken, zoals nauwkeurigheid, vloeiendheid en coherentie.
5. Model-checkpoints: GitLab's LLM-architectuur slaat op regelmatige tijdstippen model-checkpoints op. Hiermee kan GitLab de training vanaf een eerder punt hervatten als er iets misgaat.
6. Prompt-bibliotheek: GitLab's LLM-architectuur bevat een prompt-bibliotheek, wat een verzameling prompts is die gebruikt kan worden om verschillende soorten tekst te genereren vanuit het LLM.
7. Model registry: GitLab's LLM-architectuur bevat een model registry, een centrale opslagplaats voor alle LLM-modellen van GitLab.
8. Deployment-engine: GitLab's LLM-architectuur bevat een deployment-engine die het LLM naar productie deployt. De deployment-engine bevat een load balancer om het verkeer te verdelen over meerdere instanties van het LLM.

GitLab's LLM-architectuur is een krachtig hulpmiddel waarmee GitLab op schaal LLMs kan trainen, evalueren en deployen. De architectuur is ontworpen om flexibel en schaalbaar te zijn, zodat GitLab eenvoudig nieuwe technologieën kan adopteren en kan voldoen aan de behoeften van haar gebruikers.

De toekomst van LLMs

LLMs zijn nog een relatief nieuwe technologie, maar ze hebben het potentieel om vele industrieën te revolutioneren. GitLab is van mening dat LLMs een aanzienlijke impact zullen hebben op de softwareontwikkelingssector.

GitLab gebruikt al LLMs om haar producten en diensten te verbeteren. GitLab gebruikt LLMs bijvoorbeeld om codesuggesties te genereren, kwetsbaarheden uit te leggen en de gebruikerservaring van haar producten te verbeteren.

GitLab is van mening dat ook andere organisaties zouden moeten investeren in LLMs. LLMs hebben het potentieel om de productiviteit, efficiëntie en kwaliteit in vele sectoren te verbeteren.

Gebieden om in te investeren

GitLab raadt organisaties aan om in de volgende gebieden te investeren om voorop te blijven lopen in de LLM-sector:

1. Infrastructuur: LLMs vereisen een aanzienlijke investering in infrastructuur. Organisaties moeten investeren in GPU's, opslag en netwerken om LLMs te ondersteunen.
2. Tools en technologieën: Er is een reeks tools en technologieën die organisaties kan helpen bij het trainen, evalueren en deployen van LLMs. Organisaties moeten investeren in de tools en technologieën die passen bij hun behoeften.
3. Talent: LLMs vormen een complexe technologie. Organisaties moeten investeren in talent met de vaardigheden en kennis om LLMs te trainen, te evalueren en te deployen.

Door in deze gebieden te investeren, kunnen organisaties voorop blijven lopen op het gebied van LLMs en de vruchten plukken van deze krachtige technologie.

Lees onze eerdere blogs in de True ML Talks-reeks:

‍

True ML Talks #21 - LLM, Machine Learning Platform @ Voiceflow

In deze blog duiken we diep in het Machine Learning Platform bij Voiceflow. Begrijp hun ML-architectuur en hoe Generatieve AI en LLM's worden gebruikt bij Voiceflow.

TrueFoundry Blog TrueFoundry

‍

Blijf de TrueML YouTube-serie bekijken en de TrueML blogreeks lezen.

TrueFoundry is een ML Deployment PaaS op Kubernetes om de workflows van ontwikkelaars te versnellen, terwijl ze de volledige flexibiliteit behouden bij het testen en deployen van modellen met gegarandeerde beveiliging en controle voor het infrastructuurteam. Via ons platform stellen we machine learning-teams in staat om modellen binnen 15 minuten te deployen en te monitoren met 100% betrouwbaarheid, schaalbaarheid en de mogelijkheid om binnen enkele seconden een rollback uit te voeren - waardoor ze kosten besparen en modellen sneller naar productie brengen, wat leidt tot echte zakelijke waarde.