ປະລິມານແລະຄວາມຫລາກຫລາຍຂອງຂໍ້ມູນເຮັດໃຫ້ການເພີ່ມຂຶ້ນຂອງ ML algorithms ທີ່ສັບສົນແລະຊັບຊ້ອນເພື່ອຈັດການກັບວຽກ AI. ສູດການຄິດໄລ່ເຫຼົ່ານີ້ຕ້ອງການ GPUs ເຮັດວຽກຢ່າງມີປະສິດທິພາບ ແລະປະມວນຜົນຊຸດຂໍ້ມູນລະດັບດາວເຄາະເພື່ອຮັບຮູ້ຮູບແບບຕ່າງໆ. GPUs ມີປະສິດທິພາບຫຼາຍໃນການສົ່ງມອບມູນຄ່າແລະການປະຕິບັດໂດຍການຈັດການການຄິດໄລ່ທີ່ສັບສົນ, ເຮັດໃຫ້ຄວາມຕ້ອງການຂອງພວກເຂົາສູງຂຶ້ນໃນໂດເມນ ML / AI. ເຖິງວ່າຈະມີປະໂຫຍດຂອງມັນ, GPUs ມີລາຄາແພງຫຼາຍ. Advanced AI/ML workloads ຕ້ອງການການສັງເກດການ ແລະຍຸດທະສາດການຈັດການທີ່ເຂັ້ມແຂງ ແທນທີ່ຈະເປັນການປະຕິບັດໂດຍກົງເພື່ອເພີ່ມປະສິດທິພາບ ແລະທົນທານ ໃນຂະນະທີ່ການເພີ່ມປະສິດທິພາບຄ່າໃຊ້ຈ່າຍ. ການລວບລວມການວັດແທກລະດັບ GPU ສາມາດຊ່ວຍໃຫ້ຜົນໄດ້ຮັບພິເສດ, ປັບປຸງວົງຈອນຊີວິດ AI/ML. ສາມຕົວວັດແທກ GPU ລວມກັນ ຂະບວນການເຮັດວຽກຂອງຊອບແວປະກອບດ້ວຍຫຼາຍຂັ້ນຕອນເຊັ່ນ: ການໂຫຼດຂໍ້ມູນ, ການເລີ່ມຕົ້ນ, ການຫັນປ່ຽນ, ແລະການຂຽນຂໍ້ມູນ. ຂັ້ນຕອນດຽວກັນໃຊ້ກັບວຽກງານການຮຽນຮູ້ເຄື່ອງຈັກທີ່ມີການຄິດໄລ່ທີ່ຊັບຊ້ອນ. ພາກສ່ວນຕ່າງໆຂອງ GPU ແມ່ນໃຊ້ເພື່ອຕອບສະໜອງຄວາມຕ້ອງການໃນທຸກຂັ້ນຕອນ. ມັນເປັນສິ່ງສໍາຄັນສໍາລັບທີມງານວິສະວະກໍາທີ່ຈະຮູ້ຈັກການຈັດສັນແລະການວັດແທກການນໍາໃຊ້ສໍາລັບການຝຶກອົບຮົມຢ່າງຕໍ່ເນື່ອງແລະການນໍາໃຊ້. ນີ້ຊ່ວຍເຮັດໃຫ້ການຕັດສິນໃຈທີ່ມີຂໍ້ມູນແລະນໍາໃຊ້ 100% ຂອງຊັບພະຍາກອນສໍາລັບການສະກັດເອົາມູນຄ່າສູງສຸດ. ຈາກທັດສະນະຂອງການຮຽນຮູ້ເຄື່ອງຈັກ, ອົງປະກອບ GPU ຕໍ່ໄປນີ້ຖືກໃຊ້ສໍາລັບຂັ້ນຕອນການເຮັດວຽກໃນເວລາທີ່ການຝຶກອົບຮົມແບບຈໍາລອງໄດ້ຖືກລິເລີ່ມ. ພວກເຮົາຈະເຂົ້າໃຈອົງປະກອບ GPU ແລະ metrics ທີ່ພວກເຂົາເປີດເຜີຍ. ສຸດທ້າຍ, ພວກເຮົາຈະຮຽນຮູ້ວິທີການຈັບແລະໃຊ້ພວກມັນຈາກ ເພື່ອປັບປຸງວົງຈອນຊີວິດ ML ໂດຍລວມ. ຕົວເຕືອນ Prometheus : ຂໍ້ມູນ ແລະ ML pipelines ອາໄສຄວາມຈຳຫຼາຍ. ສໍາລັບການປະມວນຜົນຂໍ້ມູນໃຫຍ່, ຂໍ້ມູນຖືກຄິດໄລ່ຢູ່ໃນຫນ່ວຍຄວາມຈໍາເພື່ອໃຫ້ຜົນໄດ້ຮັບໄວຂຶ້ນ. ນ້ຳໜັກຕົວແບບ, ລະດັບຄວາມສູງ, ແລະຕົວປ່ຽນ hyperparameters/ຕົວແປອື່ນໆຖືກໂຫລດໄວ້ໃນໜ່ວຍຄວາມຈຳ GPU. ການຕິດຕາມການນໍາໃຊ້ຄວາມຊົງຈໍາສາມາດຊ່ວຍຂະຫຍາຍຂະຫນາດແລະເພີ່ມຄວາມໄວໃນການຝຶກອົບຮົມຂອງຕົວແບບ. GPU Memory : ເມື່ອຕົວແບບປະຕິບັດການທີ່ເຂັ້ມຂຸ້ນມາຕຣິກເບື້ອງ ແລະນຳໃຊ້ການສົ່ງຕໍ່/ຖອຍຫຼັງ, ແກນ GPU ຈະຈັດການກັບການດຳເນີນການເຫຼົ່ານີ້. ຕົວວັດແທກການເຄື່ອນໄຫວຫຼັກຂອງ tensor ຊ່ວຍກໍານົດວິທີການນໍາໃຊ້ຫນ່ວຍງານຮາດແວໄດ້ດີແລະມີບ່ອນຫວ່າງສໍາລັບການປັບປຸງ. GPU Cores : ການປະຕິບັດງານທີ່ແລ່ນຢູ່ໃນຫຼັກ GPU ຕ້ອງການ streaming multiprocessors (SM) ເພື່ອປະຕິບັດການຄິດໄລ່ທາງຄະນິດສາດທີ່ຕ້ອງການ. ຄວາມຖີ່ຂອງໂມງສາມາດຊ່ວຍກໍານົດຄວາມໄວຂອງຄອມພິວເຕີ້ໄດ້. SM Clock Frequencies ກຳລັງຈັບ GPU Metrics ການແລ່ນສະຄຣິບ bash ໂດຍກົງໃນ GPU ບໍ່ໄດ້ໃຫ້ຄວາມຍືດຫຍຸ່ນຂອງ Python. ພວກເຮົາສາມາດສອບຖາມແລະວິເຄາະ GPU metrics ຕະຫຼອດຂະບວນການຝຶກອົບຮົມເພື່ອເຂົ້າໃຈພຶດຕິກໍາ. ໂດຍການໃຊ້ຕົວຊີ້ບອກເຫຼົ່ານີ້, ພວກເຮົາສາມາດຕັ້ງການແຈ້ງເຕືອນ ແລະການແກ້ໄຂເພື່ອຈັດການກັບສະຖານະການທີ່ສຳຄັນ. ພິຈາລະນາຄວາມຍືດຫຍຸ່ນແລະຄວາມຍືດຍຸ່ນ, ພວກເຮົາຈະຕັ້ງຄ່າ Prometheus ເພື່ອຂູດແລະກະຕຸ້ນເຕືອນໂດຍອີງໃສ່ເກນແລະໃຊ້ Python ເພື່ອຂູດແລະບັນທຶກ GPU metrics. 1. Memory Metrics ສົມມຸດວ່າ GPU ແມ່ນ NVIDIA ແລະການຕິດຕັ້ງ ແມ່ນສໍາເລັດໃນ GPU ຂອງທ່ານ. ພວກເຮົາຈະກໍານົດ Prometheus config ເພື່ອຕິດຕາມແລະຂູດ metrics ໂດຍອີງໃສ່ເກນແລະຜົນກະທົບຕໍ່ການແຈ້ງເຕືອນຖ້າເກີນຂອບເຂດ. NVIDIA DCGM Exporter ການກໍາຫນົດເປົ້າຫມາຍ GPU ທີ່ສະຫນອງໃຫ້ຢູ່ໃນ VPC ພາຍໃຕ້ເຄືອຂ່າຍຍ່ອຍ 172.28.61.90 ແລະເປີດເຜີຍໃນພອດ 9400 ຜ່ານການຕັ້ງຄ່າ Prometheus. 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." ການຕິດຕາມ ແລະແຈ້ງເຕືອນແມ່ນເປັນປະໂຫຍດ ແລະໃຫ້ຜົນປະໂຫຍດທີ່ຈຳກັດ ເຊັ່ນ: ແຈ້ງເຕືອນພວກເຮົາເມື່ອມີບາງຢ່າງຜິດພາດ. ພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ເກັບກໍາ metrics ສໍາລັບການວິເຄາະແລະການຕັດສິນໃຈຂໍ້ມູນຂ່າວສານ. ສໍາລັບສະຖານະການນີ້, ພວກເຮົາຈະພິຈາລະນາ ສໍາລັບການຄຸ້ມຄອງຂໍ້ມູນແລະ boto3 ສໍາລັບການຫມູນໃຊ້ AWS S3. ການນໍາໃຊ້ຫ້ອງສະຫມຸດການຄຸ້ມຄອງ Nvidia (pynvml), ພວກເຮົາສາມາດເຂົ້າເຖິງແລະຈັດການ GPU ຜ່ານລະຫັດ. ພວກເຮົາຈະຂຽນ metrics ກັບ S3 ເປັນໄຟລ໌ parquet. ສໍາລັບການຄົງຕົວ, ພວກເຮົາຈະຂຽນບັນທຶກໃສ່ຖານຂໍ້ມູນໃນຫນ່ວຍຄວາມຈໍາໂດຍໃຊ້ DuckDB ແລະຂຽນພາບຫຍໍ້ຂອງຂໍ້ມູນໃສ່ S3 ສໍາລັບການວິເຄາະສະເພາະຫຼືເວລາທີ່ແທ້ຈິງ. DuckDB 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 GPUs ແມ່ນມີຊື່ສຽງສໍາລັບ ຂອງພວກເຂົາ . ເຫຼົ່ານີ້ແມ່ນຫນ່ວຍງານຮາດແວທີ່ສາມາດປະມວນຜົນຂໍ້ມູນຫຼາຍມິຕິລະດັບ. ມັນເປັນສິ່ງ ສຳ ຄັນທີ່ຈະເຂົ້າໃຈວ່າແກນ ກຳ ລັງແຈກຢາຍຫຼືປະມວນຜົນການໂຫຼດແນວໃດແລະເມື່ອພວກມັນຮອດເກນ. ພວກເຮົາສາມາດປະຕິບັດກົດລະບຽບການປັບຂະຫນາດອັດຕະໂນມັດໂດຍຜ່ານການແຈ້ງເຕືອນເຫຼົ່ານີ້ເພື່ອຈັດການວຽກເຮັດງານທໍາແລະຫຼີກເວັ້ນການຮ້ອນເກີນໄປຫຼືເກີດອຸປະຕິເຫດ. ແກນ tensor ຄ້າຍຄືກັນກັບການຕິດຕາມຄວາມຊົງຈໍາ, ພວກເຮົາຈະຕັ້ງຄ່າການຕິດຕາມແລະການເກັບກໍາຕົວຊີ້ວັດການນໍາໃຊ້ 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 Clock Frequency Metrics ຄວາມໄວທີ່ການຄິດໄລ່ເກີດຂຶ້ນແມ່ນອັດຕາສ່ວນໂດຍກົງກັບຄວາມຖີ່ຂອງໂມງ multiprocessor streaming. ຕົວວັດແທກຄວາມຖີ່ໂມງ SM ຈະຊ່ວຍກຳນົດຄວາມໄວທີ່ການຄຳນວນ tensor ຫຼື ML ກຳລັງຈະເກີດ ແລະສຳເລັດ. ພວກເຮົາສາມາດເປີດໃຊ້ Prometheus ເພື່ອກະຕຸ້ນການແຈ້ງເຕືອນເມື່ອຄວາມຖີ່ຂອງໂມງ SM ເກີນ 2000MHz. ພວກເຮົາສາມາດຕັ້ງຄ່າການແຈ້ງເຕືອນເພື່ອໃຫ້ໄດ້ຮັບການແຈ້ງການໃນເວລາທີ່ຄວາມຖີ່ຂອງການໃກ້ຈະກໍານົດ. 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 clock metrics ສາມາດຖືກສະຄິບໄດ້ຢ່າງງ່າຍດາຍເພື່ອບັນທຶກ metrics ໃນຂໍ້ມູນໃນຫນ່ວຍຄວາມຈໍາແລະ 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 ສາມາດຮູ້ວ່າມີຫຍັງເກີດຂຶ້ນພາຍໃຕ້ຝາປິດ. ພວກເຂົາສາມາດປັບປຸງຂະບວນການຝຶກອົບຮົມໂດຍການວິເຄາະ metrics ແລະການຕັ້ງຄ່າການແກ້ໄຂສໍາລັບການແຈ້ງເຕືອນຄວາມສໍາຄັນແລະຄວາມສໍາຄັນສູງ. ຄວາມຄິດສຸດທ້າຍ ການຝຶກອົບຮົມຮູບແບບການຮຽນຮູ້ເຄື່ອງຈັກແມ່ນຂະບວນການທີ່ສັບສົນແລະສັບສົນ. ຄືກັນກັບບໍ່ມີຫຼັກຖານແລະສະຖິຕິທີ່ດີ, ມັນເປັນການຍາກທີ່ຈະສະຫຼຸບວ່າຕົວແປຕົວແບບໃດທີ່ສະແດງໃຫ້ເຫັນການຄາດເດົາທີ່ມີ inference ສູງ. ພວກເຮົາຕ້ອງການ GPU metrics ເພື່ອເຂົ້າໃຈວິທີການຄອມພິວເຕີ້ທີ່ຮັບຜິດຊອບໃນການຈັດການແລະການປຸງແຕ່ງ ML workloads ເຮັດວຽກ. ດ້ວຍການວັດແທກພຽງພໍ ແລະການແຈ້ງເຕືອນແບບສົດໆ, ທີມງານ ML ສາມາດຕັ້ງຄ່າ ແລະປັບປຸງທໍ່ ML ທີ່ແຂງແຮງ ແລະທົນທານ ເຊິ່ງປັບປຸງຮອບວຽນຂອງ ML ໂດຍລວມ.
