Perhalusi Falcon 7B dan LLM lain di Amazon SageMaker dengan @remote decorator

Hari ini, model AI generatif merangkumi pelbagai tugas daripada ringkasan teks, Soal Jawab dan penjanaan imej dan video. Untuk meningkatkan kualiti output, pendekatan seperti pembelajaran n-pendek, kejuruteraan segera, Retrieval Augmented Generation (RAG) dan penalaan halus digunakan. Penalaan halus membolehkan anda melaraskan model AI generatif ini untuk mencapai prestasi yang lebih baik pada tugas khusus domain anda.

Dengan Amazon SageMaker, kini anda boleh menjalankan kerja latihan SageMaker hanya dengan menganotasi kod Python anda dengan @remote decorator. The SDK Python SageMaker menterjemahkan persekitaran ruang kerja sedia ada anda secara automatik, dan sebarang kod pemprosesan data dan set data yang berkaitan, ke dalam kerja latihan SageMaker yang dijalankan pada platform latihan. Ini mempunyai kelebihan menulis kod dalam cara yang lebih semula jadi, berorientasikan objek, dan masih menggunakan keupayaan SageMaker untuk menjalankan kerja latihan pada kelompok jauh dengan perubahan yang minimum.

Dalam siaran ini, kami mempamerkan cara memperhalusi a Falcon-7B Foundation Models (FM) menggunakan @remote decorator daripada SageMaker Python SDK. Ia juga menggunakan Penalaan halus yang cekap parameter Wajah memeluk (PEFT) perpustakaan dan teknik kuantisasi melalui bitsandbait untuk menyokong penalaan halus. Kod yang dibentangkan dalam blog ini juga boleh digunakan untuk memperhalusi FM lain, seperti Llama-2 13b.

Perwakilan ketepatan penuh model ini mungkin mempunyai cabaran untuk dimuatkan ke dalam ingatan pada satu atau bahkan beberapa Unit Pemprosesan Grafik (GPU) — atau mungkin memerlukan contoh yang lebih besar. Oleh itu, untuk memperhalusi model ini tanpa meningkatkan kos, kami menggunakan teknik yang dikenali sebagai LLM Berkuantiti dengan Penyesuai Peringkat Rendah (QLoRA). QLoRA ialah pendekatan penalaan halus yang cekap yang mengurangkan penggunaan memori LLM sambil mengekalkan prestasi yang sangat baik.

Kelebihan menggunakan @remote decorator

Sebelum pergi lebih jauh, mari kita fahami cara penghias jauh meningkatkan produktiviti pembangun semasa bekerja dengan SageMaker:

• @penghias jauh mencetuskan kerja latihan secara langsung menggunakan kod python asli, tanpa seruan eksplisit SageMaker Estimators dan saluran input SageMaker
• Halangan rendah untuk kemasukan model latihan pembangun di SageMaker.
• Tidak perlu bertukar Persekitaran pembangunan bersepadu (IDE). Teruskan menulis kod dalam IDE pilihan anda dan gunakan kerja latihan SageMaker.
• Tidak perlu belajar tentang bekas. Teruskan menyediakan tanggungan dalam a keperluan.txt dan membekalkannya kepada penghias jauh.

Prasyarat

Akaun AWS diperlukan dengan peranan AWS Identity and Access Management (AWS IAM) yang mempunyai kebenaran untuk mengurus sumber yang dibuat sebagai sebahagian daripada penyelesaian. Untuk butiran, rujuk Membuat akaun AWS.

Dalam siaran ini, kami menggunakan Amazon SageMaker Studio dengan Sains Data 3.0 imej dan a ml.t3.sederhana contoh pelancaran pantas. Walau bagaimanapun, anda boleh menggunakan mana-mana persekitaran pembangunan bersepadu (IDE) pilihan anda. Anda hanya perlu menyediakan bukti kelayakan AWS Command Line Interface (AWS CLI) anda dengan betul. Untuk maklumat lanjut, rujuk Konfigurasi AWS CLI.

Untuk penalaan halus, Falcon-7B, an ml.g5.12xbesar contoh digunakan dalam siaran ini. Sila pastikan kapasiti yang mencukupi untuk kejadian ini dalam akaun AWS.

Anda perlu mengklon ini Repositori Github untuk mereplikasi penyelesaian yang ditunjukkan dalam siaran ini.

Gambaran keseluruhan penyelesaian

1. Pasang pra-syarat untuk menala halus model Falcon-7B
2. Sediakan konfigurasi penghias jauh
3. Praproses set data yang mengandungi Soalan Lazim perkhidmatan AWS
4. Perhalusi Falcon-7B pada Soalan Lazim perkhidmatan AWS
5. Uji model penalaan halus pada contoh soalan yang berkaitan dengan perkhidmatan AWS

1. Pasang prasyarat untuk menala halus model Falcon-7B

Lancarkan buku nota falcon-7b-qlora-remote-decorator_qa.ipynb dalam SageMaker Studio dengan memilih Iahli sihir sebagai Sains Data dan Inti sebagai Python 3. Pasang semua perpustakaan yang diperlukan yang dinyatakan dalam keperluan.txt. Beberapa perpustakaan perlu dipasang pada contoh buku nota itu sendiri. Laksanakan operasi lain yang diperlukan untuk pemprosesan set data dan mencetuskan kerja latihan SageMaker.

%pip install -r requirements.txt %pip install -q -U transformer==4.31.0 %pip install -q -U datasets==2.13.1 %pip install -q -U peft==0.4.0 %pip install -q -U mempercepatkan ==0.21.0 %pip install -q -U bitsandbytes==0.40.2 %pip install -q -U boto3 %pip install -q -U sagemaker==2.154.0 %pip install -q -U scikit-learn

2. Sediakan konfigurasi penghias jauh

Buat fail konfigurasi di mana semua konfigurasi yang berkaitan dengan kerja latihan Amazon SageMaker ditentukan. Fail ini dibaca oleh @penghias jauh semasa menjalankan kerja latihan. Fail ini mengandungi tetapan seperti kebergantungan, imej latihan, contoh, dan peranan pelaksanaan yang akan digunakan untuk kerja latihan. Untuk rujukan terperinci semua tetapan yang disokong oleh fail konfigurasi, lihat Mengkonfigurasi dan menggunakan lalai dengan SDK Python SageMaker.

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

Ia tidak wajib untuk menggunakan config.yaml fail untuk berfungsi dengan penghias jarak jauh. Ini hanyalah cara yang lebih bersih untuk membekalkan semua konfigurasi kepada penghias @remote. Ini mengekalkan parameter berkaitan SageMaker dan AWS di luar kod dengan usaha sekali untuk menyediakan fail konfigurasi yang digunakan merentas ahli pasukan. Semua konfigurasi juga boleh dibekalkan secara langsung dalam hujah penghias, tetapi itu mengurangkan kebolehbacaan dan kebolehselenggaraan perubahan dalam jangka panjang. Selain itu, fail konfigurasi boleh dibuat oleh pentadbir dan dikongsi dengan semua pengguna dalam persekitaran.

Praproses set data yang mengandungi Soalan Lazim perkhidmatan AWS

Langkah seterusnya ialah memuatkan dan praproses set data untuk menyediakannya untuk kerja latihan. Mula-mula, mari kita lihat set data:

Ia menunjukkan Soalan Lazim untuk salah satu perkhidmatan AWS. Selain QLoRA, bitsanbait digunakan untuk menukar kepada ketepatan 4-bit untuk mengkuantisasi LLM beku kepada 4-bit dan dilampirkan LoRA penyesuai di atasnya.

Buat templat gesaan untuk menukar setiap sampel Soalan Lazim kepada format gesaan:

daripada import rawak randint # arahan tersuai prompt start prompt_template = f"{{question}}\n---\nJawapan:\n{{answer}}{{eos_token}}" set data templat # untuk menambah gesaan pada setiap sampel def template_dataset (sampel): sample["text"] = prompt_template.format(question=sample["question"], answer=sample["answers"], eos_token=tokenizer.eos_token) return sample

Langkah seterusnya ialah menukar input (teks) kepada ID token. Ini dilakukan oleh a Tokenizer Transformers Wajah Berpeluk.

daripada transformer import AutoTokenizer model_id = "tiiuae/falcon-7b" tokenizer = AutoTokenizer.from_pretrained(model_id) # Tetapkan Falcon tokenizer tokenizer.pad_token = tokenizer.eos_token

Sekarang hanya gunakan prompt_template berfungsi untuk menukar semua Soalan Lazim kepada format gesaan dan menyediakan set data kereta api dan ujian.

4. Perhalusi Falcon-7B pada Soalan Lazim perkhidmatan AWS

Kini anda boleh menyediakan skrip latihan dan menentukan fungsi latihan train_fn dan letakkan @penghias jauh pada fungsi.

Fungsi latihan melakukan perkara berikut:

• tokenize dan chunks set data
• sediakan BitsAndBytesConfig, yang menentukan model harus dimuatkan dalam 4-bit tetapi sementara pengiraan harus ditukar kepada bfloat16.
• Muatkan model
• Cari modul sasaran dan kemas kini matriks yang diperlukan dengan menggunakan kaedah utiliti cari_semua_nama_linear
• Buat LoRA konfigurasi yang menentukan kedudukan matriks kemas kini (s), faktor penskalaan (lora_alpha), modul untuk menggunakan matriks kemas kini LoRA (modul_sasaran), kebarangkalian keciciran untuk lapisan Lora(lora_dropout), jenis_tugas, dan lain-lain.
• Mulakan latihan dan penilaian

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")

Dan mohon train_fn()

train_fn(model_id, train_dataset, test_dataset)

Kerja penalaan akan dijalankan pada kluster latihan Amazon SageMaker. Tunggu kerja penalaan selesai.

5. Uji model fine tune pada contoh soalan yang berkaitan dengan perkhidmatan AWS

Kini, tiba masanya untuk menjalankan beberapa ujian pada model. Mula-mula, mari kita muatkan model:

daripada peft import PeftModel, PeftConfig import obor daripada transformer import AutoModelForCausalLM device="cuda" jika torch.cuda.is_available() lain 'mps' jika torch.backends.mps.is_available() lain '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(device)

Sekarang muatkan contoh soalan daripada set data latihan untuk melihat jawapan asal dan kemudian tanya soalan yang sama daripada model yang ditala untuk melihat jawapan dalam perbandingan.

Berikut ialah contoh soalan dari set latihan dan jawapan asal:

Sekarang, soalan yang sama ditanya kepada model Falcon-7B yang ditala:

Ini menyimpulkan pelaksanaan penalaan halus Falcon-7B pada set data Soalan Lazim perkhidmatan AWS menggunakan @remote decorator daripada Amazon SageMaker Python SDK.

Membersihkan

Lengkapkan langkah berikut untuk membersihkan sumber anda:

• Matikan contoh Amazon SageMaker Studio untuk mengelakkan kos tambahan.
• Bersihkan direktori Amazon Elastic File System (Amazon EFS) anda dengan mengosongkan direktori cache Hugging Face:

  rm -R ~/.cache/huggingface/hub

Kesimpulan

Dalam siaran ini, kami menunjukkan kepada anda cara menggunakan keupayaan penghias jarak jauh dengan berkesan untuk memperhalusi model Falcon-7B menggunakan QLoRA, Memeluk Wajah PEFT dengan bitsandbtyes tanpa menggunakan perubahan ketara dalam buku nota latihan, dan menggunakan keupayaan Amazon SageMaker untuk menjalankan kerja latihan pada kluster jauh.

Semua kod yang ditunjukkan sebagai sebahagian daripada siaran ini untuk memperhalusi Falcon-7B tersedia dalam repositori GitHub. Repositori juga mengandungi buku nota yang menunjukkan cara memperhalusi Llama-13B.

Sebagai langkah seterusnya, kami menggalakkan anda menyemak fungsi @penghias jauh dan API SDK Python dan gunakannya dalam pilihan persekitaran dan IDE anda. Contoh tambahan boleh didapati dalam contoh-contoh-amazon-sagemaker repositori untuk membolehkan anda bermula dengan cepat. Anda juga boleh menyemak siaran berikut:

Mengenai Pengarang

Bruno Pistone ialah Arkitek Penyelesaian Pakar AI/ML untuk AWS yang berpangkalan di Milan. Dia bekerja dengan pelanggan besar yang membantu mereka memahami dengan mendalam keperluan teknikal mereka dan mereka bentuk penyelesaian AI dan Pembelajaran Mesin yang menggunakan timbunan AWS Cloud dan Pembelajaran Mesin Amazon sebaik mungkin. Kepakaran beliau termasuk: Pembelajaran Mesin hujung ke hujung, Perindustrian Pembelajaran Mesin dan AI Generatif. Dia seronok meluangkan masa bersama rakan-rakannya dan meneroka tempat baharu, serta mengembara ke destinasi baharu.

Vikesh Pandey ialah Arkitek Penyelesaian Pakar Pembelajaran Mesin di AWS, membantu pelanggan daripada industri kewangan mereka bentuk dan membina penyelesaian pada AI generatif dan ML. Di luar kerja, Vikesh gemar mencuba masakan yang berbeza dan bermain sukan luar.