วิธีใช้ Scikit-LLM สำหรับการวิเคราะห์ข้อความด้วยโมเดลภาษาขนาดใหญ่
Scikit-LLM เป็นแพ็คเกจ Python ที่ช่วยผสานรวมโมเดลภาษาขนาดใหญ่ (LLM) เข้ากับเฟรมเวิร์ก scikit-Learn ช่วยในการทำงานวิเคราะห์ข้อความให้สำเร็จ หากคุณคุ้นเคยกับ scikit-learn คุณจะทำงานกับ Scikit-LLM ได้ง่ายขึ้น
ควรรับทราบว่า Scikit-LLM และ scikit-learn มีจุดประสงค์ที่แตกต่างกัน โดยแบบแรกได้รับการปรับแต่งให้เหมาะกับงานวิเคราะห์ข้อความ ในขณะที่แบบหลังทำหน้าที่เป็นไลบรารีการเรียนรู้ของเครื่องสำหรับวัตถุประสงค์ทั่วไปที่ครอบคลุมมากกว่า
เริ่มต้นใช้งาน Scikit-LLM
หากต้องการเริ่มต้นใช้งาน Scikit-LLM คุณจะต้องติดตั้งไลบรารีและกำหนดค่าคีย์ API ของคุณ หากต้องการติดตั้งไลบรารี ให้เปิด IDE ของคุณและสร้างสภาพแวดล้อมเสมือนใหม่ ซึ่งจะช่วยป้องกันความขัดแย้งของเวอร์ชันไลบรารีที่อาจเกิดขึ้น จากนั้นรันคำสั่งต่อไปนี้ในเทอร์มินัล
pip install scikit-llm
การดำเนินการตามคำสั่งนี้จะอำนวยความสะดวกในการติดตั้ง Scikit-LLM พร้อมด้วยข้อกำหนดเบื้องต้นที่จำเป็นทั้งหมด
ในการตั้งค่าคีย์ API ของคุณสำหรับผู้ให้บริการ Large Language Model (LLM) คุณจำเป็นต้องจัดหาจากผู้ให้บริการเหล่านั้น สำหรับผู้ที่กำลังมองหาคีย์ OpenAI API โปรดปฏิบัติตามกระบวนการต่อไปนี้:
ไปที่ หน้า OpenAI API จากนั้นคลิกที่โปรไฟล์ของคุณที่มุมขวาบนของหน้าต่าง เลือก ดูคีย์ API สิ่งนี้จะนำคุณไปยังหน้าคีย์ API
หากต้องการเข้าถึงหน้าคีย์ API และสร้างคีย์ลับใหม่ โปรดทำตามขั้นตอนเหล่านี้ในลักษณะที่ซับซ้อน:1. นำทางไปยังหน้าเว็บที่กำหนดซึ่งมีการจัดการคีย์ API ภายในแดชบอร์ดหรือแผงควบคุมของแอปพลิเคชันของคุณ สามารถเข้าถึงได้ผ่านเมนูหลักภายใต้"การตั้งค่า"หรือ"การรวมระบบ"2. เมื่อคุณเข้าถึงหน้าที่เหมาะสมแล้ว ให้ค้นหาส่วนที่เกี่ยวข้องกับการจัดการคีย์ API ของคุณ อาจตั้งอยู่ใกล้ด้านบนของหน้าหรือแสดงเป็นตัวเลือกภายในเมนูแบบเลื่อนลง3. ในส่วนนี้ ให้มองหาปุ่มที่โดดเด่นซึ่งมีข้อความว่า"สร้างคีย์ลับใหม่"ซึ่งจะเริ่มต้นกระบวนการสร้างคีย์ API ใหม่ หรือหากไม่มีปุ่มดังกล่าว ให้ค้นหาคำแนะนำหรือคำแนะนำอื่นๆ ที่อาจแนะนำคุณ
โปรดสร้างคีย์ API โดยคลิกที่ปุ่ม"สร้างคีย์ลับ"เพื่อสร้างข้อมูลประจำตัวที่จำเป็น สิ่งสำคัญคือคุณจะต้องบันทึกข้อมูลนี้อย่างปลอดภัย เนื่องจาก Open AI ไม่มีตัวเลือกในการเรียกคืนในภายหลัง ในกรณีที่คุณวางคีย์ผิด คุณต้องสร้างคีย์ใหม่แทน
สามารถเข้าถึงซอร์สโค้ดฉบับสมบูรณ์ได้ผ่านทางพื้นที่เก็บข้อมูล aGitHub ซึ่งให้การเข้าถึงและแบ่งปันความสามารถที่ง่ายดายสำหรับนักพัฒนาเพื่อทำงานร่วมกันในโครงการต่างๆ และมีส่วนร่วมในความพยายามในการพัฒนาซอฟต์แวร์โอเพ่นซอร์ส
เมื่อคุณได้รับคีย์ API แล้ว ให้ไปที่ Integrated Development Environment (IDE) ที่คุณต้องการ และรวมโมดูล SKLLMConfig ไว้ในไลบรารี Scikit-LLM การบูรณาการนี้ช่วยให้สามารถจัดการพารามิเตอร์ที่กำหนดค่าได้ซึ่งเกี่ยวข้องกับการใช้แบบจำลองทางภาษาที่กว้างขวาง
from skllm.config import SKLLMConfig
โปรดตรวจสอบให้แน่ใจว่าคุณได้ระบุคีย์ Open AI API และข้อมูลองค์กรที่เกี่ยวข้องสำหรับหลักสูตรนี้ เนื่องจากเป็นข้อกำหนดเบื้องต้นสำหรับการสำเร็จหลักสูตร
# Set your OpenAI API key
SKLLMConfig.set_openai_key("Your API key")
# Set your OpenAI organization
SKLLMConfig.set_openai_org("Your organization ID")
รหัสองค์กรและชื่อไม่เหมือนกัน รหัสองค์กรคือตัวระบุเฉพาะขององค์กรของคุณ หากต้องการรับรหัสองค์กร ให้ไปที่หน้าการตั้งค่า องค์กร OpenAI แล้วคัดลอก ตอนนี้คุณได้สร้างการเชื่อมต่อระหว่าง Scikit-LLM และโมเดลภาษาขนาดใหญ่แล้ว
Scikit-LLM จำเป็นต้องสมัครสมาชิกบริการแบบจ่ายตามการใช้งาน เนื่องจากโควต้าที่จำกัดที่กำหนดโดยบัญชี OpenAI ฟรี โดยมีข้อจำกัดสามคำขอต่อนาที นั้นไม่เพียงพอสำหรับประสิทธิภาพสูงสุดกับ Scikit-LLM
การใช้บัญชีทดลองใช้งานฟรีอาจส่งผลให้เกิดข้อผิดพลาดที่เทียบเท่ากับข้อความต่อไปนี้เมื่อพยายามวิเคราะห์ข้อความ
หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการจำกัดอัตรา ดำเนินการต่อไปที่ หน้าการจำกัดอัตรา OpenAI
การใช้แพลตฟอร์ม LLM นอกเหนือไปจากการพึ่งพา Open AI แต่เพียงผู้เดียว มีผู้ให้บริการ LLM ทางเลือกอื่นที่อาจพิจารณาตามความต้องการของคุณ
การนำเข้าไลบรารีที่จำเป็นและการโหลดชุดข้อมูล
ใช้ไลบรารี pandas เพื่อเข้าถึงและประมวลผลชุดข้อมูล นอกจากนี้ ให้นำเข้าคลาสที่จำเป็นจากทั้งไลบรารี Scikit-LLM และ 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
ในการเริ่มต้น ให้นำเข้าและโหลดชุดข้อมูลที่คุณต้องการวิเคราะห์สำหรับเนื้อหาที่เป็นข้อความ ในตัวอย่างนี้ เราจะใช้ฐานข้อมูลภาพยนตร์ IMDB เป็นข้อมูลอ้างอิง อย่างไรก็ตาม คุณสามารถปรับเปลี่ยนให้รวมชุดข้อมูลที่คุณต้องการได้
# Load your dataset
data = pd.read_csv("imdb_movies_dataset.csv")
# Extract the first 100 rows
data = data.head(100)
คุณมีตัวเลือกในการใช้ข้อมูลทั้งหมดในชุดข้อมูลของคุณ แทนที่จะจำกัดเพียง 100 แถวเริ่มต้น
ต่อไป เราจะดำเนินการแยกคอลัมน์คุณลักษณะและป้ายกำกับออกจากชุดข้อมูลของเรา ตามด้วยการแยกออกเป็นชุดการฝึกและชุดการทดสอบสำหรับการวิเคราะห์เพิ่มเติม
# 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)
หมวดหมู่การจำแนกประเภทประกอบด้วยการกำหนดที่มีไว้เพื่อการทำนาย ซึ่งแสดงด้วยคำว่า"ประเภท"ในบริบทนี้
การจำแนกข้อความแบบ Zero-Shot ด้วย Scikit-LLM
โมเดลภาษาขนาดใหญ่มีความสามารถในการจำแนกข้อความแบบ Zero-shot ซึ่งเกี่ยวข้องกับการจัดหมวดหมู่ข้อมูลที่ไม่มีป้ายกำกับเป็นคลาสที่กำหนดไว้ล่วงหน้า โดยไม่ต้องมีการฝึกอบรมเกี่ยวกับข้อมูลที่ติดป้ายกำกับล่วงหน้า แนวทางนี้พิสูจน์ให้เห็นถึงข้อได้เปรียบโดยเฉพาะอย่างยิ่งในสถานการณ์ที่เกี่ยวข้องกับการจัดประเภทข้อความเป็นหมวดหมู่ที่ไม่ได้กำหนด นอกเหนือจากที่พิจารณาในระหว่างขั้นตอนการพัฒนาแบบจำลอง
เพื่อดำเนินงานการจัดหมวดหมู่ข้อความแบบ Zero-shot โดยใช้ Scikit-LLM คุณอาจใช้คลาส ZeroShotGPTClassifier
# 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))
ผลลัพธ์จะเป็นดังนี้:
รายงานการจำแนกประเภทนำเสนอการวัดเชิงปริมาณที่เกี่ยวข้องกับฉลากแต่ละอันที่แบบจำลองพยายามจัดประเภท
การจำแนกข้อความ Zero-Shot แบบหลายป้ายกำกับด้วย Scikit-LLM
ในบางสถานการณ์ ไม่ใช่เรื่องแปลกที่ข้อความบางชิ้นจะจัดอยู่ในหมวดหมู่มากกว่าหนึ่งหมวดหมู่ในคราวเดียว วิธีการจำแนกประเภทแบบทั่วไปไม่พร้อมสำหรับการจัดการกรณีดังกล่าวอย่างมีประสิทธิภาพ อย่างไรก็ตาม ด้วยความสามารถขั้นสูง Scikit-LLM ได้แสดงให้เห็นถึงความเชี่ยวชาญที่โดดเด่นในการจัดการกับความซับซ้อนเหล่านี้ โดยเปิดใช้งานการจัดหมวดหมู่ข้อความแบบ Zero-shot แบบหลายป้ายกำกับ วิธีการนี้เกี่ยวข้องกับการติดป้ายคำอธิบายหลายป้ายให้กับตัวอย่างข้อความเดี่ยว ซึ่งมีความสำคัญอย่างยิ่งในการจับและจัดหมวดหมู่ข้อมูลภายในโดเมนที่หลากหลายอย่างแม่นยำ
ใช้ MultiLabelZeroShotGPTClassifier เพื่อตรวจสอบว่าป้ายกำกับใดใช้ได้กับข้อความที่ตัดตอนมาแต่ละรายการ
# 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))
ข้างต้น เรากำหนดศักยภาพของข้อความที่เราสามารถกำหนดให้เป็นคู่แข่งได้
ผลลัพธ์มีดังต่อไปนี้:
เอกสารปัจจุบันทำหน้าที่ให้ความกระจ่างถึงประสิทธิภาพของแบบจำลองของคุณกับป้ายกำกับต่างๆ ในสถานการณ์การจำแนกประเภทแบบหลายป้ายกำกับ โดยนำเสนอข้อมูลเชิงลึกที่มีคุณค่าเกี่ยวกับประสิทธิผลของแบบจำลองตามการกำหนดแต่ละรายการ
การสร้างเวกเตอร์ข้อความด้วย Scikit-LLM
Scikit-LLM มี GPTVectorizer ซึ่งช่วยให้สามารถแปลงข้อมูลที่เป็นข้อความเป็นรูปแบบตัวเลขที่อัลกอริทึมการเรียนรู้ของเครื่องเข้าใจได้ผ่านการสร้างเวกเตอร์ข้อความ กระบวนการแปลงนี้เกี่ยวข้องกับการแปลงข้อความเป็นเวกเตอร์มิติคงที่โดยใช้โมเดล GPT
แนวทางหนึ่งในการบรรลุเป้าหมายนี้คือการใช้วิธีการความถี่ของคำ-ความถี่ของเอกสารผกผัน
# 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
นี่คือผลลัพธ์:
ข้อมูลที่กล่าวมาข้างต้นเกี่ยวข้องกับการนำเสนอฟีเจอร์ที่ชาญฉลาดที่แปลงแล้วของอินสแตนซ์ห้าอินสแตนซ์เริ่มต้นภายในชุดข้อมูล ซึ่งแสดงเป็นผลลัพธ์การทำให้เป็นเวกเตอร์ของ TF-IDF
การสรุปข้อความด้วย Scikit-LLM
การสรุปข้อความเป็นกระบวนการที่เกี่ยวข้องกับการบีบอัดงานเขียนโดยยังคงรักษาเนื้อหาที่สำคัญไว้ GPTSummarizer ซึ่งมีอยู่ในไลบรารี Scikit-LLM ใช้โมเดลภาษาขั้นสูงตามสถาปัตยกรรม GPT เพื่อสร้างการสรุปข้อความที่กระชับ
# Perform Text Summarization
summarizer = GPTSummarizer(openai_model="gpt-3.5-turbo", max_words=15)
summaries = summarizer.fit_transform(X_test)
print(summaries)
ผลลัพธ์จะเป็นดังนี้:
สิ่งที่กล่าวมาข้างต้นทำหน้าที่เป็นภาพรวมของผลการวิจัย
สร้างแอปพลิเคชันบน LLM
Scikit-LLM นำเสนอโอกาสที่หลากหลายสำหรับการตรวจสอบข้อความอย่างครอบคลุมโดยใช้แบบจำลองภาษาขั้นสูง การเข้าใจพื้นฐานของรากฐานทางเทคโนโลยีของโมเดลเหล่านี้ถือเป็นสิ่งสำคัญ เนื่องจากช่วยให้เกิดความเข้าใจอย่างถ่องแท้เกี่ยวกับความสามารถและข้อจำกัดที่มีศักยภาพ ซึ่งเป็นเครื่องมือสำคัญในการสร้างโซลูชันซอฟต์แวร์ที่มีประสิทธิภาพสูงโดยใช้นวัตกรรมที่ล้ำสมัยนี้