{"id":647800,"date":"2025-10-15T05:30:14","date_gmt":"2025-10-15T04:30:14","guid":{"rendered":"https:\/\/blog.jetbrains.com\/?post_type=pycharm&p=647800"},"modified":"2025-10-15T05:30:23","modified_gmt":"2025-10-15T04:30:23","slug":"feintuning-und-bereitstellung-von-gpt-modellen-mit-transformers-von-hugging-face","status":"publish","type":"pycharm","link":"https:\/\/blog.jetbrains.com\/de\/pycharm\/2025\/10\/feintuning-und-bereitstellung-von-gpt-modellen-mit-transformers-von-hugging-face\/","title":{"rendered":"Feintuning und Bereitstellung von GPT-Modellen mit Transformers von Hugging Face"},"content":{"rendered":"

F\u00fcr Forschende und Interessierte im Bereich des maschinellen Lernens ist Hugging Face mittlerweile zu einem Alltagsbegriff geworden. Zu den gr\u00f6\u00dften Erfolgen von Hugging Face z\u00e4hlt Transformers<\/a>, ein Modelldefinitions-Framework f\u00fcr ML-Modelle in den Bereichen Text, Computer Vision, Audio und Video. Aufgrund der umfangreichen Sammlung modernster Machine-Learning-Modelle, die im Hugging Face Hub<\/a> verf\u00fcgbar sind, und der Kompatibilit\u00e4t mit den meisten Trainingsframeworks wird Transformers h\u00e4ufig f\u00fcr Inferenz und Modelltraining eingesetzt.<\/p>\n

Warum ben\u00f6tigen KI-Modelle ein Feintuning?<\/h2>\n

Das Feintuning von KI-Modellen ist entscheidend, um ihre Leistung an bestimmte Aufgaben und Datensammlungen anzupassen. Dadurch k\u00f6nnen sie im Vergleich zu universellen Modellen eine h\u00f6here Genauigkeit und Effizienz erzielen. Durch das Feintuning eines vortrainierten Modells muss das Training nicht von Grund auf neu erfolgen, sodass Zeit und Ressourcen gespart werden. Dar\u00fcber hinaus k\u00f6nnen spezifische Formate, Nuancen und Sonderf\u00e4lle innerhalb eines bestimmten Bereichs besser gehandhabt werden, was zuverl\u00e4ssigere und besser angepasste Ergebnisse erm\u00f6glicht.<\/p>\n

In diesem Blogartikel werden wir ein GPT-Modell f\u00fcr mathematisches Denken optimieren, damit es mathematische Fragen besser beantworten kann.<\/p>\n

Verwendung von Hugging-Face-Modellen<\/h2>\n

In PyCharm k\u00f6nnen wir unkompliziert alle auf Hugging Face bereitgestellten Modelle durchsuchen und hinzuf\u00fcgen. W\u00e4hlen Sie in einer neuen Python-Datei aus dem Men\u00fc Code<\/em> in der oberen Men\u00fcleiste die Option Insert HF Model<\/em>.<\/p>\n

\"Verwendung<\/figure>\n

Im angezeigten Men\u00fc k\u00f6nnen Sie die Modelle nach Kategorien durchsuchen oder in die Suchleiste oben einen Suchtext eingeben. Wenn Sie ein Modell ausw\u00e4hlen, wird dessen Beschreibung auf der rechten Seite angezeigt.<\/p>\n

\"Hugging-Face-Modelle<\/figure>\n

Wenn Sie auf Use Model<\/em> klicken, wird ein Codeabschnitt in Ihre Datei eingef\u00fcgt. Das war\u2019s \u2013 Sie k\u00f6nnen nun Ihr Hugging-Face-Modell verwenden.<\/p>\n

\"Hugging-Face-Modelle<\/figure>\n

GPT-Modelle (Generative Pre-Trained Transformer)<\/h2>\n

GPT-Modelle sind im Hugging Face Hub<\/a> sehr popul\u00e4r \u2013 aber was sind sie eigentlich? GPTs sind trainierte Modelle, die nat\u00fcrliche Sprache verstehen und qualitativ hochwertige Texte generieren. Sie werden haupts\u00e4chlich f\u00fcr Aufgaben im Bereich der textuellen Inferenz, der Beantwortung von Fragen, der semantischen \u00c4hnlichkeit und der Dokumentklassifizierung eingesetzt. Das bekannteste Beispiel ist das von OpenAI entwickelte ChatGPT<\/a>.<\/p>\n

Im Hugging Face Hub<\/a> sind zahlreiche OpenAI-GPT-Modelle verf\u00fcgbar. Wir werden sehen, wie wir diese Modelle mit Transformers verwenden, mit unseren eigenen Daten optimieren und in eine Anwendung integrieren k\u00f6nnen.<\/p>\n

Vorteile von Transformers<\/h2>\n

Transformers stellt in Verbindung mit anderen von Hugging Face bereitgestellten Tools hochentwickelte Instrumente f\u00fcr das Feintuning komplexer Deep-Learning-Modelle bereit. Sie m\u00fcssen nicht die Architektur und die Tokenisierungsmethode jedes einzelnen Modells bis ins Detail verstehen, denn diese Tools erm\u00f6glichen die Plug-and-Play-Nutzung von Modellen mit beliebigen kompatiblen Trainingsdaten und bieten dabei umfangreiche Anpassungsm\u00f6glichkeiten f\u00fcr Tokenisierung und Training.<\/p>\n

Transformers im Einsatz<\/h2>\n

Um einen genaueren Einblick in die Funktionsweise von Transformers zu erhalten, sehen wir uns an, wie wir es f\u00fcr die Interaktion mit einem GPT-Modell verwenden k\u00f6nnen.<\/p>\n

Inferenz unter Verwendung eines vortrainierten Modells in einer Pipeline<\/h3>\n

Nachdem wir das OpenAI-GPT-2-Modell ausgew\u00e4hlt und hinzugef\u00fcgt haben, sieht unser Code wie folgt aus:<\/p>\n

from transformers import pipeline\n\n\npipe = pipeline(\"text-generation\", model=\"openai-community\/gpt2\")<\/pre>\n
Um das Modell verwenden zu k\u00f6nnen, m\u00fcssen wir einige Vorbereitungen treffen. Zun\u00e4chst m\u00fcssen wir ein Machine-Learning-Framework installieren. In diesem Beispiel verwenden wir PyTorch<\/a>. Sie k\u00f6nnen es unkompliziert im PyCharm-Fenster Python Packages<\/em> installieren.<\/p>\n
\"PyTorch<\/figure>\n
Anschlie\u00dfend m\u00fcssen wir Transformers mithilfe der Option `torch` installieren. Sie k\u00f6nnen dies im Terminal erledigen, das Sie mit der Schaltfl\u00e4che auf der linken Seite oder mit der Tastenkombination \u2325 F12 <\/em>(macOS) bzw. Alt + F12<\/em> (Windows) \u00f6ffnen k\u00f6nnen.<\/p>\n
\"Transformers<\/figure>\n
Da wir uv verwenden, nutzen wir im Terminal die folgenden Befehle, um das Paket als Abh\u00e4ngigkeit hinzuzuf\u00fcgen und zu installieren:<\/p>\n
uv add \u201ctransformers[torch]\u201d\nuv sync<\/pre>\n
Wenn Sie pip verwenden:<\/p>\n
pip install \u201ctransformers[torch]\u201d<\/pre>\n
Au\u00dferdem installieren wir einige weitere Bibliotheken, die wir sp\u00e4ter ben\u00f6tigen werden, darunter python-dotenv, datasets, <\/em>notebook und ipywidgets. <\/em>Sie k\u00f6nnen eine der oben genannten Methoden verwenden, um sie zu installieren.
Anschlie\u00dfend empfiehlt es sich, ein GPU-System hinzuzuf\u00fcgen, um das Modell zu beschleunigen. Je nachdem, wie Ihr System ausgestattet ist, k\u00f6nnen Sie den Device-Parameter der Pipeline anpassen. <\/em>Da ich ein Mac-M2-System verwende, kann ich wie folgt device=\"mps\"<\/code> einstellen:<\/p>\n
pipe = pipeline(\"text-generation\", model=\"openai-community\/gpt2\", device=\"mps\")<\/pre>\n
Wenn Sie CUDA-GPUs haben, k\u00f6nnen Sie auch device=\"cuda\"<\/code> verwenden.<\/p>\n
Nachdem wir unsere Pipeline eingerichtet haben, testen wir sie mit einem einfachen Prompt:<\/p>\n
from transformers import pipeline\n\n\npipe = pipeline(\"text-generation\", model=\"openai-community\/gpt2\", device=\"mps\")\n\n\nprint(pipe(\"A rectangle has a perimeter of 20 cm. If the length is 6 cm, what is the width?\", max_new_tokens=200))<\/pre>\n
F\u00fchren Sie das Skript mit der Run<\/em>-Schaltfl\u00e4che () am oberen Rand aus:<\/p>\n
\"Skript<\/figure>\n
Das Ergebnis wird in etwa so aussehen:<\/p>\n
[{'generated_text': 'A rectangle has a perimeter of 20 cm. If the length is 6 cm, what is the width?nnA rectangle has a perimeter of 20 cm. If the length is 6 cm, what is the width? A rectangle has a perimeter of 20 cm. If the width is 6 cm, what is the width? A rectangle has a perimeter of 20 cm. If the width is 6 cm, what is the width? A rectangle has a perimeter of 20 cm. If the width is 6 cm, what is the width?nnA rectangle has a perimeter of 20 cm. If the width is 6 cm, what is the width? A rectangle has a perimeter of 20 cm. If the width is 6 cm, what is the width? A rectangle has a perimeter of 20 cm. If the width is 6 cm, what is the width? A rectangle has a perimeter of 20 cm. If the width is 6 cm, what is the width?nnA rectangle has a perimeter of 20 cm. If the width is 6 cm, what is the width? A rectangle has a perimeter'}]<\/pre>\n
Von Nachdenken ist hier nicht viel zu sehen \u2013 das ist nur ein Haufen Unsinn.<\/p>\n
M\u00f6glicherweise wird auch folgende Warnung angezeigt:<\/p>\n
Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.<\/pre>\n
Dies ist die Standardeinstellung. Sie k\u00f6nnen auch wie unten gezeigt eine manuelle Einstellung vornehmen, damit diese Warnung verschwindet, aber wir m\u00fcssen uns zu diesem Zeitpunkt nicht allzu viele Gedanken dar\u00fcber machen.<\/p>\n
print(pipe(\"A rectangle has a perimeter of 20 cm. If the length is 6 cm, what is the width?\", max_new_tokens=200, pad_token_id=pipe.tokenizer.eos_token_id))<\/pre>\n
Nachdem wir nun gesehen haben, wie sich GPT-2 standardm\u00e4\u00dfig verh\u00e4lt, wollen wir versuchen, seine mathematischen F\u00e4higkeiten durch etwas Feintuning zu verbessern.<\/p>\n
Eine Datensammlung vom Hugging Face Hub laden und vorbereiten<\/h3>\n
Bevor wir mit der Arbeit am GPT-Modell beginnen, ben\u00f6tigen wir zun\u00e4chst Trainingsdaten. Sehen wir uns an, wie wir eine Datensammlung vom Hugging Face Hub beziehen k\u00f6nnen.<\/p>\n
Falls Sie dies noch nicht getan haben, erstellen Sie einen Hugging-Face-Account und lassen Sie sich einen Zugangstoken ausstellen<\/a>. F\u00fcrs Erste ben\u00f6tigen wir nur einen `read`-Token. Speichern Sie Ihren Token in einer `.env`-Datei:<\/p>\n
HF_TOKEN=your-hugging-face-access-token<\/pre>\n
Wir werden dieses Math Reasoning Dataset<\/a> verwenden, dessen Beschreibung auf mathematisches Denken hinweist. Wir werden unser GPT-Modell mit dieser Datensammlung optimieren, damit es mathematische Probleme effektiver l\u00f6sen kann.<\/p>\n
Wir erstellen f\u00fcr das Feintuning ein neues Jupyter-Notebook, da wir so verschiedene Codeabschnitte nacheinander ausf\u00fchren und dabei den Fortschritt \u00fcberwachen k\u00f6nnen.<\/p>\n
In der ersten Zelle laden wir mit diesem Skript die Datensammlung vom Hugging Face Hub:<\/p>\n
from datasets import load_dataset\nfrom dotenv import load_dotenv\nimport os\n\n\nload_dotenv()\ndataset = load_dataset(\"Cheukting\/math-meta-reasoning-cleaned\", token=os.getenv(\"HF_TOKEN\"))\ndataset<\/pre>\n
F\u00fchren Sie diese Zelle aus, um die Datensammlung herunterzuladen (dies kann je nach Ihrer Internetgeschwindigkeit eine Weile dauern). Im Anschluss k\u00f6nnen wir uns das Ergebnis ansehen:<\/p>\n
DatasetDict({\n    train: Dataset({\n        features: ['id', 'text', 'token_count'],\n        num_rows: 987485\n    })\n})\n<\/pre>\n
Wenn Sie neugierig sind und einen Blick in die Daten werfen m\u00f6chten, k\u00f6nnen Sie dies in PyCharm tun. \u00d6ffnen Sie das Fenster Jupyter Variables<\/em> mit der Schaltfl\u00e4che auf der rechten Seite:<\/p>\n
\"Fenster<\/figure>\n
Wenn Sie dataset<\/em> erweitern, sehen Sie neben dataset[‘train’]<\/em> die Option View as Dataframe<\/em>:<\/p>\n
\"Das<\/figure>\n
Klicken Sie darauf, um die Daten im Toolfenster Data View<\/em> anzuzeigen:<\/p>\n
\"Toolfenster<\/figure>\n
Als N\u00e4chstes tokenisieren wir den Text in der Datensammlung:<\/p>\n
from transformers import GPT2Tokenizer\n\n\ntokenizer = GPT2Tokenizer.from_pretrained(\"openai-community\/gpt2\")\ntokenizer.pad_token = tokenizer.eos_token\n\n\ndef tokenize_function(examples):\n   return tokenizer(examples['text'], truncation=True, padding='max_length', max_length=512)\n\n\ntokenized_datasets = dataset.map(tokenize_function, batched=True)<\/pre>\n
Wir verwenden den GPT-2-Tokenizer und setzen pad_token<\/code> auf eos_token<\/code>, also den Token, der das Zeilenende anzeigt. Anschlie\u00dfend zerlegen wir mit einer Funktion den Text in Token. Beim ersten Mal kann die Ausf\u00fchrung einige Zeit in Anspruch nehmen, die Zelle wird jedoch in einem Cache gespeichert, sodass ein erneutes Ausf\u00fchren schneller erfolgt.<\/p>\n
Die Datensammlung umfasst knapp eine Million Zeilen, die f\u00fcr das Training verwendet werden k\u00f6nnen. Wenn Sie \u00fcber ausreichende Rechenleistung f\u00fcr die Verarbeitung verf\u00fcgen, k\u00f6nnen Sie alle verwenden. In dieser Demo f\u00fchren wir das Training allerdings lokal auf einem Laptop aus, daher tun wir gut daran, nur einen kleinen Teil zu verwenden!<\/p>\n
tokenized_datasets_split = tokenized_datasets[\"train\"].shard(num_shards=100, index=0).train_test_split(test_size=0.2, shuffle=True)\ntokenized_datasets_split<\/pre>\n
Hier nehme ich nur 1% der Daten und f\u00fchre dann train_test_split<\/code> aus, um die Datensammlung in zwei Teile zu unterteilen:<\/p>\n
DatasetDict({\n    train: Dataset({\n        features: ['id', 'text', 'token_count', 'input_ids', 'attention_mask'],\n        num_rows: 7900\n    })\n    test: Dataset({\n        features: ['id', 'text', 'token_count', 'input_ids', 'attention_mask'],\n        num_rows: 1975\n    })\n})\n<\/pre>\n
Nun sind wir bereit f\u00fcr das Feintuning des GPT-2-Modells.<\/p>\n
Feintuning eines GPT-Modells<\/h3>\n
In der n\u00e4chsten leeren Zelle tragen wir unsere Argumente f\u00fcr das Training ein:<\/p>\n
from transformers import TrainingArguments\ntraining_args = TrainingArguments(\n   output_dir='.\/results',\n   num_train_epochs=5,\n   per_device_train_batch_size=8,\n   per_device_eval_batch_size=8,\n   warmup_steps=100,\n   weight_decay=0.01,\n   save_steps = 500,\n   logging_steps=100,\n   dataloader_pin_memory=False\n)<\/pre>\n
Die meisten davon sind weitgehend Standard f\u00fcr das Feintuning eines Modells. Je nach Ihrem Computersystem sollten Sie jedoch eventuell einige Einstellungen anpassen:<\/p>\n