Hur man använder Scikit-LLM för textanalys med stora språkmodeller

Scikit-LLM är ett Python-paket som hjälper till att integrera stora språkmodeller (LLM) i scikit-learn-ramverket. Det hjälper till att utföra textanalysuppgifter. Om du är bekant med scikit-learn blir det lättare för dig att arbeta med Scikit-LLM.

Det är viktigt att notera att Scikit-LLM inte ersätter scikit-learn. scikit-learn är ett allmänt maskininlärningsbibliotek men Scikit-LLM är speciellt utformat för textanalysuppgifter.

Komma igång med Scikit-LLM

Att komma igång med Scikit-LLMmåste du installera biblioteket och konfigurera din API-nyckel. För att installera biblioteket, öppna din IDE och skapa en ny virtuell miljö. Detta kommer att hjälpa till att förhindra eventuella konflikter med biblioteksversioner. Kör sedan följande kommando i terminalen.

pip install scikit-llm 

Detta kommando kommer att installera Scikit-LLM och dess nödvändiga beroenden.

För att konfigurera din API-nyckel måste du skaffa en från din LLM-leverantör. Följ dessa steg för att få OpenAI API-nyckeln:

Fortsätt till OpenAI API-sida. Klicka sedan på din profil i det övre högra hörnet av fönstret. Välj Visa API-nycklar. Detta tar dig till API-nycklar sida.

På API-nycklar sida, klicka på Skapa ny hemlig nyckel knapp.

Namnge din API-nyckel och klicka på Skapa hemlig nyckel knappen för att generera nyckeln. Efter generering måste du kopiera nyckeln och förvara den på ett säkert ställe eftersom OpenAI inte kommer att visa nyckeln igen. Om du tappar bort den måste du skapa en ny.

Den fullständiga källkoden finns tillgänglig i en GitHub-förråd.

Nu när du har din API-nyckel, öppna din IDE och importera SKLLMConfig klass från Scikit-LLM-biblioteket. Denna klass låter dig ställa in konfigurationsalternativ relaterade till användningen av stora språkmodeller.

from skllm.config import SKLLMConfig

Den här klassen förväntar sig att du ställer in din OpenAI API-nyckel och organisationsinformation.

# 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 och namn är inte samma. Organisations-ID är en unik identifierare för din organisation. För att få ditt organisations-ID, fortsätt till OpenAI-organisation inställningssidan och kopiera den. Du har nu etablerat en koppling mellan Scikit-LLM och den stora språkmodellen.

Scikit-LLM kräver att du har en pay-as-you-go-plan. Detta beror på att det kostnadsfria provversionen av OpenAI-kontot har en hastighetsgräns på tre förfrågningar per minut, vilket inte är tillräckligt för Scikit-LLM.

Att försöka använda det kostnadsfria testkontot kommer att leda till ett fel som liknar det nedan när du utför textanalys.

För att lära dig mer om räntegränser. Fortsätt till Sidan med OpenAI-hastighetsgränser.

LLM-leverantören är inte begränsad till endast OpenAI. Du kan också använda andra LLM-leverantörer.

Importera de obligatoriska biblioteken och ladda datamängden

Importera pandor som du ska använda för att ladda datamängden. Importera också de obligatoriska klasserna från Scikit-LLM och 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 

Ladda sedan in den datauppsättning du vill utföra textanalys på. Den här koden använder datauppsättningen IMDB-filmer. Du kan dock justera den för att använda din egen datauppsättning.

# Load your dataset
data = pd.read_csv("imdb_movies_dataset.csv")
# Extract the first 100 rows
data = data.head(100)

Att endast använda de första 100 raderna i datamängden är inte obligatoriskt. Du kan använda hela din datauppsättning.

Extrahera sedan funktionerna och etikettkolumnerna. Dela sedan upp din datauppsättning i tåg- och testset.

# 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)

De Genre kolumnen innehåller de etiketter du vill förutsäga.

Zero-Shot textklassificering med Scikit-LLM

Zero-shot textklassificering är en funktion som erbjuds av stora språkmodeller. Den klassificerar text i fördefinierade kategorier utan behov av explicit utbildning om märkta data. Denna funktion är mycket användbar när du hanterar uppgifter där du behöver klassificera text i kategorier som du inte förutsåg under modellutbildningen.

För att utföra nollbildstextklassificering med Scikit-LLM, använd ZeroShotGPTClassifier klass.

# 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))

Utgången är som följer:

Klassificeringsrapporten tillhandahåller mätvärden för varje etikett som modellen försöker förutsäga.

Multi-Label Zero-Shot textklassificering med Scikit-LLM

I vissa scenarier kan en enskild text tillhöra flera kategorier samtidigt. Traditionella klassificeringsmodeller kämpar med detta. Scikit-LLM å andra sidan gör denna klassificering möjlig. Textklassificering med flera etiketter är avgörande för att tilldela flera beskrivande etiketter till ett enda textexempel.

Använda sig av MultiLabelZeroShotGPTClassifier för att förutsäga vilka etiketter som är lämpliga för varje textexempel.

# 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 ovan definierar du de kandidatetiketter som din text kan tillhöra.

Utgången är som visas nedan:

Den här rapporten hjälper dig att förstå hur bra din modell presterar för varje etikett i fleretikettsklassificering.

Textvektorisering med Scikit-LLM

I textvektorisering omvandlas textdata till ett numeriskt format som maskininlärningsmodeller kan förstå. Scikit-LLM erbjuder GPTVectorizer för detta. Det låter dig omvandla text till vektorer med fast dimension med hjälp av GPT-modeller.

Du kan uppnå detta med termen Frekvens-invers dokumentfrekvens.

# 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

Här är utgången:

Utdata representerar de TF-IDF vektoriserade funktionerna för de första 5 proverna i datamängden.

Textsammanfattning med Scikit-LLM

Textsammanfattning hjälper till att kondensera ett stycke text samtidigt som den mest kritiska informationen bevaras. Scikit-LLM erbjuder GPTSummarizer, som använder GPT-modellerna för att skapa kortfattade textsammanfattningar.

# Perform Text Summarization
summarizer = GPTSummarizer(openai_model="gpt-3.5-turbo", max_words=15)
summaries = summarizer.fit_transform(X_test)
print(summaries)

Utgången är som följer:

Ovanstående är en sammanfattning av testdata.

Bygg applikationer ovanpå LLM

Scikit-LLM öppnar upp en värld av möjligheter för textanalys med stora språkmodeller. Att förstå tekniken bakom stora språkmodeller är avgörande. Det hjälper dig att förstå deras styrkor och svagheter som kan hjälpa dig att bygga effektiva applikationer ovanpå denna banbrytande teknik.