Een introductie tot het gebruik van Transformers en Hugging Face

Introductie

Dankzij het vele onderzoek binnen NLP, de afkorting van Natural Language Processing, zijn de afgelopen decennia baanbrekende resultaten behaald in uiteenlopende domeinen. Hieronder vind je enkele voorbeelden van Natural Language Processing in de praktijk:

• Apple’s persoonlijke assistent Siri, die je kan helpen bij dagelijkse taken zoals wekkers zetten, sms’en, vragen beantwoorden, enzovoort.
• Onderzoekers in de medische wereld gebruiken NLP om de weg vrij te maken voor snellere medicijnontdekking.  
• Taalvertaling is een andere geweldige toepassing, omdat het ons helpt communicatiebarrières te overwinnen.  

Deze conceptuele blog behandelt Transformers, een van de krachtigste modellen ooit ontwikkeld binnen Natural Language Processing. Na een uitleg van hun voordelen ten opzichte van recurrente neurale netwerken, bouwen we je begrip van Transformers op. Daarna lopen we door enkele realistische scenario’s met Hugging Face-transformers.

Je kunt ook meer leren over het bouwen van NLP-toepassingen met Hugging Face met onze code-along.

Recurrent netwerk — de gloriejaren vóór Transformers 

Voordat we in het kernconcept van transformers duiken, bekijken we kort wat recurrente modellen zijn en waar hun beperkingen liggen.

Recurrente netwerken gebruiken een encoder-decoderarchitectuur en worden vooral ingezet bij taken waarbij zowel input als output sequenties zijn met een bepaalde volgorde. Enkele belangrijke toepassingen van recurrente netwerken zijn machinevertaling en het modelleren van tijdreeksen.

Uitdagingen bij recurrente netwerken 

Laten we het vertalen van de volgende Franse zin naar het Engels als voorbeeld nemen. De input die naar de encoder gaat, is de oorspronkelijke Franse zin, en de vertaalde output wordt door de decoder gegenereerd.

Een eenvoudige illustratie van het recurrente netwerk voor taalvertaling

• De Franse invoerzin wordt woord voor woord naar de encoder gestuurd, en de woordembeddings worden in dezelfde volgorde door de decoder gegenereerd, wat de training traag maakt.
• De verborgen toestand van het huidige woord hangt af van de verborgen toestanden van de vorige woorden, waardoor parallelle berekening onmogelijk is, ongeacht de rekenkracht. 
• Sequence-to-sequence-neurale netwerken zijn gevoelig voor exploderende gradiënten wanneer het netwerk te lang is, wat leidt tot slechte prestaties. 
• Long Short-Term Memory (LSTM)-netwerken, een ander type recurrente netwerken, zijn geïntroduceerd om het verdwijnende gradiënt tegen te gaan, maar ze zijn nog trager dan sequentiemodellen. 

Zou het niet geweldig zijn als er een model was dat de voordelen van recurrente netwerken combineert en parallelle berekening mogelijk maakt? 

Daar komen transformers van pas.

Wat zijn transformers in NLP?

Transformers is de nieuwe, eenvoudige maar krachtige neurale netwerkarchitectuur die in 2017 door Google Brain werd geïntroduceerd met hun bekende paper “Attention is all you need.” Het is gebaseerd op het attention-mechanisme in plaats van sequentiële berekening, zoals we bij recurrente netwerken zien. 

Wat zijn de belangrijkste componenten van transformers?

Net als recurrente netwerken hebben transformers twee hoofdblokken: encoder en decoder, elk met een self-attention-mechanisme. De eerste versie van transformers had een RNN- en LSTM-encoder-decoderarchitectuur, die later is vervangen door self-attention- en feed-forward-netwerken.

De volgende sectie geeft een algemeen overzicht van de belangrijkste componenten van elk blok van transformers. 

Algemene architectuur van transformers (bewerkt door auteur)

Voorbewerking van de invoerzin

Deze stap bevat twee hoofdonderdelen: (1) het genereren van embeddings van de invoerzin, en (2) het berekenen van de positionele vector van elk woord in de invoerzin. Alle berekeningen gebeuren op dezelfde manier voor zowel de bronzin (voor het encoderblok) als de doeltaalzin (voor het decoderblok). 

Embedding van de invoerdata

Voordat we embeddings van de invoerdata genereren, beginnen we met tokenisatie en maken we de embedding van elk individueel woord, zonder rekening te houden met hun relatie in de zin. 

Positionele encodering

Bij tokenisatie gaat de notie van relaties in de invoerzin verloren. Positionele encodering probeert het oorspronkelijke cyclische karakter te herstellen door voor elk woord een contextvector te genereren. 

Encoderblok 

Aan het einde van de vorige stap hebben we voor elk woord twee vectoren: (1) de embedding en (2) de contextvector. Deze vectoren worden bij elkaar opgeteld om één vector per woord te maken, die vervolgens naar de encoder wordt gestuurd. 

Multi-head attention

Zoals eerder vermeld zijn we alle notie van relaties kwijtgeraakt. Het doel van de attention-laag is om de contextuele relaties tussen verschillende woorden in de invoerzin vast te leggen. Deze stap levert voor elk woord een attentionvector op.

Position-wise feed-forward net (FFN)

In deze fase wordt op elke attentionvector een feed-forward-neuraal netwerk toegepast om ze te transformeren naar een formaat dat wordt verwacht door de volgende multi-head attention-laag in de decoder.

Decoderblok

Het decoderblok bestaat uit drie hoofdlagen: masked multi-head attention, multi-head attention en een position-wise feed-forward-netwerk. We kennen de laatste twee lagen al; die zijn hetzelfde als in de encoder. 

De decoder komt in beeld tijdens het trainen van het netwerk en ontvangt twee hoofdinputs: (1) de attentionvectoren van de invoerzin die we willen vertalen en (2) de vertaalde doeltalige zinnen in het Engels. 

Waar is de masked multi-head attention-laag voor verantwoordelijk?

Bij het genereren van het volgende Engelse woord mag het netwerk alle woorden uit het Franse woord gebruiken. Maar bij een gegeven woord in de doelsequentie (Engelse vertaling) mag het netwerk alleen de voorgaande woorden gebruiken, omdat toegang tot de volgende woorden het netwerk zou laten “valsspelen” en het leerproces zou verstoren. Hier toont de masked multi-head attention-laag zijn waarde. Die maskeert de volgende woorden door ze naar nullen te transformeren, zodat de attention-laag ze niet kan gebruiken. 

Het resultaat van de masked multi-head attention-laag gaat door de rest van de lagen om het volgende woord te voorspellen door een waarschijnlijkheidsscore te genereren. 

Deze architectuur was succesvol om de volgende redenen:

• De totale computationele complexiteit per laag is lager vergeleken met RNN’s. 
• Er is geen recursie meer nodig en sequentie-parallelisatie is mogelijk, in tegenstelling tot RNN’s die de input sequentieel verwachten. 
• RNN’s leren niet efficiënt van langetermijnsequenties vanwege de lengte van de paden voor voorwaartse en achterwaartse signalen in het netwerk. Dit pad wordt verkort met self-attention, wat het leerproces verbetert.

Transfer learning in NLP

Diepe neurale netwerken zoals transformers helemaal from scratch trainen is niet eenvoudig en kan de volgende uitdagingen met zich meebrengen: 

• De benodigde hoeveelheid data voor het doelprobleem vinden kan tijdrovend zijn
• De vereiste rekenmiddelen zoals GPU’s om zulke diepe netwerken te trainen kunnen erg kostbaar zijn.  

Transfer learning gebruiken kan veel voordelen opleveren, zoals kortere traintijd, het versnellen van het trainingsproces van nieuwe modellen en het verkorten van de doorlooptijd van projecten.

Stel dat je een model from scratch bouwt om de Mandingo-taal naar Wolof te vertalen, beide talen met weinig bronnen. Het verzamelen van data voor die talen is duur. In plaats van al deze uitdagingen aan te gaan, kun je vooraf getrainde diepe neurale netwerken hergebruiken als startpunt voor het trainen van je nieuwe model. 

Dergelijke modellen zijn getraind op een enorme corpus data, beschikbaar gesteld door iemand anders (natuurlijk persoon, organisatie, enz.), en geëvalueerd als zeer geschikt voor vertaalopdrachten zoals Frans naar Engels. 

Als je nieuw bent in NLP, kan deze Introductie in Natural Language Processing in Python-cursus je de basisvaardigheden bieden om echte problemen op te lossen.

Maar wat bedoel je met het hergebruiken van diepe neurale netwerken?

Het hergebruik van het model omvat het kiezen van een vooraf getraind model dat lijkt op jouw usecase, het verfijnen van de input-outputparen van je doeltaak en het hertrainen van de “head” van het vooraf getrainde model met jouw data. 

De introductie van Transformers heeft geleid tot state-of-the-art transfer learning-modellen zoals: 

• BERT, voluit Bidirectional Encoder Representations from Transformers, ontwikkeld door Google-onderzoekers in 2018. Het helpt bij het oplossen van veelvoorkomende taaltaken zoals named entity recognition, sentimentanalyse, vraag-antwoord, tekstsamenvatting, enz. Lees meer over BERT in deze NLP-tutorial.
• GPT-3 (Generative Pre-Training-3), voorgesteld door onderzoekers van OpenAI. Het is een meerlagige transformer, vooral gebruikt om allerlei soorten tekst te genereren. GPT-modellen kunnen mensachtige tekstreacties produceren op een gegeven vraag. Dit geweldige artikel biedt meer inzicht in wat GPT-3 uniek maakt, de technologie erachter, de risico’s en de beperkingen.

Een introductie tot Hugging Face Transformers

Hugging Face is een AI-community en Machine Learning-platform dat in 2016 is opgericht door Julien Chaumond, Clément Delangue en Thomas Wolf. Het wil NLP democratiseren door Data Scientists, AI-practitioners en engineers directe toegang te geven tot meer dan 20.000 vooraf getrainde modellen op basis van de state-of-the-art transformerarchitectuur. Deze modellen zijn toepasbaar op:

• Tekst in meer dan 100 talen voor taken zoals classificatie, informatie-extractie, vraag-antwoord, genereren en vertalen. 
• Spraak, voor taken zoals audio-objectclassificatie en spraakherkenning. 
• Visie voor objectdetectie, beeldclassificatie en segmentatie.
• Tabulaire data voor regressie- en classificatieproblemen. 
• Reinforcement Learning-transformers. 

Hugging Face Transformers biedt ook bijna 2000 datasets en gelaagde API’s, zodat programmeurs eenvoudig met die modellen kunnen werken via zo’n 31 bibliotheken. De meeste zijn deep learning-bibliotheken, zoals Pytorch, Tensorflow, Jax, ONNX, Fastai, Stable-Baseline 3, enz. 

Deze cursussen zijn een goede introductie in het gebruik van Pytorch en Tensorflow om respectievelijk diepe convolutionele neurale netwerken te bouwen. Andere componenten van Hugging Face Transformers zijn de Pipelines. 

Wat zijn Pipelines in Transformers?

• Ze bieden een gebruiksvriendelijke API via de methode pipeline() om inference uit te voeren voor uiteenlopende taken.
• Ze encapsuleren het volledige proces van elke NLP-taak, zoals tekstopschoning, tokenisatie, embedding, enz.

De methode pipeline() heeft de volgende structuur: 

from transformers import pipeline

# To use a default model & tokenizer for a given task(e.g. question-answering)
pipeline("<task-name>")

# To use an existing model
pipeline("<task-name>", model="<model_name>")

# To use a custom model/tokenizer
pipeline('<task-name>', model='<model name>',tokenizer='<tokenizer_name>')

Hugging Face Tutorial : EDITION IN PROGRESS …

Nu je een beter begrip hebt van Transformers en het Hugging Face-platform, lopen we door de volgende realistische scenario’s: taalvertaling, sequentieclassificatie met zero-shot-classificatie, sentimentanalyse en vraag-antwoord. 

Informatie over de datasets

Deze dataset is beschikbaar op Datacamp’s Datasets, is verrijkt door Facebook en is gemaakt om de populariteit van een artikel vóór publicatie te voorspellen. De analyse is gebaseerd op de kolom description. Ter illustratie gebruiken we slechts drie voorbeelden uit de data. 

Hieronder een korte beschrijving van de data. Het bevat 14 kolommen en 1428 rijen.

import pandas as pd
# Load the data from the path
data_path = "datacamp_workspace_export_2022-08-08 07_56_40.csv"
news_data = pd.read_csv(data_path, error_bad_lines=False)




# Show data information
news_data.info()

Taalvertaling

MariamMT is een efficiënt framework voor machinevertaling. Het gebruikt onder de motorkap de MarianNMT-engine, volledig ontwikkeld in C++ door Microsoft en verschillende academische instellingen zoals de University of Edinburgh en de Adam Mickiewicz University in Poznań. Dezelfde engine zit momenteel achter de dienst Microsoft Translator. 

De NLP-groep van de Universiteit van Helsinki heeft meerdere vertaalmodellen open-source beschikbaar gemaakt op Hugging Face Transformers en die hebben allemaal het volgende formaat Helsinki-NLP/opus-mt-{src}-{tgt} waarbij {src} en {tgt} respectievelijk de bron- en doeltalen zijn. 

In ons geval is de brontaal Engels (en) en de doeltaal Frans (fr)

MarianMT is een van die modellen die eerder met Marian zijn getraind op parallelle data verzameld bij Opus.

• MarianMT vereist sentencepiece naast Transformers:

pip install transformers sentencepiece
from transformers import MarianTokenizer, MarianMTModel

• Selecteer het vooraf getrainde model, haal de tokenizer op en laad het vooraf getrainde model

# Get the name of the model
model_name = 'Helsinki-NLP/opus-mt-en-fr'

# Get the tokenizer
tokenizer = MarianTokenizer.from_pretrained(model_name)
# Instantiate the model
model = MarianMTModel.from_pretrained(model_name)

• Voeg de speciale token >>{tgt}<< toe vóór elke bron (Engelse) tekst met behulp van de volgende functie.

def format_batch_texts(language_code, batch_texts):
    formated_bach = [">>{}<< {}".format(language_code, text) for text in     

                batch_texts]
return formated_bach

• Implementeer de batchvertaallogica met behulp van de volgende functie; een batch is een lijst met te vertalen teksten.

def perform_translation(batch_texts, model, tokenizer, language="fr"):

  # Prepare the text data into appropriate format for the model
  formated_batch_texts = format_batch_texts(language, batch_texts)
 
  # Generate translation using model
  translated = model.generate(**tokenizer(formated_batch_texts,

                                          return_tensors="pt", padding=True))

  # Convert the generated tokens indices back into text
  translated_texts = [tokenizer.decode(t, skip_special_tokens=True) for t in translated]
 
  return translated_texts

• Voer de vertaling uit op de eerdere voorbeeldbeschrijvingen

# Check the model translation from the original language (English) to French
translated_texts = perform_translation(english_texts, trans_model, trans_model_tkn)

# Create wrapper to properly format the text
from textwrap import TextWrapper
# Wrap text to 80 characters.
wrapper = TextWrapper(width=80)

for text in translated_texts:
  print("Original text: \n", text)
  print("Translation : \n", text)
  print(print(wrapper.fill(text)))
  print("")

Zero-shot-classificatie

Meestal vereist het trainen van een Machine Learning-model dat alle kandidaatlabels/targets vooraf bekend zijn. Dat betekent dat als je trainingslabels science, politics of education zijn, je het label healthcare niet kunt voorspellen, tenzij je je model opnieuw traint met dat label en de bijbehorende inputdata. 

Deze krachtige benadering maakt het mogelijk om het doel van een tekst in ongeveer 15 talen te voorspellen zonder dat een van de kandidaatlabels eerder gezien is. We kunnen dit model gebruiken door het simpelweg van de hub te laden. 

Het doel hier is om de categorie van elk van de eerdere beschrijvingen te classificeren: tech, politics, security of finance. 

• Importeer de pipeline-module

from transformers import pipeline

• Definieer kandidaatlabels. Dit zijn de categorieën die we willen voorspellen: tech, politics, business of finance

candidate_labels = ["tech", "politics", "business", "finance"]

• Definieer de classifier met de meertalige optie

my_classifier = pipeline("zero-shot-classification",  

                           model='joeddav/xlm-roberta-large-xnli')

• Voer de voorspellingen uit op de eerste en de laatste beschrijving 

#For the first description
prediction = my_classifier(english_texts[0], candidate_labels, multi_class = True)
pd.DataFrame(prediction).drop(["sequence"], axis=1)

Tekst voorspeld als voornamelijk finance 

Dit resultaat laat zien dat de tekst overwegend over finance gaat met 81%. 

Voor de laatste beschrijving krijgen we het volgende resultaat:

#For the last description
prediction = my_classifier(english_texts[-1], candidate_labels, multi_class = True)
pd.DataFrame(prediction).drop(["sequence"], axis=1)

Tekst voorspeld als voornamelijk tech 

Dit resultaat laat zien dat de tekst overwegend over tech gaat met 95%.

Sentimentanalyse

De meeste modellen voor sentimentclassificatie vereisen behoorlijke training. De pipeline-module van Hugging Face maakt het eenvoudig om sentimentvoorspellingen uit te voeren door een specifiek model van de hub te gebruiken en de naam ervan op te geven. 

• Kies de uit te voeren taak en laad het bijbehorende model. Hier willen we sentimentclassificatie uitvoeren met het gedistilleerde BERT-basismodel. 

model_checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"

distil_bert_model = pipeline(task="sentiment-analysis", model=model_checkpoint)

• Het model is klaar! Laten we de onderliggende sentimenten achter de laatste twee zinnen analyseren. 

# Run the predictions
distil_bert_model(english_texts[1:])

Het model voorspelde dat de eerste tekst een negatief sentiment heeft met 96% zekerheid, en dat de tweede een positief sentiment heeft met 52% zekerheid. 

Als je meer wilt ontdekken over sentimentanalyse, helpt deze Python Sentiment Analysis-cursus je om de vaardigheden op te doen om je eigen sentimentclassificatiemodel te bouwen en de basis van NLP te begrijpen.

Vraag-antwoord

Stel dat je te maken hebt met een rapport dat veel langer is dan dat over Apple. En het enige dat je interesseert, is de datum van het genoemde evenement. In plaats van het hele rapport te lezen om de kerninformatie te vinden, kunnen we een vraag-antwoordmodel van Hugging Face gebruiken dat het gezochte antwoord geeft. 

Dit kan door het model te voorzien van de juiste context (het Apple-rapport) en de vraag waarop we het antwoord willen vinden.

• Importeer de vraag-antwoordklasse en tokenizer uit transformers

from transformers import AutoModelForQuestionAnswering, AutoTokenizer

• Instantieer het model met zijn naam en de tokenizer. 

model_checkpoint = "deepset/roberta-base-squad2"

task = 'question-answering'
QA_model = pipeline(task, model=model_checkpoint, tokenizer=model_checkpoint)

• Stel het model een vraag en geef de context op. 

QA_input = {
          'question': 'when is Apple hosting an event?',
          'context': english_texts[-1]
          }

• Haal het resultaat van het model op

model_response = QA_model(QA_input)
pd.DataFrame([model_response])

Het model antwoordde dat Apple’s evenement op 10 september is, met een hoge zekerheid van 97%. 

Conclusie

In dit artikel hebben we de evolutie van taaltechnologie behandeld: van recurrente netwerken naar transformers, en hoe Hugging Face het gebruik van NLP via zijn platform heeft gedemocratiseerd. 

Als je nog twijfelt over het gebruik van transformers, denken wij dat het tijd is om ze te proberen en waarde toe te voegen aan je businesscases.