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.
Innehållsförteckning
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 sidan för API-nycklar.
På sidan för API-nycklar klickar du på knappen Skapa ny hemlig nyckel.
Namnge din API-nyckel och klicka på knappen Skapa hemlig nyckel för att skapa 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.
Nu när du har din API-nyckel, öppna din IDE och importera SKLLMConfig-klassen 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.
SKLLMConfig.set_openai_key("Your API key")
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.
data = pd.read_csv("imdb_movies_dataset.csv")
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.
X = data['Description']y = data['Genre']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
Kolumnen Genre 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-klassen.
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(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änd MultiLabelZeroShotGPTClassifier för att förutsäga vilka etiketter som är lämpliga för varje textexempel.
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)
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(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 Frequency-Inverse Document Frequency.
tfidf_vectorizer = TfidfVectorizer(max_features=1000)
X_train_tfidf = tfidf_vectorizer.fit_transform(X_train)
X_test_tfidf = tfidf_vectorizer.transform(X_test)
print("TF-IDF Vectorized Features (First 5 samples):")
print(X_train_tfidf[:5])
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 generera kortfattade sammanfattningar av text.
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.