KI-Textklassifizierung für Support-Tickets: BERT-Modelle für automatisiertes Ticket-Routing trainieren

Dieser umfassende Leitfaden zeigt, wie Sie eine Künstliche Intelligenz (KI) zur automatisierten Ticket-Klassifizierung in Helpdesk- und Support-Systemen wie OTOBO trainieren. Erfahren Sie, wie Sie intelligentes Ticket-Routing, automatisierte Prioritätszuweisung und intelligente Queue-Verteilung mithilfe modernster Machine-Learning-Techniken mit BERT (Bidirectional Encoder Representations from Transformers) implementieren.

Egal, ob Sie Ihren IT-Service-Desk optimieren, Customer-Support-Workflows automatisieren oder ein KI-gestütztes Ticket-Management implementieren möchten – dieses Tutorial deckt den gesamten Prozess von der Datenvorbereitung über das Modelltraining bis hin zur Evaluierung ab.

Warum KI-gestützte Ticket-Klassifizierung wichtig ist

Moderne Support-Teams bearbeiten täglich Hunderte oder Tausende von Tickets. Die manuelle Klassifizierung ist zeitaufwendig, fehleranfällig und inkonsistent. KI-gestützte Ticket-Automatisierung bietet:

• Reduzierte Antwortzeiten durch sofortiges, präzises Routing
• Verbesserte First-Contact-Resolution durch Zuweisung der Tickets an die richtigen Experten
• Konsistente Klassifizierung über alle eingehenden Anfragen hinweg
• Automatisierte 24/7-Ticket-Verarbeitung ohne menschliches Eingreifen
• Kosteneinsparungen durch Workflow-Optimierung und Automatisierung

Für Unternehmen, die professionelle Ticket-Automatisierungs-Services suchen, bieten wir umfassende Lösungen zur Implementierung von KI-Klassifizierungssystemen. Kontaktieren Sie uns, um zu erfahren, wie wir Ihre Support-Workflows mit maßgeschneiderten KI-Modellen und Integrations-Services optimieren können.

Wichtige Anwendungsfälle für KI-Ticket-Klassifizierung

Automatisierte Ticket-Klassifizierung auf Basis von Machine Learning kann verschiedene Support-Szenarien transformieren:

• IT-Helpdesk: Automatisches Routing von Hardware-, Software- und Netzwerkproblemen an spezialisierte Teams
• Customer Support: Klassifizierung von Produktanfragen, Beschwerden und technischen Fragen
• E-Commerce: Sortierung von Bestellproblemen, Zahlungsschwierigkeiten und Versandfragen
• SaaS-Plattformen: Angemessene Weiterleitung von Bug-Reports, Feature-Requests und Anwendungsfragen
• Multi-Channel-Support: Vereinheitlichung der Klassifizierung über E-Mail, Chat, Telefon und Social Media

Anforderungen

• Python 3.10+
• Libraries: datasets, transformerstorch, psutil, gputil, nvidia_smi, huggingface_hub, nlpaug, nltk, sentencepiece

Installieren Sie die erforderlichen Pakete 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

Zuerst müssen die Ticket-Daten vorbereitet werden. Dies umfasst das Laden der Daten, die Bereinigung und die Vorverarbeitung des Textes. Für dieses Tutorial verwenden wir die folgenden Daten:

Beispieldaten

Wir verwenden subject und body als Features, während priority und queue die Labels sind, die wir vorhersagen möchten.

Features und Labels

Bei der Text-Sequenz-Klassifizierung mit BERT können wir nur ein Feature verwenden. Daher kombinieren wir subject und body. Da wir dem subject mehr Gewicht verleihen möchten, verketten wir die Texte, indem wir das subject zweimal und den body einmal einfügen.

import pandas as pd

# Beispieldaten
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", "Accounting", "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

Um das Modell zu trainieren, müssen wir die Labels in Zahlen umwandeln. Hier ist der Code dafür:

from sklearn.preprocessing import LabelEncoder

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

# Labels in Zahlen umwandeln
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:

Da wir für unsere Klassifizierung nur ein Label haben können, haben wir nun zwei Optionen.

1. Die beiden Labels zu einem kombinieren. Dies würde zu priority_queue führen: HIGHSoftware, HIGHHardware, HIGHAccounting usw. Dies würde zu PRODUCT[len(unique(label)) for label in labels] führen, 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 Klassifizierungsproblems.
   • Potenziell schlechtere Performance bei geringer Datenmenge pro Kombination.
2. Ein separates Modell für jedes Label trainieren. In diesem Tutorial verwenden wir Methode 2. Wir haben ein separates Modell für Queue und Priority.

Code zum Aufteilen der Tabelle in Queue- und Priority-Tabelle

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

print(queue_df)
print(priority_df)

Tabelle für das Queue-Modell

Tabelle für das Priority-Modell

Tokenizer-Erklärung

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

Token-Encoding

Beim Token-Encoding werden Tokens in Zahlen umgewandelt, damit sie von Machine-Learning-Modellen 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 Encoding 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)

Beispiel-Output für "Login Issue Login Issue Unable to login to the system":

Tokens:

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

Encoded Tokens:

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

Aufteilen der Tabellen in Train- und Test-Dataset

Um unsere Modelle zu trainieren und zu testen, teilen wir die Daten in Trainings- und Test-Datensätze auf. Hier ist der Code dafür:

from sklearn.model_selection import train_test_split

# Queue-Tabelle in Train- und Test-Datensätze aufteilen
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)

# Priority-Tabelle in Train- und Test-Datensätze aufteilen
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 das Aufteilen der Daten stellen wir sicher, dass wir genügend Daten zum Trainieren und Testen unserer Modelle haben, was uns ermöglicht, deren Performance zu bewerten.

Modelltraining

In diesem Abschnitt beschreiben wir, wie das Modell mit unseren Trainingsdaten trainiert wird. Wir verwenden die transformers-Library 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, Question Answering 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 aber zu häufigeren Aktualisierungen der Modellparameter.
• epochs: Die Anzahl der vollständigen Durchläufe durch den gesamten Trainingsdatensatz. Mehr Epochen können zu einem besseren Modell führen, bergen aber das Risiko von Overfitting.
• learning_rate: Die Schrittweite, mit der das Modell seine Parameter anpasst. Eine zu hohe Learning Rate kann zu instabilen Trainingsprozessen führen, während eine zu niedrige Learning Rate 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 verwenden die vorbereiteten Datensätze queue_train, queue_test, priority_train, priority_test für Training und 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)

Modell-Evaluierung

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 stellen wir sicher, dass unsere Modelle gut trainiert und evaluiert sind, um die Klassifizierungsaufgabe erfolgreich zu lösen.

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

Vorhersage-Genauigkeit

Die Accuracy wird berechnet, indem die Anzahl der korrekten Vorhersagen durch die Gesamtzahl der Vorhersagen geteilt wird. Hier ist ein Python-Code zur Berechnung der Accuracy:

from sklearn.metrics import accuracy_score

# Beispiel-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 Accuracy
accuracy = accuracy_score(y_true, y_pred)
print(f"Accuracy: {accuracy * 100:.2f}%")

Evaluierung mit kontinuierlichen Zahlen

Bei kontinuierlichen Zahlen wie 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 des Mean Absolute Error und des Mean Squared Error.

Mean Absolute Error

Der Mean Absolute Error misst, wie weit Vorhersagen von den tatsächlichen Werten entfernt sind. Hier ist ein Python-Code zur Berechnung des Mean Absolute Error:

import numpy as np

# Beispiel-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 des Mean Absolute Error
mean_absolute_error = np.mean(np.abs(y_true - y_pred))
print(f"Mean Absolute Error: {mean_absolute_error}")

Mean Squared Error

Der Mean Squared Error misst die quadratische Abweichung der Vorhersagen von den tatsächlichen Werten, wodurch größere Fehler stärker gewichtet werden. Hier ist ein Python-Code zur Berechnung des Mean Squared Error:

# Berechnung des Mean Squared Error
mean_squared_error = np.mean((y_true - y_pred) ** 2)
print(f"Mean Squared Error: {mean_squared_error}")

Mit diesen Metriken können wir die Performance unserer Modelle besser verstehen und verbessern. Die Accuracy gibt uns einen Gesamtüberblick über die Performance, während Mean Absolute Error und Mean Squared Error für kontinuierliche Zahlen eine detailliertere Evaluierung ermöglichen.

Professionelle Ticket-Automatisierungs-Services

Während dieses Tutorial die Grundlage für den Aufbau KI-gestützter Ticket-Klassifizierungssysteme bietet, erfordert die Implementierung produktionsreifer Lösungen zusätzliche Expertise in:

• Modell-Optimierung und Fine-Tuning für Ihre spezifischen Ticket-Typen
• Integration in bestehende Ticket-Systeme (OTOBO, Znuny, Zammad und andere)
• Skalierbares Deployment und Infrastruktur-Setup
• Kontinuierliche Modellverbesserung basierend auf Feedback und neuen Daten
• Mehrsprachigkeits-Support für internationale Helpdesks
• Benutzerdefinierte Klassifizierungskategorien, die auf Ihre geschäftlichen Anforderungen zugeschnitten sind

Unsere Ticket-Automatisierungs-Services

Wir bieten umfassende Beratungs- und Implementierungs-Services für Ticket-Automatisierung:

• KI-Modellentwicklung: Maßgeschneiderte Modelle für Ihre spezifischen Ticket-Typen und Workflows
• Systemintegration: Nahtlose Integration in OTOBO, OTRS, Znuny und andere Ticketing-Plattformen
• API-Entwicklung: REST APIs für Echtzeit-Ticket-Klassifizierung und Routing
• Training & Support: Team-Schulungen und laufender technischer Support
• Performance-Optimierung: Kontinuierliche Modellverbesserung und Fine-Tuning

Erfahren Sie mehr über unsere automatisierten Ticket-Klassifizierungslösungen unter OpenTicketAI.com – einer spezialisierten Plattform für KI-gestütztes Ticket-Management und intelligente Helpdesk-Automatisierung.

Sofort einsatzbereite Lösungen

Wenn Sie eine verwaltete Lösung dem Eigenbau vorziehen, schauen Sie sich an:

• OpenTicketAI.com: Cloud-basierte KI-Ticket-Klassifizierung mit einfacher Integration
• REST API für Ticket-Klassifizierung: Lesen Sie unseren Leitfaden zur Automated Ticket Classification API für API-basierte Lösungen

Für individuelle Anforderungen oder Enterprise-Implementierungen kontaktieren Sie uns unter atc-api@softoft.de, um Ihre Anforderungen an die Ticket-Automatisierung zu besprechen.

Zusammenfassung

In diesem Artikel haben wir gezeigt, wie man ein KI-Modell für die automatisierte Ticket-Klassifizierung mit BERT und Python trainiert. Durch die Nutzung von Machine-Learning-Libraries wie Transformers und Scikit-Learn können Sie intelligente Systeme erstellen, die Support-Tickets automatisch nach Priorität, Queue und Kategorie klassifizieren.

Dieser KI-gestützte Ansatz für das Ticket-Management verbessert signifikant:

• Effizienz des Support-Teams durch automatisiertes Routing
• Kundenzufriedenheit durch schnellere Antwortzeiten
• Betriebskosten durch Reduzierung manueller Klassifizierungsarbeit
• Konsistenz der Ticket-Bearbeitung im gesamten Unternehmen

Die hier behandelten Techniken bilden das Fundament für den Aufbau anspruchsvoller Helpdesk-Automatisierungs- und intelligenter Ticket-Routing-Systeme. Egal, ob Sie dies selbst implementieren oder professionelle Unterstützung suchen – die KI-gestützte Ticket-Klassifizierung transformiert moderne Customer-Support-Operationen.

Weiterführende Ressourcen

• Automated Ticket Classification API - Erfahren Sie mehr über REST-API-Lösungen
• OpenTicketAI.com - Managed KI-Ticket-Klassifizierungs-Service
• OTOBO Dokumentation - Open-Source-Ticketing-System-Integration