סיווג טקסטים (בעיקר) באמצעות מודלים של Naive Bayes Classifier

עולם סיווג הטקסט בנוי על רעיון פשוט: המרת מסמכים לוקטורים מספריים, והחלטה לאיזו מחלקה הם שייכים.

גישות שונות של למידת מכונה פותחו כדי לענות על השאלה "לאיזו מחלקה שייך המסמך" ואחת הבולטות מבוססת על Naive Bayes אשר נחשב לסוס העבודה עולם עיבוד השפה NLP (Natural Language Processing).

בגלל שכל כך מקובלת להשתמש ב-Naive Bayes לצורך NLP נתרכז באופן השימוש בו במסגרת חבילת scikit-learn תוך הבאת קוד המממש pipeline הכולל: preprocessing → vectorization → classification.

אחרי שנבסס את הצורך ואת אופן השימוש ב-pipeline נראה כמה קל להחליף את המודל המסווג בתהליך למודלים שאינם Naive Bayes דוגמת: Logistic Regression ו-SVM.

לבסוף, מדריך זה יעזור לך להבין את ההבדלים בין המודלים המסווגים, את היתרונות של כל אחד, ובעיקר לאילו משימות כדאי לבחור בכל אחד מהם.

להורדת הקוד אותו נפתח במדריך (imbd_classifier_nb.zip)

מסווג בייס נאיבי Naive Bayes Classifier הוא אלגוריתם למידת מכונה הסתברותי הנמצא בשימוש נרחב למשימות סיווג טקסט. הוא מבוסס על משפט בייס, עם הנחה "נאיבית" לפיה הפיצ'רים, דוגמת שכיחות מילים, הם נפרדים ואינם תלויים זה בזה.

במדריך זה נדגים את השימוש ב-Naive Bayes Classifier ומודלים נוספים של sklearn לצורך סיווג הסנטימנט של ביקורות על סרטים אשר נאספו לתוך מסד הנתונים IMDB.

במדריכים קודמים הסברנו את משפט בייס ואת ההצדקה לשימוש בהנחת הנאיביות כאשר מסווגים באמצעות Naive Bayes Classifier. קריאה של מדריכים אילו תסייע רבות להבנת המדריך הנוכחי.

לצורך סיווג מסמכים documents לקבוצות מוגדרות במסגרת מחלקות classes נשתמש במשפט בייס באופן הבא:

P(Class|Document) = [P(Document|Class) * P(Class)] / P(Document)

כאשר:

P(Class|Document): הסתברות פוסטריורית להשתייכות המסמך למחלקה מסוימת.

P(Document|Class): הסבירות likelihood לצפייה במסמך בהינתן המחלקה.

P(Class): הסתברות קודמת prior של המחלקה.

P(Document): הסתברות המסמך בכלל מסד הנתונים (בין אם במחלקה ובין אם לאו).

ההנחה הנאיבית היא שקיום מילה מסוימת אחת במסמך אינה תלויה בנוכחות של מילים אחרות, בהינתן מחלקת המסמך. הנחה אשר מפשטת את החישוב לכדי:

P(Document|Class) = P(word1|Class) * P(word2|Class) * ... * P(wordN|Class)

בלמידת מכונה מבחינים בין שני שלבים: אימון ובחינה.

בשלב האימון המודל לומד את ההסתברויות הפריוריות prior של כל מחלקה P(Class) ואת ההסתברות המותנית של כל מילה בהינתן מחלקה P(word|Class) מסט נתוני האימון. דוגמה למחלקות הם ביקורות חיוביות או שליליות.

בשלב הבחינה המודל נחשף לסט נתוני הבחינה, אליהם הוא לא נחשף בעת האימון, והוא נדרש לסווג כל מסמך תוך חיזוי איזו מהמחלקות היא הסבירה ביותר בהינתן המסמך.

לשימוש במודל למידת מכונה מסוג Naive Bayes לצורך סיווג טקסטים יש כמה יתרונות:

• קל ופשוט ליישם מודל מסוג זה.
• תוצאות אמינות אפילו במקרה של מסד נתונים קטן.
• יכולת לסווג לכמה מחלקות ולא רק שתיים.

לשימוש במודל למידת מכונה מסוג Naive Bayes יש חסרון מרכזי הקשור בהנחה הבסיסית לפיה המילים אינם תלויות אחת בשנייה במסמך מה שהניסיון שלנו מלמד שאינו נכון. ואף על פי כן, המודל מצליח להגיע לתוצאות טובות בדרך כלל.

ייבוא הנתונים והכנה ללמידת מכונה

• את המדריך פיתחתי בסביבת Colab של גוגל.

לצורך יישום המדריך, יש לטעון את מערך הנתונים של IMDB, אשר מכיל 50,000 ביקורות סרטים המסומנות כחיוביות או שליליות. מקור מסד הנתונים הוא kaggle שהוא מיזם שכל מדען נתונים מקצועי או חובב חייב להכיר.

import os
BASE_DIR = './'
DATA_DIR = os.path.join(BASE_DIR, 'data/')
# make data directory
!mkdir -p ./data/

כדי לייבא את מסד הנתונים:

# import dataset to the data directory
import kagglehub
import pandas as pd


# Download latest version of the IMDB database
path = kagglehub.dataset_download("lakshmi25npathi/imdb-dataset-of-50k-movie-reviews")
imdb_dataset = os.path.join(path, "IMDB Dataset.csv")
print("Path to dataset files:", imdb_dataset)

הכי נוח הוא להפוך את מסד הנתונים ל-DataFrame של Pandas:

df = pd.read_csv(imdb_dataset, encoding = "ISO-8859-1") 


# df = df[:100] # You could limit the number of items for testing

נסקור את הנתונים.

לסקירת הרשומות הראשונות במסד הנתונים:

df.head()

df.shape

(5000, 2)

• יופי הרבה פריטים, מעט פיצ'רים.

האם חסרים נתונים?

df.isnull().sum().sum()

np.int64(0)

• לא חסרים נתונים שזה פלוס גדול.

מהם המחלקות אליהם מתחלקים הנתונים?

df.sentiment.unique()

array(['positive', 'negative'], dtype=object)

• קיימות 2 מחלקות. הביקורות מסווגות לחיוביות לעומת שליליות.

כמה ביקורות יש בכל קטגוריה?

df.groupby(['sentiment']).count()

sentiment
---------------------
negative        25000
positive        25000

• מסד הנתונים מאוזן הודות למספר שווה של ביקורות חיוביות ושליליות.

עיבוד מקדים של הטקסט (Text preprocessing) במסגרת הכנתו ללמידת מכונה

נתוני טקסט גולמיים דורשים ניקוי וטרנספורמציה. זה כולל לעתים קרובות:

• הסרת תגיות HTML, תווים מיוחדים ומספרים.
• המרת טקסט לאותיות קטנות.
• הסרת מילות עצירה (מילים נפוצות כמו "the", "a", "is" שאינן נושאות משמעות רבה).
• שימוש בגזירה (stemming) או lemmatization כדי להעמיד מילים על צורת השורש שלהן.

import re
import nltk
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer


nltk.download('stopwords')
stop_words = set(stopwords.words('english'))
stemmer = PorterStemmer()


def preprocess_text(text):
   text = re.sub(r'<br />', ' ', text) # Remove <br /> tags
   text = re.sub(r'[^a-zA-Z]', ' ', text) # Remove non-alphabetic characters
   text = text.lower()
   words = text.split()
   words = [stemmer.stem(word) for word in words if word not in stop_words]
   return ' '.join(words)


df['review_preprocessed'] = df['review'].apply(preprocess_text)

פיצול מסד הנתונים לקבוצות אימון ובדיקה

כדי להעריך את יכולת המודל להתמודד עם מידע חדש, מפרידים תחילה בין משתני הקלט X, הסקירות שכתבו המשתמשים, לבין משתני המטרה Y שהם הסנטימנט (חיובי או שלילי). לאחר מכן מבצעים פיצול של המסד לשתי קבוצות: קבוצת אימון, המשמשת ללימוד המודל, ו־קבוצת בדיקה, המכילה דוגמאות שלא נחשפו למודל בזמן האימון. כך ניתן לבדוק בצורה מהימנה עד כמה המודל מצליח לחזות סנטימנט גם עבור סקירות שלא ראה בעת האימון.

from sklearn.model_selection import train_test_split


def prepare_data(df_X, df_Y):
   X = df_X
   y = df_Y.apply(lambda x: 1 if x == 'positive' else 0) # Convert 'positive'/'negative' to 1/0
   X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


   return X_train, X_test, y_train, y_test

X = df['review_preprocessed']


X_train, X_test, y_train, y_test = prepare_data(df["review_preprocessed"], df["sentiment"])

• פה פיצלנו ל-80% קבוצת אימון והיתר לבדיקה.

וקטוריזציה של הטקסט

Naive Bayes Classifier, כמו רוב המודלים ללמידת מכונה, דורשים קלט מספרי. המרת טקסטים לייצוגים מספריים נעשים באמצעות טכניקות דוגמת: Bag-of-Words (BoW) ו-TF-IDF (Term Frequency-Inverse Document Frequency). בעוד BoW מייצג מסמך כאוסף של מספרי מילים תוך התעלמות מסדר והקשר, TF-IDF נותן משקל למילים על פי תדירות ונדירות על פני כל קורפוס המסמכים.

נתחיל משימוש ב-CountVectorizer שהוא כלי המיישם BoW.

from sklearn.feature_extraction.text import CountVectorizer # Or TfidfVectorizer

vectorizer = CountVectorizer()
X_train_vect = vectorizer.fit_transform(X_train)
X_test_vect = vectorizer.transform(X_test)

למידה ממסד הנתונים

קיימים 3 סוגים של מסווגים מסוג Naive Bayes classifiers הנבדלים במקרי השימוש:

• Multinomial Naive Bayes - מתאים לפיצ'רים (עמודות) המיוצגים בצורת התפלגות בדידה, כמו ספירת מילים, כאשר משתמשים בשיטות קידוד המתחשבות בתדירות האירועים (מילים) דוגמת BoW.
• Bernoulli Naive Bayes - מתאים לתכונות בינאריות. לדוגמה, שיטות קידוד נתונים המציינות נוכחות או היעדרות של מילה.
• Gaussian Naive Bayes - עבור נתונים המשכיים המתפלגים נורמלית.

נתחיל משימוש ב- Multinomial Naive Bayes לצורך פיתוח המודל. המודל לומד מסט אימון שעבר עיבוד ווקטוריזציה:

from sklearn.naive_bayes import MultinomialNB


clf = MultinomialNB(alpha=1.0) # Using default alpha


clf.fit(X_train_vect, y_train)

הערכת ביצועי המודל

לאחר שאימנו את המודל צריך לבדוק את הביצועים שלו באמצעות מדדים מקובלים על נתונים שאליהם הוא לא נחשף בעת האימון דוגמת סט המבחן ששמנו בצד.

from sklearn.metrics import confusion_matrix, accuracy_score, classification_report, f1_score


y_pred = clf.predict(X_test_vect)

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix


def evaluate(clf, X_test, y_test, y_pred):
   acc = clf.score(X_test, y_test)*100
   print(f"Classifier Accuracy: {round(acc, 2)}%")
   print(classification_report(y_test, y_pred))


evaluate(clf, X_test_vect, y_test, y_pred)

• דיוק המודל 85% וכך גם מדד F1. לקריאה אודות מדדים להערכת המודל בלמידת מכונה.

מה בנוגע ל-confusion matrix?

print(confusion_matrix(y_test, y_pred))

[[4321  640]
 [ 818 4221]]

הפונקציה הבאה תאפשר לנו להציג confusion matrix באופן המושך את העין:

import matplotlib.pyplot as plt
import numpy as np


def plot_confusion_matrix(y_test, y_pred):
   cm = confusion_matrix(y_test, y_pred)


   fig, ax = plt.subplots(figsize=(5, 5))
   im = ax.imshow(cm)   # No explicit colors allowed


   # Labeling
   ax.set_xticks(np.arange(2))
   ax.set_yticks(np.arange(2))
   ax.set_xticklabels(['Predicted (Neg)', 'Predicted (Pos)'])
   ax.set_yticklabels(['Actual (Neg)', 'Actual (Pos)'])


   # Annotate values
   for i in range(cm.shape[0]):
       for j in range(cm.shape[1]):
           ax.text(j, i, cm[i, j], ha='center', va='center')


   plt.title("Confusion Matrix Heatmap")
   plt.xlabel("Predicted Label")
   plt.ylabel("True Label")
   plt.tight_layout()
   plt.show()

plot_confusion_matrix(y_test, y_pred)

מעניין לגלות לגבי אילו מסמכים טעה המודל. לצורך כך, נאתר את הדוגמאות השגויות באמצעות "מסכה":

misclassified_mask = (y_pred != y_test)

נשתמש בפונקציה הבאה להציג את המסמכים שהמודל שגה בסיווג שלהם:

from IPython.display import HTML, display
import pandas as pd


def format_review(text):
   return f"""
   <div style="
       max-height: 200px;
       overflow-y: scroll;
       padding: 8px;
       border: 1px solid #ccc;
       border-radius: 6px;
       background-color: #fafafa;">
       {text}
   </div>
   """


def display_misclassified(y_pred, y_test):
   # Convert predictions to a pandas Series with matching index
   y_pred_series = pd.Series(y_pred, index=y_test.index)


   # Boolean mask + indices
   misclassified_mask = (y_pred_series != y_test)
   misclassified_indices = misclassified_mask[misclassified_mask].index


   # Build a DataFrame of misclassified rows
   mis_df = pd.DataFrame({
       "Predicted": y_pred_series.loc[misclassified_indices].map({1: "positive", 0: "negative"}),
       "Actual":    y_test.loc[misclassified_indices].map({1: "positive", 0: "negative"}),
       "Review":    X_test.loc[misclassified_indices]
   })


   mis_df_html = mis_df.copy()
   mis_df_html["Review"] = mis_df["Review"].apply(format_review)


   # Display as HTML
   display(HTML(mis_df_html.to_html(escape=False)))



display_misclassified(y_pred, y_test)

בחינת המודל על דוגמאות שאינם במסד הנתונים

נבחן את יכולת הסיווג של המודל המאומן על מסמכים שאינם במסד הנתונים. הרשימה הבאה כוללת 5 ביקורות מומצאות:

test_reviews = [
       "What a disappointment. The plot makes no sense and the pacing is painfully uneven.",
       "An absolute delight from start to finish with lots of charming moments.",
       "This film tries to be deep but ends up feeling pretentious and boring.",
       "The movie has a few interesting ideas but overall suffers from weak execution.",
       "The camera work is fantastic, but the story is messy and the characters are shallow.",
]

ונעזר בפונקציה הבאה לבחינת הביקורות:

def predict_reviews(clf, preprocessed_reviews, reviews=None):
   if reviews == None:
       reviews = preprocessed_reviews


   preds = clf.predict(preprocessed_reviews)
   prob = clf.predict_proba(preprocessed_reviews)


   # Convert numeric labels → words
   sentiment_map = {1: "positive", 0: "negative"}
   sentiments = [sentiment_map[p] for p in preds]


   df = pd.DataFrame({
         "Review": reviews,
         "Sentiment": sentiments,
         "Probability": prob[:, 1]
   })


   return df

נריץ את הפונקציה:

test_reviews_df = pd.DataFrame(test_reviews, columns=['Text'])
preprocessed_reviews = test_reviews_df['Text'].apply(preprocess_text)
reviews_vect = vectorizer.transform(preprocessed_reviews)


predict_reviews(clf, reviews_vect, test_reviews)

התוצאות מסוכמות בטבלה הבאה:

שימוש ב-pipeline

בחינת השפעת שינוי פרמטרים ואף שלבים שלמים על המודל עלולה להיות מייגעת, וכאן בא לעזרה pipeline של sklearn. לדוגמה, pipeline אשר מאפשר הרצה לפי סדר של שלבי עיבוד הטקסט ואח"כ הרצת המודל ללמידת מכונה:

from sklearn.pipeline import Pipeline


clf = Pipeline([
   ('vectorizer', CountVectorizer()),
   ('classifier', MultinomialNB(alpha=1.0))
])

עכשיו כל מה שנשאר לעשות הוא להריץ את ה-pipeline אשר יעשה את צעדי העיבוד והסיווג ללא הצורך להוסיף כל אחד מהשלבים באופן ידני.

X_train, X_test, y_train, y_test = prepare_data(df["review"], df["sentiment"])

clf.fit(X_train, y_train)

נבחן את ביצועי המודל המאומן על סט נתוני הביקורת:

y_pred = clf.predict(X_test)

evaluate(clf, X_test, y_test, y_pred)

Classifier Accuracy: 84.9%
              precision    recall  f1-score   support

           0       0.83      0.88      0.85      4961
           1       0.87      0.82      0.85      5039

    accuracy                           0.85     10000
   macro avg       0.85      0.85      0.85     10000
weighted avg       0.85      0.85      0.85     10000

שימוש ב-pipeline על פונקציות שאינן שייכות לספריית sklearn

ניתן להשתמש ב-pipeline של sklearn על פונקציות שאינן שייכות לספרייה. כדי להדגים זאת נפתח קלאס לעיבוד מקדים של טקסט אותו נשלב בשלב הבא לתוך ה-pipeline.

from sklearn.base import BaseEstimator, TransformerMixin
import pandas as pd
import numpy as np
import re
import nltk
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer


# Ensure stopwords are downloaded
nltk.download("stopwords")
stop_words = set(stopwords.words("english"))
stemmer = PorterStemmer()


class TextPreprocessor(BaseEstimator, TransformerMixin):
   """
   Full preprocessing transformer:
   - Remove HTML
   - Strip non-letters
   - Lowercase
   - Remove stopwords
   - Stemming
   """


   def __init__(self):
       pass  # no parameters (for now)


   def clean_text(self, text):
       # Basic preprocessing
       text = re.sub(r"<br /?>", " ", text)
       text = re.sub(r"[^a-zA-Z]", " ", text)
       text = text.lower()
       words = text.split()
       words = [stemmer.stem(w) for w in words if w not in stop_words]
       return " ".join(words)


   def fit(self, X, y=None):
       return self  # No fitting needed


   def transform(self, X):
       # Accept Series, lists, numpy arrays
       if isinstance(X, pd.Series):
           return X.apply(self.clean_text).tolist()


       if isinstance(X, (list, np.ndarray)):
           return [self.clean_text(x) for x in X]


       raise TypeError(f"Unsupported input type: {type(X)}")

את הקלאס TextPreprocessor לעיל נשלב ב-pipline באופן הבא:

from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB


clf = Pipeline([
   ('preprocess', TextPreprocessor()),
   ('vectorize', CountVectorizer()), # Optional: TfidfVectorizer()
   ('model', MultinomialNB(alpha=1.0))
])

נפצל את מסד הנתונים המקורי לסט אימון ובחינה:

X_train, X_test, y_train, y_test = prepare_data(df["review"], df["sentiment"])

ונריץ את ה-pipeline על סט נתוני האימון:

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

evaluate(clf, X_test, y_test, y_pred)

Classifier Accuracy: 85.42%
              precision    recall  f1-score   support

           0       0.84      0.87      0.86      4961
           1       0.87      0.84      0.85      5039

    accuracy                           0.85     10000
   macro avg       0.85      0.85      0.85     10000
weighted avg       0.85      0.85      0.85     10000

predict_reviews(clf, test_reviews)

from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.linear_model import LogisticRegression

clf = Pipeline([
    ('preprocess', TextPreprocessor()),
    ('vectorizer', TfidfVectorizer()),
    ('classifier', MultinomialNB()),
])

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

evaluate(clf, X_test, y_test, y_pred)

Classifier Accuracy: 86.03%
              precision    recall  f1-score   support

           0       0.85      0.87      0.86      4961
           1       0.87      0.85      0.86      5039

    accuracy                           0.86     10000
   macro avg       0.86      0.86      0.86     10000
weighted avg       0.86      0.86      0.86     10000

predict_reviews(clf, test_reviews)

from sklearn.naive_bayes import MultinomialNB
... (vectorize text data, e.g., using CountVectorizer or TfidfVectorizer)
model = MultinomialNB()
model.fit(X_train, y_train)

from sklearn.naive_bayes import BernoulliNB
vectorize text → ensure binary features (0/1)
model = BernoulliNB()
model.fit(X_train, y_train)

from sklearn.naive_bayes import ComplementNB
vectorize text (counts or TF–IDF)
model = ComplementNB()
model.fit(X_train, y_train)

from sklearn.naive_bayes import GaussianNB
model = GaussianNB()
model.fit(X_train_dense, y_train)

from sklearn.naive_bayes import BernoulliNB

clf = Pipeline([
    ('preprocess', TextPreprocessor()),
    ('vectorizer', TfidfVectorizer()),
    ('classifier', BernoulliNB()),
])

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

evaluate(clf, X_test, y_test, y_pred)

Classifier Accuracy: 89.21%
              precision    recall  f1-score   support

           0       0.90      0.88      0.89      4961
           1       0.88      0.91      0.89      5039

    accuracy                           0.89     10000
   macro avg       0.89      0.89      0.89     10000
weighted avg       0.89      0.89      0.89     10000

from sklearn.linear_model import LogisticRegression

clf = Pipeline([
    ('preprocess', TextPreprocessor()),
    ('vectorizer', TfidfVectorizer()),
    ('classifier', LogisticRegression(solver='saga')), # For small datasets, ‘liblinear’ is a good choice, whereas ‘sag’ and ‘saga’ are faster for large ones
])

X_train, X_test, y_train, y_test = prepare_data(df["review"], df["sentiment"])

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

evaluate(clf, X_test, y_test, y_pred)

Classifier Accuracy: 89.21%
              precision    recall  f1-score   support

           0       0.90      0.88      0.89      4961
           1       0.88      0.91      0.89      5039

    accuracy                           0.89     10000
   macro avg       0.89      0.89      0.89     10000
weighted avg       0.89      0.89      0.89     10000

from sklearn.svm import SVC

clf = Pipeline([
    ('preprocess', TextPreprocessor()),
    ('vectorizer', TfidfVectorizer()),
    ('classifier', SVC(kernel='linear', probability=True)),
])

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

evaluate(clf, X_test, y_test, y_pred)

predict_reviews_pipeline(clf, test_reviews)

from sklearn.ensemble import RandomForestClassifier

clf = Pipeline([
    ('preprocess', TextPreprocessor()),
    ('vectorizer', TfidfVectorizer()),
    ('classifier', RandomForestClassifier(n_estimators=100, random_state=42)),
])

X_train, X_test, y_train, y_test = prepare_data(df["review"], df["sentiment"])

clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

evaluate(clf, X_test, y_test, y_pred)

Classifier Accuracy: 85.41%
              precision    recall  f1-score   support

           0       0.85      0.86      0.85      4961
           1       0.86      0.85      0.85      5039

    accuracy                           0.85     10000
   macro avg       0.85      0.85      0.85     10000
weighted avg       0.85      0.85      0.85     10000