EU AI Act Compliance für LLM-Fine-Tuning: Automatisiertes FLOPs-Tracking in AWS

Der EU AI Act verpflichtet Organisationen, die Large Language Models (LLMs) fine-tunen, die eingesetzten Rechenressourcen in Form von Gleitkommaoperationen (floating point operations; FLOPs) zu erfassen, um ihre Compliance-Pflichten zu bestimmen. Da Kunden zunehmend LLMs für domänenspezifische Anwendungsfälle fine-tunen, hören wir eine häufige Frage: Woher weiß ich, ob mein Trainingsjob neue regulatorische Pflichten auslöst?

Amazon SageMaker AI bietet einen verwalteten Machine-Learning-Service (ML) zum Erstellen, Trainieren und Bereitstellen von Modellen. Diese Lösung nutzt Amazon SageMaker Training-Jobs, um Fine-Tuning-Workloads auf vollständig verwalteter Infrastruktur auszuführen. SageMaker-Training-Jobs übernehmen die Ressourcenbereitstellung, Skalierung und Cluster-Verwaltung mit integrierter Unterstützung für verteiltes Training, Integration mit AWS CloudTrail und Amazon CloudWatch für Governance sowie automatischer Freigabe von Compute-Ressourcen nach Abschluss des Trainings. Das Fine-Tuning FLOPs Meter erweitert diese Funktionen um ein speziell entwickeltes Compliance-Tracking, das sich in Ihre bestehenden SageMaker-AI-Pipelines integriert.

In diesem Beitrag zeigen wir Ihnen, wie Sie das FLOPs-Tracking während des LLM-Fine-Tunings mit dem Open-Source-Toolkit Fine-Tuning FLOPs Meter in Amazon SageMaker AI einrichten. Sie erfahren, wie Sie Ihren Compliance-Status mit einem einzigen Konfigurationsparameter bestimmen und prüfungsfähige Dokumentation generieren.

EU AI Act und Anforderungen an das FLOPs-Tracking

Am 2. August 2025 führte der EU AI Act neue Anforderungen für Organisationen ein, die mit General-Purpose-Artificial-Intelligence-Modellen (GPAI) arbeiten. Wenn Sie ein LLM fine-tunen, müssen Sie feststellen, ob Ihre Änderungen Sie von einem Downstream-Nutzer (einer Organisation, die ein bestehendes Modell ohne wesentliche Änderung verwendet) zu einem GPAI-Modellanbieter (einer Organisation, die rechtlich für die Compliance eines Modells verantwortlich ist) umklassifizieren. Die Einstufung hängt davon ab, wie viel Rechenleistung Ihr Fine-Tuning verbraucht, gemessen in FLOPs.

Die Ein-Drittel-Regel unterscheidet zwischen geringfügigen Änderungen und substanziellem Nachtraining. Die Begründung für den 30-Prozent-Schwellenwert: Die regulatorische Analyse hat ergeben, dass die Nutzung von mehr als einem Drittel der ursprünglichen Trainings-Rechenleistung typischerweise zu signifikanten Verhaltensänderungen des Modells führt und damit effektiv ein neues Modell mit anderen Risiken entsteht, das die vollen Anbieterpflichten rechtfertigt.

Die meisten Organisationen verwenden Szenario 2 in der folgenden Tabelle, da Modellanbieter selten exakte Trainings-FLOPs veröffentlichen. Sofern Sie keine dokumentierten Pretraining-Rechenleistungswerte von Ihrem Modellanbieter haben, gilt der Standardschwellenwert von 3,3×10²² FLOPs.

Es gibt 3 anwendbare Szenarien und Schwellenwerte:

Das Fine-Tuning FLOPs Meter bestimmt automatisch, welches Szenario zutrifft, basierend darauf, ob Sie die Umgebungsvariable PRETRAIN_FLOPS angeben.

Um schnell zu bestimmen, welcher Schwellenwertpfad für Sie gilt, verwenden Sie den folgenden Entscheidungsablauf:

Schritt 1: Kennen Sie die Pretraining-FLOPs Ihres Basismodells?

• Nein: Fahren Sie direkt mit dem Standardschwellenwert von 3,3×10²² FLOPs fort.

• Ja: Gehen Sie zum nächsten Bewertungsschritt.

Schritt 2: Bewerten Sie die Größenordnung der Pretraining-Rechenleistung

Wenn Sie Ihre Pretraining-Rechenleistung kennen, vergleichen Sie diese mit den folgenden Größenordnungen:

1. Ist die Pretraining-Rechenleistung ≥ 10²⁵ FLOPs?

• Ja: Sie fallen unter den Schwellenwert für systemisches Risiko. Verwenden Sie einen Schwellenwert von 3,3×10²⁴ FLOPs.

• Nein: Gehen Sie zur nächsten Frage.

2. Ist die Pretraining-Rechenleistung ≥ 10²³ FLOPs?

• Ja: Verwenden Sie einen relativen Schwellenwert von 30 % der tatsächlichen Pretraining-Rechenleistung.

• Nein: Fahren Sie mit dem Standardschwellenwert von 3,3×10²² FLOPs fort.

Beispielsweise setzt das Fine-Tuning von Llama-3-70B (vortrainiert mit geschätzten mindestens 1,5×10²⁴ FLOPs) den Schwellenwert bei 4,5×10²³ FLOPs. Das Überschreiten dieses Schwellenwerts bedeutet, dass Sie die vollen Pflichten eines GPAI-Modellanbieters übernehmen. Diese Pflichten umfassen die Bereitstellung detaillierter Offenlegungen zu Architektur und Trainingsprozess, eine öffentlich zugängliche Liste der verwendeten Datenquellen sowie den Nachweis der Einhaltung des EU-Urheberrechts. Bei Nichteinhaltung drohen Bußgelder von bis zu 15 Millionen Euro oder 3 % des weltweiten Jahresumsatzes, je nachdem, welcher Betrag höher ist.

Die Herausforderung des manuellen FLOPs-Trackings

Diese Schwellenwerte stellen drei Compliance-Herausforderungen dar:

1. FLOPs-Formeln sind komplex und unterscheiden sich je nachdem, ob Sie ein vollständiges Fine-Tuning durchführen oder parametereffiziente Methoden verwenden (Trainingsansätze wie Low-Rank Adaptation (LoRA), die nur eine kleine Teilmenge der Modellparameter aktualisieren).

2. Der anwendbare Schwellenwert ist schwer zu bestimmen, da Pretraining-Rechenleistungswerte selten veröffentlicht werden.

3. Die Pflege eines Audit-Trails (eine permanente Aufzeichnung von Compliance-Metriken für die regulatorische Überprüfung) über mehrere Trainingsjobs hinweg verursacht operativen Mehraufwand.

Fehlerhafte Berechnungen ändern, ob Sie als Downstream-Nutzer agieren oder als vollständiger GPAI-Modellanbieter eingestuft werden. Das Fine-Tuning FLOPs Meter automatisiert den Tracking-Prozess und adressiert diese Herausforderungen.

Lösungsübersicht

Das Fine-Tuning FLOPs Meter ist ein Open-Source-Toolkit, verfügbar im Amazon SageMaker Generative AI Recipes Repository, das sich in Hugging Face-Trainingsworkflows in Amazon SageMaker AI integriert. Es erfasst Rechenressourcen über den gesamten Fine-Tuning-Lebenszyklus. Das folgende Diagramm veranschaulicht den Compliance-Workflow.

Abbildung 1. Compliance-Workflow des Fine-Tuning FLOPs Meter

Das Toolkit deckt drei Phasen des Fine-Tuning-Lebenszyklus ab, wobei das Runtime-Tracking die Kernfunktion darstellt.

Erste Phase: Ein optionales Pre-Training-Schätzwerkzeug ermöglicht den Vergleich erwarteter FLOPs über verschiedene Trainingsmethoden (LoRA, Spectrum, Full) hinweg, bevor Sie einen Job starten.

Zweite Phase: Das Runtime-Tracking, die Hauptfunktion, verwendet einen Hugging Face TrainerCallback, um FLOPs in Echtzeit während des Trainings zu berechnen — sowohl mittels architekturbasierter Analytik als auch hardwarebasiertem GPU-Monitoring (Graphics Processing Unit) über die NVIDIA Management Library (NVML).

Dritte Phase: Ein Post-Training-Audit-Trail speichert automatisch vollständige Compliance-Metriken im JSON-Format. Sie können die Ergebnisse in Amazon S3, Amazon DynamoDB oder MLflow in Amazon SageMaker AI persistieren.

Sie können die Funktion mit einer einzigen Konfigurationszeile aktivieren (compute_flops: true). Das FLOPs Meter beinhaltet parametereffiziente Erkennung mittels einer erweiterten Formel zur genauen Schätzung für vollständiges, LoRA- und Spectrum-Fine-Tuning. Es generiert prüfungsfähige Compliance-Dokumentation, die die für die EU-AI-Act-Berichterstattung erforderlichen Felder abdeckt, und führt einen automatisierten Schwellenwertvergleich durch, der den anwendbaren regulatorischen Schwellenwert bestimmt und kennzeichnet, ob Ihr Fine-Tuning-Job diesen überschreitet.

Technische Implementierung

Die folgenden Abschnitte beschreiben, wie FLOPs berechnet werden und wie sich das Tracking in Ihren Trainingsworkflow in Amazon SageMaker AI integriert.

Voraussetzungen

Sie müssen die folgenden Voraussetzungen erfüllen, bevor Sie die FLOPs-Meter-Anleitung durchführen können:

1. Stellen Sie die folgende Kontingenterhöhung für SageMaker AI. Für diesen Anwendungsfall benötigen Sie mindestens 1 ml.g5.4xlarge-Instanz (mit 1 x NVIDIA A10G GPU). Fordern Sie in der Service Quotas [EN]-Konsole das folgende SageMaker-AI-Kontingent an:

— G5-Instanzen (ml.g5.4xlarge) für Training-Job-Nutzung: 1

2. Erstellen Sie eine AWS Identity and Access Management (IAM)-Rolle [EN] mit den verwalteten Richtlinien AmazonSageMakerFullAccess und AmazonS3FullAccess, um SageMaker AI den erforderlichen Zugriff für die Ausführung der Beispiele zu gewähren.

3. Weisen Sie Ihrer IAM-Rolle die folgende Vertrauensrichtlinie zu:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "sagemaker.amazonaws.com"
        ]
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

4. (Optional) Erstellen Sie eine Amazon SageMaker Studio-Domäne (siehe Schnelleinrichtung für Amazon SageMaker AI verwenden [EN]), um mit der oben genannten Rolle auf Jupyter-Notebooks [EN] zuzugreifen. Sie können auch JupyterLab in Ihrer lokalen Umgebung verwenden.

Diese Berechtigungen gewähren umfassenden Zugriff und werden nicht für den Einsatz in Produktionsumgebungen empfohlen. Hinweise zur Definition feingranularer Berechtigungen finden Sie im SageMaker AI Developer Guide [EN].

Formeln zur FLOPs-Berechnung

Verwenden Sie für die Compliance-Berichterstattung die analytische Methode (Flops_architecture) als primäre Metrik. Das Toolkit berechnet zusätzlich eine hardwarebasierte Obergrenze für konservative Berichterstattung. Beide Methoden laufen automatisch.

Die EU-AI-Act-Leitlinien (Abschnitt A.2.1) beschreiben zwei Ansätze zur Schätzung der Trainings-Rechenleistung:

1. Architekturbasierter Ansatz (analytisch):

Die Standard-EU-Formel für dichte Transformer ist:

C ≈ 6 × P × D

Dabei ist P die Anzahl der Parameter und D die Anzahl der Trainings-Token. Dies setzt ein vollständiges Fine-Tuning voraus, bei dem alle Parameter trainierbar sind.

Eine erweiterte Formel berücksichtigt parametereffiziente Methoden:

F_ft = (4 × N_total + 2 × N_trainable) × tokens_processed

Die Aufschlüsselung:

• 4 × N_total — Forward-Pass (2×) plus Backward-Pass-Gradientenberechnung durch jede Schicht (2×), einschließlich eingefrorener Schichten

• 2 × N_trainable — Gradientenberechnung nur bezüglich der trainierbaren Gewichte

Für vollständiges Fine-Tuning, bei dem N_total = N_trainable, reduziert sich dies auf 6 × N × D — äquivalent zur EU-Formel. Für LoRA oder Spectrum liefert es eine genauere (und niedrigere) Schätzung, die widerspiegelt, dass weniger Parameter Gradienten-Updates erhalten.

2. Hardwarebasierter Ansatz (Obergrenze):

Dieser Ansatz verwendet die folgende Formel:

C = N_gpus × L × H × U

Dabei ist N_gpus die Anzahl der GPUs, L die Trainingsdauer in Sekunden, H die theoretische Spitzenleistung (FLOP/s) und U die Auslastung. Das FLOPs Meter verwendet U = 1.0 (100 % Auslastung), um über NVML-GPU-Monitoring eine konservative Obergrenze zu erzeugen.

Schwellenwertlogik

Das Toolkit implementiert die EU-AI-Act-Schwellenwertlogik in determine_compliance_threshold():

EU_AI_ACT_GPAI_THRESHOLD = 1e23      # 10²³ FLOPs
EU_AI_ACT_DEFAULT_THRESHOLD = 3.3e22  # Ein Drittel von 10²³

if pretrain_flops is None or pretrain_flops < EU_AI_ACT_GPAI_THRESHOLD:
    threshold = EU_AI_ACT_DEFAULT_THRESHOLD       # "default_3.3e22"
else:
    threshold = 0.30 * pretrain_flops              # "30pct_of_actual_pretraining"

Integration mit SageMaker-Training-Jobs

Das FLOPs Meter funktioniert als Hugging Face TrainerCallback. Um das Tracking zu aktivieren, fügen Sie eine einzelne Zeile in der Rezept-YAML hinzu:

compute_flops: true

Beim Trainingsstart prüft das Trainingsskript (sft.py) dieses Flag und initialisiert bei Aktivierung den FlopsMeterCallback mit Modellparameterzählungen und einer optionalen Umgebungsvariable PRETRAIN_FLOPS. Ein benutzerdefinierter TokenCountingSFTTrainer ersetzt den Standard-SFTTrainer, um Nicht-Padding-Token bei jedem Trainingsschritt zu zählen.

n_total = sum(p.numel() for p in model.parameters())
n_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)

flops_cb = FlopsMeterCallback(
    pad_token_id=tokenizer.pad_token_id,
    pretrain_flops=pretrain_flops,       # aus der Umgebungsvariable PRETRAIN_FLOPS
    sample_nvml=True,
    n_total=n_total,
    n_trainable=n_trainable,
    model_name=model_args.model_name_or_path,
    num_epochs=training_args.num_train_epochs,
)

Nach Abschluss des Trainings berechnet der Callback sowohl analytische als auch hardwarebasierte FLOPs, bestimmt den anwendbaren Schwellenwert und schreibt eine flops_meter.json-Datei nach /opt/ml/output/. Der Pipeline-Schritt ProcessTrainingOutputs lädt die Ergebnisse anschließend nach Amazon S3 hoch und persistiert sie in Amazon DynamoDB für Audit-Trail-Zwecke.

Schritt-für-Schritt-Anleitung

Die folgende Anleitung verwendet meta-llama/Llama-3.2-3B-Instruct (3,21 Milliarden Parameter). Da Meta keine exakten Pretraining-FLOPs für dieses Modell veröffentlicht hat, gilt der Standardschwellenwertpfad: 3,3×10²² als Compliance-Schwellenwert.

Pre-Training-Schätzung (optional)

Ein eigenständiges Schätzwerkzeug (estimate_flops.py) vergleicht erwartete FLOPs über verschiedene Trainingsmethoden (LoRA, Spectrum und vollständiges Fine-Tuning) hinweg, bevor Sie einen Job starten. Dies ist nützlich für die Planung: Es zeigt, wie nah eine gegebene Konfiguration an den Compliance-Schwellenwert herankommt, und hilft Ihnen, fundierte Entscheidungen über Trainingsmethode und Datensatzgröße zu treffen. Das Schätzwerkzeug ist vom Kern-Runtime-Tracking getrennt und kann unabhängig in einem Notebook ausgeführt werden.

Runtime-Tracking

Während des Trainings erfasst der FlopsMeterCallback FLOPs in Echtzeit. Hier findet die eigentliche Compliance-Messung statt:

• Beim Trainingsstart (on_train_begin): Der Callback erfasst die Modellparameterzählungen (N_total, N_trainable), startet einen NVML-GPU-Monitoring-Thread und zeichnet den Startzeitstempel auf.

• Bei jedem Trainings-Teilschritt (on_substep_end): Nicht-Padding-Token werden pro Batch gezählt und bei verteiltem Training über GPUs hinweg aggregiert.

• Beim Trainingsende (on_train_end): Der Callback berechnet architekturbasierte FLOPs aus der akkumulierten Token-Anzahl, stoppt das NVML-Monitoring zur Berechnung der Hardware-Obergrenze, bestimmt den anwendbaren Schwellenwert und schreibt die vollständigen Metriken in flops_meter.json.

Eine Rezeptkonfiguration für Llama-3.2-3B mit LoRA und aktiviertem FLOPs-Tracking:

model_name_or_path: meta-llama/Llama-3.2-3B-Instruct
dataset_id_or_path: your-dataset.jsonl
use_peft: true
compute_flops: true
per_device_train_batch_size: 8
num_train_epochs: 10
learning_rate: 2e-5
peft_config:
  r: 8
  lora_alpha: 16
  target_modules: ["q_proj", "v_proj"]

Verwenden Sie in Ihrem Amazon SageMaker AI-Notebook oder Python-Skript die ModelTrainer-Klasse aus dem SageMaker Python SDK v3, um den Trainingsjob als SageMaker-Training-Job zu starten:

from sagemaker.modules.configs import Compute, SourceCode
from sagemaker.modules.train import ModelTrainer

training_instance_type = "ml.g5.4xlarge"

pytorch_image_uri = sagemaker.image_uris.retrieve(
    framework="pytorch",
    region=sess.boto_session.region_name,
    version="2.7.1",
    instance_type=training_instance_type,
    image_scope="training",
)

source_code = SourceCode(
    source_dir="./sagemaker_code",
    command="bash sm_accelerate_train.sh --config hf_recipes/meta-llama/Llama-3.2-3B-Instruct--vanilla-peft-qlora.yaml",
)

compute = Compute(
    instance_type=training_instance_type,
    instance_count=1,
    volume_size_in_gb=300,
)

model_trainer = ModelTrainer(
    training_image=pytorch_image_uri,
    source_code=source_code,
    compute=compute,
    role=role,
    environment={
        "FLOPS_METER_NVML": "1",
    },
)

model_trainer.train()

Da die Pretraining-FLOPs für dieses Modell nicht bekannt sind, wird die Umgebungsvariable PRETRAIN_FLOPS weggelassen. Der Standardschwellenwert wird automatisch angewendet.

Compliance-Dokumentation

Nach Abschluss des Trainings generiert der Callback eine flops_meter.json-Datei mit den für die regulatorische Dokumentation erforderlichen Metriken:

{
  "Flops_architecture": "1.45e+13",
  "Flops_hardware": "1.52e+15",
  "Flops_original": null,
  "N_total": 1585294704,
  "N_trainable": 680094720,
  "threshold_type": "default_3.3e22",
  "threshold_value": "3.30e+22",
  "pct_of_pretrain": 0.000000439,
  "exceeds_30pct": false,
  "tokens_processed": 2150,
  "model_name": "meta-llama/Llama-3.2-3B-Instruct",
  "num_epochs": 10,
  "training_duration_seconds": 245.30,
  "gpu_name": "NVIDIA A10G",
  "instance_type": "ml.g5.4xlarge",
  "training_job_name": "pipelines-abc123-TrainingStep-xyz789",
  "recipe_config": "hf_recipes/meta-llama/Llama-3.2-3B-Instruct--vanilla-peft-qlora.yaml"
}

Wichtige Compliance-Kennzahlen:

• Flops_architecture — die primäre Compliance-Metrik. Sie spiegelt Ihre tatsächliche Trainingskonfiguration genau wider.

• Flops_hardware — hardwarebasierte Obergrenze, die als Sicherheitsmarge für besonders vorsichtige Berichterstattung dienen kann.

• threshold_type — gibt an, welche Schwellenwertregel angewendet wurde (default_3.3e22, da die Pretraining-FLOPs unbekannt sind).

• exceeds_30pct — boolesches Flag für eine schnelle Compliance-Bewertung.

• Flops_original — null, wenn keine Pretraining-FLOPs angegeben wurden.

Die Pipeline lädt diese Datei automatisch nach Amazon S3 hoch und speichert sie in Amazon DynamoDB, wodurch ein persistenter Audit-Trail über Trainingsläufe hinweg entsteht.

Was passiert, wenn Sie den Schwellenwert überschreiten?

Wenn Ihr Compliance-Bericht exceeds_30pct: true anzeigt, werden Sie unter dem EU AI Act als GPAI-Modellanbieter eingestuft. Ihre nächsten Schritte umfassen: (1) Dokumentation Ihrer Modellarchitektur und Ihres Trainingsprozesses, (2) Erstellung einer öffentlich zugänglichen Liste der Trainingsdatenquellen, (3) Nachweis der Einhaltung des EU-Urheberrechts und (4) gegebenenfalls Konsultation eines mit EU-KI-Regulierung vertrauten Rechtsbeistands. Beachten Sie, dass zusätzliche Pflichten bestehen, wenn Ihr GPAI-Modell als systemisches Risiko eingestuft wird. Sie können auch erwägen, Ihren Trainingsumfang zu reduzieren (weniger Epochen, kleinerer Datensatz oder Wechsel zu LoRA), um unter dem Schwellenwert zu bleiben.

Skalierung auf Produktions-Workloads

Dieses Beispiel verwendete einen kleinen Datensatz zu Demonstrationszwecken (2.150 Token). In der Produktion verarbeiten Sie typischerweise Millionen von Token. Beispielsweise ergibt das Fine-Tuning von Llama-3.2-3B mit 1 Million Token und LoRA circa 6,7×10¹⁸ FLOPs — deutlich unter dem Schwellenwert von 3,3×10²². Vollständiges Fine-Tuning auf demselben Datensatz verbraucht jedoch circa 1,9×10¹⁹ FLOPs und bringt Sie näher an den Schwellenwert.

Als Faustregel beginnt die Compliance-Relevanz, wenn Ihre FLOPs 10²¹ oder höher erreichen — circa 3 % des Standardschwellenwerts. Ab diesem Punkt empfehlen wir, das Pre-Training-Schätzwerkzeug vor jedem Job auszuführen, um die Einhaltung der Compliance-Standards zu überprüfen. Für die meisten LoRA-Fine-Tuning-Jobs auf Modellen unter 10B Parametern bleiben Sie selbst mit Millionen von Trainings-Token deutlich unter dem Schwellenwert.

Erste Schritte

Das FLOPs Meter ist als Teil des Amazon SageMaker Generative AI Recipes Repository verfügbar.

Voraussetzungen

Stellen Sie vor Beginn sicher, dass Sie über Folgendes verfügen:

• Ein AWS-Konto mit Zugriff auf Amazon SageMaker AI

• AWS Command Line Interface (AWS CLI), konfiguriert mit entsprechenden Anmeldeinformationen

• Python 3.11 oder höher

• Vertrautheit mit Hugging Face Transformers und PyTorch

Vorgehensweise

So starten Sie das FLOPs-Tracking:

1. Klonen Sie das Repository:

git clone https://github.com/aws-samples/amazon-sagemaker-generativeai.git

2. Öffnen Sie Ihre Rezeptkonfigurationsdatei (beispielsweise hf_recipes/meta-llama/Llama-3.2-3B-Instruct--vanilla-peft-qlora.yaml) und fügen Sie die folgende Zeile hinzu:

compute_flops: true

3. (Optional) Wenn Sie die Pretraining-FLOPs für Ihr Basismodell kennen, setzen Sie die Umgebungsvariable:

export PRETRAIN_FLOPS="1.5e24"  # Beispiel: Llama-3-70B

4. Starten Sie Ihren Trainingsjob in Amazon SageMaker AI:

a. Öffnen Sie Ihr SageMaker-AI-Notebook oder Python-Skript.

b. Konfigurieren Sie den ModelTrainer (siehe das Codebeispiel im Abschnitt „Schritt-für-Schritt-Anleitung“).

c. Führen Sie model_trainer.train() aus, um den Trainingsjob zu starten.

5. Überprüfen Sie nach Abschluss des Trainings die generierte Datei flops_meter.json in Ihrem Amazon-S3-Ausgabeort. Sie sollten eine JSON-Datei mit FLOPs-Metriken, Schwellenwertbestimmung und Compliance-Status sehen.

Einen tieferen Einblick in die Implementierung finden Sie im Quellcode von flops_meter.py.

Bereinigung

Um laufende Kosten zu vermeiden, löschen Sie die von Ihnen erstellten Ressourcen:

1. Stoppen Sie laufende SageMaker-AI-Trainingsjobs:

• Öffnen Sie die Amazon SageMaker AI-Konsole [EN]

• Navigieren Sie zu Training und dann zu Training jobs

• Wählen Sie Running Jobs und dann Stop

2. Löschen Sie Amazon-S3-Ausgaben:

• Öffnen Sie die Amazon S3-Konsole [EN]

• Navigieren Sie zu Ihrem Trainingsausgabe-Bucket

• Wählen Sie die flops_meter.json-Dateien und dann Delete

• Oder löschen Sie den gesamten Bucket, wenn Sie ihn speziell für diese Anleitung erstellt haben

3. Löschen Sie die Amazon DynamoDB-Tabelle, wenn Sie diese speziell für diese Anleitung erstellt haben:

• Öffnen Sie die Amazon DynamoDB-Konsole [EN]

• Wählen Sie die Tabelle und dann Delete

4. Entfernen Sie SageMaker-AI-Endpunkte, wenn Sie Ihr fine-getuntes Modell bereitgestellt haben.

Fazit

In diesem Beitrag haben wir Ihnen gezeigt, wie Sie FLOPs-Tracking während des LLM-Fine-Tunings in Amazon SageMaker AI implementieren. Sie haben erfahren, wie das Fine-Tuning FLOPs Meter Rechenressourcen sowohl mit analytischen als auch hardwarebasierten Methoden berechnet, wie es die Ein-Drittel-Regel zur Bestimmung regulatorischer Schwellenwerte anwendet und wie Sie prüfungsfähige JSON-Dokumentation mit einem einzigen Konfigurationsparameter generieren.

Mit diesem Werkzeug können Sie sich auf die Modellentwicklung konzentrieren und gleichzeitig volle Transparenz über Ihren Rechenaufwand bewahren.

Klonen Sie zum Einstieg das Repository und führen Sie das Pre-Training-Schätzwerkzeug mit Ihrem geplanten Modell und Datensatz aus. Weitere Informationen zum Aufbau compliance-konformer KI-Systeme in AWS finden Sie in der Amazon SageMaker AI-Dokumentation [EN].

Über die Autoren

	Alexander Tselikov ist Senior AI/ML Architect bei AWS Professional Services. Er unterstützt Unternehmenskunden leidenschaftlich beim Aufbau und der Skalierung innovativer KI- und Datenlösungen, um praktische Ergebnisse zu erzielen und kritische Geschäftsentscheidungen zu beschleunigen.
	Shukhrat Khodjaev ist Senior Engagement Manager bei AWS ProServe mit Spezialisierung auf KI. Er ermöglicht Kunden, ihre KI-Transformation zu beschleunigen, Innovationen voranzutreiben und die Grenzen der KI-Anwendung zu erweitern, um greifbare Geschäftsergebnisse zu erzielen.