Feinabstimmung Lama 3.2 3b für Lappen - Analytics Vidhya

Kleine Sprachmodelle (SLMs) haben einen signifikanten Einfluss auf die KI. Sie bieten eine starke Leistung und sind gleichzeitig effizient und kostengünstig. Ein herausragendes Beispiel ist das Lama 3.2 3b. Es ist außergewöhnlich gut bei den Aufgaben des Abrufs ( ARRAVEAL-AUGMENTED-Generation ), die Rechenkosten und Speicherverbrauch senkt und gleichzeitig eine hohe Genauigkeit aufrechterhalten. In diesem Artikel wird untersucht, wie das Lama 3.2 3B-Modell eine Feinabstimmung. Erfahren Sie, wie kleinere Modelle in Lappenaufgaben überzeugt werden können, und überschreiten die Grenzen dessen, was kompakte AI -Lösungen erreichen können.

Inhaltsverzeichnis

• Was ist Lama 3.2 3b?
• Flossenlama 3.2 3b
• Lora
• Bibliotheken erforderlich
• Importieren Sie die Bibliotheken
• Initialisieren Sie das Modell und die Tokenisierer
• Initialisieren Sie das Modell für PEFT
• Datenverarbeitung
• Einrichten der Trainerparameter
• Feinabstimmung des Modells
• Testen und speichern Sie das Modell
• Abschluss
• Häufig gestellte Fragen

Was ist Lama 3.2 3b?

Das von Meta entwickelte Lama 3.2 3B -Modell ist ein mehrsprachiger SLM mit 3 Milliarden Parametern, die für Aufgaben wie Fragenbeantwortung, Zusammenfassung und Dialogsysteme entwickelt wurden. Es übertrifft viele Open-Source-Modelle zu Branchenbenchmarks und unterstützt verschiedene Sprachen. LLAMA 3.2 erhältlich in verschiedenen Größen bietet eine effiziente Rechenleistung und enthält quantisierte Versionen für eine schnellere und speichereffiziente Bereitstellung in mobilen und Kantenumgebungen.

Lesen Sie auch: Top 13 kleine Sprachmodelle (SLMs)

Flossenlama 3.2 3b

Die Feinabstimmung ist für die Anpassung von SLM oder LLMs an bestimmte Bereiche oder Aufgaben wie medizinische, legale oder Lag-Anwendungen von wesentlicher Bedeutung. Während vor der Ausbildung Sprachmodelle es ermöglicht, Texte für verschiedene Themen zu generieren, führt die Feinabstimmung das Modell zu domänenspezifischen oder aufgabenspezifischen Daten neu aus, um die Relevanz und Leistung zu verbessern. Um die hohen Berechnungskosten für die Feinabstimmung aller Parameter zu beheben, konzentrieren sich Techniken wie Parameter effiziente Feinabstimmung (PEFT) auf das Training nur eine Teilmenge der Parameter des Modells, um die Ressourcenverbrauch zu optimieren und gleichzeitig die Leistung aufrechtzuerhalten.

Lora

Eine solche PEFT -Methode ist eine niedrige Anpassung (LORA).

In Lora wird die Gewichtsmatrix in SLM oder LLM in ein Produkt von zwei niedrigrangigen Matrizen zerlegt.

 W = wa * wb

Wenn W M -Zeilen und N -Säulen hat, kann es mit M -Zeilen und R -Säulen in WA zerlegt werden und WB mit R -Zeilen und N -Spalten. Hier ist R viel weniger als m oder n. Anstatt M*n -Werte zu trainieren, können wir nur die Werte r*(mn) trainieren. R wird als Rang bezeichnet, was der Hyperparameter ist, den wir wählen können.

 Def lora_linear (x):<br> H = X @ W # Regular Linear<br> H = Skala * (x @ w_a @ w_b) # Low-Rank-Update<br> Rückkehr h

Kasse: parametereffiziente Feinabstimmung von Großsprachenmodellen mit Lora und Qlora

Lassen Sie uns Lora im Lama 3.2 3B -Modell implementieren.

Bibliotheken erforderlich

• Unloth - 2024.12.9
• Datensätze - 3.1.0

Durch die Installation der obigen Faultierversion werden auch die kompatiblen Pytorch-, Transformers- und NVIDIA -GPU -Bibliotheken installiert. Wir können Google Colab verwenden, um auf die GPU zuzugreifen.

Schauen wir uns jetzt die Implementierung an!

Importieren Sie die Bibliotheken

 aus Unloth importieren Sie FastLanguagemodel, is_bfloat16_Supported, Train_on_responses_only

Aus Datensätzen importieren Sie load_dataset, Datensatz

An apply_chat_template aus trl import SFTTRAINER

Aus Transformers Importing TrainingArguments, DataCollatorForseq2Seq, Textstreamer

Taschenlampe importieren

Initialisieren Sie das Modell und die Tokenisierer

 max_seq_length = 2048 
DTYPE = NONE # Keine für die automatische Erkennung.
load_in_4bit = true # verwenden 4bit quantization, um die Speicherverwendung zu reduzieren. Kann falsch sein.

Modell, Tokenizer = fastLanguagemodel.from_Pretrained (
	model_name = "sloth/lama-3.2-3b-instruct",
	max_seq_length = max_seq_length,
	DTYPE = DTYPE,
	load_in_4bit = lader_in_4bit,
	# token = "hf _...", # Verwenden Sie, wenn Gated-Modelle wie Meta-Llama/Lama-3.2-11b verwendet werden
)

Für andere von Unloth unterstützte Modelle können wir uns auf dieses Dokument beziehen.

Initialisieren Sie das Modell für PEFT

 model = fastLanguagemodel.get_peft_model (
	Modell,
	r = 16,
	target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                  	"Gate_Proj", "Up_Proj", "Down_proj",],
	lora_alpha = 16,
	lora_dropout = 0,, 
	Bias = "keine",
	Use_gradient_Checkpointing = "Unloth",
	random_state = 42,
	use_rslora = false, 
	loftq_config = keine,
)

Beschreibung für jeden Parameter

• R : Rang von Lora; Höhere Werte verbessern die Genauigkeit, verwenden jedoch mehr Speicher (vorgeschlagen: 8–128).
• target_modules : Module zur Feinabstimmung; Fügen Sie alle für bessere Ergebnisse ein
• lora_alpha : Skalierungsfaktor; Typischerweise gleich oder doppelt so hoch wie der Rang r.
• lora_dropout : Ausfallrate; Setzen Sie auf 0 für optimiertes und schnelleres Training.
• Voreingenommenheit : Bias -Typ; "Keine" ist für Geschwindigkeit und minimale Überanpassung optimiert.
• Use_gradient_Checkpointing : Reduziert das Speicher für ein langes Kontext-Training; "Unloth" wird sehr empfohlen.
• Random_State : Saatgut für deterministische Läufe, um reproduzierbare Ergebnisse zu gewährleisten (z. B. 42).
• Use_RSlora : Automatisiert die Alpha -Auswahl; nützlich für rangstabilisierte Lora.
• loftq_config : Initialisiert Lora mit Top R-Singularvektoren für eine bessere Genauigkeit, obwohl speicherintensiv.

Datenverarbeitung

Wir werden die Lag -Daten zum Fintune verwenden. Laden Sie die Daten von SuggingFace herunter.

 DataSet = load_dataset ("Neural-Bridge/Rag-Dataset-1200", Split = "Train")

Der Datensatz hat drei Schlüssel wie folgt:

Datensatz ({Funktionen: ['Kontext', 'Frage', 'Antwort'], num_rows: 960})

Die Daten müssen je nach Sprachmodell in einem bestimmten Format liegen. Weitere Informationen finden Sie hier .

Konvertieren wir die Daten also in das erforderliche Format:

 Def convert_dataset_to_dict (Datensatz):
    DataSet_dict = {
        "Eingabeaufforderung": [],
        "Fertigstellung": []
    }

    Für Zeile im Datensatz:
        user_content = f "context: {row ['context']} \ nquestion: {row ['Frage']}"
        Assistant_Content = row ['Antwort']

        DataSet_Dict ["Eingabeaufforderung"]. Anhang ([[
            {"Rolle": "Benutzer", "Inhalt": user_content}
        ]))
        DataSet_Dict ["Fertigstellung"]. Anhang ([[
            {"Rolle": "Assistant", "Inhalt": Assistant_Content}
        ]))
    return dataset_dict
    
    
converted_data = convert_dataset_to_dict (Datensatz)
DataSet = dataSet.from_dict (Converted_data)
dataSet = dataSet.map (apply_chat_template, fn_kwargs = {"tokenizer": tokenizer})

Die Datensatznachricht lautet wie folgt:

Einrichten der Trainerparameter

Wir können den Trainer für die Fülle des SLM initialisieren:

 Trainer = SftTrainer (
	Modell = Modell,
	Tokenizer = Tokenizer,
	train_dataset = dataset,
	max_seq_length = max_seq_length,
	Data_Collator = DataCollatorForseq2Seq (Tokenizer = Tokenizer),
	dataset_num_proc = 2,,
	packing = false, # kann das Training 5x für kurze Sequenzen schneller machen.
	args = TrainingArgumente (
    	per_device_train_batch_size = 2,,
    	gradient_accumulation_steps = 4,,
    	Warmup_steps = 5,
    	# num_train_epochs = 1, # Legen Sie dies für 1 vollständige Trainingslauf ein.
    	max_steps = 6, # mit kleiner Nummer zum Testen verwendet
    	Learning_Rate = 2E-4,
    	fp16 = nicht is_bfloat16_supported (),
    	bf16 = is_bfloat16_supported (),
    	logging_steps = 1,,
    	optim = "adamw_8bit",
    	wight_decay = 0,01,
    	lr_scheduler_type = "linear",
    	Samen = 3407,
    	output_dir = "Ausgänge",
    	Report_to = "Keine", # Verwenden Sie dies für Wandb etc.
	),
)

Beschreibung einiger der Parameter:

• per_device_train_batch_size: Stapelgröße pro Gerät; Erhöhen Sie, um mehr GPU -Speicher zu verwenden, aber nach Padding -Ineffizienzen (vorgeschlagen: 2).
• gradient_accumulation_steps: simuliert größere Stapelgrößen ohne zusätzliche Speicherverwendung; Erhöhen Sie für glattere Verlustkurven (vorgeschlagen: 4).
• max_steps: Gesamttrainingsschritte; Setzen Sie für schnellere Läufe (z. B. 60) oder verwenden Sie `num_train_epochs` für vollständige Datensatzübergänge (z. B. 1–3).
• Learning_rate: Kontrolliert die Trainingsgeschwindigkeit und Konvergenz; Niedrigere Raten (z. B. 2E-4) verbessern die Genauigkeit, aber ein langsames Training.

Führen Sie den Modellzug nur auf Antworten durch, indem Sie die Antwortvorlage angeben:

 Trainer = train_on_responses_only (
	Trainer,
	Anweisungen_Part = " user  \ n \ n",
	response_part = " Assistent  \ n \ n",
)

Feinabstimmung des Modells

 Trainer_Stats = Trainer.Train ())

Hier sind die Trainingsstatistiken:

Testen und speichern Sie das Modell

Verwenden wir das Modell für Inferenz:

 FASTLAGUAGEMODEL.FOR_INDERATION (Modell)

Nachrichten = [
	{"Rolle": "Benutzer", "Inhalt": "Kontext: Der Himmel ist tagsüber in der Regel klar. Frage: Welche Farbe hat das Wasser?"},
]
inputs = tokenizer.apply_chat_template (
	Nachrichten,
	tokenize = true,
	add_generation_prompt = true,
	return_tensors = "pt",
) .to ("Cuda")

text_streamer = textStreamer (Tokenizer, Skip_prompt = true)
_ = model.generate (input_ids = Eingänge, Streamer = text_streamer, max_new_tokens = 128,
               	Use_cache = true, Temperatur = 1,5, min_p = 0,1)

Verwenden Sie den folgenden Code, um die trainierten einschließlich Lora -Gewichte zu speichern

 model.save_pretraed_merged ("modell", tokenizer, save_method = "merged_16bit"))

Checkout: Leitfaden zur Feinabstimmung von großsprachigen Modellen

Abschluss

Feinabstimmungslama 3.2 3b für Lappenaufgaben zeigt die Effizienz kleinerer Modelle, um eine hohe Leistung mit reduzierten Rechenkosten zu liefern. Techniken wie Lora optimieren die Ressourcenverbrauch und halten gleichzeitig die Genauigkeit. Dieser Ansatz ermöglicht domänenspezifische Anwendungen und macht fortgeschrittene KI zugänglicher, skalierbarer und kostengünstigerer, die Innovationen bei der agebruft-generierten Generation und der Demokratisierung der KI für reale Herausforderungen vorantreiben.

Lesen Sie auch: Erste Schritte mit Meta Lama 3.2

Häufig gestellte Fragen

Q1. Was ist Lag?

A. RAG kombiniert Abrufsysteme mit generativen Modellen, um die Antworten zu verbessern, indem sie in externem Wissen geerdet werden, wodurch es ideal für Aufgaben wie die Beantwortung und Zusammenfassung von Fragen ist.

Q2. Warum Lama 3.2 3b für die Feinabstimmung wählen?

A. LLAMA 3.2 3B bietet ein Gleichgewicht zwischen Leistung, Effizienz und Skalierbarkeit, wodurch es für Lappenaufgaben geeignet ist und gleichzeitig die Rechen- und Speicheranforderungen reduziert.

Q3. Was ist Lora und wie verbessert es die Feinabstimmung?

A. LORA-Anpassungsanpassung (LORA) minimiert den Ressourcenverbrauch, indem nur niedrige Matrizen anstelle aller Modellparameter trainiert werden, wodurch eine effiziente Feinabstimmung auf eingeschränkte Hardware ermöglicht wird.

Q4. Welcher Datensatz wird für die Feinabstimmung in diesem Artikel verwendet?

A. Sugging Face bietet den RAG-Datensatz, der Kontext, Fragen und Antworten enthält, um das Lama 3.2 3B-Modell für eine bessere Aufgabenleistung zu optimieren.

Q5. Kann das fein abgestimmte Modell auf Kantengeräten bereitgestellt werden?

A. Ja, Lama 3.2 3b, insbesondere in seiner quantisierten Form, ist für die maßstabsgerechte Bereitstellung für Kanten und mobile Umgebungen optimiert.

Das obige ist der detaillierte Inhalt vonFeinabstimmung Lama 3.2 3b für Lappen - Analytics Vidhya. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!