Komplett guide för Hugging Face LLM-verktyg

Hugging Face är ett AI-forskningslaboratorium och nav som har byggt en gemenskap av forskare, utvecklare och entusiaster. På kort tid har Hugging Face skaffat sig en betydande närvaro inom AI-området. Stora teknologiföretag som Google (GOOGL ), Amazon (AMZN ) och Nvidia (NVDA ) har investerat betydande belopp i AI-startupen Hugging Face, vilket har gjort dess värdering till 4,5 miljarder dollar.

I den här guiden kommer vi att introducera transformer, LLM och hur Hugging Face-biblioteket spelar en viktig roll i att främja en öppen källkods-AI-gemenskap. Vi kommer också att gå igenom de viktigaste funktionerna i Hugging Face, inklusive pipelines, datamängder, modeller och mer, med praktiska Python-exempel.

Transformer i NLP

År 2017 publicerade Cornell University en inflytelserik artikel som introducerade transformer. Dessa är djupinlärningsmodeller som används i NLP. Denna upptäckt drev utvecklingen av stora språkmodeller som ChatGPT.

Stora språkmodeller eller LLM är AI-system som använder transformer för att förstå och skapa mänskligt språk. Men att skapa dessa modeller är dyrt och kräver ofta miljontals dollar, vilket begränsar deras tillgänglighet till stora företag.

Hugging Face, som startades 2016, syftar till att göra NLP-modeller tillgängliga för alla. Trots att det är ett kommersiellt företag erbjuder det en mängd öppen källkodsresurser som hjälper människor och organisationer att bygga och använda transformer-modeller på ett ekonomiskt sätt. Maskininlärning handlar om att lära datorer att utföra uppgifter genom att känna igen mönster, medan djupinlärning, en underkategori till maskininlärning, skapar ett nätverk som lär sig oberoende. Transformer är en typ av djupinlärningsarkitektur som effektivt och flexibelt använder indata, vilket gör dem till ett populärt val för att bygga stora språkmodeller på grund av lägre krav på utbildningstid.

Hur Hugging underlättar NLP- och LLM-projekt

Hugging Face har gjort det enklare att arbeta med LLM genom att erbjuda:

1. En mängd förtränade modeller att välja mellan.
2. Verktyg och exempel för att finjustera dessa modeller till dina specifika behov.
3. Lätta distributionsalternativ för olika miljöer.

En utmärkt resurs som finns tillgänglig via Hugging Face är Open LLM Leaderboard. Den fungerar som en omfattande plattform som systematiskt övervakar, rankar och utvärderar effektiviteten hos en mängd stora språkmodeller (LLM) och chatbotar, vilket ger en noggrann analys av framstegen inom det öppna källkodsområdet.

LLM-benchmark mäter modeller med hjälp av fyra mått:

• AI2 Reasoning Challenge (25-skott) — en serie frågor om grundläggande vetenskapsämnen.
• HellaSwag (10-skott) — en test av sunt förnuft som, även om den är enkel för människor, utgör en betydande utmaning för avancerade modeller.
• MMLU (5-skott) — en multifacetterad utvärdering som berör en språkmodells förmåga inom 57 olika områden, inklusive grundläggande matematik, juridik och datavetenskap, bland annat.
• TruthfulQA (0-skott) — ett verktyg för att fastställa en modells tendens att upprepa vanligt förekommande felaktig information på internet.

Benchmarkerna, som beskrivs med termer som “25-skott”, “10-skott”, “5-skott” och “0-skott”, anger antalet exempel som en modell får under utvärderingsprocessen för att bedöma dess prestanda och resonemangsförmåga inom olika områden. I “fåskott”-paradigm får modellerna en liten mängd exempel för att vägleda deras svar, medan i en “0-skott”-situation får modellerna inga exempel och måste förlita sig enbart på sin förutbildade kunskap för att svara korrekt.

Komponenter i Hugging

Pipelines

‘Pipelines’ är en del av Hugging Faces transformer-bibliotek, en funktion som underlättar användningen av förtränade modeller som finns i Hugging Faces repository. Den erbjuder en intuitiv API för en mängd uppgifter, inklusive sentimentanalys, frågesvar, maskerad språkmodellering, namngivning av entiteter och sammanfattning.

Pipelines integrerar tre centrala komponenter i Hugging Face:

1. Tokenisator: Förbereder din text för modellen genom att omvandla den till ett format som modellen kan förstå.
2. Modell: Detta är hjärtat i pipelinen där de faktiska förutsägelserna görs baserat på den förbearbetade inmatningen.
3. Postprocessor: Omvandlar modellens råa förutsägelser till en mänskligt läsbar form.

Dessa pipelines minskar inte bara omfattande kodning utan erbjuder också ett användarvänligt gränssnitt för att utföra olika NLP-uppgifter.

Transformer-tillämpningar med Hugging Face-biblioteket

En höjdpunkt i Hugging Face-biblioteket är Transformers-biblioteket, som förenklar NLP-uppgifter genom att koppla en modell med nödvändiga för- och efterbearbetningsstadier, vilket strömlinjeformar analysprocessen. För att installera och importera biblioteket används följande kommandon:

pip install -q transformers
from transformers import pipeline

Efter att ha gjort detta kan du utföra NLP-uppgifter, börjande med sentimentanalys, som kategoriserar text i positiva eller negativa sentiment. Bibliotekets kraftfulla pipeline()-funktion fungerar som en nav för andra pipelines och underlättar uppgiftsspecifika tillämpningar inom ljud-, syn- och multimodala domäner.

Praktiska tillämpningar

Textklassificering

Textklassificering blir enkel med Hugging Faces pipeline()-funktion. Här är hur du kan initiera en textklassificeringspipeline:

classifier = pipeline("text-classification")

För en praktisk upplevelse, mata in en sträng eller en lista med strängar i din pipeline för att få förutsägelser, som kan visualiseras snyggt med Python-biblioteket Pandas. Här är ett Python-utdrag som demonstrerar detta:

sentences = ["Jag är så glad att introducera er till den underbara världen av AI.",
"Hoppas att det inte kommer att besvika er."]

# Få klassificeringsresultat för varje mening i listan
results = classifier(sentences)

# Loopa igenom varje resultat och skriv ut etiketten och poängen
for i, result in enumerate(results):
print(f"Resultat {i + 1}:")
print(f" Etikett: {result['label']}")
print(f" Poäng: {round(result['score'], 3)}\n")

Utdata

Resultat 1:
Etikett: POSITIVT
Poäng: 1.0

Resultat 2:
Etikett: POSITIVT
Poäng: 0.996

Namngivning av entiteter (NER)

NER är avgörande för att extrahera verkliga världens objekt, kallade “namngivna entiteter”, från texten. Använd NER-pipelinen för att identifiera dessa entiteter effektivt:

ner_tagger = pipeline("ner", aggregation_strategy="simple")
text = "Elon Musk är VD för SpaceX."
outputs = ner_tagger(text)
print(outputs)

Utdata

 Elon Musk: PER, SpaceX: ORG 

Frågesvar

Frågesvar innebär att extrahera exakta svar på specifika frågor från en given kontext. Initiera en frågesvars-pipeline och mata in din fråga och kontext för att få det önskade svaret:

reader = pipeline("question-answering")
text = "Hugging Face är ett företag som skapar verktyg för NLP. Det är baserat i New York och grundades 2016."
question = "Var är Hugging Face baserat?"
outputs = reader(question=question, context=text)
print(outputs)

Utdata

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

Hugging Faces pipeline()-funktion erbjuder en mängd förbyggda pipelines för olika uppgifter, förutom textklassificering, NER och frågesvar. Här är information om en del av de tillgängliga uppgifterna:

Tabell: Hugging Face-pipeline-uppgifter

För detaljerade beskrivningar och fler uppgifter, se pipeline-dokumentationen på Hugging Faces webbplats.

Varför Hugging flyttar fokus till Rust

Hugging Face Safetensors och tokenisator GitHub-sida

Hugging Face (HF)-ekosystemet började använda Rust i sina bibliotek, såsom safetensors och tokenisatorer.

Hugging Face har nyligen släppt ett nytt maskinlärningsramverk som kallas Candle. Till skillnad från traditionella ramverk som använder Python, är Candle byggt med Rust. Målet med att använda Rust är att förbättra prestanda och förenkla användarupplevelsen samtidigt som det stöder GPU-åtgärder.

Candles huvudmål är att möjliggöra serverlös inferens, vilket gör det möjligt att distribuera lätta binärfiler och ta bort Python från produktionsarbetsflöden, som ibland kan sakta ner processer på grund av sina overhead-kostnader. Detta ramverk kommer som en lösning för att övervinna problemen som uppstår med fullständiga maskinlärningsramverk som PyTorch, som är stora och långsamma när de skapas på en kluster.

Låt oss undersöka varför Rust blir ett alltmer populärt val.

1. Hastighet och prestanda – Rust är känt för sin otroliga hastighet, som överträffar Python, som traditionellt används i maskinlärningsramverk. Pythons prestanda kan ibland bromsas på grund av dess Global Interpreter Lock (GIL), men Rust har inte detta problem, vilket lovar snabbare körning av uppgifter och förbättrad prestanda i projekt där det implementeras.
2. Säkerhet – Rust erbjuder minnesäkerhetsgarantier utan en soptömme, ett aspekt som är avgörande för att säkerställa säkerheten i samtidiga system. Detta spelar en avgörande roll i områden som safetensors, där säkerhet vid hantering av datastrukturer är en prioritet.

Safetensors

Safetensors dra nytta av Rusts hastighet och säkerhetsfunktioner. Safetensors handlar om manipulation av tensorer, en komplex matematisk enhet, och att ha Rust säkerställer att operationerna inte bara är snabba utan också säkra, undviker vanliga buggar och säkerhetsproblem som kan uppstå på grund av felhantering av minne.

Tokenisator

Tokenisatorer hanterar nedbrytning av meningar eller fraser till mindre enheter, såsom ord eller termer. Rust hjälper till i denna process genom att påskynda exekveringstiden, vilket säkerställer att tokeniseringsprocessen inte bara är exakt utan också snabb, förbättrar effektiviteten i naturligt språkbehandling.

I hjärtat av Hugging Faces tokenisator ligger konceptet subword-tokenisering, som balanserar mellan ord- och teckennivå-tokenisering för att optimera informationsbevarande och ordförrådsstorlek. Det fungerar genom att skapa subtokens, såsom “##ing” och “##ed”, som bevarar semantisk rikedom samtidigt som de undviker ett överbelastat ordförråd.

Subword-tokenisering innefattar en utbildningsfas för att identifiera den mest effektiva balansen mellan tecken- och ordnivå-tokenisering. Det går utöver enkla prefix- och suffixregler och kräver en omfattande analys av språkmönster i stora textkorpus för att utforma en effektiv subword-tokenisator. Den genererade tokenisatorn är skicklig på att hantera nya ord genom att bryta ner dem i kända subwords, vilket upprätthåller en hög nivå av semantisk förståelse.

Tokeniseringskomponenter

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

Tokenisator-biblioteket delar upp tokeniseringsprocessen i flera steg, var och en som hanterar en särskild aspekt av tokenisering. Låt oss dyka in i dessa komponenter:

• Normalisator: Tar initiala transformationer på inmatningssträngen, applicerar nödvändiga justeringar som till exempel omvandling till gemener, Unicode-normalisering och avlägsnande.
• Förtokenisator: Ansvarig för att dela in inmatningssträngen i fördelar, bestämmer delarna baserat på fördefinierade regler, såsom utrymmesavgränsningar.
• Modell: Övervakar upptäckten och skapandet av subtokens, anpassar sig till specifikationerna för din indata och erbjuder utbildningsförmåga.
• Postprocessor: Förbättrar konstruktionsfunktioner för att möjliggöra kompatibilitet med många transformer-baserade modeller, som BERT, genom att lägga till token som [CLS] och [SEP].

För att komma igång med Hugging Face-tokenisatorer, installera biblioteket med kommandot pip install tokenizers och importera det i din Python-miljö. Biblioteket kan tokenisera stora mängder text på mycket kort tid, vilket sparar värdefulla beräkningsresurser för mer krävande uppgifter som modellutbildning.

Tokenisator-biblioteket använder Rust, som ärver C++:s syntaktiska likhet medan den introducerar nya koncept i programspråksdesign. I kombination med Python-bindningar säkerställer det att du kan njuta av prestandan hos ett lägre nivåspråk medan du arbetar i en Python-miljö.

Datamängder

Hugging Face-datamängder

Datamängder är grunden för AI-projekt. Hugging Face erbjuder en mängd olika datamängder, lämpliga för en rad NLP-uppgifter och mer. För att använda dem effektivt är det viktigt att förstå processen för att ladda och analysera dem. Här är ett välkommenterat Python-skript som visar hur man kan utforska datamängder som finns tillgängliga på Hugging Face:

from datasets import load_dataset
# Ladda en datamängd
dataset = load_dataset('squad')
# Visa den första posten
print(dataset[0])

Detta skript använder load_dataset-funktionen för att ladda SQuAD-datamängden, som är ett populärt val för frågesvarsuppgifter.

Användning av förtränade modeller och att föra allt samman

Hugging Face-modeller

Förtränade modeller utgör ryggraden i många djupinlärningsprojekt, vilket möjliggör för forskare och utvecklare att starta sina initiativ utan att börja från scratch. Hugging Face underlättar utforskningen av en mångfald förtränade modeller, som visas i koden nedan:

from transformers import AutoModelForQuestionAnswering, AutoTokenizer

# Ladda den förtränade modellen och tokenisatorn
model = AutoModelForQuestionAnswering.from_pretrained('bert-large-uncased-whole-word-masking-finetuned-squad')
tokenizer = AutoTokenizer.from_pretrained('bert-large-uncased-whole-word-masking-finetuned-squad')

# Visa modellens arkitektur
print(model)

Med modellen och tokenisatorn laddade kan vi nu skapa en funktion som tar en text och en fråga som indata och returnerar svaret som extraheras från texten. Vi kommer att använda tokenisatorn för att bearbeta indata-texten och frågan till ett format som är kompatibelt med modellen, och sedan mata in detta bearbetade indata i modellen för att få svaret:

def get_answer(text, question):
# Tokenisera indata-texten och frågan
inputs = tokenizer(question, text, return_tensors='pt', max_length=512, truncation=True)
outputs = model(**inputs)

# Få start- och slutpoäng för svaret
answer_start = torch.argmax(outputs.start_logits)
answer_end = torch.argmax(outputs.end_logits) + 1

answer = tokenizer.convert_tokens_to_string(tokenizer.convert_ids_to_tokens(inputs['input_ids'][0][answer_start:answer_end]))
return answer

I kodavsnittet importerar vi nödvändiga moduler från transformers-paketet, laddar sedan en förtränad modell och dess motsvarande tokenisator med from_pretrained-metoden. Vi väljer en BERT-modell som är finjusterad på SQuAD-datamängden.

Låt oss se ett exempel på hur man använder denna funktion där vi har en text och vill extrahera ett specifikt svar på en fråga från den:

text = """
The Eiffel Tower, located in Paris, France, is one of the most iconic landmarks in the world. It was designed by Gustave Eiffel and completed in 1889. The tower stands at a height of 324 meters and was the tallest man-made structure in the world at the time of its completion.
"""

question = "Vem designade Eiffeltornet?"

# Få svaret på frågan
answer = get_answer(text, question)
print(f"SVaret på frågan är: {answer}")
# Utdata: SVaret på frågan är: Gustave Eiffel

I detta skript bygger vi en get_answer-funktion som tar en text och en fråga, tokeniserar dem lämpligt och använder den förtränade BERT-modellen för att extrahera svaret från texten. Det demonstrerar en praktisk tillämpning av Hugging Faces transformers-bibliotek för att bygga ett enkelt men kraftfullt frågesvarssystem. För att förstå koncepten väl rekommenderas det att ha en praktisk experiment med en Google Colab Notebook.

Slutsats

Genom sin omfattande samling av öppen källkodsverktyg, förtränade modeller och användarvänliga pipelines, möjliggör Hugging Face både erfarna proffs och nybörjare att dyka in i den expansiva världen av AI med en känsla av lätthet och förståelse. Dessutom understryker initiativet att integrera Rust, på grund av dess hastighets- och säkerhetsfunktioner, Hugging Faces åtagande att främja innovation samtidigt som det säkerställer effektivitet och säkerhet i AI-tillämpningar. Det omvandlande arbetet med Hugging Face inte bara demokratiserar tillgången till avancerade AI-verktyg utan skapar också en samarbetsmiljö för lärande och utveckling inom AI-området, vilket möjliggör en framtid där AI är tillgängligt för alla.