Complete Beginnersgids voor Hugging Face LLM-hulpmiddelen

Hugging Face is een AI-onderzoekscentrum en -hub dat een gemeenschap van geleerden, onderzoekers en enthousiastelingen heeft opgebouwd. In een korte tijd heeft Hugging Face een aanzienlijke aanwezigheid in de AI-ruimte verworven. Technologiebedrijven zoals Google (GOOGL ), Amazon (AMZN ) en Nvidia (NVDA ) hebben AI-startup Hugging Face gesteund met aanzienlijke investeringen, waardoor de waardering $4,5 miljard bedraagt.

In deze gids introduceren we transformers, LLM’s en de rol van de Hugging Face-bibliotheek bij het bevorderen van een opensource AI-gemeenschap. We zullen ook de essentiële functies van Hugging Face behandelen, waaronder pipelines, datasets, modellen en meer, met praktische Python-voorbeelden.

Transformers in NLP

In 2017 publiceerde de Cornell-universiteit een invloedrijk artikel dat transformers introduceerde. Deze zijn diepe leermodellen die in NLP worden gebruikt. Deze ontdekking zette de ontwikkeling van grote taalmodellen zoals ChatGPT in gang.

Grote taalmodellen of LLM’s zijn AI-systemen die transformers gebruiken om menselijke tekst te begrijpen en te creëren. Het creëren van deze modellen is echter duur, vaak miljoenen dollars, waardoor de toegang beperkt is tot grote bedrijven.

Hugging Face, opgericht in 2016, streeft ernaar NLP-modellen toegankelijk te maken voor iedereen. Ondanks dat het een commercieel bedrijf is, biedt het een reeks opensource-hulpmiddelen aan om mensen en organisaties in staat te stellen betaalbaar transformermodellen te bouwen en te gebruiken. Machine learning gaat over het leren van computers taken uit te voeren door patronen te herkennen, terwijl diepe leer, een subset van machine learning, een netwerk creëert dat onafhankelijk leert. Transformers zijn een type diepe leerarchitectuur die effectief en flexibel invoerdata gebruikt, waardoor het een populaire keuze is voor het bouwen van grote taalmodellen vanwege de lagere trainingsvereisten.

Hoe Hugging NLP- en LLM-projecten faciliteert

Hugging Face heeft het werken met LLM’s eenvoudiger gemaakt door:

1. Een reeks vooraf getrainde modellen om uit te kiezen.
2. Hulpmiddelen en voorbeelden om deze modellen te fine-tunen voor uw specifieke behoeften.
3. Makkelijke implementatieopties voor verschillende omgevingen.

Een geweldige bron die beschikbaar is via Hugging Face is de Open LLM Leaderboard. Dit fungeert als een uitgebreid platform dat een reeks grote taalmodellen (LLM’s) en chatbots systematisch monitort, rangschikt en beoordeelt, waardoor een gedetailleerde analyse van de vooruitgang in de opensource-domein mogelijk is

LLM-benchmarks meten modellen met behulp van vier metrics:

• AI2 Reasoning Challenge (25-shot) – een reeks vragen over elementaire wetenschappelijke onderwerpen.
• HellaSwag (10-shot) – een test voor gezond verstand dat, hoewel eenvoudig voor mensen, een aanzienlijke uitdaging vormt voor state-of-the-art-modellen.
• MMLU (5-shot) – een multifaceted evaluatie die de vaardigheid van een tekstmodel in 57 verschillende domeinen beoordeelt, waaronder basiswiskunde, recht en informatica, onder andere.
• TruthfulQA (0-shot) – een hulpmiddel om de neiging van een model te bepalen om vaak voorkomende online misinformatie te herhalen.

De benchmarks, die worden beschreven met termen zoals “25-shot”, “10-shot”, “5-shot” en “0-shot”, geven het aantal promptvoorbeelden aan dat een model krijgt tijdens het evaluatieproces om zijn prestaties en redeneervaardigheden in verschillende domeinen te meten. In “few-shot”-paradigma’s krijgen modellen een kleine hoeveelheid voorbeelden om hun antwoorden te begeleiden, terwijl in een “0-shot”-situatie modellen geen voorbeelden krijgen en moeten vertrouwen op hun bestaande kennis om adequaat te reageren.

Componenten van Hugging

Pipelines

‘Pipelines‘ zijn onderdeel van Hugging Face’s transformers-bibliotheek, een functie die het gemakkelijk maakt om vooraf getrainde modellen in de Hugging Face-repository te gebruiken. Het biedt een intuïtieve API voor een reeks taken, waaronder sentimentanalyse, vraagbeantwoording, gemaskerde taalmodellering, named entity recognition en samenvatting.

Pipelines integreren drie centrale Hugging Face-componenten:

1. Tokenizer: bereidt uw tekst voor op het model door deze om te zetten in een formaat dat het model kan begrijpen.
2. Model: dit is het hart van de pipeline waar de daadwerkelijke voorspellingen op basis van de voorbewerkte invoer worden gedaan.
3. Post-processor: transformeert de ruwe voorspellingen van het model in een voor mensen leesbare vorm.

Deze pipelines verminderen niet alleen uitgebreid coderen, maar bieden ook een gebruikersvriendelijke interface om verschillende NLP-taken uit te voeren.

Transformer-toepassingen met de Hugging Face-bibliotheek

Een van de highlights van de Hugging Face-bibliotheek is de Transformers-bibliotheek, die NLP-taken vereenvoudigt door een model te verbinden met de nodige voor- en nabewerkingsfasen, waardoor het analyseproces wordt gestroomlijnd. Om de bibliotheek te installeren en te importeren, gebruikt u de volgende opdrachten:

pip install -q transformers
from transformers import pipeline

Nadat u dit hebt gedaan, kunt u NLP-taken uitvoeren, beginnend met sentimentanalyse, die tekst indeelt in positieve of negatieve sentimenten. De krachtige pipeline()-functie van de bibliotheek fungeert als een hub die andere pipelines omvat en takenpecifieke toepassingen in audio-, visie- en multimodale domeinen mogelijk maakt.

Praktische toepassingen

Tekstclassificatie

Tekstclassificatie wordt een fluitje van een cent met Hugging Face’s pipeline()-functie. Hieronder ziet u hoe u een tekstclassificatiepipeline kunt initialiseren:

classifier = pipeline("tekstclassificatie")

Om een hands-on ervaring te krijgen, voert u een tekenreeks of een lijst met tekenreeksen in uw pipeline in om voorspellingen te krijgen, die netjes kunnen worden weergegeven met Python’s Pandas-bibliotheek. Hieronder ziet u een Python-fragment dat dit demonstreert:

zinnen = ["Ik ben verheugd om u voor te stellen aan de prachtige wereld van AI.",
"Hopelijk zal het u niet teleurstellen."]

# Krijg classificatieresultaten voor elke zin in de lijst
resultaten = classifier(zinnen)

# Loop door elk resultaat en print het label en de score
for i, resultaat in enumerate(resultaten):
print(f"Resultaat {i + 1}:")
print(f" Label: {resultaat['label']}")
print(f" Score: {round(resultaat['score'], 3)}\n")

Uitvoer

Resultaat 1:
Label: POSITIEF
Score: 1.0

Resultaat 2:
Label: POSITIEF
Score: 0.996

Named Entity Recognition (NER)

NER is cruciaal bij het extraheren van werkelijke objecten, genoemd ‘genoemde entiteiten’, uit de tekst. Gebruik de NER-pipeline om deze entiteiten effectief te identificeren:

ner_tagger = pipeline("ner", aggregation_strategy="simple")
tekst = "Elon Musk is de CEO van SpaceX."
uitvoer = ner_tagger(tekst)
print(uitvoer)

Uitvoer

 Elon Musk: PERSOON, SpaceX: ORGANISATIE 

Vraagbeantwoording

Vraagbeantwoording houdt in dat u precieze antwoorden extrahert uit een gegeven context. Initialiseer een vraagbeantwoordingspipeline en voer uw vraag en context in om het gewenste antwoord te krijgen:

reader = pipeline("vraagbeantwoording")
tekst = "Hugging Face is een bedrijf dat tools voor NLP maakt. Het is gevestigd in New York en is opgericht in 2016."
vraag = "Waar is Hugging Face gevestigd?"
uitvoer = reader(vraag=vraag, context=tekst)
print(uitvoer)

Uitvoer

 { 'score': 0.998, 'start': 51, 'end': 60, 'antwoord': 'New York' } 

Hugging Face’s pipeline()-functie biedt een reeks vooraf gebouwde pipelines voor verschillende taken, naast tekstclassificatie, NER en vraagbeantwoording. Hieronder vindt u details over een subset van de beschikbare taken:

Tabel: Hugging Face-pipeline-taken

Voor gedetailleerde beschrijvingen en meer taken, verwijzen we naar de pipeline-documentatie op de website van Hugging Face.

Waarom Hugging de focus verlegt naar Rust

Hugging Face Safetensors en tokenizer GitHub-pagina

Het Hugging Face-ecosysteem (HF) begon onlangs Rust te gebruiken in zijn bibliotheken, zoals safetensors en tokenizers.

Hugging Face heeft onlangs ook een nieuw machine learning-kader genaamd Candle uitgebracht. In tegenstelling tot traditionele kaders die Python gebruiken, is Candle gebouwd met Rust. Het doel van het gebruik van Rust is om de prestaties te verbeteren en de gebruikerservaring te vereenvoudigen, terwijl het ondersteuning biedt voor GPU-bewerkingen.

Het belangrijkste doel van Candle is om serverloze inferentie te faciliteren, waardoor het mogelijk wordt om lichte binaries te implementeren en Python uit de productieworkloads te verwijderen, die soms processen kunnen vertragen vanwege de overhead. Dit kader komt als oplossing om de problemen te overwinnen die worden aangetroffen met volledige machine learning-kaders zoals PyTorch, die groot en langzaam zijn bij het maken van instanties op een cluster.

Laten we onderzoeken waarom Rust een meer populaire keuze wordt dan Python.

1. Snelheid en prestaties – Rust is bekend om zijn verbazingwekkende snelheid, waarmee het Python overtreft, dat traditioneel in machine learning-kaders wordt gebruikt. De prestaties van Python kunnen soms worden vertraagd vanwege de Global Interpreter Lock (GIL), maar Rust heeft dit probleem niet, waardoor het snellere uitvoering van taken en betere prestaties in projecten mogelijk maakt waarin het wordt geïmplementeerd.
2. Veiligheid – Rust biedt garanties voor geheugerveiligheid zonder een garbage collector, een aspect dat essentieel is voor het waarborgen van de veiligheid van gelijktijdige systemen. Dit speelt een cruciale rol in gebieden zoals safetensors, waar veiligheid bij het omgaan met gegevensstructuren een prioriteit is.

Safetensors

Safetensors profiteren van de snelheid en veiligheidsfuncties van Rust. Safetensors houdt zich bezig met het manipuleren van tensors, een complexe wiskundige entiteit, en het gebruik van Rust zorgt ervoor dat de bewerkingen niet alleen snel zijn, maar ook veilig, waardoor veelvoorkomende bugs en beveiligingsproblemen die kunnen ontstaan door geheugenmishandeling worden vermeden.

Tokenizer

Tokenizers behandelen het opdelen van zinnen of frasen in kleinere eenheden, zoals woorden of termen. Rust helpt bij dit proces door de uitvoeringstijd te versnellen, waardoor het tokenisatieproces niet alleen nauwkeurig is, maar ook snel, waardoor de efficiëntie van natuurlijke taalverwerkingstaken wordt verbeterd.

In het hart van Hugging Face’s tokenizer ligt het concept van subwoordtokenisatie, dat een delicate balans tussen woord- en karakterniveau-tokenisatie bereikt om informatiebehoud en woordenschatgrootte te optimaliseren. Het werkt door subtokens te creëren, zoals “##ing” en “##ed”, waardoor semantische rijkdom behouden blijft, terwijl een opgeblazen woordenschat wordt vermeden.

Subwoordtokenisatie omvat een trainingsfase om de meest effectieve balans tussen karakter- en woordniveau-tokenisatie te identificeren. Het gaat verder dan eenvoudige prefix- en suffixregels, waardoor een grondige analyse van taalpatronen in uitgebreide tekstcorpora nodig is om een efficiënte subwoordtokenizer te ontwerpen. De gegenereerde tokenizer is in staat om om te gaan met nieuwe woorden door ze op te delen in bekende subwoorden, waardoor een hoog niveau van semantisch begrip behouden blijft.

Tokenisatiecomponenten

https://huggingface.co/learn/nlp-course/chapter6/4

De tokenizers-bibliotheek splitst het tokenisatieproces op in verschillende stappen, waarbij elke stap een ander aspect van tokenisatie behandelt. Laten we deze componenten onderzoeken:

• Normalizer: voert initiële transformaties uit op de invoerstring, waaronder noodzakelijke aanpassingen zoals omzetting naar kleine letters, Unicode-normalisatie en strippen.
• Voor-tokenizer: is verantwoordelijk voor het opdelen van de invoerstring in voor-segmenten, waarbij de splitsingen worden bepaald op basis van vooraf gedefinieerde regels, zoals spatiescheiding.
• Model: zorgt voor het ontdekken en creëren van subtokens, waarbij het zich aanpast aan de specificaties van uw invoergegevens en trainingsmogelijkheden biedt.
• Nabewerker: verbetert constructiefuncties om compatibiliteit te bieden met veel transformer-gebaseerde modellen, zoals BERT, door tokens toe te voegen zoals [CLS] en [SEP].

Om te beginnen met Hugging Face-tokenizers, installeert u de bibliotheek met de opdracht pip install tokenizers en importeert u deze in uw Python-omgeving. De bibliotheek kan grote hoeveelheden tekst in heel korte tijd tokeniseren, waardoor waardevolle rekentijd wordt bespaard voor intensievere taken zoals modeltraining.

De tokenizers-bibliotheek gebruikt Rust, die syntactische gelijkenis met C++ heeft, maar nieuwe concepten in taalontwerp introduceert. In combinatie met Python-bindings zorgt dit ervoor dat u de prestaties van een lagere taal geniet, terwijl u in een Python-omgeving werkt.

Datasets

Hugging Face-datasets

Datasets vormen de basis van AI-projecten. Hugging Face biedt een breed scala aan datasets, geschikt voor een reeks NLP-taken en meer. Om ze efficiënt te gebruiken, is het essentieel om het proces van laden en analyseren te begrijpen. Hieronder vindt u een goed gedocumenteerd Python-script dat laat zien hoe u datasets op Hugging Face kunt verkennen:

from datasets import load_dataset
# Laad een dataset
dataset = load_dataset('squad')
# Toon de eerste entry
print(dataset[0])

Dit script gebruikt de load_dataset-functie om de SQuAD-dataset te laden, die een populaire keuze is voor vraagbeantwoordingstaken.

Gebruik van vooraf getrainde modellen en het combineren van alles

Hugging Face-modellen

Vooraf getrainde modellen vormen de ruggengraat van veel diepe leerprojecten, waardoor onderzoekers en ontwikkelaars hun projecten kunnen starten zonder vanaf nul te beginnen. Hugging Face faciliteert het verkennen van een breed scala aan vooraf getrainde modellen, zoals hieronder wordt getoond:

from transformers import AutoModelForQuestionAnswering, AutoTokenizer

# Laad het vooraf getrainde model en de tokenizer
model = AutoModelForQuestionAnswering.from_pretrained('bert-large-uncased-whole-word-masking-finetuned-squad')
tokenizer = AutoTokenizer.from_pretrained('bert-large-uncased-whole-word-masking-finetuned-squad')

# Toon de architectuur van het model
print(model)

Met het model en de tokenizer geladen, kunnen we nu een functie maken die een stuk tekst en een vraag als invoer neemt en het antwoord uit de tekst retourneert. We zullen de tokenizer gebruiken om de invoerstring en vraag te verwerken tot een formaat dat compatibel is met het model, en vervolgens deze verwerkte invoer in het model invoeren om het antwoord te krijgen:

def get_antwoord(tekst, vraag):
# Tokeniseer de invoerstring en vraag
inputs = tokenizer(vraag, tekst, return_tensors='pt', max_length=512, truncation=True)
outputs = model(**inputs)

# Krijg de start- en eindscores voor het antwoord
antwoord_start = torch.argmax(outputs.start_logits)
antwoord_end = torch.argmax(outputs.end_logits) + 1

antwoord = tokenizer.convert_tokens_to_string(tokenizer.convert_ids_to_tokens(inputs['input_ids'][0][antwoord_start:antwoord_end]))
return antwoord

In het codefragment importeren we de nodige modules uit het transformers-pakket, laden we vervolgens een vooraf getraind model en de corresponderende tokenizer met de from_pretrained-methode. We kiezen een BERT-model dat is gefinetuned op de SQuAD-dataset.

Laten we een voorbeeldgeval van deze functie bekijken waarbij we een alinea tekst hebben en een specifiek antwoord op een vraag uit die tekst willen extraheren:

tekst = """
De Eiffeltoren, gelegen in Parijs, Frankrijk, is een van de meest iconische landmarks ter wereld. Het is ontworpen door Gustave Eiffel en voltooid in 1889. De toren is 324 meter hoog en was het hoogste door de mens gemaakte bouwwerk ter wereld op het moment van voltooiing.
"""

vraag = "Wie ontwierp de Eiffeltoren?"

# Krijg het antwoord op de vraag
antwoord = get_antwoord(tekst, vraag)
print(f"Het antwoord op de vraag is: {antwoord}")
# Uitvoer: Het antwoord op de vraag is: Gustave Eiffel

In dit script bouwen we een get_antwoord-functie die een stuk tekst en een vraag als invoer neemt, de invoerstring en vraag tokeniseert, en vervolgens het antwoord uit de tekst extrahert met behulp van het vooraf getrainde BERT-model. Het demonstreert een praktische toepassing van Hugging Face’s transformers-bibliotheek om een eenvoudig maar krachtig vraagbeantwoordingsysteem te bouwen. Om de concepten goed te begrijpen, wordt aanbevolen om hands-on experimenten uit te voeren met een Google Colab-notebook.

Conclusie

Door zijn uitgebreide reeks opensource-hulpmiddelen, vooraf getrainde modellen en gebruikersvriendelijke pipelines, maakt Hugging Face het mogelijk voor zowel ervaren professionals als nieuwkomers om de uitgebreide wereld van AI te betreden met een gevoel van gemak en begrip. Bovendien benadrukt de inspanning om Rust te integreren vanwege de snelheids- en veiligheidsfuncties de toewijding van Hugging Face aan het bevorderen van innovatie, waarbij efficiëntie en beveiliging in AI-toepassingen worden gewaarborgd. Het transformatieve werk van Hugging Face democratiseert niet alleen de toegang tot hoogwaardige AI-hulpmiddelen, maar creëert ook een samenwerkingsomgeving voor leren en ontwikkeling in de AI-ruimte, waardoor een toekomst mogelijk wordt gemaakt waarin AI toegankelijk is voor iedereen.