Training einer KI zur Text Klassifizierung

In diesem Artikel wird beschrieben, wie man eine Künstliche Intelligenz (KI) trainiert, um Tickets in einem Ticketsystem wie OTOBO zu klassifizieren. Dieser Prozess umfasst Datenvorbereitung, Modelltraining und Evaluation.

Voraussetzungen

• Python 3.10+
• Bibliotheken: datasets, transformers[torch], psutil, gputil, nvidia_smi, huggingface_hub, nlpaug, nltk, sentencepiece

Installieren Sie die erforderlichen Packete mit:

pip install datasets transformers[torch] psutil gputil nvidia_smi huggingface_hub nlpaug nltk sentencepiece

oder in einem Jupyter Notebook:

!pip install datasets transformers[torch] psutil gputil nvidia_smi huggingface_hub nlpaug nltk sentencepiece

Schritt 1: Datenvorbereitung

Zunächst müssen die Ticketdaten vorbereitet werden. Dies beinhaltet das Laden der Daten, das Bereinigen und das Vorverarbeiten des Textes. Für dieses Tutroial nutzen wir folgende Daten:

Beispieldaten

subject	body	priority	queue
Login Issue	Unable to login to the system	High	Software
Password Reset	Need to reset my password	Medium	Hardware
Email Problem	Not receiving emails	Low	Buchhaltung
Network Down	Network is down in building 5	High	Software
Printer Issue	Printer not working	Medium	Hardware

Wir nutzen subject und body als Features und priority und queue sind die Labels, die wir vorhersagen wollen.

Features und Labels

Feature 1	Feature 2	Label 1	Label 2
Login Issue	Unable to login to the system	High	Software
Password Reset	Need to reset my password	Medium	Hardware
Email Problem	Not receiving emails	Low	Buchhaltung
Network Down	Network is down in building 5	High	Software
Printer Issue	Printer not working	Medium	Hardware

Beim Einsatz von Text-Sequence-Klassifizierung mit BERT können wir nur ein Feature nutzen. Daher fügen wir subject und body zusammen. Da wir dem subject mehr Gewicht geben wollen, kombinieren wir die Texte, indem wir den subject zweimal und den body einmal einfügen.

import pandas as pd

# Beispiel Daten
data = {
    'subject': ["Login Issue", "Password Reset", "Email Problem", "Network Down", "Printer Issue"],
    'body': ["Unable to login to the system", "Need to reset my password", "Not receiving emails",
             "Network is down in building 5", "Printer not working"],
    'priority': ["High", "Medium", "Low", "High", "Medium"],
    'queue': ["Software", "Hardware", "Buchhaltung", "Software", "Hardware"]
}

df = pd.DataFrame(data)

# Kombiniertes Feature erstellen
df['combined_feature'] = df.apply(lambda row: f"{row['subject']} {row['subject']} {row['body']}", axis=1)

print(df[['combined_feature', 'priority', 'queue']])

Transformierte Tabelle

Combined Feature	Label 1	Label 2
Login Issue Login Issue Unable to login to the system	High	Software
Password Reset Password Reset Need to reset my password	Medium	Hardware
Email Problem Email Problem Not receiving emails	Low	Buchhaltung
Network Down Network Down Network is down in building 5	High	Software
Printer Issue Printer Issue Printer not working	Medium	Hardware

Um das Modell zu trainieren, müssen wir die Labels in Zahlen konvertieren. Hier ist der Code, um dies zu tun:

from sklearn.preprocessing import LabelEncoder

# Label Encoder initialisieren
le_priority = LabelEncoder()
le_queue = LabelEncoder()

# Labels in Zahlen konvertieren
df['priority_encoded'] = le_priority.fit_transform(df['priority'])
df['queue_encoded'] = le_queue.fit_transform(df['queue'])

print(df[['combined_feature', 'priority_encoded', 'queue_encoded']])

Ergebnis:

Combined Feature	priority_encoded	queue_encoded
Login Issue Login Issue Unable to login to the system	0	2
Password Reset Password Reset Need to reset my password	2	1
Email Problem Email Problem Not receiving emails	1	0
Network Down Network Down Network is down in building 5	0	2
Printer Issue Printer Issue Printer not working	2	1

Da wir nur ein Label für unsere Klassifizierung haben dürfen, haben wir jetzt zwei Möglichkeiten.

1. Die beiden Labels zu einem Label zusammenfügen. Dies würde dann priority_queue ergeben: HIGHSoftware, HIGHHardware, HIGHBuchhaltung, etc. Das würde dazu führen, dass wir PRODUCT[len(unique(label)) for label in labels] hätten, also in unserem Fall len(unique(priorities)) * len(unique(queues)), also 3 * 3 = 9.

   Vorteile:

   • Einfache Implementierung und Verwaltung.
   • Ein Modell für die gesamte Klassifizierung.

   Nachteile:

   • Erhöhte Komplexität und Größe des Klassifikationsproblems.
   • Potenziell schlechtere Leistung bei geringer Datenmenge pro Kombination.

2. Für jedes Label ein eigenes Modell trainieren. In diesem Tutorial nutzen wir Methode 2. Wir haben für Queue und Priorität jeweils ein eigenes Modell.

Code zur Aufteilung der Tabelle in Queue- und Priority-Tabelle

# Aufteilen in Queue- und Priority-Tabellen
queue_df = df[['combined_feature', 'queue_encoded']]
priority_df = df[['combined_feature', 'priority_encoded']]

print(queue_df)
print(priority_df)

Tabelle für Queue-Modell

Combined Feature	queue_encoded
Login Issue Login Issue Unable to login to the system	2
Password Reset Password Reset Need to reset my password	1
Email Problem Email Problem Not receiving emails	0
Network Down Network Down Network is down in building 5	2
Printer Issue Printer Issue Printer not working	1

Tabelle für Prioritäts-Modell

Combined Feature	priority_encoded
Login Issue Login Issue Unable to login to the system	0
Password Reset Password Reset Need to reset my password	2
Email Problem Email Problem Not receiving emails	1
Network Down Network Down Network is down in building 5	0
Printer Issue Printer Issue Printer not working	2

Tokenizer Erklärung

Ein Tokenizer wandelt Text in kleinere Einheiten, sogenannte Tokens, um. Diese Tokens können Wörter, Satzzeichen oder Satzbestandteile sein. Tokenizer sind wichtig, da Maschinenlern- und NLP-Modelle Texte in einer Form benötigen, die sie verarbeiten können. Durch Tokenisierung können Modelle den Text analysieren und lernen, Muster zu erkennen.

Token-Encoding

Beim Token-Encoding werden die Tokens in Zahlen umgewandelt, damit sie von maschinellen Lernmodellen verarbeitet werden können. Hier ist ein Beispiel, wie ein tokenisierter und kodierter Text für unsere Tabelle aussehen könnte:

from transformers import BertTokenizer

# BERT Tokenizer initialisieren
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Tokenisierung und Kodierung eines Beispiels
example_text = df['combined_feature'][0]
tokens = tokenizer.tokenize(example_text)
encoded_tokens = tokenizer.convert_tokens_to_ids(tokens)
print(tokens)
print(encoded_tokens)

Beispielausgabe für "Login Issue Login Issue Unable to login to the system":

Tokens:

['login', 'issue', 'login', 'issue', 'unable', 'to', 'login', 'to', 'the', 'system']

Kodierte Tokens:

[2653, 3277, 2653, 3277, 3928, 2000, 2653, 2000, 1996, 2291]

Aufteilen der Tabellen in Train- und Testdatensatz

Um unsere Modelle zu trainieren und zu testen, teilen wir die Daten in Trainings- und Testdatensätze auf. Hier ist der Code, um dies zu tun:

from sklearn.model_selection import train_test_split

# Aufteilen der Queue-Tabelle in Train- und Testdatensätze
queue_train, queue_test, y_queue_train, y_queue_test = train_test_split(queue_df['combined_feature'],
                                                                        queue_df['queue_encoded'], test_size=0.2,
                                                                        random_state=42)

# Aufteilen der Priority-Tabelle in Train- und Testdatensätze
priority_train, priority_test, y_priority_train, y_priority_test = train_test_split(priority_df['combined_feature'],
                                                                                    priority_df['priority_encoded'],
                                                                                    test_size=0.2, random_state=42)

print(queue_train, queue_test, y_queue_train, y_queue_test)
print(priority_train, priority_test, y_priority_train, y_priority_test)

Durch diese Aufteilung stellen wir sicher, dass wir genügend Daten haben, um unsere Modelle zu trainieren und zu testen, und können so die Leistung unserer Modelle bewerten.

Schritt 2: Modelltraining

Modelltraining

In diesem Artikel beschreiben wir, wie wir das Modell mit unseren Trainingsdaten trainieren. Wir nutzen dafür die Bibliothek transformers von Hugging Face und torch für das Training von BERT-Modellen.

BERT Modell

BERT (Bidirectional Encoder Representations from Transformers) ist ein vortrainiertes Sprachmodell, das in der Lage ist, den Kontext von Wörtern in einem Satz zu erfassen. Es wird häufig für Aufgaben wie Textklassifizierung, Fragebeantwortung und viele andere NLP-Aufgaben verwendet.

Parameter für das Training

• batch_size: Die Anzahl der Beispiele, die in einem Durchgang durch das Modell verarbeitet werden. Kleinere Batch-Größen benötigen weniger Speicher, führen jedoch zu einer häufigeren Aktualisierung der Modellparameter.
• epochs: Die Anzahl der kompletten Durchläufe durch den gesamten Trainingsdatensatz. Mehr Epochen können zu einem besseren Modell führen, bergen aber das Risiko des Überanpassens.
• learning_rate: Die Schrittweite, mit der das Modell seine Parameter anpasst. Eine zu hohe Lernrate kann zu instabilen Trainingsprozessen führen, während eine zu niedrige Lernrate zu langsamem Lernen führen kann.

Initialisierung des Modells

Wir definieren eine Klasse TicketClassifier, die das Modell und die Trainingsparameter initialisiert.

from transformers import BertForSequenceClassification, BertTokenizer, Trainer, TrainingArguments


class TicketClassifier:
    def __init__(self, model_name: str):
        self.tokenizer = BertTokenizer.from_pretrained(model_name)
        self.model = BertForSequenceClassification.from_pretrained(model_name, num_labels=3)  # Für 3 Klassen (Low, Medium, High)

    def train(self, train_data, train_labels):
        training_args = TrainingArguments(output_dir='./results')

        trainer = Trainer(model=self.model, args=training_args, train_dataset=train_data)
        trainer.train()
        return trainer


classifier = TicketClassifier(model_name='bert-base-uncased')

Training des Modells

Wir nutzen die vorbereiteten Datensätze queue_train, queue_test, priority_train, priority_test für das Training und die Evaluierung.

# Training des Queue-Modells
trainer_queue = classifier.train(queue_train, y_queue_train)

# Training des Priority-Modells
trainer_priority = classifier.train(priority_train, y_priority_train)

Evaluierung des Modells

Nach dem Training evaluieren wir das Modell mit den Testdaten.

# Evaluierung des Queue-Modells
eval_queue_results = trainer_queue.evaluate(eval_dataset=queue_test)
print(eval_queue_results)

# Evaluierung des Priority-Modells
eval_priority_results = trainer_priority.evaluate(eval_dataset=priority_test)
print(eval_priority_results)

Durch diese Schritte können wir sicherstellen, dass unsere Modelle gut trainiert und evaluiert werden, um die Klassifizierungsaufgabe erfolgreich zu lösen.

Nach der Evaluation der Modelle erhalten wir verschiedene Metriken, die die Leistung des Modells beschreiben. Eine der wichtigsten Metriken ist die Genauigkeit (Accuracy), die angibt, wie viele der Vorhersagen korrekt sind.

Genauigkeit der Vorhersagen

Die Genauigkeit wird berechnet, indem die Anzahl der korrekten Vorhersagen durch die Gesamtanzahl der Vorhersagen geteilt wird. Hier ist ein Python-Code, um die Genauigkeit zu berechnen:

from sklearn.metrics import accuracy_score

# Beispielhafte Vorhersagen und tatsächliche Labels
y_true = [0, 2, 1, 0, 2]  # Tatsächliche Labels
y_pred = [0, 2, 1, 0, 1]  # Vorhergesagte Labels

# Berechnung der Genauigkeit
accuracy = accuracy_score(y_true, y_pred)
print(f"Genauigkeit: {accuracy * 100:.2f}%")

Evaluierung bei fortlaufenden Zahlen

Bei fortlaufenden Zahlen wie den Prioritätsstufen ist es wichtig, die Nähe der Vorhersagen zu berücksichtigen. Zum Beispiel ist die Vorhersage 2 näher an 1 als 3 an 1. Eine Möglichkeit, dies zu evaluieren, ist die Berechnung der durchschnittlichen Abweichung und des durchschnittlichen quadrierten Abstands.

Durchschnittliche Abweichung

Die durchschnittliche Abweichung misst, wie weit die Vorhersagen von den tatsächlichen Werten entfernt sind. Hier ist ein Python-Code, um die durchschnittliche Abweichung zu berechnen:

import numpy as np

# Beispielhafte Vorhersagen und tatsächliche Labels
y_true = np.array([0, 2, 1, 0, 2])  # Tatsächliche Labels
y_pred = np.array([0, 2, 1, 0, 1])  # Vorhergesagte Labels

# Berechnung der durchschnittlichen Abweichung
mean_absolute_error = np.mean(np.abs(y_true - y_pred))
print(f"Durchschnittliche Abweichung: {mean_absolute_error}")

Durchschnittlicher quadrierter Abstand

Der durchschnittliche quadrierte Abstand misst die quadratische Abweichung der Vorhersagen von den tatsächlichen Werten, was größere Fehler stärker gewichtet. Hier ist ein Python-Code, um den durchschnittlichen quadrierten Abstand zu berechnen:

# Berechnung des durchschnittlichen quadrierten Abstands
mean_squared_error = np.mean((y_true - y_pred) ** 2)
print(f"Durchschnittlicher quadrierter Abstand: {mean_squared_error}")

Durch diese Metriken können wir die Leistung unserer Modelle besser verstehen und verbessern. Die Genauigkeit gibt uns einen allgemeinen Überblick über die Leistung, während die durchschnittliche Abweichung und der quadrierte Abstand bei fortlaufenden Zahlen eine detailliertere Bewertung ermöglichen.

Zusammenfassung

In diesem Artikel haben wir gezeigt, wie man eine KI zur Klassifizierung von Tickets trainiert. Durch die Verwendung von Python und Bibliotheken wie scikit-learn konnten wir ein einfaches, aber effektives Modell erstellen. Dieses Modell kann weiter verbessert werden, indem man komplexere Algorithmen und umfangreichere Datensätze verwendet.