Rot: Skalierung der Textklassifizierung mit Expertendelegation

Mit dem neuen Zeitalter der durch Großsprachenmodelle (LLM) verstärkten Problemlösung bleiben nur noch eine Handvoll Probleme mit unterdurchschnittlichen Lösungen vorhanden. Die meisten Klassifizierungsprobleme (auf POC-Ebene) können gelöst werden, indem LLMs bei 70–90% Präzision/F1 mit nur guten, schnellen technischen Techniken sowie adaptiven In-Context-Studying-Beispielen (ICL) genutzt werden.

Was passiert, wenn Sie konsequent Leistung erzielen möchten? höher als das – wenn eine schnelle Engineering nicht mehr ausreicht?

Das Klassifizierungs -Rätsel

Die Textklassifizierung ist eines der ältesten und intestine verstandenen Beispiele für beaufsichtigtes Lernen. Angesichts dieser Prämisse sollte es wirklich nicht schwierig sein, robuste, intestine leistungsfähige Klassifizierer zu erstellen, die eine große Anzahl von Eingabegemassen verarbeiten, richtig …?

Welpe. Es ist.

Es muss tatsächlich viel mehr mit den „Einschränkungen“ anfangen, unter denen der Algorithmus allgemein erwartet wird:

• geringe Menge an Trainingsdaten professional Klasse
• Hochklassifizierungsgenauigkeit (die sinkt, wenn Sie weitere Klassen hinzufügen)
• Mögliche Zugabe von Neue Klassen zu einer vorhandenen Untergruppe von Klassen
• Schnelles Coaching/Inferenz
• Kosteneffizienz
• (potenziell) wirklich große Anzahl von Trainingsklassen
• (potenziell) endlos erforderlich Umschulung von manche Klassen aufgrund von Datendrift usw.

Haben Sie jemals versucht, einen Klassifikator zu bauen, der unter diesen Bedingungen über ein paar Dutzend Klassen hinausgeht? (Ich meine, sogar GPT könnte mit nur wenigen Beispielen einen großartigen Job bis zu ~ 30 Textklassen machen…)

In Anbetracht dessen, dass Sie die GPT -Route nehmen – wenn Sie mehr als ein paar Dutzend Klassen oder eine beträchtliche Menge an Datenklassifizierung haben, müssen Sie mit der Systemaufforderung, der Eingabeaufforderung für Benutzer, nur wenigen Schuss -Beispiel -Token tief in Ihre Taschen greifen, die Sie klassifizieren müssen eine Probe. Nach dem Frieden mit dem Durchsatz der API Frieden, auch wenn Sie asynchronisierte Abfragen ausführen.

Bei angewandten ML sind Probleme wie diese im Allgemeinen schwierig zu lösen, da sie die Anforderungen des überwachten Lernens nicht vollständig erfüllen oder nicht billig/schnell genug sind, um über ein LLM ausgeführt zu werden. Dieser besondere Schmerzpunkt ist das, was der rote Algorithmus anspricht: Semi-überprüftes Lernen, wenn die Trainingsdaten professional Klasse nicht ausreichen, um herkömmliche Klassifizierer zu erstellen.

Der rote Algorithmus

ROT: Rekursiv Expertendelegation ist ein neuartiger Framework, der die Artwork und Weise verändert, wie wir uns der Textklassifizierung nähern. Dies ist ein angewandtes ML -Paradigma – dh es gibt keine grundsätzlich anders Architektur für das, was existiert, aber es ist eine Spotlight -Ideenrolle, die am besten geeignet ist, etwas zu bauen, das praktisch und skalierbar ist.

In diesem Beitrag werden wir ein bestimmtes Beispiel durcharbeiten, bei dem eine große Anzahl von Textklassen (100–1000), jede Klasse nur nur wenige Proben (30–100) enthält und es eine nicht triviale Anzahl von Proben gibt, die klassifiziert werden können (10.000–100.000). Wir nähern uns das als Semi-betriebliches Lernen Drawback über Rot

Lassen Sie uns eintauchen.

Wie es funktioniert

Anstatt einen einzelnen Klassifikator zwischen einer großen Anzahl von Klassen zu klassifizieren, clever:

1. Teilt und erobert – Teilen Sie den Etikettenraum (große Anzahl von Eingangsbezeichnungen) in mehrere Untergruppen von Etiketten ein. Dies ist ein gieriger Ansatz der Subset -Formation.
2. Lernt effizient – Züge Spezialklassifizierer für jede Untergruppe. Dieser Schritt konzentriert sich auf den Aufbau eines Klassifikators, der über die Lärm übertrieben wird, wobei Rauschen clever als Daten aus modelliert wird Andere Untergruppen.
3. Delegierungen an einen Experten – beschäftigt LLMs nur als Experte Oracles für eine spezifische Etikett -Validierung und -Korrektur, ähnlich wie ein Staff von Domänenexperten. Mit einem LLM als Proxy „ahmt es empirisch nach“ Wie Ein menschlicher Experte bestätigt eine Ausgabe.
4. Rekursive Umschulung – Durch kontinuierliche Abzüge mit frischen Proben, die vom Experten zurückgegeben werden, bis keine Proben hinzugefügt werden müssen/eine Sättigung durch den Informationsgewinn erreicht wird

Die Instinct dahinter ist nicht sehr schwer zu verstehen: Aktives Lernen beschäftigt Menschen als Domänenexperten, um die Ausgänge aus einem ML -Modell kontinuierlich zu „korrigieren“ oder „validieren“. Dies stoppt, wenn das Modell eine akzeptable Leistung erzielt. Wir intuitiv und umbenennen gleich, mit einigen cleveren Innovationen, die in einer Forschung später vorab detailliert werden.

Lassen Sie uns einen tieferen Blick darauf werfen …

Gierige Untergruppenauswahl mit am wenigsten ähnlichen Elementen

Wenn die Anzahl der Eingabetiketten (Klassen) hoch ist, nimmt die Komplexität des Lernens einer linearen Entscheidungsgrenze zwischen Klassen zu. Daher verschlechtert sich die Qualität des Klassifikators, wenn die Anzahl der Klassen zunimmt. Dies gilt insbesondere dann, wenn der Klassifikator nicht genug hat Proben Zu lernen – dh jeder der Trainingskurse hat nur wenige Stichproben.

Dies spiegelt sehr ein reales Szenario und die Hauptmotivation hinter der Schaffung von Rot wider

Einige Möglichkeiten, die Leistung eines Klassifikators unter diesen Einschränkungen zu verbessern:

• Beschränken Die Anzahl der Klassen, die ein Klassifizierer zwischen Klassifizierung muss
• Machen Sie die Entscheidungsgrenze zwischen den Klassen klarer, dh den Klassifikator auszubilden sehr unterschiedliche Klassen

Die gierige Subset -Auswahl macht genau das – da der Umfang des Issues ist TextklassifizierungWir bilden Einbettungen der Trainingsetiketten, reduzieren ihre Dimensionalität über UMAP und bilden sich dann S Untergruppen von ihnen. Jedes der S Untergruppen haben Elemente als N Trainingsetiketten. Wir wählen Trainingsbezeichnungen gierig und stellen sicher, dass jedes Etikett, das wir für die Untergruppe auswählen, das unterschiedlichste Etikett für die anderen Etiketten ist, die in der Untergruppe vorhanden sind:

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity


def avg_embedding(candidate_embeddings):
    return np.imply(candidate_embeddings, axis=0)

def get_least_similar_embedding(target_embedding, candidate_embeddings):
    similarities = cosine_similarity(target_embedding, candidate_embeddings)
    least_similar_index = np.argmin(similarities)  # Use argmin to search out the index of the minimal
    least_similar_element = candidate_embeddings(least_similar_index)
    return least_similar_element


def get_embedding_class(embedding, embedding_map):
    reverse_embedding_map = {worth: key for key, worth in embedding_map.gadgets()}
    return reverse_embedding_map.get(embedding)  # Use .get() to deal with lacking keys gracefully


def select_subsets(embeddings, n):
    visited = {cls: False for cls in embeddings.keys()}
    subsets = ()
    current_subset = ()

    whereas any(not visited(cls) for cls in visited):
        for cls, average_embedding in embeddings.gadgets():
            if not current_subset:
                current_subset.append(average_embedding)
                visited(cls) = True
            elif len(current_subset) >= n:
                subsets.append(current_subset.copy())
                current_subset = ()
            else:
                subset_average = avg_embedding(current_subset)
                remaining_embeddings = (emb for cls_, emb in embeddings.gadgets() if not visited(cls_))
                if not remaining_embeddings:
                    break # deal with edge case
                
                least_similar = get_least_similar_embedding(target_embedding=subset_average, candidate_embeddings=remaining_embeddings)

                visited_class = get_embedding_class(least_similar, embeddings)

                
                if visited_class shouldn't be None:
                  visited(visited_class) = True


                current_subset.append(least_similar)
    
    if current_subset:  # Add any remaining parts in current_subset
        subsets.append(current_subset)
        

    return subsets

Das Ergebnis dieser gierigen Untergruppe ist alle Trainingsetiketten klar in Teilmengen, wobei jede Teilmenge höchstens nur hat N Klassen. Dies erleichtert die Aufgabe eines Klassifikators im Vergleich zum Unique S Klassen Es müsste zwischen sonst klassifizieren!

Semi-überprüfte Klassifizierung mit Lärmüberabtastung

Kaskade dies nach der Erstbekundungs ​​-Teilmengebildung – dh dieser Klassifikator klassifiziert nur zwischen einem gegebenen Teilmenge von Klassen.

Stellen Sie sich Folgendes vor: Wenn Sie niedrige Trainingsdaten haben, können Sie absolut keinen Maintain-out-Set erstellen, der für die Bewertung von Bedeutung ist. Solltest du es überhaupt tun? Woher wissen Sie, ob Ihr Klassifikator intestine funktioniert?

Wir haben uns diesem Drawback etwas anders angesprochen-wir haben die grundlegende Aufgabe eines halbübergreifenden Klassifikators definiert, um es zu sein Präventiv Klassifizierung einer Stichprobe. Dies bedeutet, dass unabhängig davon, was eine Probe zu einem späteren Zeitpunkt „verifiziert“ und „korrigiert“ wird: Dieser Klassifikator muss nur feststellen, was überprüft werden muss.

Als solches haben wir ein Design für die Behandlung seiner Daten erstellt:

• N+1 Klassen, wo die letzte Klasse ist Lärm
• Lärm: Daten aus Klassen, die sich nicht im Zuständigkeitsbereich des aktuellen Klassifikators befinden. Die Rauschklasse wird als 2 -fach die durchschnittliche Größe der Daten für die Etiketten des Klassifikators beträgt

Überabsteuerung des Rauschens ist ein Kennzeichen für die Fake-Sicherheit, um sicherzustellen, dass benachbarte Daten, die zu einer anderen Klasse gehört, höchstwahrscheinlich als Rauschen vorhergesagt werden, anstatt zur Überprüfung durchzuschlitten.

Wie überprüft man, ob dieser Klassifikator intestine funktioniert – in unseren Experimenten definieren wir dies als die Anzahl der „unsicheren“ Proben in der Vorhersage eines Klassifikators. Mithilfe von Probenahme und Informationsgewinnprinzipien konnten wir effektiv einschätzen, wenn ein Klassifikator „lernt“ oder nicht, was als Zeiger auf die Klassifizierungsleistung fungiert. Dieser Klassifizierer wird durchweg umgeschrieben, es sei denn, es gibt einen Wendepunkt in der Anzahl ungewöhnlicher Proben, oder es gibt nur eine Delta von Informationen, die durch neue Proben iterativ hinzugefügt werden.

Proxy Energetic Studying über einen LLM -Agenten

Dies ist das Herzstück des Ansatzes – die Verwendung eines LLM als Proxy für einen menschlichen Validator. Der menschliche Validator -Ansatz, über den wir sprechen, ist eine aktive Kennzeichnung

Lassen Sie uns ein intuitives Verständnis der aktiven Kennzeichnung erhalten:

• Verwenden Sie ein ML -Modell, um in einem Beispieleingabedatensatz zu lernen, und prognostizieren Sie auf einem großen Satz von Datenpunkten
• Für die Vorhersagen, die in den DataPoints angegeben sind
• Rekursiv werden neue „korrigierte“ Proben als Trainingsdaten zum ML -Modell hinzugefügt
• Das ML -Modell lernt/stellt konsequent ab und macht Vorhersagen, bis das KMU durch die Qualität der Vorhersagen zufrieden ist

Damit die aktive Kennzeichnung funktioniert, sind Erwartungen für ein KMU beteiligt:

• Wenn wir erwarten, dass ein menschlicher Experte eine Ausgangsprobe „validieren“, versteht der Experte, was die Aufgabe ist
• Ein menschlicher Experte wird ein Urteil verwenden, um „Was sonst“ definitiv zu einem Etikett gehört L Bei der Entscheidung, ob eine neue Stichprobe zu gehören sollte L

Angesichts dieser Erwartungen und Intuitionen können wir diese mit einem LLM „nachahmen“:

• Geben Sie dem LLM ein „Verständnis“ dessen, was jedes Etikett bedeutet. Dies kann durch Verwendung eines größeren Modells zu erfolgen Bewerten Sie die Beziehung kritisch Zwischen {Label: Daten zu Kennzeichnung} für alle Etiketten. In unseren Experimenten wurde dies mit a durchgeführt 32B Variante von Deepseek Das battle selbst gehostet.

• Anstatt vorherzusagen, was das richtige Etikett ist, Nutzen Sie die LLM, um festzustellen, ob eine Vorhersage nur „gültig“ oder „ungültig“ ist (IE, LLM muss nur eine binäre Abfrage beantworten).
• Verstärken Sie die Idee, wie andere gültige Proben für das Etikett aussehen, dh für jede präventiv vorhergesagte Etikett für eine Probe dynamisch Quelle C Nächste Muster in der Schulung (garantiert gültig), wenn sie zur Validierung aufgefordert werden.

Das Ergebnis? Ein kostengünstiger Rahmen, der sich auf einen schnellen, billigen Klassifizierer stützt, um präventive Klassifizierungen vorzunehmen, und ein LLM, das diese mithilfe der Verwendung überprüft (was bedeutet, dass das Etikett + dynamisch gesammelte Trainingsmuster ähnlich der aktuellen Klassifizierung entspricht):

import math

def calculate_uncertainty(clf, pattern):
    predicted_probabilities = clf.predict_proba(pattern.reshape(1, -1))(0)  # Reshape pattern for predict_proba
    uncertainty = -sum(p * math.log(p, 2) for p in predicted_probabilities)
    return uncertainty


def select_informative_samples(clf, information, okay):
    informative_samples = ()
    uncertainties = (calculate_uncertainty(clf, pattern) for pattern in information)

    # Kind information by descending order of uncertainty
    sorted_data = sorted(zip(information, uncertainties), key=lambda x: x(1), reverse=True)

    # Get prime okay samples with highest uncertainty
    for pattern, uncertainty in sorted_data(:okay):
        informative_samples.append(pattern)

    return informative_samples


def proxy_label(clf, llm_judge, okay, testing_data):
    #llm_judge - any LLM with a system immediate tuned for verifying if a pattern belongs to a category. Anticipated output is a bool : True or False. True verifies the unique classification, False refutes it
    predicted_classes = clf.predict(testing_data)

    # Choose okay most informative samples utilizing uncertainty sampling
    informative_samples = select_informative_samples(clf, testing_data, okay)

    # Checklist to retailer right samples
    voted_data = ()

    # Consider informative samples with the LLM decide
    for pattern in informative_samples:
        sample_index = testing_data.tolist().index(pattern.tolist()) # modified from testing_data.index(pattern) due to numpy array sort situation
        predicted_class = predicted_classes(sample_index)

        # Test if LLM decide agrees with the prediction
        if llm_judge(pattern, predicted_class):
            # If right, add the pattern to voted information
            voted_data.append(pattern)

    # Return the listing of right samples with proxy labels
    return voted_data

Durch die Fütterung der gültigen Proben (VODT_DATA) in unseren Klassifikator unter kontrollierten Parametern erreichen wir den „rekursiven“ Teil unseres Algorithmus:

Auf diese Weise konnten wir in kontrollierten Datensätzen mit mehreren Klassen eng an der Human-Knowledgeable-Validierungsnummern erfolgen. Experimentell skaliert rote Skalen bis zu 1.000 Klassen und gleichzeitig ein kompetentes Maß an Genauigkeit beibehalten Quick entspricht menschlicher Experten (90%+ Vereinbarung).

Ich glaube, dies ist eine erhebliche Errungenschaft in der angewandten ML und verfügt über reale Verwendungen für die Erwartungen von Produktionsqualität an Kosten, Geschwindigkeit, Skalierung und Anpassungsfähigkeit. Der technische Bericht, der später in diesem Jahr veröffentlicht wird, zeigt relevante Codeproben sowie experimentelle Setups, die zur Erzielung der gegebenen Ergebnisse verwendet werden.

Alle Bilder, sofern nicht anders angegeben, stammen vom Autor

Interessiert an weiteren Particulars? Wach mich an Medium Oder E -Mail für einen Chat!