වැඩිදියුණු කළ ML ජීවන චක්‍රය සඳහා GPU මත Prometheus Alertmanager පිහිටුවීම

දත්තවල ප්‍රමාණය සහ විවිධත්වය AI කාර්ය භාරය හැසිරවීමට සංකීර්ණ සහ නවීන ML ඇල්ගොරිතමවල නැගීම සඳහා ඉන්ධන සපයයි. මෙම ඇල්ගොරිතම සඳහා GPUs කාර්යක්ෂමව ක්‍රියා කිරීමට සහ රටා හඳුනා ගැනීමට ග්‍රහලෝක පරිමාණ දත්ත කට්ටල සැකසීමට අවශ්‍ය වේ. ML/AI වසම තුළ ඔවුන්ගේ ඉල්ලුම ඉහළ යමින් සංකීර්ණ ගණනය කිරීම් හසුරුවමින් අගය සහ කාර්ය සාධනය ලබාදීමේදී GPU ඉතා ඵලදායී වේ.

ඒවායේ ප්‍රයෝජනය තිබියදීත්, GPU ඉතා මිල අධිකයි. උසස් AI/ML වැඩ බර සඳහා පිරිවැය ප්‍රශස්ත කරන අතරම කාර්ය සාධනය සහ කල්පැවැත්ම ඉහළ නැංවීම සඳහා සෘජු ක්‍රියාත්මක කිරීම් වෙනුවට ශක්තිමත් නිරීක්ෂණ සහ කළමනාකරණ උපාය මාර්ග අවශ්‍ය වේ. GPU මට්ටමේ ප්‍රමිතික එකතු කිරීම AI/ML ජීවන චක්‍රය වැඩිදියුණු කිරීමට සුවිශේෂී ප්‍රතිඵල ලබා ගැනීමට උපකාරී වේ.

එකතු කළ හැකි GPU මෙට්‍රික් තුනක්

මෘදුකාංග කාර්ය ප්‍රවාහයන් දත්ත පැටවීම, ආරම්භ කිරීම, පරිවර්තනය කිරීම සහ දත්ත ලිවීම වැනි අදියර කිහිපයකින් සමන්විත වේ. සංකීර්ණ ගණනය කිරීම් සහිත යන්ත්‍ර ඉගෙනුම් වැඩ බර සඳහා ද එම අදියර අදාළ වේ. සෑම අදියරකදීම ඉල්ලුම සපුරාලීම සඳහා GPU හි විවිධ කොටස් භාවිතා වේ. ඉංජිනේරු කණ්ඩායම් සඳහා අඛණ්ඩ පුහුණුව සහ යෙදවීම් සඳහා වෙන්කිරීම් සහ උපයෝගිතා ප්‍රමිතික දැනගැනීම වැදගත් වේ. මෙය දැනුවත් තීරණ ගැනීමට සහ උපරිම අගය නිස්සාරණය සඳහා සම්පත් වලින් 100%ක් භාවිතා කිරීමට උපකාරී වේ.

යන්ත්‍ර ඉගෙනීමේ දෘෂ්ටි කෝණයකින්, ආදර්ශ පුහුණුව ආරම්භ කරන විට පහත සඳහන් GPU සංරචක කාර්ය ප්‍රවාහ අදියර සඳහා යොදා ගනී. ඔවුන් නිරාවරණය කරන GPU සංරචක සහ ප්‍රමිතික අපි තේරුම් ගනිමු. අවසාන වශයෙන්, සමස්ත ML ජීවන චක්‍රය වැඩිදියුණු කිරීම සඳහා Prometheus alertmanager වෙතින් ඒවා ග්‍රහණය කර ප්‍රයෝජනයට ගන්නා ආකාරය අපි ඉගෙන ගනිමු.

1. GPU මතකය : දත්ත සහ ML නල මාර්ග මතකය මත දැඩි ලෙස රඳා පවතී. විශාල දත්ත සැකසීම සඳහා, වේගවත් ප්රතිඵල සඳහා දත්ත මතකය තුළ ගණනය කරනු ලැබේ. ආදර්ශ බර, අනුක්‍රමණය සහ අනෙකුත් අධිපරිමාණ/විචල්‍ය GPU මතකයේ පටවනු ලැබේ. මතක භාවිතය පිළිබඳ වාර්තාවක් තබා ගැනීමෙන් ආකෘතියේ පුහුණු වේගය පරිමාණය කිරීමට සහ වැඩි කිරීමට උපකාරී වේ.
2. GPU Cores : මාදිලි matrix-තීව්‍ර මෙහෙයුම් සිදු කරන විට සහ ඉදිරි/පසුගාමී ගමන් බලපත්‍ර යොදන විට, GPU cores මෙම මෙහෙයුම් හසුරුවනු ඇත. ටෙන්සර් මූලික ක්‍රියාකාරකම් ප්‍රමිතික දෘඪාංග ඒකක කෙතරම් හොඳින් භාවිත කරන්නේද යන්න තීරණය කිරීමට සහ වැඩිදියුණු කිරීමට ඉඩ තිබේද යන්න තීරණය කිරීමට උපකාරී වේ.
3. SM ඔරලෝසු සංඛ්‍යාත : GPU මධ්‍යයේ ක්‍රියාත්මක වන මෙහෙයුම් සඳහා අවශ්‍ය ගණිතමය ගණනය කිරීම් සිදු කිරීමට ප්‍රවාහ බහු සැකසුම් (SM) අවශ්‍ය වේ. ඔරලෝසු සංඛ්‍යාත මඟින් ගණනය කිරීමේ වේගය තීරණය කිරීමට උපකාරී වේ.

GPU මෙට්‍රික් ග්‍රහණය කිරීම

GPU මත සෘජුවම bash ස්ක්‍රිප්ට් ධාවනය කිරීම Python හි නම්‍යශීලී බවක් ලබා නොදේ. හැසිරීම අවබෝධ කර ගැනීම සඳහා පුහුණු ක්‍රියාවලිය පුරාම අපට GPU ප්‍රමිතික විමසා විශ්ලේෂණය කළ හැකිය. මෙම ප්‍රමිතික උත්තේජනය කිරීමෙන්, තීරණාත්මක අවස්ථා හැසිරවීමට අපට ඇඟවීම් සහ ප්‍රතිකර්ම පිහිටුවිය හැක.

නම්‍යශීලී බව සහ විස්තාරණය සැලකිල්ලට ගනිමින්, අපි එළිපත්ත මත පදනම්ව ඇඟවීම් සීරීමට සහ ප්‍රේරක කිරීමට Prometheus පිහිටුවන අතර GPU ප්‍රමිතික සීරීමට සහ ලොග් කිරීමට Python භාවිතා කරන්නෙමු.

1. මතක මිතික

GPU NVIDIA සහ NVIDIA DCGM අපනයනකරු පිහිටුවීම ඔබේ GPU මත සම්පූර්ණයි යැයි උපකල්පනය කරයි. එළිපත්ත මත පදනම්ව ප්‍රමිතික නිරීක්ෂණය කිරීමට සහ සීරීමට අපි ප්‍රොමිතියස් වින්‍යාසය නිර්වචනය කරන්නෙමු සහ එළිපත්ත ඉක්මවන්නේ නම් ස්ලැක් දැනුම්දීම ප්‍රේරණය කරන්නෙමු.

උපජාල 172.28.61.90 යටතේ VPC තුළ ලබා දී ඇති GPU ඉලක්ක කර Prometheus configs හරහා 9400 port මත නිරාවරණය වේ.

 configs_scrapper: - job_name: 'nvidia_gpu_metrics_scrapper' static_configs: - targets: ['172.28.61.90:9400']

ඉලක්කය නිර්වචනය කර ඇති විට, අපට සෑම මිනිත්තු දෙකකට වරක් මතක භාවිතය පරීක්ෂා කිරීමට ප්‍රකාශනය ලබා ගත හැක. එළිපත්ත 80% ඉක්මවන විට, විවේචනාත්මක ඇඟවීමක් ක්‍රියාත්මක වේ.

 groups: -name: GPU_Memory_Alerts rules: - alert: HighGPUMemoryUsage expr: (dcgm_gpu_mem_used / dcgm_gpu_mem_total) * 100 > 80 for: 2m   labels: severity: critical   annotations:summary: "GPU Memory usage is high on {{ $labels.instance }}" description: "GPU memory utilization is over 80% from more than 2 minutes on {{ $labels.instance }}."

ප්‍රමිතික පසුව ඇඟවීම් ලෙස යැවිය හැක. Slack හට ඇඟවීම් සැකසීම සඳහා පහසුම ඒකාබද්ධ කිරීමේ විකල්ප ඇත. එබැවින්, පහත YAML වින්‍යාසය භාවිතයෙන්, අපට Slack හි කණ්ඩායම් හෝ තනි පරිශීලක නාම වෙත අනතුරු ඇඟවීම සක්‍රීය කළ හැකිය.

 global: resolve_timeout: 2m route: receiver: 'slack_memory_notifications' group_wait: 5s group_interval: 2m repeat_interval: 1h receivers: - name: 'slack_memory_notifications' slack_configs: - api_url: 'https://databracket.slack.com/services/shrad/webhook/url' channel: 'databracket' username: 'Prometheus_Alertmanager' send_resolved: true title: 'GPU Memory Utilization >80% Alert' text: "A high memory utilization was observed triggering alert on GPU."

නිරීක්ෂණය සහ අනතුරු ඇඟවීම ප්‍රයෝජනවත් වන අතර යම් දෙයක් වැරදී ඇති විට අපට දැනුම් දීම වැනි සීමිත ප්‍රතිලාභ ලබා දෙයි. අපි විශ්ලේෂණය සඳහා ප්‍රමිතික ග්‍රහණය කර දැනුවත් තීරණ ගත යුතුයි.

මෙම අවස්ථාව සඳහා, අපි දත්ත කළමනාකරණය සඳහා DuckDB සහ AWS S3 හැසිරවීම සඳහා boto3 සලකා බලමු. Nvidia කළමනාකරණ පුස්තකාලය (pynvml) භාවිතයෙන්, අපට කේතය හරහා GPU වෙත ප්‍රවේශ වී කළමනාකරණය කළ හැක. අපි ප්‍රමිතික S3 වෙත පාකට් ගොනු ලෙස ලියන්නෙමු. නොනැසී පැවතීම සඳහා, අපි DuckDB භාවිතයෙන් මතකයේ ඇති දත්ත ගබඩාවකට ලඝු-සටහන් ලියන්නෙමු සහ තාවකාලික හෝ තත්‍ය කාලීන විශ්ලේෂණය සඳහා දත්තවල සැණරුවක් S3 වෙත ලියන්නෙමු.

 import time import pynvml import duckdb import boto3 import osfrom datetime import datetime pynvml.nvmlInit() s3 = boto3.client('s3') con = duckdb.connect(database=':memory:') con.execute(''' CREATE TABLE gpu_memory_usage ( Timestamp VARCHAR, Overall_memory DOUBLE, Memory_in_use DOUBLE, Available_memory DOUBLE ) ''') def get_gpu_memory_info(gpu_id=0): handle = pynvml.nvmlDeviceGetHandleByIndex(gpu_id) memory_info = pynvml.nvmlDeviceGetMemoryInfo(handle) return { "Overall_memory": memory_info.total / (1024 ** 2), "Memory_in_use": memory_info.used / (1024 ** 2), "Available_memory": memory_info.free / (1024 ** 2) } def upload_parquet_to_s3(bucket_name, object_name, file_path): try: s3.upload_file(file_path, bucket_name, object_name) print(f"Parquet file uploaded to S3: {object_name}") except Exception as e: print(f"Failed to upload Parquet to S3: {e}") def log_memory_utilization_to_parquet(bucket_name, filename, gpu_id=0, interval=1.0, local_file_path='gpu_memory_stats.parquet'): try: while True: gpu_memory_info = get_gpu_memory_info(gpu_id) timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S') con.execute(''' INSERT INTO gpu_memory_usage VALUES (?, ?, ?, ?) ''', (timestamp, gpu_memory_info['Overall_memory'], gpu_memory_info['Memory_in_use'], gpu_memory_info['Available_memory'])) print(f"Logged at {timestamp}: {gpu_memory_info}") if int(datetime.now().strftime('%S')) %60 == 0: # Upload Every Minute object_name = f"{filename}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.parquet" upload_parquet_to_s3(bucket_name, object_name, local_file_path) time.sleep(interval) except KeyboardInterrupt: print("Logging stopped by user.") bucket_name = 'prometheus-alerts-cof' filename = 'gpu_memory_stats' log_memory_utilization_to_parquet(bucket_name, filename, gpu_id=0, interval=2.0)

2. GPU Core Metrics

GPU ඒවායේ ටෙන්සර් කෝර් සඳහා ප්‍රසිද්ධය. මේවා බහු-මාන දත්ත සැකසීමට හැකි දෘඪාංග ඒකක වේ. හරය බර පැටවීම් බෙදා හරින හෝ සකසන ආකාරය සහ ඒවා එළිපත්තට පහර දෙන විට තේරුම් ගැනීම ඉතා වැදගත් වේ. වැඩ බර හැසිරවීමට සහ අධික උනුසුම් වීම හෝ බිඳ වැටීම් වළක්වා ගැනීමට අපට මෙම ඇඟවීම් හරහා ස්වයංක්‍රීය පරිමාණ නීති ක්‍රියාත්මක කළ හැකිය.

මතක අධීක්‍ෂණයට සමානව, අපි GPU මූලික භාවිත ප්‍රමිතික නිරීක්ෂණය කිරීමට සහ ග්‍රහණය කර ගැනීමට වින්‍යාසයන් සකසන්නෙමු. සෑම මිනිත්තුවක් සඳහාම, මූලික භාවිතය 80% ඉක්මවන විට, විවේචනාත්මක ඇඟවීමක් යවනු ලබන අතර, මධ්‍යස්ථ භාවිතය සඳහා, සෑම විනාඩි පහකට වරක් තත්ව යාවත්කාලීන කිරීමක් යවනු ලැබේ.

 groups: - name: gpu_alerts rules: - alert: HighGPUCoreUtilization expr: gpu_core_utilization > 80 for: 1m labels: severity: critical annotations: summary: "GPU Core Utilization >80% Alert" description: "GPU core utilization is above 80% for over 1 minute." - alert: MediumGPUCoreUtilization expr: gpu_core_utilization > 50 for: 5m labels: severity: warning annotations: summary: "GPU Memory Utilization = Moderate" description: "GPU core utilization is above 50% for over 5 minutes."

මෙහිදී, අපි උපාංග හැසිරවීමේ දර්ශකය ලබාගෙන උපයෝගිතා අනුපාත ලබා දෙන ක්‍රමයක් අමතන්නෙමු. ප්‍රතිචාරය පසුව මතකයේ ඇති DuckDB දත්ත ගබඩාවට ලොග් වී සැකසූ කාල මුද්‍රාව සමඟ s3 බාල්දියට දමනු ලැබේ.

 con.execute(''' CREATE TABLE gpu_core_usage ( Timestamp VARCHAR, GPU_Utilization_Percentage DOUBLE ) ''') def get_gpu_utilization(gpu_id=0): """Returns the GPU utilization percentage.""" handle = pynvml.nvmlDeviceGetHandleByIndex(gpu_id) utilization = pynvml.nvmlDeviceGetUtilizationRates(handle) return utilization.gpu def log_gpu_utilization_to_parquet(bucket_name, filename, gpu_id=0, interval=1.0, local_file_path='gpu_core_stats.parquet'): """Logs GPU utilization to a Parquet file and uploads it to S3 periodically.""" try: while True: gpu_utilization = get_gpu_utilization(gpu_id) timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S') con.execute(''' INSERT INTO gpu_core_usage VALUES (?, ?) ''', (timestamp, gpu_utilization)) print(f"Logged at {timestamp}: GPU Utilization = {gpu_utilization}%") if int(datetime.now().strftime('%S')) % 60 == 0: con.execute(f"COPY gpu_core_usage TO '{local_file_path}' (FORMAT PARQUET)") object_name = f"{filename}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.parquet" upload_parquet_to_s3(bucket_name, object_name, local_file_path) con.execute("DELETE FROM gpu_core_usage") time.sleep(interval) except KeyboardInterrupt: print("Logging stopped by user.") # Example usage: bucket_name = 'prometheus-alerts-cof' filename = 'gpu_core_stats' log_gpu_utilization_to_parquet(bucket_name, filename, gpu_id=0, interval=2.0)

3. SM ඔරලෝසු සංඛ්‍යාත මෙට්‍රික්ස්

ගණනය කිරීම් සිදුවන වේගය ප්‍රවාහ බහු ප්‍රොසෙසර ඔරලෝසු සංඛ්‍යාතයට සෘජුව සමානුපාතික වේ. SM ඔරලෝසු සංඛ්‍යාත මෙට්‍රික් ටෙන්සර් හෝ එම්එල් ගණනය කිරීම් ක්‍රියාරම්භ කරන සහ සම්පූර්ණ කරන වේගය තීරණය කිරීමට උපකාරී වේ.

SM ඔරලෝසු සංඛ්‍යාතය 2000MHz ඉක්මවන විට ඇඟවීම් අවුලුවාලීමට අපට Prometheus සබල කළ හැක. සංඛ්‍යාතය සීමාවට ළඟා වන විට දැනුම් දීම සඳහා අපට අනතුරු ඇඟවීමේ ඇඟවීම් පිහිටුවිය හැක.

 groups: - name: gpu_sm_clock_alerts rules: - alert: LowSMClockFrequency expr: gpu_sm_clock_frequency >= 1000 for: 1m labels: severity: warning annotations: summary: "Low SM Clock Frequency" description: "The SM clock frequency is below 500 MHz for over 1 minute." - alert: HighSMClockFrequency expr: gpu_sm_clock_frequency > 2000 for: 1m labels: severity: critical annotations: summary: "High SM Clock Frequency" description: "The SM clock frequency is above 2000 MHz for over 1 minute."

SM ඔරලෝසු ප්‍රමිතික සමුච්චය කිරීම මතකයේ දත්ත සහ S3 හි ප්‍රමිතික ලොග් කිරීමට පහසුවෙන් ස්ක්‍රිප්ට් කළ හැක.

 con.execute(''' CREATE TABLE sm_clock_usage ( Timestamp VARCHAR, SM_Clock_Frequency_MHz INT ) ''') def get_sm_clock_frequency(gpu_id=0): handle = pynvml.nvmlDeviceGetHandleByIndex(gpu_id) sm_clock = pynvml.nvmlDeviceGetClockInfo(handle, pynvml.NVML_CLOCK_SM) return sm_clock def log_sm_clock_to_parquet(bucket_name, filename, gpu_id=0, interval=1.0, local_file_path='sm_clock_stats.parquet'): try: while True: sm_clock_frequency = get_sm_clock_frequency(gpu_id) timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S') con.execute(''' INSERT INTO sm_clock_usage VALUES (?, ?) ''', (timestamp, sm_clock_frequency)) print(f"Logged at {timestamp}: SM Clock Frequency = {sm_clock_frequency} MHz") if int(datetime.now().strftime('%S')) % 10 == 0: con.execute(f"COPY sm_clock_usage TO '{local_file_path}' (FORMAT PARQUET)") object_name = f"{filename}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.parquet" upload_parquet_to_s3(bucket_name, object_name, local_file_path) con.execute("DELETE FROM sm_clock_usage") time.sleep(interval) except KeyboardInterrupt: print("Logging stopped by user.") bucket_name = 'prometheus-alerts-cof' filename = 'sm_clock_stats' log_sm_clock_to_parquet(bucket_name, filename, gpu_id=0, interval=2.0)

මෙම ප්‍රමිතික උත්තෝලනය කිරීමෙන් ML ඉංජිනේරුවන්ට තොප්පිය යටතේ සිදුවන්නේ කුමක්ද යන්න දැන ගත හැකිය. ඔවුන්ට ප්‍රමිතික විශ්ලේෂණය කිරීමෙන් සහ ඉහළ විවේචනාත්මක සහ ප්‍රමුඛතා ඇඟවීම් සඳහා පිළියම් සැකසීමෙන් පුහුණු ක්‍රියාවලිය වැඩිදියුණු කළ හැකිය.

අවසාන සිතුවිලි

යන්ත්‍ර ඉගෙනුම් ආදර්ශ පුහුණුව සංකීර්ණ හා ව්‍යාකූල ක්‍රියාවලියකි. හොඳ සාක්ෂි සහ සංඛ්‍යාලේඛන නොමැතිව මෙන්ම, ඉහළ අනුමාන සහිත අනාවැකි ප්‍රදර්ශනය කරන්නේ කුමන මාදිලියේ ප්‍රභේදද යන්න නිගමනය කිරීම අපහසුය. ML කාර්ය භාරය හැසිරවීමට සහ සැකසීමට වගකිව යුතු ගණනය කිරීමේ අවස්ථාව ක්‍රියාත්මක වන ආකාරය තේරුම් ගැනීමට අපට GPU ප්‍රමිතික අවශ්‍ය වේ. ප්‍රමාණවත් ප්‍රමිතික සහ තත්‍ය කාලීන ඇඟවීම් සමඟින්, ML කණ්ඩායම්වලට සමස්ත ML ජීවන චක්‍රය වැඩිදියුණු කරන ශක්තිමත් සහ කල් පවතින ML නල මාර්ග පිහිටුවීමට සහ විධිමත් කිරීමට හැකිය.