Η Μόνη Οδηγός που Χρειάζεστε για την Λεπτοβελτίωση του Llama 3 ή Οποιουδήποτε Άλλου Ανοικτού Κώδικα Μοντέλου

Η λεπτοβελτίωση μεγάλων γλωσσικών μοντέλων (LLMs) όπως το Llama 3, περιλαμβάνει την προσαρμογή ενός προ-εκπαιδευμένου μοντέλου σε συγκεκριμένες εργασίες χρησιμοποιώντας ένα dataset ειδικού τομέα. Αυτή η διαδικασία αξιοποιεί τις προϋπάρχουσες γνώσεις του μοντέλου, καθιστώντας την αποτελεσματική και οικονομική σε σύγκριση με την εκπαίδευση από την αρχή. Σε αυτόν τον οδηγό, θα περάσουμε τα βήματα για την λεπτοβελτίωση του Llama 3 χρησιμοποιώντας το QLoRA (Quantized LoRA), μια μέθοδο που ελαττώνει τη χρήση μνήμης και τους υπολογιστικούς κόστους.

Επισκόπηση της Λεπτοβελτίωσης

Η λεπτοβελτίωση περιλαμβάνει plusieurs κρίσιμα βήματα:

1. Επιλογή Προ-Εκπαιδευμένου Μοντέλου: Επιλέξτε ένα βασικό μοντέλο που συμφωνεί με την επιθυμητή αρχιτεκτονική.
2. Συλλογή Σχετικού Συνόλου Δεδομένων: Συλλέξτε και προεπεξεργαστείτε ένα σύνολο δεδομένων που αφορά την εργασία σας.
3. Λεπτοβελτίωση: Προσαρμόστε το μοντέλο χρησιμοποιώντας το σύνολο δεδομένων για να βελτιώσετε την απόδοσή του σε συγκεκριμένες εργασίες.
4. Αξιολόγηση: Αξιολογήστε το λεπτοβελτιωμένο μοντέλο χρησιμοποιώντας ποιοτικά και ποσοτικά μέτρα.

Εννοιολογίες και Τεχνικές

Fine-tuning Large Language Models

Πλήρης Λεπτοβελτίωση

Πλήρης λεπτοβελτίωση ενημερώνει όλα τα παράμετρα του μοντέλου, καθιστώντας το ειδικό για την νέα εργασία. Αυτή η μέθοδος απαιτεί σημαντικούς υπολογιστικούς πόρους και είναι συχνά ακατόρθωτη για πολύ μεγάλα μοντέλα.

Λεπτοβελτίωση Παρόχου Παραμέτρων (PEFT)

Η PEFT ενημερώνει μόνο ένα υποσύνολο των παραμέτρων του μοντέλου, μειώνοντας τις απαιτήσεις μνήμης και τους υπολογιστικούς κόστους. Αυτή η τεχνική αποτρέπει την καταστροφική λήθη και διατηρεί τις γενικές γνώσεις του μοντέλου.

Χαμηλό Ράνκ Προσαρμογή (LoRA) και Quantized LoRA (QLoRA)

Η LoRA λεπτοβελτίζει μόνο quelques χαμηλού ράνκ πίνακες, ενώ η QLoRA quantizes αυτούς τους πίνακες για να μειώσει περαιτέρω την αποτύπωση μνήμης.

Μέθοδοι Λεπτοβελτίωσης

1. Πλήρης Λεπτοβελτίωση: Αυτό περιλαμβάνει την εκπαίδευση όλων των παραμέτρων του μοντέλου στο σύνολο δεδομένων της εργασίας. Αν και αυτή η μέθοδος μπορεί να είναι πολύ αποτελεσματική, είναι επίσης υπολογιστικά εκτενής και απαιτεί σημαντική μνήμη.
2. Λεπτοβελτίωση Παρόχου Παραμέτρων (PEFT): Η PEFT ενημερώνει μόνο ένα υποσύνολο των παραμέτρων του μοντέλου, καθιστώντας την πιο αποδοτική στη μνήμη. Τεχνικές όπως η LoRA και η QLoRA ανήκουν σε αυτήν την κατηγορία.

Τι είναι η LoRA;

Comparing finetuning methods: QLORA enhances LoRA with 4-bit precision quantization and paged optimizers for memory spike management

Η LoRA είναι μια βελτιωμένη μέθοδος λεπτοβελτίωσης όπου, αντί να λεπτοβελτιώσετε όλα τα βάρη του προ-εκπαιδευμένου μοντέλου, δύο μικρότεροι πίνακες που προσεγγίζουν τον μεγαλύτερο πίνακα λεπτοβελτιώνονται. Αυτοί οι πίνακες αποτελούν τον προσαρμογέα LoRA. Αυτός ο λεπτοβελτιωμένος προσαρμογέας φορτώνεται στο προ-εκπαιδευμένο μοντέλο και χρησιμοποιείται για ερμηνεία.

Κλειδιά Πλεονεκτήματα της LoRA:

• Αποδοτικότητα Μνήμης: Η LoRA μειώνει την αποτύπωση μνήμης λεπτοβελτιώνοντας μόνο μικρούς πίνακες αντί του ολόκληρου μοντέλου.
• Επανχρησιμοποίηση: Το αρχικό μοντέλο παραμένει αμετάβλητο, και πολλοί προσαρμογείς LoRA possono χρησιμοποιηθούν με αυτό, διευκολύνοντας την αντιμετώπιση πολλών εργασιών με χαμηλότερες απαιτήσεις μνήμης.

Τι είναι η Quantized LoRA (QLoRA);

Η QLoRA παίρνει την LoRA ένα βήμα παραπέρα quantizing τα βάρη των προσαρμογέων LoRA σε χαμηλότερη ακρίβεια (π.χ. 4-bit αντί 8-bit). Αυτό μειώνει περαιτέρω τη χρήση μνήμης και τις απαιτήσεις αποθήκευσης ενώ διατηρεί ένα συγκρίσιμο επίπεδο αποτελεσματικότητας.

Κλειδιά Πλεονεκτήματα της QLoRA:

• Ακόμα Μεγαλύτερη Αποδοτικότητα Μνήμης: Quantizing τα βάρη, η QLoRA μειώνει σημαντικά τις απαιτήσεις μνήμης και αποθήκευσης του μοντέλου.
• Διατήρηση Απόδοσης:尽管 η μειωμένη ακρίβεια, η QLoRA διατηρεί επίπεδα απόδοσης κοντά σε αυτά των μοντέλων πλήρους ακρίβειας.

Εργασιακή Προσαρμογή

Κατά τη διάρκεια της λεπτοβελτίωσης, οι παράμετροι του μοντέλου điều chỉnhονται με βάση το νέο σύνολο δεδομένων, βοηθώντας το να κατανοήσει και να παράγει περιεχόμενο σχετικό με την συγκεκριμένη εργασία. Αυτή η διαδικασία διατηρεί τις γενικές γνώσεις γλώσσας που κερδίζονται κατά τη διάρκεια της προ-εκπαίδευσης ενώ προσαρμόζει το μοντέλο στις ιδιαιτερότητες του στόχου τομέα.

Λεπτοβελτίωση στην Πράξη

Πλήρης Λεπτοβελτίωση vs. PEFT

• Πλήρης Λεπτοβελτίωση: Αυτό περιλαμβάνει την εκπαίδευση του ολόκληρου μοντέλου, η οποία μπορεί να είναι υπολογιστικά εκτενής και απαιτεί σημαντική μνήμη.
• Λεπτοβελτίωση Παρόχου Παραμέτρων (LoRA και QLoRA): Η PEFT λεπτοβελτιώνει μόνο ένα υποσύνολο των παραμέτρων, μειώνοντας τις απαιτήσεις μνήμης και αποτρέποντας την καταστροφική λήθη, καθιστώντας την μια πιο αποτελεσματική εναλλακτική.

Βήματα Υλοποίησης

1. Ρύθμιση Περιβάλλοντος: Εγκαταστήστε τις απαραίτητες βιβλιοθήκες και ρυθμίστε το περιβάλλον υπολογισμού.
2. Φόρτωση και Προεπεξεργασία Συνόλου Δεδομένων: Φορτώστε το σύνολο δεδομένων και προεπεξεργαστείτε το σε μορφή κατάλληλη για το μοντέλο.
3. Φόρτωση Προ-Εκπαιδευμένου Μοντέλου: Φορτώστε το βασικό μοντέλο με ρυθμίσεις quantization αν χρησιμοποιείτε QLoRA.
4. Τokenization: Tokenize το σύνολο δεδομένων για να το ετοιμάσετε για εκπαίδευση.
5. Εκπαίδευση: Λεπτοβελτιώστε το μοντέλο χρησιμοποιώντας το προετοιμασμένο σύνολο δεδομένων.
6. Αξιολόγηση: Αξιολογήστε την απόδοση του μοντέλου σε συγκεκριμένες εργασίες χρησιμοποιώντας ποιοτικά και ποσοτικά μέτρα.

Βήμα προς Βήμα Οδηγός για την Λεπτοβελτίωση του LLM

Ρύθμιση του Περιβάλλοντος

Θα χρησιμοποιήσουμε ένα Jupyter notebook για αυτόν τον οδηγό. Πλατφόρμες όπως το Kaggle, το οποίο προσφέρει δωρεάν χρήση GPU, ή το Google Colab είναι ιδανικά για την εκτέλεση αυτών των πειραμάτων.

1. Εγκατάσταση Απαραίτητων Βιβλιοθηκών

Πρώτα, βεβαιωθείτε ότι έχετε εγκαταστήσει τις απαραίτητες βιβλιοθήκες:

!pip install -qqq -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score

2. Εισαγωγή Βιβλιοθηκών και Ρύθμιση Περιβάλλοντος

import os
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments,
pipeline, HfArgumentParser
)
from trl import ORPOConfig, ORPOTrainer, setup_chat_format, SFTTrainer
from tqdm import tqdm
import gc
import pandas as pd
import numpy as np
from huggingface_hub import interpreter_login

# Disable Weights and Biases logging
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Φόρτωση Συνόλου Δεδομένων

Θα χρησιμοποιήσουμε το σύνολο δεδομένων DialogSum για αυτόν τον οδηγό:

Προεπεξεργαστείτε το σύνολο δεδομένων σύμφωνα με τις απαιτήσεις του μοντέλου, συμπεριλαμβανομένης της εφαρμογής κατάλληλων προτύπων και της διασφάλισης ότι η μορφή δεδομένων είναι κατάλληλη για την λεπτοβελτίωση​ (Hugging Face)​​ (DataCamp)​.

dataset_name = "neil-code/dialogsum-test"
dataset = load_dataset(dataset_name)

Ελέγξτε τη δομή του συνόλου δεδομένων:

print(dataset['test'][0])

4. Δημιουργία Ρυθμίσεων BitsAndBytes

Για να φορτώσετε το μοντέλο σε μορφή 4-bit:

compute_dtype = getattr(torch, "float16")
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type='nf4',
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=False,
)

5. Φόρτωση Προ-Εκπαιδευμένου Μοντέλου

Χρησιμοποιώντας το μοντέλο Phi-2 της Microsoft για αυτόν τον οδηγό:

model_name = 'microsoft/phi-2'
device_map = {"": 0}
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

6. Tokenization

Ρυθμίστε τον tokenizer:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

Λεπτοβελτίωση του Llama 3 ή Άλλων Μοντέλων

Όταν λεπτοβελτιώσετε μοντέλα όπως το Llama 3 ή οποιοδήποτε άλλο μοντέλο ανοικτού κώδικα, υπάρχουν συγκεκριμένες προσοχές και προσαρμογές που απαιτούνται για να διασφαλιστεί η βέλτιστη απόδοση. Εδώ είναι τα λεπτομερή βήματα και οι ενημερώσεις για το πώς να προσεγγίσετε αυτό για διαφορετικά μοντέλα, συμπεριλαμβανομένου του Llama 3, GPT-3 και Mistral.

5.1 Χρήση Llama 3

Επιλογή Μοντέλου:

• Βεβαιωθείτε ότι έχετε τον σωστό αναγνωριστικό μοντέλου από το Hugging Face model hub. Για παράδειγμα, το μοντέλο Llama 3 μπορεί να αναγνωριστεί ως meta-llama/Meta-Llama-3-8B στο Hugging Face.
• Βεβαιωθείτε να ζητήσετε πρόσβαση και να συνδεθείτε στο λογαριασμό σας Hugging Face αν απαιτείται για μοντέλα όπως το Llama 3​ (Hugging Face)​​

Tokenization:

• Χρησιμοποιήστε τον κατάλληλο tokenizer για το Llama 3, διασφαλίζοντας ότι είναι συμβατός με το μοντέλο και υποστηρίζει τις απαιτούμενες λειτουργίες όπως padding και ειδικοί token.

Μνήμη και Υπολογισμοί:

• Η λεπτοβελτίωση μεγάλων μοντέλων όπως το Llama 3 απαιτεί σημαντικούς υπολογιστικούς πόρους. Βεβαιωθείτε ότι το περιβάλλον σας, όπως μια ισχυρή ρύθμιση GPU, μπορεί να χειριστεί τις απαιτήσεις μνήμης και επεξεργασίας. Βεβαιωθείτε ότι το περιβάλλον μπορεί να χειριστεί τις απαιτήσεις μνήμης, οι οποίες μπορούν να ελαττωθούν χρησιμοποιώντας τεχνικές όπως η QLoRA για να μειώσουν την αποτύπωση μνήμης​ (Hugging Face Forums)

Παράδειγμα:

model_name = 'meta-llama/Meta-Llama-3-8B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

Tokenization:

Ανάλογα με την συγκεκριμένη περίπτωση και τις απαιτήσεις του μοντέλου, διασφαλίστε τη σωστή ρύθμιση του tokenizer χωρίς περιττές ρυθμίσεις. Για παράδειγμα, use_fast=True συνιστάται για καλύτερη απόδοση​ (Hugging Face)​​ (GitHub)​

5.2 Χρήση Άλλων Δημοφιλών Μοντέλων (π.χ. GPT-3, Mistral)

Επιλογή Μοντέλου:

• Για μοντέλα όπως το GPT-3 και το Mistral, βεβαιωθείτε ότι χρησιμοποιείτε το σωστό όνομα και αναγνωριστικό μοντέλου από το Hugging Face model hub ή άλλες πηγές.

Tokenization:

• Παρόμοια με το Llama 3, βεβαιωθείτε ότι ο tokenizer είναι σωστά ρυθμισμένος και συμβατός με το μοντέλο.

Μνήμη και Υπολογισμοί:

• Κάθε μοντέλο μπορεί να έχει διαφορετικές απαιτήσεις μνήμης. Ρυθμίστε την ρύθμιση του περιβάλλοντος σας ανάλογα.

Παράδειγμα για GPT-3:

model_name = 'openai/gpt-3'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

Παράδειγμα για Mistral:

model_name = 'mistral-7B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

Σκέψεις για Tokenization: Κάθε μοντέλο μπορεί να έχει μοναδικές απαιτήσεις tokenization. Βεβαιωθείτε ότι ο tokenizer ταιριάζει με το μοντέλο και είναι σωστά ρυθμισμένος.

Παράδειγμα Tokenizer για Llama 3:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

Παράδειγμα Tokenizer για GPT-3 και Mistral:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
use_fast=True
)

7. Δοκιμή του Μοντέλου με Zero-Shot Inferencing

Αξιολογήστε το βασικό μοντέλο με ένα δείγμα εισόδου:

from transformers import set_seed

set_seed(42)
index = 10
prompt = dataset['test'][index]['dialogue']
formatted_prompt = f"Instruct: Summarize the following conversation.\n{prompt}\nOutput:\n"

# Generate output
def gen(model, prompt, max_length):
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=max_length)
return tokenizer.batch_decode(outputs, skip_special_tokens=True)

res = gen(original_model, formatted_prompt, 100)
output = res[0].split('Output:\n')[1]

print(f'INPUT PROMPT:\n{formatted_prompt}')
print(f'MODEL GENERATION - ZERO SHOT:\n{output}')

8. Προεπεξεργασία του Συνόλου Δεδομένων

Μετατρέψτε ζευγάρια διαλόγου-περίληψης σε προτροπές:

def create_prompt_formats(sample):
blurb = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
instruction = "### Instruct: Summarize the below conversation."
input_context = sample['dialogue']
response = f"### Output:\n{sample['summary']}"
end = "### End"

parts = [blurb, instruction, input_context, response, end]
formatted_prompt = "\n\n".join(parts)
sample["text"] = formatted_prompt
return sample

dataset = dataset.map(create_prompt_formats)

Tokenize το προεπεξεργασμένο σύνολο δεδομένων:

def preprocess_batch(batch, tokenizer, max_length):
return tokenizer(batch["text"], max_length=max_length, truncation=True)

max_length = 1024
train_dataset = dataset["train"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
eval_dataset = dataset["validation"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)

Ετοιμάστε το μοντέλο για την αποτελεσματική λεπτοβελτίωση παραμέτρων:

original_model = prepare_model_for_kbit_training(original_model)

Οι υπερπαράμετροι παίζουν κρίσιμο ρόλο στην βελτίωση της απόδοσης του μοντέλου σας. Εδώ είναι некоторые κρίσιμες υπερπαράμετροι να λάβετε υπόψη:

1. Ρυθμός Μάθησης: Ελέγχει την ταχύτητα με την οποία το μοντέλο ενημερώνει τις παραμέτρους του. Ένας υψηλός ρυθμός μάθησης μπορεί να οδηγήσει σε ταχύτερη σύγκλιση αλλά μπορεί να υπερβεί την ιδανική λύση. Ένας χαμηλός ρυθμός μάθησης διασφαλίζει σταθερή σύγκλιση αλλά μπορεί να απαιτήσει περισσότερες επαναλήψεις.
2. Μέγεθος Μπατσ: Ο αριθμός των δειγμάτων που επεξεργάζονται πριν το μοντέλο ενημερώσει τις παραμέτρους του. Μεγαλύτερα μεγέθη μπατσ μπορούν να βελτιώσουν τη σταθερότητα αλλά απαιτούν περισσότερη μνήμη. Μικρότερα μεγέθη μπατσ μπορεί να οδηγήσουν σε περισσότερο θόρυβο στη διαδικασία εκπαίδευσης.
3. Βήματα Συγκέντρωσης Gradient: Αυτή η παράμετρος βοηθά στην προσομοίωση μεγαλύτερων μεγεθών μπατσ συσσωρευώντας gradients σε πολλά βήματα πριν από την ενημέρωση των παραμέτρων.
4. Αριθμός Επαναλήψεων: Ο αριθμός των φορών που το ολόκληρο σύνολο δεδομένων περνάει από το μοντέλο. Περισσότερες επαναλήψεις μπορούν να βελτιώσουν την απόδοση αλλά μπορεί να οδηγήσουν σε υπερ-προσαρμογή αν δεν διαχειριστούνται σωστά.
5. Λήθη Βάρους: Τεχνική κανονικοποίησης για την αποφυγή υπερ-προσαρμογής.
6. Προγραμματιστής Ρυθμού Μάθησης: Ρυθμίζει τον ρυθμό μάθησης κατά τη διάρκεια της εκπαίδευσης για να βελτιώσει την απόδοση και τη σύγκλιση.

Προσαρμόστε τη ρύθμιση εκπαίδευσης προσαρμόζοντας υπερπαράμετροι όπως ο ρυθμός μάθησης, το μέγεθος μπατσ και τα βήματα συσσώρευσης gradient με βάση τις συγκεκριμένες απαιτήσεις του μοντέλου και της εργασίας. Για παράδειγμα, τα μοντέλα Llama 3 μπορεί να απαιτούν διαφορετικούς ρυθμούς μάθησης σε σύγκριση με μικρότερα μοντέλα​ (Weights & Biases)​​ (GitHub)​

Παράδειγμα Ρύθμισης Εκπαίδευσης

orpo_args = ORPOConfig(
learning_rate=8e-6,
lr_scheduler_type="linear",max_length=1024,max_prompt_length=512,
beta=0.1,per_device_train_batch_size=2,per_device_eval_batch_size=2,
gradient_accumulation_steps=4,optim="paged_adamw_8bit",num_train_epochs=1,
evaluation_strategy="steps",eval_steps=0.2,logging_steps=1,warmup_steps=10,
report_to="wandb",output_dir="./results/",)

10. Εκπαίδευση του Μοντέλου

Ρυθμίστε τον εκπαιδευτή και ξεκινήστε την εκπαίδευση:

trainer = ORPOTrainer(
model=original_model,
args=orpo_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
tokenizer=tokenizer,)
trainer.train()
trainer.save_model("fine-tuned-llama-3")

Αξιολόγηση του Λεπτοβελτιωμένου Μοντέλου

Μετά την εκπαίδευση, αξιολογήστε την απόδοση του μοντέλου χρησιμοποιώντας ποιοτικά και ποσοτικά μέτρα.

1. Ανθρώπινη Αξιολόγηση

Συγκρίνετε τις γενημένες περιλήψεις με ανθρώπινες για να αξιολογήσετε την ποιότητα.

2. Ποσοτική Αξιολόγηση

Χρησιμοποιήστε μετρικά όπως το ROUGE για να αξιολογήσετε την απόδοση:

from rouge_score import rouge_scorer

scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
scores = scorer.score(reference_summary, generated_summary)
print(scores)

Κοινές Προκλήσεις και Λύσεις

1. Περιορισμοί Μνήμης

Η χρήση της QLoRA βοηθά στην αντιμετώπιση των προβλημάτων μνήμης quantizing τα βάρη του μοντέλου σε 4-bit. Βεβαιωθείτε ότι έχετε αρκετή μνήμη GPU για να χειριστείτε το μέγεθος μπατσ και το μέγεθος του μοντέλου.

2. Υπερ-Προσαρμογή

Παρακολουθήστε τα μετρικά επαλήθευσης για να αποτρέψετε την υπερ-προσαρμογή. Χρησιμοποιήστε τεχνικές όπως η πρώιμη διακοπή και η λήθη βάρους.

3. Αργή Εκπαίδευση

Βελτιώστε την ταχύτητα εκπαίδευσης προσαρμόζοντας το μέγεθος μπατς, τον ρυθμό μάθησης και χρησιμοποιώντας βήματα συσσώρευσης gradient.

4. Ποιότητα Δεδομένων

Βεβαιωθείτε ότι το σύνολο δεδομένων είναι καθαρό και καλά προεπεξεργασμένο. Κακή ποιότητα δεδομένων μπορεί να επηρεάσει σημαντικά την απόδοση του μοντέλου.

Συμπέρασμα

Η λεπτοβελτίωση των LLMs χρησιμοποιώντας QLoRA είναι ένας αποτελεσματικός τρόπος για να προσαρμόσετε μεγάλα προ-εκπαιδευμένα μοντέλα σε συγκεκριμένες εργασίες με μειωμένους υπολογιστικούς κόστους. Ακολουθώντας αυτόν τον οδηγό, μπορείτε να λεπτοβελτιώσετε το PHI, Llama 3 ή οποιοδήποτε άλλο μοντέλο ανοικτού κώδικα για να επιτύχετε υψηλή απόδοση στις συγκεκριμένες εργασίες σας.