Bouw een aangepast AI-model deze week: een praktische Unsloth-gids

U heeft een taalmodel nodig dat uw bedrijfsgegevens begrijpt. U kunt ChatGPT niet gebruiken omdat uw gegevens privé zijn. Generieke modellen maken te veel fouten in uw domein.

Aan het einde van deze gids hebt u een afgestemd taalmodel dat lokaal draait. Het zal vragen beantwoorden op basis van uw aangepaste dataset. U weet ook of u deze benadering moet schalen of iets anders moet proberen.

Wat u nodig heeft voordat u begint

Tijd: 90-120 minuten voor de eerste uitvoering Vaardigheden: Basis-Python, vertrouwdheid met de opdrachtregel Hardware: Een computer met een NVIDIA GPU (8 GB VRAM minimum) of toegang tot Google Colab Pro Software: Python 3.9+, Git

Als u geen GPU heeft, gebruikt u de gratis laag van Google Colab. De training zal trager zijn, maar zal nog steeds werken.

Stap-voor-stap-implementatiehandleiding

Stap 1: Stel uw omgeving in

Open uw terminal en voer de volgende opdrachten uit:

```bash

Maak een nieuwe projectmap

mkdir custom-ai-model && cd custom-ai-model

Maak een virtuele omgeving

python -m venv unsloth-env
source unsloth-env/bin/activate # Op Windows: unsloth-env\Scripts\activate

Installeer Unsloth en afhankelijkheden

pip install "unsloth[colab] @ git+https://github.com/unslothai/unsloth.git"
pip install trl transformers datasets
```

Gotcha: Als u CUDA-fouten krijgt, controleert u uw PyTorch-installatie. Unsloth heeft PyTorch met CUDA-ondersteuning nodig. Voer pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 uit als dat nodig is.

Stap 2: Bereid uw trainingsgegevens voor

Maak een bestand met de naam prepare_data.py:

```python
from datasets import Dataset
import json

from datasets import Dataset
import json

Uw aangepaste gegevens - vervang door uw eigen bedrijfsgegevens

examples = [
{
"instruction": "Wat is ons retourbeleid voor elektronica?",
"input": "",
"output": "Elektronica kan binnen 30 dagen worden geretourneerd met originele verpakking. Geen restockkosten van toepassing."
},
{
"instruction": "Hoe reset ik mijn accountwachtwoord?",
"input": "",
"output": "Ga naar instellingen > beveiliging > wachtwoord reset. U ontvangt een e-mail met een link die 24 uur geldig is."
},
# Voeg 50-100 meer voorbeelden toe voor behoorlijke resultaten
]

Converteer naar Hugging Face-datasetformaat

dataset = Dataset.from_list(examples)
dataset.save_to_disk("./my_training_data")
print(f"Opgeslagen {len(dataset)\} voorbeelden")

Voer het uit: python prepare_data.py

Troubleshooting Tip: Begin met 50-100 voorbeelden. Meer gegevens geven betere resultaten, maar nemen langer de tijd in beslag om te trainen. Gebruik uw eigen klantenservice-logboeken, documentatie of productSpecificaties.

Stap 3: Configureer en voer training uit

Maak train_model.py:

```python
from unsloth import FastLanguageModel
import torch
from datasets import load_from_disk
from trl import SFTTrainer
from transformers import TrainingArguments

Laad een klein, efficiënt model

model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/mistral-7b-bnb-4bit",
max_seq_length = 2048,
dtype = torch.float16,
load_in_4bit = True, # Bespaart 75% geheugen
)

Schakel LoRA in voor snellere training met minder geheugen

model = FastLanguageModel.get_peft_model(
    model,
    r = 16,  # LoRA-rang
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    use_gradient_checkpointing = True,
    random_state = 3407,
)

Laad uw gegevens

train_dataset = load_from_disk("./my_training_data")

Configureer training

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = train_dataset,
    dataset_text_field = "output",
    max_seq_length = 1024,
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 10,
        max_steps = 60,  # Begin klein
        learning_rate = 2e-4,
        fp16 = not torch.cuda.is_bf16_supported(),
        bf16 = torch.cuda.is_bf16_supported(),
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = "outputs",
    ),
)

Train

trainer.train()

Sla het model op

model.save_pretrained("my_fine_tuned_model")
tokenizer.save_pretrained("my_fine_tuned_model")
print("Training voltooid! Model opgeslagen in 'my_fine_tuned_model'")
```

Voer training uit: python train_model.py

Verwachte uitvoer: U ziet de verlieswaarde dalen elke paar stappen. Trainen van 60 stappen op 100 voorbeelden duurt ongeveer 15-20 minuten op een RTX 4090.

Gotcha: Als u geen geheugen meer heeft, verlaag per_device_train_batch_size naar 1. Als de training te langzaam is, verlaag max_seq_length naar 512.

Stap 4: Test uw model

Maak test_model.py:

```python
from unsloth import FastLanguageModel
import torch

Laad uw afgestemde model

model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "./my_fine_tuned_model",
max_seq_length = 1024,
dtype = torch.float16,
load_in_4bit = True,
)

FastLanguageModel.for_inference(model)

Maak een prompt

test_vraag = "Wat is ons retourbeleid voor elektronica?"
inputs = tokenizer(
[f"<s>Below is an instruction. Write a response.\n\n### Instruction:\n{test_vraag}\n\n### Response:\n"],
return_tensors = "pt",
).to("cuda")

Genereer antwoord

outputs = model.generate(**inputs, max_new_tokens=100, use_cache=True)
antwoord = tokenizer.batch_decode(outputs)[0]

Haal alleen het antwoord op

antwoord_start = antwoord.find("### Response:\n") + len("### Response:\n")
schoon_antwoord = antwoord[antwoord_start:].strip()
print(f"Vraag: {test_vraag}")
print(f"Antwoord: {schoon_antwoord}")
```

Voer het uit: python test_model.py

Succesmetriek: Het model moet antwoorden met iets dat lijkt op uw trainingsgegevens. Het zal niet perfect zijn bij de eerste poging.

Waar u op moet letten

Gegevenskwaliteit bepaalt resultaten Uw model zal alleen zo goed zijn als uw trainingsvoorbeelden. Als uw gegevens tegenstrijdigheden of fouten bevatten, zal het model deze leren. Begin met een schone, consistente dataset van 50-100 hoogwaardige voorbeelden voordat u opschalt.
Dit is een prototype, geen productie Het model dat u zojuist hebt gemaakt, werkt voor het testen van concepten. Voor productiegebruik heeft u meer gegevens nodig (500-1000+ voorbeelden), juiste evaluatiemetrics en implementatie-infrastructuur. Implementeer deze versie niet bij uw klanten.

Uw volgende stap

Voer deze gids eenmaal uit met voorbeeldgegevens om de workflow te begrijpen. Neem de tijd op. Noteer waar u tegen bottlenecks aanloopt.

Vervolgens beslist u: als het prototype veelbelovend is, wijdt u 40 uur toe aan het voorbereiden van 500+ hoogwaardige trainingsvoorbeelden en voert u een juiste training uit. Als de resultaten zwak zijn na 100 voorbeelden, overweegt u of fine-tuning de juiste aanpak is voor uw gebruiksscenario.

Bezoek Unsloth's officiële site voor geavanceerde functies zoals multi-GPU-training en Hugging Face Jobs-integratie wanneer u klaar bent om op te schalen.

Bouw een aangepast AI-model deze week: een praktische gids zonder uitstel