CPU, GPU և համակարգային մետրիկների ավելացումը BentoML սերվիսի մետրիկների endpoint-ին
Այն բացակայող կտորը, որ պետք էր BentoML-ով տեղակայված սերվիսների մոնիթորինգի համար։
Տեղակայված սերվիսներին հետևելը էական է, եթե ուզում եք արագ արձագանքել արտադրողականության խնդիրներին կամ սխալներին՝ դրանց հայտնվելուն պես։ Երբ սերվիսը ներսում ապավինում է մեքենայական ուսուցման մոդելներին, կարևոր է մոնիթորինգ անել այն ռեսուրսները, որոնցից կախված է նրա աշխատանքը։
BentoML-ը՝ մեքենայական ուսուցման մոդելներ սպասարկելու տարածված ընտրություն, լռելյայն տրամադրում է REST API՝ հիմնական, ընդհանուր հնարավորություններով, ինչպիսիք են առողջության ստուգումները (health checks) և սերվիսի մետրիկների մոնիթորինգը։ Մետրիկները հրապարակվում են open-telemetry ձևաչափով և կարող են միացվել Prometheus-ին և Grafana-ին՝ ագրեգացիայի, մոնիթորինգի և ծանուցումների համար։
Այս հոդվածում ես նախ ցույց կտամ, թե որ մետրիկներին է BentoML-ը հետևում լռելյայն։ Հետո կբացատրեմ, թե որ մետրիկներն են, իմ կարծիքով, բացակայում և ինչպես դրանք ավելացնել։ Վերջում կցուցադրեմ, թե ինչպես ստուգել առաջարկվող փոփոխությունը և կդիտարկեմ, թե ինչպես է այն ազդում սերվիսի արտադրողականության վրա։ Սկսենք։
Ինչո՞ւ BentoML
Ինչպես նշվեց ներածության մեջ, BentoML-ը ֆրեյմվորք է պրոդակշնի համար պատրաստ ML սերվիսներ կառուցելու և տեղակայելու համար։ Մինչդեռ MLFlow-ը որպես իր HTTP սերվեր (WSGI) ապավինում է Flask-ին, BentoML-ը օգտագործում է FastAPI (ASGI), որն ավելի հարմար է պրոդակշնում մոդելներ սպասարկելու համար։ Այլ կերպ ասած՝ BentoML-ի ուժը նրա ասինխրոն հաղորդակցության աջակցության մեջ է։ Այն աշխատում է բազմաթիվ տարածված ֆրեյմվորքերի հետ, օրինակ՝ scikit-learn, Transformers, ONNX, PyTorch և TensorFlow, այնպես որ մեկ ֆրեյմվորք կարելի է օգտագործել ML մոդելների տարբեր տեսակների համար։ Դրանից բացի, գործիքը լռելյայն առաջարկում է բազմաթիվ հարմար հնարավորություններ, ինչպես OpenAPI ձևաչափով սերվիսի API փաստաթղթավորումը և հարցումների քանակի ու մշակման ժամանակների մասին հիմնական մետրիկները Open Telemetry ձևաչափով։ Այն արագ և պարզ է դարձնում տեղակայման օպտիմիզացիան տարբեր Runner դասերի միջոցով, ինչպես Triton Inference Server-ը, և հարմարվողական հարցումների խմբավորմամբ (adaptive request batching)։ Այն թույլ է տալիս կառուցել բաշխված մոդելների հաջորդականություններ և կառավարել GPU և CPU ռեսուրսները, ինչպես նաև worker-ների քանակը։ BentoML-ը առաքվում է ներկառուցված Model Store-ով՝ մոդելների տարբերակավորման համար, bento արտեֆակտների փաթեթավորման ձևաչափով և Docker կոնտեյների կառուցման գործիքով, որը կոնտեյներացումն ու տեղակայումը դարձնում է անխափան։
Ընդհանուր առմամբ, BentoML-ը ընդհանուր նշանակության ֆրեյմվորք է ML սերվիսներ մշակելու համար, որն առաջարկում է ձեզ պետք եկող շատ հնարավորություններ և ապահովում է արագ նախատիպավորում։ Միևնույն ժամանակ, այն խիստ կարգավորելի է, ուստի կարելի է հարմարեցնել ձեր պահանջներին։ Ամենակարևորը՝ այն աջակցում է ամենալայն օգտագործվող ֆրեյմվորքերին, ինչը նշանակում է, որ այն հարմար է գրեթե ցանկացած ML նախագծի համար։
Լռելյայն մետրիկներ
Ստորև բերված ցանկը ցույց է տալիս այն մետրիկները, որոնց BentoML սերվիսը հետևում է լռելյայն։ Ակնհայտ է, որ սրանք ընդհանուր, հարցումների վրա կենտրոնացած մետրիկներ են, որոնք ընդգրկում են ամբողջ API սերվիսը և առանձին runner-ները։
bentoml_runner_request_duration_seconds- Քանի վայրկյան է պետք յուրաքանչյուր runner-ին RPC-ն ավարտելու համարbentoml_runner_request_in_progress- Քանի runner RPC է ընթացքի մեջ ընդհանուր առմամբ այս պահինbentoml_runner_adaptive_batch_size- Runner-ի հարմարվողական batch-ի չափըbentoml_runner_request_total- Runner RPC-ների ընդհանուր քանակըbentoml_api_server_request_total- Սերվերի HTTP հարցումների ընդհանուր քանակըbentoml_api_server_request_in_progress- Քանի սերվերային HTTP հարցում է ընթացքի մեջ ընդհանուր առմամբ այս պահինbentoml_api_server_request_duration_seconds- Քանի վայրկյան է տևում սերվերային HTTP հարցումն ավարտելը
Ի՞նչ մետրիկներ են բացակայում
Իմ կարծիքով, բացակայում են համակարգային մետրիկները, որոնք ցույց են տալիս, թե ինչպես են ռեսուրսները սպառվում հարցումները մշակելիս։ Հիմնականներն են RAM-ի և CPU-ի օգտագործումը, իսկ սարքավորմամբ արագացում օգտագործող մոդելների համար՝ նաև VRAM-ի և GPU-ի սպառումը։ Այս հիմնական մետրիկները արժե հետևել ցանկացած AI մոդելի համար, քանի որ դրանք թույլ են տալիս գնահատել, թե որքան պատրաստ է սերվիսի մոդելը մեծ քանակությամբ հարցումների հետ գլուխ հանել, և օգնում են նկատել հնարավոր հիշողության արտահոսքերն ու եզրային դեպքերը, երբ հիշողությունը սպառվում է։
Դրանց ավելացումը
BentoML-ի լոգերը լռելյայն չեն ներառում համակարգային մետրիկներ։ Սակայն մենք կարող ենք ընդլայնել BentoML ֆրեյմվորքի Runner դասը և լոգավորել ցանկացած հարմարեցված մետրիկ, որ կուզենք. մեր դեպքում՝ համակարգային մետրիկներ, որոնք ընդգրկում են CPU, GPU, RAM և VRAM օգտագործումը։ Ստորև բերված կոդը հավաքում է այս մետրիկները՝ օգտագործելով psutil և pynvml գրադարանները։
import psutil
import pynvml
import bentoml
pynvml.nvmlInit()
driver_version = pynvml.nvmlSystemGetDriverVersion()
gpu_number = pynvml.nvmlDeviceGetCount()
metrics_system_keys_dict = {
"node_ram_usage_percentage": "RAM usage in %",
"node_ram_usage_bytes": "RAM usage in bytes",
"node_ram_total_bytes": "RAM total in bytes",
"node_ram_free_bytes": "RAM free in bytes",
"node_swap_usage_percentage": "swap memory usage in %",
"node_swap_usage_bytes": "swap memory usage in bytes",
"node_swap_total_bytes": "swap total memory in bytes",
"node_swap_free_bytes": "swap memory free in bytes",
"node_disk_usage_percentage": "disk usage in %",
"node_disk_usage_bytes": "disk usage in bytes",
"node_disk_total_bytes": "disk total in bytes",
"node_disk_free_bytes": "disk free in bytes",
"node_process_number": "Number of processes runnning in the system",
}
metric_dict = {
key: bentoml.metrics.Gauge(name=key, documentation=value)
for key, value in metrics_system_keys_dict.items()
}
metric_gpu_keys_dict = {
"total_memory": "VRAM total in bytes",
"free_memory": "VRAM free in bytes",
"used_memory": "VRAM used in bytes",
"power_usage": "GPU device power usage in Watts",
"fan_speed": "GPU fan speed in rpm",
"utilization_percent": "GPU utilization in %"
}
for gpu_device in range(0, gpu_number):
for key, value in metric_gpu_keys_dict.items():
name = f"node_gpu_{gpu_device}_{key}"
metric_dict[name] = bentoml.metrics.Gauge(name=name, documentation=value)
def update_gpu_metrics():
for gpu_device in range(0, gpu_number):
handle = pynvml.nvmlDeviceGetHandleByIndex(gpu_device)
info = pynvml.nvmlDeviceGetMemoryInfo(handle)
metric_dict[f"node_gpu_{gpu_device}_total_memory"].set(info.total)
metric_dict[f"node_gpu_{gpu_device}_free_memory"].set(info.free)
metric_dict[f"node_gpu_{gpu_device}_used_memory"].set(info.used)
metric_dict[f"node_gpu_{gpu_device}_power_usage"].set(
pynvml.nvmlDeviceGetPowerUsage(handle)
)
metric_dict[f"node_gpu_{gpu_device}_fan_speed"].set(
pynvml.nvmlDeviceGetFanSpeed(handle)
)
metric_dict[f"node_gpu_{gpu_device}_utilization_percent"].set(
pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
)
cpu_list = psutil.cpu_percent(percpu=True)
cpu_no = len(cpu_list)
cpu_usage_metric_list = []
for index in range(0, cpu_no):
key = f"node_cpu_{index}_usage_percentage"
metric_dict[key] = bentoml.metrics.Gauge(
name=key,
documentation=f"CPU{index} usage in %",
)
def update_metrics():
"""Update system metrics."""
for index, cpu_usage in enumerate(psutil.cpu_percent(percpu=True)):
key = f"node_cpu_{index}_usage_percentage"
metric_dict[key].set(cpu_usage)
ram = psutil.virtual_memory()
metric_dict["node_ram_usage_percentage"].set(ram.percent)
metric_dict["node_ram_usage_bytes"].set(ram.active)
metric_dict["node_ram_total_bytes"].set(ram.total)
metric_dict["node_ram_free_bytes"].set(ram.free)
swap = psutil.swap_memory()
metric_dict["node_swap_usage_percentage"].set(swap.percent)
metric_dict["node_swap_usage_bytes"].set(swap.used)
metric_dict["node_swap_total_bytes"].set(swap.total)
metric_dict["node_swap_free_bytes"].set(swap.free)
disk = psutil.disk_usage("/")
metric_dict["node_disk_usage_percentage"].set(disk.percent)
metric_dict["node_disk_usage_bytes"].set(disk.used)
metric_dict["node_disk_total_bytes"].set(disk.total)
metric_dict["node_disk_free_bytes"].set(disk.free)
metric_dict["node_process_number"].set(len(psutil.pids()))
update_gpu_metrics()
Հիշեք, որ pynvml գրադարանը ներսում ապավինում է NVIDIA NVML գրադարանին, ուստի համոզվեք, որ այն տեղադրված է ձեր կատարման միջավայրում (օրինակ՝ Docker կոնտեյներում)։ Ավելի մանրամասները կգտնեք նախագծի ռեպոզիտորիայում՝ https://github.com/gpuopenanalytics/pynvml։
Մենք ուզում ենք, որ Runner դասը կանչի update_metrics ֆունկցիան անմիջապես AI մոդելի վրա inference աշխատեցնելուց հետո՝ __call__ ֆունկցիայի ներսում։
"""File containing Transformer model handler."""
from typing import Any, Dict, List
import bentoml
from bentoml.io import JSON
from examples.services.metrics import update_metrics
MODEL_NAME = "classification-pipeline"
SERVICE_NAME = "classification-pipeline-service"
model = bentoml.transformers.get(f"{MODEL_NAME}:latest")
_BuiltinRunnable = model.to_runnable()
class CustomRunnable(_BuiltinRunnable):
@bentoml.Runnable.method(batchable=True, batch_dim=0)
def __call__(self, input_data: List[str]) -> Dict[str, Any]:
output = self.model(input_data)
update_metrics()
return output
runner = bentoml.Runner(CustomRunnable)
svc = bentoml.Service(
SERVICE_NAME,
runners=[runner],
models=[model],
)
@svc.api(input=JSON(), output=JSON()) # type: ignore
async def classify(input_series: Dict[str, Any]) -> Dict[str, Any]:
"""Perform inference on the deployed model.
Args:
input_series: Dictionary with key "data" containing text.
Returns:
JSON response with key "prediction" containing list of predicted
classes.
"""
response = await runner.async_run(input_series["data"]) # type: ignore
return {"predictions": response}
Այժմ, երբ մոդելը տեղակայված է, BentoML սերվիսի լռելյայն մետրիկների endpoint-ը (/metrics) կբացահայտի համակարգային ռեսուրսների սպառման մասին լրացուցիչ լոգեր։
Արդյունքներ
Ստուգելու համար, որ մեր մետրիկները ագրեգացվում և բացահայտվում են open-telemetry ձևաչափով լռելյայն /metrics endpoint-ում, կարող ենք բրաուզերում բացել ML մոդելը աշխատեցնող սերվիսի հասցեն։ Swagger API փաստաթղթավորման էջում կարող ենք մոդելին թեստային inference հարցում ուղարկել՝ համապատասխան payload-ով /classify endpoint-ին դիմելով, ապա կանչելով /metrics endpoint-ը։ Լռելյայն լոգերի հետ մեկտեղ արդյունքը կներառի համակարգային ռեսուրսների սպառման մետրիկներ։
Արտադրողականություն
Runner-ի կոդին ավելացված լրացուցիչ տրամաբանությունը մոդելին ստիպում է ավելի դանդաղ արձագանքել։ Benchmark թեստերում մետրիկների հավաքումը միջինում ավելացնում է մոտ 5 ms ուշացում։ Այս ծախսը հաստատուն է, քանի որ կախված չէ նրանից, թե որ ML մոդելն է օգտագործվում, և շատ հավանական է, որ կարելի է օպտիմիզացնել։
Ամփոփում
Այս հոդվածը ցույց տվեց, թե ինչ տեսք ունեն BentoML սերվիսի տրամադրած մետրիկները լռելյայն և ինչպես ընդլայնել դրանք ըստ կարիքի։ Համակարգային մետրիկները հնարավորություն են տալիս մոնիթորինգ անել այն հիմնական ռեսուրսները, որոնք մեքենայական ուսուցման մոդելներն ինտենսիվ օգտագործում են, և դրանց հետևելը հնարավոր է դարձնում հայտնաբերել և շտկել հիշողության արտահոսքերն ու եզրային դեպքերը։
Հաջորդ հոդվածում ես ցույց կտամ, թե ինչպես օգտագործել բեռնվածքային թեստավորման գործիք Grafana ինտեգրացիայի հետ միասին՝ համակարգային ռեսուրսների օգտագործումը հարցումները մշակելիս մոնիթորինգ անելու համար՝ ապավինելով այստեղ ներկայացված հարմարեցված մետրիկներին։ Մնացեք մեզ հետ։