Bagikan melalui

Menyebarkan model bahasa di titik akhir batch

  • Artikel

BERLAKU UNTUK:Ekstensi ml Azure CLI v2 (saat ini)Python SDK azure-ai-ml v2 (saat ini)

Titik Akhir Batch dapat digunakan untuk menyebarkan model mahal, seperti model bahasa, melalui data teks. Dalam tutorial ini, Anda mempelajari cara menyebarkan model yang dapat melakukan ringkasan teks urutan panjang teks menggunakan model dari HuggingFace. Ini juga menunjukkan cara melakukan pengoptimalan inferensi menggunakan HuggingFace optimum dan accelerate pustaka.

Tentang sampel ini

Model yang akan kita kerjakan dibangun menggunakan transformer pustaka populer dari HuggingFace bersama dengan model yang telah dilatih sebelumnya dari Facebook dengan arsitektur BART. Ini diperkenalkan dalam makalah BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation. Model ini memiliki batasan berikut, yang penting untuk diingat untuk penyebaran:

  • Ini dapat bekerja dengan urutan hingga 1024 token.
  • Ini dilatih untuk ringkasan teks dalam bahasa Inggris.
  • Kita akan menggunakan Torch sebagai backend.

Contoh dalam artikel ini didasarkan pada sampel kode yang terkandung dalam repositori azureml-examples . Untuk menjalankan perintah secara lokal tanpa harus menyalin atau menempelkan YAML dan file lainnya, gunakan perintah berikut untuk mengkloning repositori dan masuk ke folder untuk bahasa pengkodian Anda:

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

File untuk contoh ini ada di:

cd endpoints/batch/deploy-models/huggingface-text-summarization

Ikuti di Jupyter Notebooks

Anda dapat mengikuti sampel ini di Jupyter Notebook. Di repositori kloning, buka buku catatan: text-summarization-batch.ipynb.

Prasyarat

  • Langganan Azure. Jika Anda tidak memiliki langganan Azure, buat akun gratis sebelum Anda memulai.

  • Ruang kerja Azure Machine Learning. Untuk membuat ruang kerja, lihat Mengelola ruang kerja Azure Pembelajaran Mesin.

  • Izin berikut di ruang kerja Azure Pembelajaran Mesin:

    • Untuk membuat atau mengelola titik akhir dan penyebaran batch: Gunakan Pemilik, Kontributor, atau peran kustom yang telah diberi Microsoft.MachineLearningServices/workspaces/batchEndpoints/* izin.
    • Untuk membuat penyebaran Azure Resource Manager di grup sumber daya ruang kerja: Gunakan Peran Pemilik, Kontributor, atau kustom yang telah diberi Microsoft.Resources/deployments/write izin di grup sumber daya tempat ruang kerja disebarkan.

  • Azure Pembelajaran Mesin CLI atau Azure Pembelajaran Mesin SDK untuk Python:

    Jalankan perintah berikut untuk menginstal Azure CLI dan mlekstensi untuk Azure Pembelajaran Mesin:

    az extension add -n ml

    Penyebaran komponen alur untuk titik akhir batch diperkenalkan dalam ekstensi versi 2.7 ml untuk Azure CLI. az extension update --name ml Gunakan perintah untuk mendapatkan versi terbaru.

Menyambungkan ke ruang kerja Anda

Ruang kerja adalah sumber daya tingkat teratas untuk Azure Machine Learning. Ini menyediakan tempat terpusat untuk bekerja dengan semua artefak yang Anda buat saat Anda menggunakan Azure Pembelajaran Mesin. Di bagian ini, Anda menyambungkan ke ruang kerja tempat Anda melakukan tugas penyebaran.

Dalam perintah berikut, masukkan ID langganan, nama ruang kerja, nama grup sumber daya, dan lokasi Anda:

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Mendaftarkan model

Karena ukuran model, model belum disertakan dalam repositori ini. Sebagai gantinya, Anda dapat mengunduh salinan dari hub model HuggingFace. Anda memerlukan paket transformers dan torch diinstal di lingkungan yang Anda gunakan.

%pip install transformers torch

Gunakan kode berikut untuk mengunduh model ke folder model:

from transformers import pipeline

model = pipeline("summarization", model="facebook/bart-large-cnn")
model_local_path = 'model'
summarizer.save_pretrained(model_local_path)

Kita sekarang dapat mendaftarkan model ini di registri Azure Pembelajaran Mesin:

MODEL_NAME='bart-text-summarization'
az ml model create --name $MODEL_NAME --path "model"

Membuat titik akhir

Kita akan membuat titik akhir batch bernama text-summarization-batch tempat untuk menyebarkan model HuggingFace untuk menjalankan ringkasan teks pada file teks dalam bahasa Inggris.

  1. Tentukan nama titik akhir. Nama titik akhir berakhir di URI yang terkait dengan titik akhir Anda. Karena itu, nama titik akhir batch harus unik dalam wilayah Azure. Misalnya, hanya ada satu titik akhir batch dengan nama mybatchendpoint di westus2.

    Dalam hal ini, mari kita tempatkan nama titik akhir dalam variabel sehingga kita dapat dengan mudah mereferensikannya nanti.

    ENDPOINT_NAME="text-summarization-batch"

  2. Mengonfigurasi titik akhir batch Anda

    File YAML berikut mendefinisikan titik akhir batch:

    endpoint.yml

    $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: text-summarization-batch
description: A batch endpoint for summarizing text using a HuggingFace transformer model.
auth_mode: aad_token

  3. Buat titik akhir:

    az ml batch-endpoint create --file endpoint.yml  --name $ENDPOINT_NAME

Membuat penyebaran

Mari kita buat penyebaran yang menghosting model:

  1. Kita perlu membuat skrip penilaian yang dapat membaca file CSV yang disediakan oleh penyebaran batch dan mengembalikan skor model dengan ringkasan. Skrip berikut melakukan tindakan ini:

    • init Menunjukkan fungsi yang mendeteksi konfigurasi perangkat keras (CPU vs GPU) dan memuat model yang sesuai. Baik model maupun tokenizer dimuat dalam variabel global. Kami tidak menggunakan pipeline objek dari HuggingFace untuk memperhitungkan batasan dalam urutan lengh model yang saat ini kami gunakan.
    • Perhatikan bahwa kami melakukan pengoptimalan model untuk meningkatkan performa menggunakan optimum dan accelerate pustaka. Jika model atau perangkat keras tidak mendukungnya, kami akan menjalankan penyebaran tanpa pengoptimalan tersebut.
    • run Menunjukkan fungsi yang dijalankan untuk setiap batch mini yang disediakan penyebaran batch.
    • Fungsi run membaca seluruh batch menggunakan datasets pustaka. Teks yang perlu kita ringkas ada di kolom text.
    • Metode ini run melakukan iterasi pada setiap baris teks dan menjalankan prediksi. Karena ini adalah model yang sangat mahal, menjalankan prediksi di seluruh file akan menghasilkan pengecualian di luar memori. Perhatikan bahwa model tidak dijalankan dengan pipeline objek dari transformers. Ini dilakukan untuk memperhitungkan urutan teks yang panjang dan batasan token 1024 dalam model yang mendasar yang kami gunakan.
    • Ini mengembalikan ringkasan teks yang disediakan.

    code/batch_driver.py

    import os
import time
import torch
import subprocess
import mlflow
from pprint import pprint
from transformers import AutoTokenizer, BartForConditionalGeneration
from optimum.bettertransformer import BetterTransformer
from datasets import load_dataset


def init():
    global model
    global tokenizer
    global device

    cuda_available = torch.cuda.is_available()
    device = "cuda" if cuda_available else "cpu"

    if cuda_available:
        print(f"[INFO] CUDA version: {torch.version.cuda}")
        print(f"[INFO] ID of current CUDA device: {torch.cuda.current_device()}")
        print("[INFO] nvidia-smi output:")
        pprint(
            subprocess.run(["nvidia-smi"], stdout=subprocess.PIPE).stdout.decode(
                "utf-8"
            )
        )
    else:
        print(
            "[WARN] CUDA acceleration is not available. This model takes hours to run on medium size data."
        )

    # AZUREML_MODEL_DIR is an environment variable created during deployment
    model_path = os.path.join(os.environ["AZUREML_MODEL_DIR"], "model")

    # load the tokenizer
    tokenizer = AutoTokenizer.from_pretrained(
        model_path, truncation=True, max_length=1024
    )

    # Load the model
    try:
        model = BartForConditionalGeneration.from_pretrained(
            model_path, device_map="auto"
        )
    except Exception as e:
        print(
            f"[ERROR] Error happened when loading the model on GPU or the default device. Error: {e}"
        )
        print("[INFO] Trying on CPU.")
        model = BartForConditionalGeneration.from_pretrained(model_path)
        device = "cpu"

    # Optimize the model
    if device != "cpu":
        try:
            model = BetterTransformer.transform(model, keep_original_model=False)
            print("[INFO] BetterTransformer loaded.")
        except Exception as e:
            print(
                f"[ERROR] Error when converting to BetterTransformer. An unoptimized version of the model will be used.\n\t> {e}"
            )

    mlflow.log_param("device", device)
    mlflow.log_param("model", type(model).__name__)


def run(mini_batch):
    resultList = []

    print(f"[INFO] Reading new mini-batch of {len(mini_batch)} file(s).")
    ds = load_dataset("csv", data_files={"score": mini_batch})

    start_time = time.perf_counter()
    for idx, text in enumerate(ds["score"]["text"]):
        # perform inference
        inputs = tokenizer.batch_encode_plus(
            [text], truncation=True, padding=True, max_length=1024, return_tensors="pt"
        )
        input_ids = inputs["input_ids"].to(device)
        summary_ids = model.generate(
            input_ids, max_length=130, min_length=30, do_sample=False
        )
        summaries = tokenizer.batch_decode(
            summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False
        )

        # Get results:
        resultList.append(summaries[0])
        rps = idx / (time.perf_counter() - start_time + 00000.1)
        print("Rows per second:", rps)

    mlflow.log_metric("rows_per_second", rps)
    return resultList

    Tip

    Meskipun file disediakan dalam batch mini oleh penyebaran, skrip penilaian ini memproses satu baris pada satu waktu. Ini adalah pola umum saat berhadapan dengan model mahal (seperti transformator) seperti mencoba memuat seluruh batch dan mengirimkannya ke model sekaligus dapat mengakibatkan tekanan memori tinggi pada pelaksana batch (eksekusi OOM).

  2. Kita perlu menunjukkan lingkungan mana yang akan kita jalankan penyebarannya. Dalam kasus kami, model kami berjalan dan Torch memerlukan pustaka transformers, , acceleratedan optimum dari HuggingFace. Azure Pembelajaran Mesin sudah memiliki lingkungan dengan dukungan Torch dan GPU yang tersedia. Kami hanya akan menambahkan beberapa dependensi dalam conda.yaml file.

    environment/torch200-conda.yaml

    name: huggingface-env
channels:
  - conda-forge
dependencies:
  - python=3.8.5
  - pip
  - pip:
    - torch==2.0
    - transformers
    - accelerate
    - optimum
    - datasets
    - mlflow
    - azureml-mlflow
    - azureml-core
    - azureml-dataset-runtime[fuse]

  3. Kita dapat menggunakan file conda yang disebutkan sebelumnya sebagai berikut:

    Definisi lingkungan disertakan dalam file penyebaran.

    deployment.yml

    compute: azureml:gpu-cluster
environment:
  name: torch200-transformers-gpu
  image: mcr.microsoft.com/azureml/openmpi4.1.0-cuda11.8-cudnn8-ubuntu22.04:latest

    Penting

    Lingkungan torch200-transformers-gpu yang telah kami buat memerlukan perangkat keras yang kompatibel dengan CUDA 11.8 untuk menjalankan Torch 2.0 dan Ubuntu 20.04. Jika perangkat GPU Anda tidak mendukung versi CUDA ini, Anda dapat memeriksa lingkungan conda alternatif torch113-conda.yaml (juga tersedia di repositori), yang menjalankan Torch 1.3 melalui Ubuntu 18.04 dengan CUDA 10.1. Namun, akselerasi menggunakan optimum pustaka dan accelerate tidak akan didukung pada konfigurasi ini.

  4. Setiap penyebaran berjalan pada kluster komputasi. Mereka mendukung kluster Azure Pembelajaran Mesin Compute (AmlCompute) atau kluster Kubernetes. Dalam contoh ini, model kami dapat memperoleh manfaat dari akselerasi GPU, itulah sebabnya kami menggunakan kluster GPU.

    az ml compute create -n gpu-cluster --type amlcompute --size STANDARD_NV6 --min-instances 0 --max-instances 2

    Catatan

    Anda tidak dikenakan biaya untuk komputasi pada saat ini karena kluster tetap pada 0 node sampai titik akhir batch dipanggil dan pekerjaan penilaian batch dikirimkan. Pelajari selengkapnya tentang mengelola dan mengoptimalkan biaya untuk AmlCompute.

  5. Sekarang, mari kita buat penyebaran.

    Untuk membuat penyebaran baru di bawah titik akhir yang dibuat, buat YAML konfigurasi seperti berikut ini. Anda dapat memeriksa skema YAML titik akhir batch lengkap untuk properti tambahan.

    deployment.yml

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
endpoint_name: text-summarization-batch
name: text-summarization-optimum
description: A text summarization deployment implemented with HuggingFace and BART architecture with GPU optimization using Optimum.
type: model
model: azureml:bart-text-summarization@latest
compute: azureml:gpu-cluster
environment:
  name: torch200-transformers-gpu
  image: mcr.microsoft.com/azureml/openmpi4.1.0-cuda11.8-cudnn8-ubuntu22.04:latest
  conda_file: environment/torch200-conda.yaml
code_configuration:
  code: code
  scoring_script: batch_driver.py
resources:
  instance_count: 2
settings:
  max_concurrency_per_instance: 1
  mini_batch_size: 1
  output_action: append_row
  output_file_name: predictions.csv
  retry_settings:
    max_retries: 1
    timeout: 3000
  error_threshold: -1
  logging_level: info

    Kemudian, buat penyebaran dengan perintah berikut:

    az ml batch-deployment create --file deployment.yml --endpoint-name $ENDPOINT_NAME --set-default

    Penting

    Anda akan melihat dalam penyebaran ini nilai tinggi dalam timeout parameter retry_settings. Alasannya adalah karena sifat model yang kita jalankan. Ini adalah model dan inferensi yang sangat mahal pada satu baris mungkin memakan waktu hingga 60 detik. Parameter timeout mengontrol berapa banyak waktu Penyebaran Batch harus menunggu skrip penilaian selesai memproses setiap batch mini. Karena model kami menjalankan prediksi baris demi baris, pemrosesan file yang panjang mungkin memakan waktu. Perhatikan juga bahwa jumlah file per batch diatur ke 1 (mini_batch_size=1). Ini lagi-lagi terkait dengan sifat pekerjaan yang kita lakukan. Memproses satu file pada satu waktu per batch cukup mahal untuk membenarkannya. Anda akan melihat ini menjadi pola dalam pemrosesan NLP.

  6. Meskipun Anda dapat memanggil penyebaran tertentu di dalam titik akhir, Anda biasanya ingin memanggil titik akhir itu sendiri dan membiarkan titik akhir memutuskan penyebaran mana yang akan digunakan. Penyebaran tersebut diberi nama penyebaran "default". Ini memberi Anda kemungkinan mengubah penyebaran default dan karenanya mengubah model yang melayani penyebaran tanpa mengubah kontrak dengan pengguna yang memanggil titik akhir. Gunakan instruksi berikut untuk memperbarui penyebaran default:

    DEPLOYMENT_NAME="text-summarization-hfbart"
az ml batch-endpoint update --name $ENDPOINT_NAME --set defaults.deployment_name=$DEPLOYMENT_NAME

  7. Pada titik ini, titik akhir batch kami siap digunakan.

Menguji penyebaran

Untuk menguji titik akhir kami, kami akan menggunakan sampel himpunan data BillSum: Corpus untuk Ringkasan Otomatis Undang-Undang AS. Sampel ini disertakan dalam repositori dalam folder data. Perhatikan bahwa format data adalah CSV dan konten yang akan diringkas berada di bawah kolom text, seperti yang diharapkan oleh model.

  1. Mari kita panggil titik akhir:

    JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input data --input-type uri_folder --query name -o tsv)

    Catatan

    Utilitas jq mungkin tidak diinstal pada setiap penginstalan. Anda bisa mendapatkan instruksi di tautan ini.

    Tip

    Perhatikan bahwa dengan menunjukkan jalur lokal sebagai input, data diunggah ke akun penyimpanan default Azure Pembelajaran Mesin.

  2. Pekerjaan batch dimulai segera setelah perintah kembali. Anda dapat memantau status pekerjaan hingga selesai:

    az ml job show -n $JOB_NAME --web

  3. Setelah penyebaran selesai, kita dapat mengunduh prediksi:

    Untuk mengunduh prediksi, gunakan perintah berikut:

    az ml job download --name $JOB_NAME --output-name score --download-path .

Pertimbangan saat menyebarkan model yang memproses teks

Seperti disebutkan dalam beberapa catatan di sepanjang tutorial ini, memproses teks mungkin memiliki beberapa kekhasan yang memerlukan konfigurasi khusus untuk penyebaran batch. Perhatikan pertimbangan berikut saat merancang penyebaran batch:

  • Beberapa model NLP mungkin sangat mahal dalam hal memori dan waktu komputasi. Jika demikian, pertimbangkan untuk mengurangi jumlah file yang disertakan pada setiap batch mini. Dalam contoh di atas, angka diambil ke minimum, 1 file per batch. Meskipun ini mungkin bukan kasus Anda, pertimbangkan berapa banyak file yang dapat dicetak model Anda setiap saat. Perlu diingat bahwa hubungan antara ukuran input dan jejak memori model Anda mungkin tidak linier untuk model pembelajaran mendalam.
  • Jika model Anda bahkan tidak dapat menangani satu file pada satu waktu (seperti dalam contoh ini), pertimbangkan untuk membaca data input dalam baris/gugus. Terapkan batching di tingkat baris jika Anda perlu mencapai throughput atau pemanfaatan perangkat keras yang lebih tinggi.
  • Tetapkan timeout nilai penyebaran Anda dengan tepat ke seberapa mahal model Anda dan berapa banyak data yang anda harapkan untuk diproses. Ingatlah bahwa timeout menunjukkan waktu penyebaran batch akan menunggu skrip penilaian Anda berjalan untuk batch tertentu. Jika batch Anda memiliki banyak file atau file dengan banyak baris, ini berdampak pada nilai parameter ini yang tepat.

Pertimbangan untuk model MLflow yang memproses teks

Pertimbangan yang sama seperti yang disebutkan di atas berlaku untuk model MLflow. Namun, karena Anda tidak diharuskan untuk memberikan skrip penilaian untuk penyebaran model MLflow Anda, beberapa rekomendasi yang disebutkan mungkin memerlukan pendekatan yang berbeda.

  • Model MLflow di Titik Akhir Batch mendukung pembacaan data tabular sebagai data input, yang mungkin berisi urutan teks yang panjang. Lihat Dukungan jenis file untuk detail tentang jenis file mana yang didukung.
  • Penyebaran batch memanggil fungsi prediksi model MLflow Anda dengan konten seluruh file sebagai kerangka data Pandas. Jika data input Anda berisi banyak baris, kemungkinan menjalankan model kompleks (seperti yang disajikan dalam tutorial ini) menghasilkan pengecualian di luar memori. Jika ini adalah kasus Anda, Anda dapat mempertimbangkan:
    • Sesuaikan bagaimana model Anda menjalankan prediksi dan menerapkan batching. Untuk mempelajari cara menyesuaikan inferensi model MLflow, lihat Pengelogan model kustom.
    • Tulis skrip penilaian dan muat model Anda menggunakan mlflow.<flavor>.load_model(). Lihat Menggunakan model MLflow dengan skrip penilaian untuk detailnya.