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.
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)
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.
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.
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!
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
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.
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,
)
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:
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:
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", )
Trainer_Stats = Trainer.Train ())
Hier sind die Trainingsstatistiken:
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
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
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!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
