Vylaďte Falcon 7B a další LLM na Amazon SageMaker pomocí @remote decorator

Dnes generativní modely umělé inteligence pokrývají různé úkoly od sumarizace textu, otázek a odpovědí až po generování obrázků a videí. Ke zlepšení kvality výstupu se používají přístupy jako n-short learning, Prompt engineering, Retrieval Augmented Generation (RAG) a jemné ladění. Jemné ladění vám umožňuje upravit tyto generativní modely umělé inteligence, abyste dosáhli lepšího výkonu při úkolech specifických pro vaši doménu.

S Amazon SageMaker nyní můžete spustit výukovou úlohu SageMaker jednoduše tím, že označíte svůj Python kód pomocí @remote decorator. The SageMaker Python SDK automaticky přeloží vaše stávající prostředí pracovního prostoru a jakýkoli související kód pro zpracování dat a datové sady do školicí úlohy SageMaker, která běží na školicí platformě. To má výhodu v tom, že kód píšete přirozenějším, objektově orientovaným způsobem a stále využívá schopnosti SageMakeru ke spouštění školicích úloh na vzdáleném clusteru s minimálními změnami.

V tomto příspěvku ukážeme, jak doladit a Falcon-7B Foundation Models (FM) pomocí @remote decorator ze SageMaker Python SDK. Také používá Parametrově efektivní jemné doladění Hugging Face (PEFT) prostřednictvím knihovny a kvantizačních technik bitsandbajtů na podporu jemného doladění. Kód prezentovaný v tomto blogu lze také použít k doladění dalších FM, jako je např Lama-2 13b.

Plně přesné reprezentace tohoto modelu mohou mít problémy s uložením do paměti na jednom nebo dokonce několika Grafické procesorové jednotky (GPU) — nebo může dokonce potřebovat větší instanci. Proto, abychom tento model doladili bez zvýšení nákladů, používáme techniku známou jako Kvantované LLM s adaptéry s nízkou hodností (QLoRA). QLoRA je účinný přístup k jemnému ladění, který snižuje využití paměti LLM při zachování velmi dobrého výkonu.

Výhody použití @remote decorator

Než půjdeme dále, pojďme pochopit, jak vzdálený dekorátor zlepšuje produktivitu vývojářů při práci se SageMakerem:

• @remote decorator spouští tréninkovou úlohu přímo pomocí nativního kódu pythonu, bez explicitního vyvolání SageMaker Estimators a vstupních kanálů SageMaker
• Nízká bariéra vstupu pro vývojáře školící modely na SageMaker.
• Není třeba přepínat Integrovaná vývojová prostředí (IDE). Pokračujte v psaní kódu podle vašeho výběru IDE a vyvolejte úlohy školení SageMaker.
• Není třeba se učit o kontejnerech. Pokračujte v poskytování závislostí v a požadavky.txt a dodat to vzdálenému dekoratérovi.

Předpoklady

Je potřeba účet AWS s rolí AWS Identity and Access Management (AWS IAM), která má oprávnění ke správě prostředků vytvořených jako součást řešení. Podrobnosti naleznete v části Vytvoření účtu AWS.

V tomto příspěvku používáme Amazon SageMaker Studio s Data Science 3.0 obrázek a a ml.t3.střední instance rychlého spuštění. Můžete však použít libovolné integrované vývojové prostředí (IDE) dle vašeho výběru. Stačí správně nastavit přihlašovací údaje rozhraní příkazového řádku AWS (AWS CLI). Další informace naleznete v části Konfigurace rozhraní AWS CLI.

Pro jemné doladění slouží Falcon-7B, an ml.g5,12xvelký instance je použita v tomto příspěvku. Zajistěte prosím dostatečnou kapacitu pro tuto instanci v účtu AWS.

Musíte to naklonovat úložiště Github za replikaci řešení ukázaného v tomto příspěvku.

Přehled řešení

1. Nainstalujte předpoklady pro jemné doladění modelu Falcon-7B
2. Nastavte vzdálené konfigurace dekoratérů
3. Předběžně zpracujte datovou sadu obsahující často kladené dotazy ke službám AWS
4. Dolaďte Falcon-7B na služby AWS – časté dotazy
5. Vyzkoušejte dolaďovací modely na vzorových otázkách týkajících se služeb AWS

1. Nainstalujte předpoklady pro jemné doladění modelu Falcon-7B

Spusťte notebook falcon-7b-qlora-remote-decorator_qa.ipynb v SageMaker Studio výběrem Ikouzelník tak jako Data Science a Jádro tak jako Python 3. Nainstalujte všechny požadované knihovny uvedené v požadavky.txt. Jen málo knihoven je třeba nainstalovat do samotné instance notebooku. Proveďte další operace potřebné pro zpracování datové sady a spuštění úlohy školení SageMaker.

Instalace %pip -r požadavky.txt Instalace %pip -q -U transformátory==4.31.0 Instalace %pip -q -U datové sady==2.13.1 Instalace %pip -q -U peft==0.4.0 Instalace %pip -q -U akcelerace ==0.21.0 Instalace %pip -q -U bitsandbytes==0.40.2 Instalace %pip -q -U boto3 %pip instalace -q -U sagemaker==2.154.0 Instalace %pip -q -U scikit-learn

2. Nastavte vzdálené konfigurace dekorátoru

Vytvořte konfigurační soubor, ve kterém budou specifikovány všechny konfigurace související s úlohou školení Amazon SageMaker. Tento soubor čte @remote decorator při spuštění úlohy školení. Tento soubor obsahuje nastavení, jako jsou závislosti, tréninkový obraz, instance a spouštěcí role, která se má použít pro tréninkovou úlohu. Pro podrobný odkaz na všechna nastavení podporovaná konfiguračním souborem se podívejte Konfigurace a používání výchozích hodnot pomocí sady SageMaker Python SDK.

SchemaVersion: '1.0' SageMaker: PythonSDK: Moduly: RemoteFunction: Závislosti: ./requirements.txt ImageUri: '{aws_account_id}.dkr.ecr.{region}.amazonaws.com/huggingface-pytorch-training:2.0.0-transformers .28.1-gpu-py310-cu118-ubuntu20.04' InstanceType: ml.g5.12xlarge RoleArn: arn:aws:iam::111122223333:role/ExampleSageMakerRole

Není povinné používat config.yaml abyste mohli pracovat s @remote dekorátorem. Toto je jen čistší způsob, jak dodat všechny konfigurace dekorátoru @remote. To udržuje parametry související se SageMakerem a AWS mimo kód s jednorázovým úsilím o nastavení konfiguračního souboru používaného mezi členy týmu. Všechny konfigurace by také mohly být dodány přímo v argumentech dekorátoru, ale to z dlouhodobého hlediska snižuje čitelnost a udržovatelnost změn. Konfigurační soubor může také vytvořit správce a sdílet ho se všemi uživateli v prostředí.

Předběžně zpracujte datovou sadu obsahující často kladené dotazy ke službám AWS

Dalším krokem je načtení a předzpracování datové sady, aby byla připravena pro trénovací úlohu. Nejprve se podívejme na datovou sadu:

Zobrazuje FAQ pro jednu ze služeb AWS. Kromě QLoRA, bitsanbajtů se používá k převodu na 4bitovou přesnost pro kvantování zmrazeného LLM na 4bitové a připojení LoRA adaptéry na něm.

Vytvořte šablonu výzvy k převedení každého vzorku nejčastějších dotazů do formátu výzvy:

z náhodného importu randint # vlastní pokyn příkaz start prompt_template = f"{{question}}\n---\nOdpověď:\n{{answer}}{{eos_token}}" # šablona datová sada pro přidání výzvy ke každé ukázkové def template_dataset (sample): sample["text"] = prompt_template.format(question=sample["question"], answer=sample["answers"], eos_token=tokenizer.eos_token) return sample

Dalším krokem je převedení vstupů (textu) na ID tokenů. To provádí a Objímání Face Transformers Tokenizer.

z transformátorů import AutoTokenizer model_id = "tiiuae/falcon-7b" tokenizer = AutoTokenizer.from_pretrained(model_id) # Nastavte Falcon tokenizer tokenizer.pad_token = tokenizer.eos_token

Nyní jednoduše použijte prompt_template funkce pro převod všech nejčastějších dotazů do formátu výzvy a nastavení datových sad vlaků a testů.

4. Vylaďte Falcon-7B na často kladené otázky o službách AWS

Nyní můžete připravit tréninkový skript a definovat tréninkovou funkci train_fn a na funkci nastavte @remote decorator.

Tréninková funkce dělá následující:

• tokenizuje a rozděluje datovou sadu
• založit BitsAndBytesConfig, který určuje, že model by měl být načten ve 4 bitech, ale výpočet by měl být převeden na bfloat16.
• Načtěte model
• Najděte cílové moduly a aktualizujte potřebné matice pomocí obslužné metody find_all_linear_names
• Vytvořit LoRA konfigurace, které určují hodnocení matic aktualizace (s), faktor měřítka (lora_alpha), moduly pro použití aktualizačních matic LoRA (cílové_moduly), pravděpodobnost výpadku pro vrstvy Lora(lora_dropout), task_type, atd.
• Začněte školení a hodnocení

import bitsandbytes as bnb

def find_all_linear_names(hf_model):
    lora_module_names = set()
    for name, module in hf_model.named_modules():
        if isinstance(module, bnb.nn.Linear4bit):
            names = name.split(".")
            lora_module_names.add(names[0] if len(names) == 1 else names[-1])

    if "lm_head" in lora_module_names:
        lora_module_names.remove("lm_head")
    return list(lora_module_names)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from sagemaker.remote_function import remote
import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import transformers

# Start training
@remote(volume_size=50)
def train_fn(
        model_name,
        train_ds,
        test_ds,
        lora_r=8,
        lora_alpha=32,
        lora_dropout=0.05,
        per_device_train_batch_size=8,
        per_device_eval_batch_size=8,
        learning_rate=2e-4,
        num_train_epochs=1
):
    # tokenize and chunk dataset
    lm_train_dataset = train_ds.map(
        lambda sample: tokenizer(sample["text"]), batched=True, batch_size=24, remove_columns=list(train_dataset.features)
    )


    lm_test_dataset = test_ds.map(
        lambda sample: tokenizer(sample["text"]), batched=True, remove_columns=list(test_dataset.features)
    )

    # Print total number of samples
    print(f"Total number of train samples: {len(lm_train_dataset)}")

    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_use_double_quant=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.bfloat16
    )
    # Falcon requires you to allow remote code execution. This is because the model uses a new architecture that is not part of transformers yet.
    # The code is provided by the model authors in the repo.
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        trust_remote_code=True,
        quantization_config=bnb_config,
        device_map="auto")

    model.gradient_checkpointing_enable()
    model = prepare_model_for_kbit_training(model, use_gradient_checkpointing=True)

    # get lora target modules
    modules = find_all_linear_names(model)
    print(f"Found {len(modules)} modules to quantize: {modules}")

    config = LoraConfig(
        r=lora_r,
        lora_alpha=lora_alpha,
        target_modules=modules,
        lora_dropout=lora_dropout,
        bias="none",
        task_type="CAUSAL_LM"
    )

    model = get_peft_model(model, config)
    print_trainable_parameters(model)

    trainer = transformers.Trainer(
        model=model,
        train_dataset=lm_train_dataset,
        eval_dataset=lm_test_dataset,
        args=transformers.TrainingArguments(
            per_device_train_batch_size=per_device_train_batch_size,
            per_device_eval_batch_size=per_device_eval_batch_size,
            logging_steps=2,
            num_train_epochs=num_train_epochs,
            learning_rate=learning_rate,
            bf16=True,
            save_strategy="no",
            output_dir="outputs"
        ),
        data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
    )
    model.config.use_cache = False

    trainer.train()
    trainer.evaluate()

    model.save_pretrained("/opt/ml/model")

A vyvolat train_fn()

train_fn(id_modelu, soubor_dat_vlaku, soubor_dat_testu)

Úloha ladění by běžela na tréninkovém clusteru Amazon SageMaker. Počkejte na dokončení ladění.

5. Otestujte modely jemného ladění na vzorových otázkách týkajících se služeb AWS

Nyní je čas provést několik testů modelu. Nejprve načteme model:

z peft importovat PeftModel, PeftConfig importovat pochodeň z transformátorů importovat AutoModelForCausalLM device="cuda" if torch.cuda.is_available() jinak 'mps' if torch.backends.mps.is_available() jinak 'cpu' config = PeftConfig.from"_pretrained ./model") model = AutoModelForCausalLM.from_pretrained(config.base_model_name_or_path, trust_remote_code=True) model = PeftModel.from_pretrained(model, "./model") model.to(zařízení)

Nyní načtěte ukázkovou otázku z trénovací datové sady, abyste viděli původní odpověď, a poté položte stejnou otázku z vyladěného modelu, abyste viděli odpověď v porovnání.

Zde je ukázka otázky z tréninkové sady a původní odpověď:

Nyní je stejná otázka položena vyladěnému modelu Falcon-7B:

Tímto je dokončena implementace jemného ladění Falcon-7B na datové sadě FAQ služeb AWS pomocí @remote decorator z Amazon SageMaker Python SDK.

Čištění

Chcete-li vyčistit své zdroje, proveďte následující kroky:

• Vypněte instance aplikace Amazon SageMaker Studio, abyste předešli dalším nákladům.
• Vyčistěte svůj adresář Amazon Elastic File System (Amazon EFS) vymazáním adresáře mezipaměti Hugging Face:

  rm -R ~/.cache/huggingface/hub

Závěr

V tomto příspěvku jsme vám ukázali, jak efektivně využít schopnosti dekorátoru @remote k doladění modelu Falcon-7B pomocí QLoRA, Hugging Face PEFT s bitsandbtyes bez použití významných změn v tréninkovém notebooku a využívali schopnosti Amazon SageMaker ke spouštění školicích úloh na vzdáleném clusteru.

Veškerý kód zobrazený jako součást tohoto příspěvku pro jemné doladění Falconu-7B je k dispozici v úložiště GitHub. Úložiště také obsahuje notebook ukazující, jak doladit Llama-13B.

Jako další krok vám doporučujeme vyzkoušet funkci @remote decorator a Python SDK API a použijte jej ve svém výběru prostředí a IDE. Další příklady jsou k dispozici v příklady amazonského mudrce úložiště, abyste mohli rychle začít. Můžete se také podívat na následující příspěvky:

O autorech

Bruno Pistone je AI/ML Specialist Solutions Architect pro AWS se sídlem v Miláně. Pracuje s velkými zákazníky, pomáhá jim hluboce porozumět jejich technickým potřebám a navrhovat řešení AI a strojového učení, která nejlépe využívají AWS Cloud a Amazon Machine Learning stack. Mezi jeho odborné znalosti patří: strojové učení od začátku do konce, industrializace strojového učení a generativní umělá inteligence. Rád tráví čas se svými přáteli a poznává nová místa a také cestuje do nových destinací.

Vikesh Pandey je specialistou na řešení strojového učení ve společnosti AWS, který pomáhá zákazníkům z finančních odvětví navrhovat a vytvářet řešení na generativní umělé inteligenci a ML. Mimo práci Vikesh rád zkouší různé kuchyně a hraje venkovní sporty.