יישום למידה אקטיבית לאופטימיזציה של תיוג נתונים

תיוג נתונים הוא החלק היקר ביותר בפרויקט למידת מכונה. עבור NLP עם מאות אלפי דוגמאות, תקציב ההערות עולה לעיתים קרובות על תקציב האימון. ראינו פרויקטים שבהם לקוחות בילו 80% מזמנם בתיוג ידני, ובכל זאת שיפור המדדים היה רק 2%. הסיבה: 90% מהדוגמאות שהמודל מזהה בביטחון — תיוגן חסר טעם. למידה פעילה (AL) פותרת זאת: האלגוריתם עצמו בוחר אובייקטים "קשים" שבהם ביטחון המודל נמוך. רק אותם יש לתייג. תוצאה: חיסכון של פי 5-10 בתקציב התיוג תוך שמירה על איכות של 90% מתיוג מלא. טכניקה זו, הידועה גם כלמידת בחירה פעילה, מתמקדת בדוגמאות האינפורמטיביות ביותר. AL היא טכניקת מפתח לאוטומציה של תיוג. המהנדסים שלנו מיישמים שיטה זו מקצה לקצה: מבחירת אסטרטגיה ועד אינטגרציה עם פלטפורמות. מאמר זה מכסה את האסטרטגיות העיקריות, קוד וניסיון יישום.

למידה פעילה היא שיטת למידת מכונה שבה האלגוריתם בוחר את הדוגמאות האינפורמטיביות ביותר לתיוג.

אילו אסטרטגיות עובדות הכי טוב?

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

דגימת אי-ודאות

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

import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.base import BaseEstimator

class UncertaintySampler:
    def __init__(self, model: BaseEstimator, strategy='entropy'):
        self.model = model
        self.strategy = strategy

    def query(self, X_unlabeled: np.ndarray, n_instances: int = 10) -> np.ndarray:
        proba = self.model.predict_proba(X_unlabeled)
        if self.strategy == 'entropy':
            scores = -np.sum(proba * np.log(proba + 1e-10), axis=1)
        elif self.strategy == 'margin':
            sorted_proba = np.sort(proba, axis=1)
            scores = 1 - (sorted_proba[:, -1] - sorted_proba[:, -2])
        elif self.strategy == 'least_confident':
            scores = 1 - proba.max(axis=1)
        return np.argsort(scores)[-n_instances:]

דגימת אי-ודאות פשוטה ליישום ועובדת עבור כל מודל עם predict_proba. עם זאת, היא אינה מתחשבת בגיוון, ולכן עשויה לבחור דוגמאות דומות עם אי-ודאות.

שאילתה על ידי ועדה

כאן אנו מאמנים לא מודל אחד אלא אנסמבל (למשל, על דגימות bootstrap). חוסר הסכמה בין חברי הוועדה מצביע על אינפורמטיביות:

from sklearn.base import clone
class CommitteeSampler:
    def __init__(self, base_estimator, n_members=5):
        self.committee = [clone(base_estimator) for _ in range(n_members)]

    def fit_committee(self, X_labeled, y_labeled):
        n = len(X_labeled)
        for member in self.committee:
            bootstrap_idx = np.random.choice(n, n, replace=True)
            member.fit(X_labeled[bootstrap_idx], y_labeled[bootstrap_idx])

    def query(self, X_unlabeled, n_instances=10):
        predictions = np.array([
            member.predict(X_unlabeled) for member in self.committee
        ])
        vote_entropy = []
        for sample_idx in range(X_unlabeled.shape[0]):
            votes = predictions[:, sample_idx]
            unique, counts = np.unique(votes, return_counts=True)
            probs = counts / len(votes)
            entropy = -np.sum(probs * np.log(probs + 1e-10))
            vote_entropy.append(entropy)
        return np.argsort(vote_entropy)[-n_instances:]

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

דגימת Core-Set

אם אנו רוצים לכסות את כל מרחב התכונות, לא רק את גבולות ההחלטה, אנו משתמשים ב-Core-Set. היא בוחרת נקודות רחוקות ביותר מאלה שכבר תויגו:

from sklearn.metrics import pairwise_distances

def core_set_selection(X_labeled, X_unlabeled, n_instances):
    selected_indices = []
    labeled_pool = X_labeled.copy()
    for _ in range(n_instances):
        distances = pairwise_distances(X_unlabeled, labeled_pool)
        min_distances = distances.min(axis=1)
        best_idx = np.argmax(min_distances)
        selected_indices.append(best_idx)
        labeled_pool = np.vstack([labeled_pool, X_unlabeled[best_idx]])
    return np.array(selected_indices)

במדדים שלנו, שאילתה על ידי ועדה מניבה עד 30% דיוק גבוה יותר של המודל בהשוואה לדגימת אי-ודאות על מערכי נתונים רועשים. דגימת Core-Set מכסה את מרחב התכונות ביעילות פי 5 יותר מבחירה אקראית.

מגבלות של למידה פעילה

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

בחירה בין ועדה לדגימת אי-ודאות

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

למידה פעילה עבור NER

עבור תיוג רצפים אנו משתמשים באי-ודאות ברמת טוקן. אנו מצרפים אנטרופיה על כל הטוקנים במשפט — בוחרים את המשפטים הכי לא ודאיים:

import torch
from transformers import AutoModelForTokenClassification, AutoTokenizer

def ner_uncertainty_sampling(texts, model, tokenizer, n_instances=20):
    sentence_uncertainties = []
    for i, text in enumerate(texts):
        inputs = tokenizer(text, return_tensors='pt', truncation=True, max_length=512)
        with torch.no_grad():
            outputs = model(**inputs)
        probs = torch.softmax(outputs.logits, dim=-1).squeeze()
        token_entropy = -(probs * torch.log(probs + 1e-10)).sum(dim=-1)
        sentence_uncertainty = token_entropy.max().item()
        sentence_uncertainties.append((i, sentence_uncertainty))
    sentence_uncertainties.sort(key=lambda x: x[1], reverse=True)
    return [idx for idx, _ in sentence_uncertainties[:n_instances]]

גישה זו מניבה חיסכון של פי 3-5 עבור מערכי נתונים של NER. עבור מערך נתונים של NER עם 100 אלף משפטים, השגנו הפחתה של פי 3 במאמץ התיוג.

צינור למידה פעילה מלא

class ActiveLearningPipeline:
    def __init__(self, model, sampler, labeling_budget):
        self.model = model
        self.sampler = sampler
        self.budget = labeling_budget
        self.labeled_count = 0
        self.performance_history = []

    def run(self, X_initial, y_initial, X_pool, batch_size=20):
        X_labeled, y_labeled = X_initial.copy(), y_initial.copy()
        X_unlabeled = X_pool.copy()

        while self.labeled_count < self.budget and len(X_unlabeled) > 0:
            self.model.fit(X_labeled, y_labeled)
            current_metric = self.evaluate(X_labeled, y_labeled)
            self.performance_history.append({
                'n_labeled': len(X_labeled),
                'metric': current_metric
            })

            query_idx = self.sampler.query(X_unlabeled, n_instances=batch_size)
            new_y = get_labels_from_annotator(X_unlabeled[query_idx])
            X_labeled = np.vstack([X_labeled, X_unlinked[query_idx]])
            y_labeled = np.concatenate([y_labeled, new_y])
            X_unlabeled = np.delete(X_unlabeled, query_idx, axis=0)
            self.labeled_count += batch_size

        return self.performance_history

קוד זה ממחיש את המחזור המלא — אנו מתאימים אותו לתשתית שלך.

כיצד אנו מיישמים למידה פעילה בפרויקט שלך

התהליך האופייני כולל 5 שלבים:

1. ניתוח נתונים ומשימה עסקית — הגדרת מדדים, מבנה מערך נתונים, סוגי הערות זמינים.
2. בחירת אסטרטגיית בחירה — בדיקת דגימת אי-ודאות, ועדה ו-Core-Set על המשימה שלך; בחירת הטובה ביותר על בסיס עקומת למידה.
3. פיתוח צינור — יישום המחזור: אימון → בחירה → תיוג → אימון מחדש. אינטגרציה עם פלטפורמות Label Studio או Scale AI.
4. השקה פיילוט — על מערך נתונים קטן (1000-5000 דוגמאות) לוודא יעילות.
5. ייצור — אוטומציה של התהליך, הגדרת ניטור מדדים (latency p99, ניצול GPU) והפעלות מחזור מחדש.

לצוות שלנו ניסיון של למעלה מ-5 שנים בלמידה פעילה, לאחר שיישם אותה ביותר מ-15 פרויקטים.

לוחות זמנים ועלות

העלות נקבעת לאחר ניתוח. עלויות היישום מתחילות ב-$5,000, עם חיסכון אופייני העולה על $100,000 בשנה עבור פרויקטים גדולים.

מה כלול בהטמעה

• צינור למידה פעילה עובד המשולב במערכת התיוג שלך
• לוח מחוונים למדדים: דינמיקת איכות המודל, חיסכון בתקציב, התפלגות דוגמאות שנבחרו
• תיעוד ומדריך למשתמש
• 3 חודשי תמיכה לאחר ההשקה

יישמנו למידה פעילה ביותר מ-15 פרויקטים ב-NLP וראייה ממוחשבת. מקרה אחרון: משימת סיווג ביקורות — הפחתנו את נפח התיוג מ-50,000 ל-8,000 דוגמאות תוך שמירה על F1 ב-0.94. בפרויקט אחרון, השגנו הפחתה של פי 6 בעלויות התיוג בעוד שציון F1 של המודל ירד רק ב-0.01.

למידה פעילה היא מתודולוגיה מוכחת שכבר חסכה ללקוחותינו כ-$9k–13k בחיסכון. אנו מבטיחים איכות יישום ותוצאות שקופות.

צור קשר: ספר לנו על המשימה שלך — נציע את אסטרטגיית הלמידה הפעילה האופטימלית. קבל ייעוץ ממהנדס למידת מכונה.