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

Diese umfassende Anleitung zeigt, wie man eine Künstliche Intelligenz (KI) für die automatisierte Ticket-Klassifizierung in Helpdesk- und Support-Systemen wie OTOBO trainiert. Erfahren Sie, wie Sie intelligentes Ticket-Routing, automatisierte Prioritätszuweisung und intelligente Warteschlangenverteilung mit modernsten Techniken des maschinellen Lernens und BERT (Bidirectional Encoder Representations from Transformers) implementieren.

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

Warum KI-gestützte Ticket-Klassifizierung wichtig ist

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

• Reduzierte Antwortzeiten durch sofortiges, genaues Routing
• Verbesserte First-Contact-Resolution durch Zuordnung von Tickets zu den richtigen Experten
• Konsistente Klassifizierung über alle eingehenden Anfragen hinweg
• 24/7 automatisierte Ticket-Verarbeitung ohne menschliches Eingreifen
• Kosteneinsparungen durch Workflow-Optimierung und Automatisierung

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

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

Automatisierte Ticket-Klassifizierung, gestützt auf maschinelles Lernen, kann verschiedene Support-Szenarien transformieren:

• IT-Helpdesk: Automatisches Routing von Hardware-, Software- und Netzwerkproblemen zu spezialisierten Teams
• Kundensupport: Klassifizierung von Produktanfragen, Beschwerden und technischen Fragen
• E-Commerce: Sortierung von Bestellproblemen, Zahlungsproblemen und Versandanfragen
• SaaS-Plattformen: Gezielte Weiterleitung von Bug-Reports, Feature-Requests und Nutzungsfragen
• Multi-Channel-Support: Vereinheitlichung der Klassifizierung über E-Mail, Chat, Telefon und Social Media hinweg

Voraussetzungen

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

Installieren Sie die benötigten 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 Vorverarbeitung des Textes. Für dieses Tutorial verwenden wir die folgenden Daten:

Beispiel-Daten

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

Features und Labels

Bei der Verwendung von Textsequenzklassifizierung mit BERT können wir nur ein Feature verwenden. Daher kombinieren wir subject und body. Da wir dem subject mehr Gewicht geben möchten, verketten wir die Texte, indem wir das 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", "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 nur ein Label für unsere Klassifizierung haben können, haben wir nun zwei Möglichkeiten.

1. Die beiden Labels zu einem kombinieren. Dies würde zu priority_queue führen: HIGHSoftware, HIGHHardware, HIGHAccounting, etc. Dies würde zu PRODUKT[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 geringen Daten 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 Queue-Modell

Tabelle für Priority-Modell

Tokenizer-Erklärung

Ein Tokenizer wandelt Text in kleinere Einheiten, sogenannte Tokens, um. Diese Tokens können Wörter, Satzzeichen oder Satzkomponenten sein. Tokenizer sind wichtig, weil maschinelle Lern- 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-Kodierung

Bei der Token-Kodierung werden 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 Trainings- und Testdatensätze

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

from sklearn.model_selection import train_test_split

# Queue-Tabelle in Trainings- und Testdatensä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 Trainings- und Testdatensä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, ihre Performance zu bewerten.

Schritt 2: Modelltraining

Modelltraining

In diesem Artikel beschreiben wir, wie das Modell mit unseren Trainingsdaten trainiert wird. Wir verwenden die transformers-Bibliothek 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 Durchlauf 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 Schrittgröße, mit der das Modell seine Parameter anpasst. Eine zu hohe Lernrate kann zu instabilen Trainingsprozessen führen, während eine zu niedrige Lernrate zu langsamen 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 Evaluation.

# 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-Evaluation

Nach dem Training evaluieren wir das Modell mit den Testdaten.

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

# Evaluation 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 Evaluation der Modelle erhalten wir verschiedene Metriken, die die Performance des Modells beschreiben. Eine der wichtigsten Metriken ist die Genauigkeit (Accuracy), die angibt, wie viele der Vorhersagen korrekt sind.

Vorhersagegenauigkeit

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

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

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

Evaluation mit kontinuierlichen Zahlen

Für kontinuierliche 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 mittleren absoluten Fehlers und des mittleren quadratischen Fehlers.

Mittlerer absoluter Fehler

Der mittlere absolute Fehler misst, wie weit Vorhersagen von den tatsächlichen Werten entfernt sind. Hier ist ein Python-Code zur Berechnung des mittleren absoluten Fehlers:

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

# Mittleren absoluten Fehler berechnen
mean_absolute_error = np.mean(np.abs(y_true - y_pred))
print(f"Mittlerer absoluter Fehler: {mean_absolute_error}")

Mittlerer quadratischer Fehler

Der mittlere quadratische Fehler misst die quadrierte Abweichung der Vorhersagen von den tatsächlichen Werten, was größere Fehler stärker gewichtet. Hier ist ein Python-Code zur Berechnung des mittleren quadratischen Fehlers:

# Mittleren quadratischen Fehler berechnen
mean_squared_error = np.mean((y_true - y_pred) ** 2)
print(f"Mittlerer quadratischer Fehler: {mean_squared_error}")

Mit diesen Metriken können wir die Performance unserer Modelle besser verstehen und verbessern. Die Genauigkeit gibt uns einen Gesamtüberblick über die Performance, während der mittlere absolute Fehler und der mittlere quadratische Fehler für kontinuierliche Zahlen eine detailliertere Evaluation ermöglichen.

Professionelle Ticket-Automatisierungsdienste

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

• Modelloptimierung und Feinabstimmung für Ihre spezifischen Ticket-Typen
• Integration mit bestehenden Ticket-Systemen (OTOBO, Znuny, Zammad und andere)
• Skalierbare Bereitstellung und Infrastruktur-Einrichtung
• Kontinuierliche Modellverbesserung basierend auf Feedback und neuen Daten
• Mehrsprachige Unterstützung für internationale Helpdesks
• Benutzerdefinierte Klassifizierungskategorien, die auf Ihre Geschäftsanforderungen zugeschnitten sind

Unsere Ticket-Automatisierungsdienste

Wir bieten umfassende Ticket-Automatisierungsberatung und Implementierungsdienste an:

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

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.

Fertige Lösungen

Wenn Sie eine verwaltete Lösung dem Aufbau von Grund auf vorziehen, sehen Sie sich an:

• OpenTicketAI.com: Cloud-basierte KI-Ticket-Klassifizierung mit einfacher Integration
• REST API für Ticket-Klassifizierung: Lesen Sie unsere Anleitung zur Automatisierten Ticket-Klassifizierungs-API für API-basierte Lösungen

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

Zusammenfassung

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

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

• Die Effizienz des Support-Teams durch automatisiertes Routing
• Die Kundenzufriedenheit durch schnellere Antwortzeiten
• Die Betriebskosten durch Reduzierung manueller Klassifizierungsarbeit
• Die Konsistenz der Ticket-Bearbeitung in Ihrer Organisation

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

Verwandte Ressourcen

• Automatisierte Ticket-Klassifizierungs-API – Erfahren Sie mehr über REST-API-Lösungen
• OpenTicketAI.com – Verwalteter KI-Ticket-Klassifizierungsdienst
• OTOBO-Dokumentation – Integration von Open-Source-Ticketing-Systemen