Kraftige sprogmodeller + Scikit-learn = Scikit-LLM. Udfør tekstanalyseopgaver på farten ved hjælp af dette bibliotek.
Scikit-LLM er en Python-pakke, der hjælper med at integrere store sprogmodeller (LLM'er) i scikit-learn-rammen. Det hjælper med at udføre tekstanalyseopgaver. Hvis du er fortrolig med scikit-learn, vil det være lettere for dig at arbejde med Scikit-LLM.
Det er vigtigt at bemærke, at Scikit-LLM ikke erstatter scikit-learn. scikit-learn er et maskinlæringsbibliotek til generelle formål, men Scikit-LLM er specielt designet til tekstanalyseopgaver.
Kom godt i gang med Scikit-LLM
Til at komme i gang med Scikit-LLM, skal du installere biblioteket og konfigurere din API-nøgle. For at installere biblioteket skal du åbne din IDE og skabe et nyt virtuelt miljø. Dette vil hjælpe med at forhindre potentielle biblioteksversionskonflikter. Kør derefter følgende kommando i terminalen.
pip install scikit-llm
Denne kommando vil installere Scikit-LLM og dets nødvendige afhængigheder.
For at konfigurere din API-nøgle skal du anskaffe en fra din LLM-udbyder. Følg disse trin for at få OpenAI API-nøglen:
Fortsæt til OpenAI API-side. Klik derefter på din profil i øverste højre hjørne af vinduet. Vælg Se API-nøgler. Dette vil tage dig til API nøgler side.
På den API nøgler side, klik på Opret ny hemmelig nøgle knap.
Navngiv din API-nøgle og klik på Opret hemmelig nøgle knappen for at generere nøglen. Efter generering skal du kopiere nøglen og opbevare den et sikkert sted, da OpenAI ikke vil vise nøglen igen. Hvis du mister den, bliver du nødt til at generere en ny.
Den fulde kildekode er tilgængelig i en GitHub-depot.
Nu hvor du har din API-nøgle, skal du åbne din IDE og importere SKLLMConfig klasse fra Scikit-LLM biblioteket. Denne klasse giver dig mulighed for at indstille konfigurationsmuligheder relateret til brugen af store sprogmodeller.
from skllm.config import SKLLMConfig
Denne klasse forventer, at du indstiller din OpenAI API-nøgle og organisationsdetaljer.
# Set your OpenAI API key
SKLLMConfig.set_openai_key("Your API key")
# Set your OpenAI organization
SKLLMConfig.set_openai_org("Your organization ID")Organisations-id'et og navnet er ikke det samme. Organisations-id er en unik identifikator for din organisation. For at få dit organisations-id skal du fortsætte til OpenAI organisation indstillingssiden og kopier den. Du har nu etableret en forbindelse mellem Scikit-LLM og den store sprogmodel.
Scikit-LLM kræver, at du har en pay-as-you-go-plan. Dette skyldes, at den gratis prøveversion af OpenAI-kontoen har en hastighedsgrænse på tre anmodninger i minuttet, hvilket ikke er tilstrækkeligt for Scikit-LLM.
At prøve at bruge den gratis prøvekonto vil føre til en fejl svarende til den nedenfor, mens du udfører tekstanalyse.
For at lære mere om satsgrænser. Fortsæt til OpenAI rate grænser side.
LLM-udbyderen er ikke begrænset til kun OpenAI. Du kan også bruge andre LLM-udbydere.
Import af de nødvendige biblioteker og indlæsning af datasættet
Importer pandaer, som du vil bruge til at indlæse datasættet. Importer også de påkrævede klasser fra Scikit-LLM og scikit-learn.
import pandas as pd
from skllm import ZeroShotGPTClassifier, MultiLabelZeroShotGPTClassifier
from skllm.preprocessing import GPTSummarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.preprocessing import MultiLabelBinarizer
Indlæs derefter det datasæt, du vil udføre tekstanalyse på. Denne kode bruger IMDB-filmdatasættet. Du kan dog tilpasse det til at bruge dit eget datasæt.
# Load your dataset
data = pd.read_csv("imdb_movies_dataset.csv")
# Extract the first 100 rows
data = data.head(100)Det er ikke obligatorisk at bruge kun de første 100 rækker af datasættet. Du kan bruge hele dit datasæt.
Udtræk derefter funktionerne og etiketkolonnerne. Opdel derefter dit datasæt i tog- og testsæt.
# Extract relevant columns
X = data['Description']
# Assuming 'Genre' contains the labels for classification
y = data['Genre']
# Split the dataset into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
Det Genre kolonnen indeholder de etiketter, du vil forudsige.
Zero-Shot tekstklassificering med Scikit-LLM
Zero-shot tekstklassificering er en funktion, der tilbydes af store sprogmodeller. Den klassificerer tekst i foruddefinerede kategorier uden behov for eksplicit træning i mærkede data. Denne funktion er meget nyttig, når du skal håndtere opgaver, hvor du skal klassificere tekst i kategorier, du ikke havde forudset under modeltræning.
For at udføre nul-shot-tekstklassificering ved hjælp af Scikit-LLM, skal du bruge ZeroShotGPTClassifier klasse.
# Perform Zero-Shot Text Classification
zero_shot_clf = ZeroShotGPTClassifier(openai_model="gpt-3.5-turbo")
zero_shot_clf.fit(X_train, y_train)
zero_shot_predictions = zero_shot_clf.predict(X_test)
# Print Zero-Shot Text Classification Report
print("Zero-Shot Text Classification Report:")
print(classification_report(y_test, zero_shot_predictions))
Udgangen er som følger:
Klassificeringsrapporten indeholder metrics for hver etiket, som modellen forsøger at forudsige.
Multi-Label Zero-Shot tekstklassificering med Scikit-LLM
I nogle scenarier kan en enkelt tekst tilhøre flere kategorier samtidigt. Traditionelle klassifikationsmodeller kæmper med dette. Scikit-LLM på den anden side gør denne klassificering mulig. Multi-label zero-shot tekstklassificering er afgørende for at tildele flere beskrivende etiketter til en enkelt teksteksempel.
Brug MultiLabelZeroShotGPTClassifier at forudsige, hvilke etiketter der er passende for hver teksteksempel.
# Perform Multi-Label Zero-Shot Text Classification
# Make sure to provide a list of candidate labels
candidate_labels = ["Action", "Comedy", "Drama", "Horror", "Sci-Fi"]
multi_label_zero_shot_clf = MultiLabelZeroShotGPTClassifier(max_labels=2)
multi_label_zero_shot_clf.fit(X_train, candidate_labels)
multi_label_zero_shot_predictions = multi_label_zero_shot_clf.predict(X_test)# Convert the labels to binary array format using MultiLabelBinarizer
mlb = MultiLabelBinarizer()
y_test_binary = mlb.fit_transform(y_test)
multi_label_zero_shot_predictions_binary = mlb.transform(multi_label_zero_shot_predictions)
# Print Multi-Label Zero-Shot Text Classification Report
print("Multi-Label Zero-Shot Text Classification Report:")
print(classification_report(y_test_binary, multi_label_zero_shot_predictions_binary))
I koden ovenfor definerer du de kandidatetiketter, som din tekst kan høre til.
Udgangen er som vist nedenfor:
Denne rapport hjælper dig med at forstå, hvor godt din model klarer sig for hver etiket i multi-label-klassificering.
Tekstvektorisering med Scikit-LLM
I tekstvektorisering konverteres tekstdata til et numerisk format, som maskinlæringsmodeller kan forstå. Scikit-LLM tilbyder GPTVectorizer til dette. Det giver dig mulighed for at transformere tekst til vektorer med fast dimension ved hjælp af GPT-modeller.
Du kan opnå dette ved at bruge Term Frequency-Inverse Document Frequency.
# Perform Text Vectorization using TF-IDF
tfidf_vectorizer = TfidfVectorizer(max_features=1000)
X_train_tfidf = tfidf_vectorizer.fit_transform(X_train)
X_test_tfidf = tfidf_vectorizer.transform(X_test)
# Print the TF-IDF vectorized features for the first few samples
print("TF-IDF Vectorized Features (First 5 samples):")
print(X_train_tfidf[:5]) # Change to X_test_tfidf if you want to print the test set
Her er outputtet:
Outputtet repræsenterer de TF-IDF vektoriserede funktioner for de første 5 prøver i datasættet.
Tekstopsummering med Scikit-LLM
Tekstopsummering hjælper med at kondensere et stykke tekst, mens dens mest kritiske information bevares. Scikit-LLM tilbyder GPTSummarizer, som bruger GPT-modellerne at generere kortfattede tekstresuméer.
# Perform Text Summarization
summarizer = GPTSummarizer(openai_model="gpt-3.5-turbo", max_words=15)
summaries = summarizer.fit_transform(X_test)
print(summaries)
Udgangen er som følger:
Ovenstående er et resumé af testdataene.
Byg applikationer oven på LLM'er
Scikit-LLM åbner op for en verden af muligheder for tekstanalyse med store sprogmodeller. At forstå teknologien bag store sprogmodeller er afgørende. Det vil hjælpe dig med at forstå deres styrker og svagheder, som kan hjælpe dig med at bygge effektive applikationer oven på denne banebrydende teknologi.
