Slik bruker du Hugging Face Transformers i Python

Slik Bruker Du Hugging Face Transformers I Python



Hugging Face er anerkjent som et kunstig intelligent fellesskap som er åpen kildekode og det gir alle viktige rammeverk, verktøy, modeller og arkitekturer som hjelper til med å kommunisere eller trene med språkmodellene (naturlig språkbehandling). Hugging Face-transformatorer er en språkarkitektur som hjelper til med å tilby de ferdigtrente språkbehandlingsmodellene i Python. Disse transformatorene fra Hugging Face gir et bredt spekter av datasett og lagdelte APIer som hjelper programmererne til enkelt å skape en interaksjon med de forhåndstrente modellene med bibliotekpakkene deres.

Syntaks

De toppmoderne Hugging Face-transformatorene har et stort utvalg av ferdigtrente modeller. Disse modellene kan brukes på ulike språkmodeller som er oppført i følgende:

  • Disse transformatorene kan behandle teksten på forskjellige språk og kan utføre forskjellige oppgaver på teksten som tekstklassifisering, spørsmål og svar, oversettelse av teksten til forskjellige språk og generering av teksten.
  • Vi kan også bruke disse transformatorene i Hugging Face for synsbaserte klassifiseringsoppgaver som gjenstandsdeteksjon og talebaserte oppgaver, f.eks. høyttalerklassifisering eller taleidentifikasjon/-gjenkjenning.

Transformatorene fra Hugging Face inkluderer TensorFlow, PyTorch, ONNX osv. For syntaksen for å installere pakken for disse transformatorene bruker vi følgende kommando:







$ pip installere transformatorer

Nå prøver vi å prøve forskjellige eksempler der vi bruker modellene fra Hugging Face-transformatoren til forskjellige språkbehandlingsoppgaver.



Eksempel 1: Tekstgenerering ved å bruke transformatorene for hugging face

Dette eksemplet dekker metoden for å bruke transformatorene for tekstgenerering. For tekstgenerering bruker og importerer vi den ferdigtrente tekstgenereringsmodellen fra transformatoren. Transformatoren har et grunnleggende bibliotek som er kjent som 'rørledninger'. Disse rørledningene fungerer for transformatorer ved å gjøre all nødvendig forhånds- og etterbehandling av dataene som kreves for å bli matet til de forhåndstrente modellene som input.



Vi begynner å kode eksemplet ved først å installere bibliotekpakken til 'transformatorene' i Python-terminalen. For å laste ned transformatorens pakke, bruk 'pip-installasjon med navnet på pakken, dvs. transformator'. Når vi lastet ned og installerte transformatorpakken, går vi videre ved å importere 'pipelines'-pakken fra transformatoren. Rørledningen brukes til å behandle dataene før de mates til modellen.





Vi importerer 'pprint' fra pprint. Denne pakken er installert for å skrive ut utdataene fra tekstgenereringsmodellen i en mer lesbar, strukturert og godt formatert form. Ellers, hvis vi bruker 'print()'-funksjonen, viser den utdataene på en enkelt linje som ikke er godt formatert og lett lesbar. Tekstgenereringsmodellene hjelper til med å generere eller legge til mer tekst til teksten som vi opprinnelig ga til modellen som input.

For å kalle den opplærte modellen fra transformatoren bruker vi pipeline()-funksjonen som har de to parameterne som input. Den første spesifiserer navnet på den valgte oppgaven og den andre er modellens navn fra en transformator. I dette scenariet er den valgte oppgaven tekstgenereringen. Den ferdigtrente modellen som vi bruker fra transformatoren er 'gpt'.



Etter å ha brukt pipeline-funksjonen, bestemmer vi hvilken input vi vil gi til modellen vår for å generere ekstra tekst for den. Deretter sender vi denne inngangen til funksjonen 'task_pipeline()'. Denne funksjonen lager utdata for modellen ved å ta inn input, maksimal lengde på utdata og antall setninger som utdata skal ha som inputparametere.

Vi gir innspillet som 'Dette er en språkmodell'. Vi fikser maksimal lengde på utgangen til '30' og antall setninger i utgangen til '3'. Nå kaller vi bare pprint()-funksjonen for å vise resultatene som er generert fra modellen vår.

!pip installer transformatorer

fra transformatorer import rørledning
fra pprint import pprint

SELECTED_TASK = 'tekstgenerering'
MODELL = 'gpt2'
oppgave = pipeline(f'{SELECTED_TASK}', modell = MODELL)

INPUT = 'Dette er en språkmodell'
OUT_put = oppgave(INPUT, max_length = 30, num_return_sequences=3)

pprint(OUT_put)

Fra den tidligere nevnte kodebiten og utgangen kan vi se at modellen genererer tilleggsinformasjonen/teksten som er relevant for inndataene vi matet til den.

Eksempel 2: Tekstklassifisering ved bruk av rørledninger fra transformatorene

Det forrige eksemplet dekket metoden for å generere tilleggsteksten som er relevant for input ved hjelp av transformatorene og deres pakkerørledninger. Dette eksemplet viser oss hvordan du utfører tekstklassifiseringen med rørledningene. Tekstklassifisering er prosessen med å identifisere input som mates til modellen som medlem av en spesifikk klasse, f.eks. positiv eller negativ.

Vi importerer først rørledningene fra transformatorene. Deretter kaller vi funksjonen 'pipeline()'. Vi overfører modellens navn, som i vårt tilfelle er 'tekstklassifisering' til parameterne. Når modellen er spesifisert ved hjelp av rørledningen, kan vi nå navngi den som 'klassifiserer'. Inntil dette er standardmodellen for tekstklassifiseringen lastet ned til vår vertsmaskin. Nå kan vi bruke denne modellen til oppgaven vår.

Så importer pandaene som 'pd'. Vi ønsker å importere denne pakken fordi vi ønsker å skrive ut output fra modellen i form av DataFrame. Nå spesifiserer vi teksten vi ønsker å gi til modellen vår som input for å klassifisere den som en positiv eller en negativ setning. Vi setter teksten som 'Jeg er en god fyr'. Vi sender denne teksten til classifier()-modellen som vi nettopp opprettet i dette eksemplet og lagrer resultatene i en 'output'-variabel.

For å vise utdata kaller vi prefikset til Pandas, dvs. pd som “.Dataframe()” og sender utdata fra klassifiseringsmodellen til denne funksjonen. Den viser nå resultatene fra klassifiseringsmodellen som vist i følgende utdatabit. Klassifiseringsmodellen vår klassifiserer teksten som den positive klassen.

!pip installer transformatorer
fra transformatorer import rørledning
importer pandaer som pd
classifier = pipeline('tekstklassifisering',modell = 'tekstangrep/distilbert-base-uncased-CoLA')
tekst = 'jeg er en god fyr'
resultat = klassifiserer(tekst)
pprint(resultat)
df = pd.DataFrame(result)

Konklusjon

Denne guiden dekket transformatorarkitekturen fra Hugging Face. Vi diskuterte 'pipeline'-biblioteket fra Hugging Face-transformatoren. Deretter, ved hjelp av dette biblioteket, brukte vi de ferdigtrente transformatormodellene for tekstgenerering og klassifiseringsoppgaver.