Docker-ი AI/ML დატვირთვებისთვის

ისწავლეთ როგორ ეფექტურად მოახდინოთ AI და მანქანური სწავლების დატვირთვების კონტეინერიზაცია, გაშვება და ორკესტრაცია Docker-ით

დავით მაჭახელიძე
@devius

Docker-ი AI/ML დატვირთვებისთვის

Docker-ი წარმოადგენს შესანიშნავ პლატფორმას AI და მანქანური სწავლების მოდელების შემუშავების, გაწვრთნისა და გაშვებისთვის, რაც უზრუნველყოფს განმეორებადობას, პორტაბელურობასა და მასშტაბირებადობას რთული AI სამუშაო პროცესებისთვის. AI/ML გარემოს კონტეინერიზაციით, მონაცემთა მეცნიერებსა და ML ინჟინრებს შეუძლიათ უზრუნველყონ თანმიმდევრული შესრულება დეველოპმენტის, ტესტირებისა და პროდაქშენის სისტემებში, ამასთანავე აღმოფხვრან ცნობილი "ჩემს მანქანაზე მუშაობს" პრობლემა, რომელიც ხშირად ახლავს რთულ ML დამოკიდებულებებს. Docker-ი ასევე უზრუნველყოფს ეფექტურ თანამშრომლობას გუნდებს შორის, მთელი გარემოს ვერსიების კონტროლს და შეუფერხებელ ინტეგრაციას ორკესტრაციის ხელსაწყოებთან განაწილებული გაწვრთნისა და დასკვნის (inference) პროცესებისთვის.

AI/ML დეველოპმენტის გარემო

საბაზისო იმიჯები AI/ML-ისთვის

  • NVIDIA CUDA იმიჯები GPU დატვირთვებისთვის
    • წინასწარ კონფიგურირებული CUDA დრაივერებითა და ბიბლიოთეკებით
    • ხელმისაწვდომია სხვადასხვა ვერსიები კონკრეტული CUDA მოთხოვნების შესაბამისად
    • ოპტიმიზირებულია სხვადასხვა GPU არქიტექტურისთვის (Pascal, Volta, Turing, Ampere)
    • საბაზისო ფენა მორგებული ღრმა სწავლების გარემოს ასაგებად
    • მაგალითი: nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04
  • TensorFlow-ის ოფიციალური იმიჯები
    • სრული გარემო წინასწარ დაყენებული TensorFlow-ით
    • ხელმისაწვდომია CPU და GPU ვარიანტები
    • Jupyter notebooks-ის ინტეგრაცია ბევრ იმიჯში
    • თანმიმდევრული ვერსიონირება TensorFlow-ის გამოშვებებთან
    • მაგალითი: tensorflow/tensorflow:2.12.0-gpu
  • PyTorch-ის კონტეინერების ეკოსისტემა
    • ოფიციალური PyTorch-ის ინსტალაციები CUDA-ს მხარდაჭერით
    • ოპტიმიზირებულია წარმადობისთვის GPU აჩქარებით
    • მოიცავს გავრცელებულ PyTorch-ის ბიბლიოთეკებსა და გაფართოებებს
    • სხვადასხვა Python-ის ვერსიის ოპციები
    • მაგალითი: pytorch/pytorch:2.0.1-cuda11.7-cudnn8-runtime
  • Scikit-learn-ი და მონაცემთა მეცნიერების სტეკები
    • Python-ის მონაცემთა მეცნიერების სრული ხელსაწყოების ნაკრები
    • Pandas, NumPy, Matplotlib და სხვა გავრცელებული ბიბლიოთეკები
    • მზა Jupyter-ის გარემო
    • ოპტიმიზირებულია მონაცემთა დამუშავების პაიპლაინებისთვის
    • მაგალითი: jupyter/scipy-notebook:python-3.10
  • სპეციალიზებული ღრმა სწავლების იმიჯები
    • დომენ-სპეციფიკური კონტეინერები (NLP, კომპიუტერული ხედვა და ა.შ.)
    • წინასწარ გაწვრთნილი მოდელები და ფრეიმვორქები
    • Hugging Face Transformers, Detectron2 და ა.შ.
    • პროდაქშენისთვის-ოპტიმიზირებული დასკვნის კონტეინერები
    • მაგალითი: huggingface/transformers-pytorch-gpu:4.29.2

GPU-ს მხარდაჭერის დაყენება

  • NVIDIA Container Toolkit (nvidia-docker)
    • სისტემური კომპონენტი, რომელიც უზრუნველყოფს GPU-ზე წვდომას კონტეინერებიდან
    • უზრუნველყოფს Docker-ისთვის გაშვების დროის გაფართოებებს
    • მართავს NVIDIA დრაივერის მიბმას ჰოსტსა და კონტეინერს შორის
    • აუცილებელი წინაპირობა GPU-აჩქარებული კონტეინერებისთვის
    • ინსტალაცია: apt-get install nvidia-container-toolkit
  • GPU-ს გადაცემის კონფიგურაცია
    • აჩენს კონკრეტულ GPU-ებს კონტეინერებისთვის
    • აკონტროლებს, რომელ კონტეინერებს შეუძლიათ რომელ GPU-ებზე წვდომა
    • უზრუნველყოფს რესურსების დეტალურ განაწილებას
    • კონფიგურირდება --gpus ფლაგით ან docker-compose-ში
    • მაგალითი: docker run --gpus device=0,1 nvidia/cuda nvidia-smi
  • დრაივერის თავსებადობის მოსაზრებები
    • კონტეინერის CUDA ვერსია თავსებადი უნდა იყოს ჰოსტის დრაივერთან
    • დრაივერის ვერსიას უნდა ჰქონდეს საჭირო CUDA ვერსიის მხარდაჭერა
    • თავსებადობის მატრიცა ხელმისაწვდომია NVIDIA-ს დოკუმენტაციაში
    • მინიმალური დრაივერის ვერსია დამოკიდებულია CUDA toolkit-ის ვერსიაზე
    • საუკეთესო პრაქტიკა: გამოიყენეთ კონტეინერის CUDA ვერსია ≤ ჰოსტის დრაივერის CUDA შესაძლებლობას
  • რესურსების განაწილება
    • მეხსიერების ლიმიტები OOM შეცდომების თავიდან ასაცილებლად
    • GPU მეხსიერების მონიტორინგი და მართვა
    • NVIDIA MPS გაზიარებული GPU-ზე წვდომისთვის
    • nvidia-smi-ის გამოყენება რესურსების მონიტორინგისთვის
    • მაგალითი: nvidia-smi --query-gpu=utilization.gpu,memory.used --format=csv
  • მრავალ-GPU-იანი დაყენებები
    • მონაცემთა პარალელიზმი მრავალ GPU-ზე
    • პროცესის-GPU-ზე მიბმის მართვა
    • NCCL კონფიგურაცია GPU-ებს შორის კომუნიკაციისთვის
    • NVLink-ის მოსაზრებები მაღალი გამტარუნარიანობის კავშირებისთვის
    • კონტეინერის განთავსების ოპტიმიზაცია GPU ტოპოლოგიისთვის

აუცილებელი Docker-ის იმიჯები AI/ML-ისთვის

# TensorFlow GPU-ს მხარდაჭერით
FROM tensorflow/tensorflow:latest-gpu
# ეს იმიჯი მოიცავს:
# - TensorFlow ფრეიმვორქს GPU აჩქარებით
# - Python-სა და აუცილებელ სამეცნიერო ბიბლიოთეკებს
# - წინასწარ კონფიგურირებულ CUDA-სა და cuDNN-ს
# - თავსებადია NVIDIA Container Toolkit-თან
# - Jupyter სერვერს ინტერაქტიული დეველოპმენტისთვის

# PyTorch CUDA-თი
FROM pytorch/pytorch:latest
# ეს იმიჯი მოიცავს:
# - PyTorch-ის ღრმა სწავლების ფრეიმვორქს
# - CUDA-სა და cuDNN-ს, ოპტიმიზირებულს PyTorch-ისთვის
# - TorchVision-ს, TorchAudio-სა და TorchText-ს
# - Python 3-ს სამეცნიერო გამოთვლების პაკეტებით
# - ოპტიმიზირებულ წარმადობას გაწვრთნისა და დასკვნისთვის

# RAPIDS GPU-აჩქარებული მონაცემთა მეცნიერებისთვის
FROM rapidsai/rapidsai:latest
# ეს იმიჯი მოიცავს:
# - RAPIDS-ის ნაკრებს GPU-აჩქარებული მონაცემთა მეცნიერებისთვის
# - cuDF-ს (GPU DataFrame ბიბლიოთეკა pandas-ის მსგავსი)
# - cuML-ს (მანქანური სწავლების ალგორითმები GPU-ზე)
# - cuGraph-ს (გრაფების ანალიტიკა GPU-ზე)
# - Dask-ს განაწილებული გამოთვლებისთვის
# - ინტეგრაციას scikit-learn API-სთან

# Scikit-learn-ი და გავრცელებული მონაცემთა მეცნიერების ხელსაწყოები
FROM jupyter/scipy-notebook:latest
# ეს იმიჯი მოიცავს:
# - Jupyter Lab/Notebook სერვერს
# - pandas-ს, NumPy-ს, Matplotlib-ს, Seaborn-ს
# - scikit-learn-ს, SciPy-სა და StatsModels-ს
# - Patsy-სა და სხვა მონაცემთა ანალიზის ხელსაწყოებს
# - Python-ის სრულ სამეცნიერო სტეკს
# - მზადაა CPU-ზე დაფუძნებული მანქანური სწავლებისთვის

# Hugging Face Transformers
FROM huggingface/transformers-pytorch-gpu:latest
# ეს იმიჯი მოიცავს:
# - Transformers ბიბლიოთეკას NLP ამოცანებისთვის
# - წინასწარ გაწვრთნილ მოდელებსა და ტოკენიზატორებს
# - PyTorch-ს GPU აჩქარებით
# - ოპტიმიზირებულია დასკვნისა და დაზუსტებისთვის
# - BERT-ის, GPT-ის, T5-ისა და სხვა არქიტექტურების მხარდაჭერას

Dockerfile-ების ოპტიმიზაცია ML-ისთვის

# Dockerfile-ის მაგალითი ML დეველოპმენტისთვის
FROM python:3.10-slim as builder

WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip wheel --no-cache-dir --no-deps --wheel-dir /app/wheels -r requirements.txt

FROM python:3.10-slim

WORKDIR /app
COPY --from=builder /app/wheels /wheels
RUN pip install --no-cache /wheels/*

COPY src/ ./src
COPY models/ ./models
COPY config.yaml .

ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1 \
    MODEL_PATH=/app/models \
    WORKERS=4

ENTRYPOINT ["python", "src/serve.py"]

მონაცემთა მართვის სტრატეგიები

დისკის დამონტაჟება მონაცემთა ნაკრებებისთვის

  • დაამონტაჟეთ დიდი მონაცემთა ნაკრებები როგორც დისკები
    • თავიდან აიცილეთ მონაცემების კოპირება კონტეინერებში
    • უზრუნველყავით მონაცემთა ნაკრებების გაზიარება მრავალ კონტეინერს შორის
    • შეინახეთ მონაცემები კონტეინერის სიცოცხლის ციკლის მიღმა
    • გააუმჯობესეთ ბილდის დრო და შეამცირეთ იმიჯის ზომა
    • მაგალითი: docker run -v /host/data:/data:ro tensorflow/tensorflow:latest-gpu
  • მონაცემთა ქეშირების კონფიგურაცია
    • დანერგეთ მრავალ-დონიანი ქეშირების სტრატეგიები
    • გამოიყენეთ tmpfs-ის დამონტაჟება მაღალსიჩქარიანი დროებითი საცავისთვის
    • გამოიყენეთ SSD შუალედური მონაცემთა ნაკრებებისთვის და HDD არქივისთვის
    • მოახდინეთ წინასწარ დამუშავებული მონაცემების ქეშირება ზედმეტი გამოთვლების თავიდან ასაცილებლად
    • მაგალითი: --mount type=tmpfs,destination=/cache,tmpfs-size=16g
  • მონაცემთა დირექტორიების სტრუქტურირება
    • მოაწყვეთ მონაცემთა ნაკრების, ვერსიისა და დაყოფის მიხედვით (train/val/test)
    • დანერგეთ თანმიმდევრული დასახელების კონვენციები
    • შექმენით მეტამონაცემების ფაილები, რომლებიც აღწერენ მონაცემთა ნაკრების თვისებებს
    • განიხილეთ სვეტოვანი ფორმატები (Parquet, Arrow) ეფექტურობისთვის
    • დააპროექტეთ პარალელური წვდომის შაბლონებისთვის განაწილებულ გაწვრთნაში
  • მონაცემთა ნაკრებების ეფექტური ვერსიონირება
    • დანერგეთ კონტენტ-მისამართებადი საცავის შაბლონები
    • გამოიყენეთ მონაცემთა ნაკრების ვერსიონირების ხელსაწყოები (DVC, Pachyderm და ა.შ.)
    • შექმენით მონაცემთა ნაკრების მანიფესტები საკონტროლო ჯამებით
    • თვალყური ადევნეთ მონაცემთა ნაკრების წარმომავლობასა და ტრანსფორმაციებს
    • განიხილეთ ACID-თან თავსებადი მონაცემთა ნაკრების მართვა
  • I/O ოპერაციების ოპტიმიზაცია
    • გამოიყენეთ მეხსიერების მიბმა დიდი ფაილებისთვის
    • დანერგეთ ასინქრონული მონაცემთა ჩატვირთვის პაიპლაინები
    • განიხილეთ მონაცემთა შეკუმშვის კომპრომისები
    • დაარეგულირეთ ბუფერის ზომები კონკრეტული საცავის სისტემებისთვის
    • მაგალითი: TensorFlow tf.data API წინასწარი ჩატვირთვითა და პარალელიზმით

მოდელის შენახვა და ვერსიონირება

  • მოდელის ეფექტური სერიალიზაცია
    • შეარჩიეთ შესაბამისი სერიალიზაციის ფორმატები (saved_model, ONNX, TorchScript)
    • ოპტიმიზაცია გაუკეთეთ ზომისა და ჩატვირთვის სიჩქარის კომპრომისებს
    • განიხილეთ კვანტიზაცია მოდელის შეკუმშვისთვის
    • დანერგეთ პარამეტრების შერჩევითი შენახვა
    • მაგალითი: დიდი მოდელების გადაყვანა fp16 სიზუსტეზე შენახვისთვის
  • მოდელის რეესტრთან ინტეგრაცია
    • დაუკავშირდით MLflow-ს, Weights & Biases-ს ან მორგებულ რეესტრებს
    • დანერგეთ ავტომატური ვერსიონირება გაწვრთნის დასრულებისას
    • მონიშნეთ მოდელები მეტამონაცემებით (მეტრიკები, მონაცემთა ნაკრების ვერსია და ა.შ.)
    • მოდელის წარმომავლობის თვალყურის დევნების მხარდაჭერა
    • მაგალითი: mlflow.tensorflow.log_model(model, "model")
  • მოდელების ვერსიების კონტროლი
    • შეინახეთ მოდელები სემანტიკური ვერსიონირებით
    • დანერგეთ უცვლელი მოდელის არტეფაქტები
    • თვალყური ადევნეთ მოდელის დამოკიდებულებებსა და გარემოს
    • მართეთ ექსპერიმენტული და პროდაქშენის მოდელები
    • მაგალითი: გამოიყენეთ Git LFS ან სპეციალიზებული მოდელის ვერსიონირების ხელსაწყოები
  • არტეფაქტების მართვა
    • განსაზღვრეთ მოდელის შენახვის სასიცოცხლო ციკლის პოლიტიკა
    • დანერგეთ წვდომის კონტროლი მოდელის არტეფაქტებზე
    • შეინახეთ შეფასების მეტრიკები მოდელებთან ერთად
    • ჩართეთ ნიმუშის შეყვანები/გამოტანები მოდელებთან
    • თვალყური ადევნეთ გაწვრთნისთვის გამოყენებულ გამოთვლით რესურსებს
  • განმეორებადი მოდელის ჩატვირთვა
    • შეინახეთ მოდელის კონფიგურაცია წონებისგან ცალკე
    • დაადოკუმენტირეთ ინიციალიზაციის პროცედურები
    • ვერსიონირება გაუკეთეთ მოდელის ჩამტვირთველებს მოდელებთან ერთად
    • დანერგეთ მოდელის თავსებადობის შემოწმება
    • მაგალითი: შექმენით მოდელის ბარათები განმეორებადობის ინსტრუქციებით

გაწვრთნის სამუშაო პროცესები

# docker-compose.yml ML გაწვრთნისთვის
version: '3.8'
services:
  training:
    build: 
      context: .
      dockerfile: Dockerfile.train
    volumes:
      - ./data:/data
      - ./output:/output
    environment:
      - EPOCHS=100
      - BATCH_SIZE=32
      - LEARNING_RATE=0.001
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

დასკვნის სერვისი

მოდელის სერვისის ოპციები

  • TensorFlow Serving
    • პროდაქშენის დონის სერვისის სისტემა TensorFlow-ის მოდელებისთვის
    • მოდელის ვერსიონირებისა და ცხელი შეცვლის მხარდაჭერა
    • მაღალ-ოპტიმიზირებულია TensorFlow SavedModel ფორმატისთვის
    • უზრუნველყოფს როგორც gRPC, ისე REST API-ებს
    • უზრუნველყოფს ბაჩირებასა და მაღალ-წარმადობიან დასკვნას
    • მაგალითი: tensorflow/serving:2.12.0
  • NVIDIA Triton Inference Server
    • მრავალ-ფრეიმვორქიანი დასკვნის სერვერი (TensorFlow, PyTorch, ONNX და ა.შ.)
    • დინამიური ბაჩირება და თანმიმდევრობის ბაჩირება
    • მოდელის ერთდროული შესრულება
    • მოდელის ანსამბლის მხარდაჭერა
    • ოპტიმიზირებულია NVIDIA GPU-ებისთვის TensorRT-ის ინტეგრაციით
    • მაგალითი: nvcr.io/nvidia/tritonserver:23.04-py3
  • TorchServe
    • პროდაქშენის სერვისის სისტემა PyTorch-ის მოდელებისთვის
    • მოდელის ვერსიონირება და მართვა
    • REST და gRPC ენდფოინთები
    • A/B ტესტირების შესაძლებლობები
    • მორგებული დამმუშავებლები წინასწარი/შემდგომი დამუშავებისთვის
    • მაგალითი: pytorch/torchserve:0.7.1-gpu
  • ONNX Runtime
    • კროს-პლატფორმული დასკვნის ძრავა ONNX მოდელებისთვის
    • აპარატურული აჩქარება სხვადასხვა მოწყობილობაზე (CPU, GPU, TPU)
    • კვანტიზაციისა და ოპტიმიზაციის მხარდაჭერა
    • ფართო ფრეიმვორქის თავსებადობა
    • გრაფის ოპტიმიზაცია წარმადობისთვის
    • მაგალითი: mcr.microsoft.com/azureml/onnxruntime:latest
  • მორგებული REST API სერვისები
    • მოქნილი API-ები, აგებული Flask-ზე, FastAPI-ზე ან სხვა ფრეიმვორქებზე
    • სრული კონტროლი მოთხოვნის დამუშავებასა და დამუშავებაზე
    • მარტივი ინტეგრაცია ბიზნეს ლოგიკასთან
    • მორგებული ავთენტიფიკაცია და ავტორიზაცია
    • მორგებული მასშტაბირებისა და გაშვების ოპციები
    • მაგალითი: FastAPI მოდელის ჩატვირთვით გაშვებისას

დასკვნის კონტეინერების ოპტიმიზაცია

# ოპტიმიზირებული TensorFlow Serving კონტეინერი
FROM tensorflow/serving:latest

# SavedModel-ის კოპირება
COPY ./models/saved_model /models/my_model/1
# ვერსიის დირექტორიის სტრუქტურა მნიშვნელოვანია TF Serving-ისთვის
# /models/my_model/1 მიუთითებს მოდელის 1-ელ ვერსიას

# გარემოს ცვლადების დაყენება
ENV MODEL_NAME=my_model
# ეს აყენებს საბაზისო მოდელის სახელს, რომელიც იქნება სერვისირებული

# REST-ისა და gRPC-ისთვის პორტების გამოჩენა
EXPOSE 8501 8500
# 8501: RESTful API პორტი HTTP მოთხოვნებისთვის
# 8500: gRPC პორტი მაღალ-წარმადობიანი კლიენტებისთვის

# ოპტიმიზაციების კონფიგურაცია
ENV TF_CPP_MIN_LOG_LEVEL=2 \
    TF_ENABLE_ONEDNN_OPTS=1 \
    OMP_NUM_THREADS=4 \
    MALLOC_TRIM_THRESHOLD_=0
# TF_CPP_MIN_LOG_LEVEL=2: თრგუნავს ინფორმაციისა და გაფრთხილების ლოგებს
# TF_ENABLE_ONEDNN_OPTS=1: რთავს Intel MKL-DNN ოპტიმიზაციებს
# OMP_NUM_THREADS=4: აკონტროლებს ნაკადების პარალელიზმს
# MALLOC_TRIM_THRESHOLD_=0: თიშავს მეხსიერების შემცირებას წარმადობისთვის

# შესვლის წერტილის დაყენება
ENTRYPOINT ["tensorflow_model_server", "--port=8500", "--rest_api_port=8501", "--model_config_file=/models/models.config"]
# models.config საშუალებას იძლევა მრავალი მოდელის სერვისირებას ერთი სერვერიდან
# კონფიგურაცია მოიცავს მოდელის სახელს, პლატფორმასა და ვერსიის პოლიტიკას

განაწილებული გაწვრთნა

# განაწილებული გაწვრთნის მაგალითი Docker Compose-ით
version: '3.8'
services:
  parameter-server:
    image: my-ml-training:latest
    command: ["python", "distributed_train.py", "--job_name=ps", "--task_index=0"]
    # პარამეტრების სერვერი კოორდინაციას უწევს განაწილებულ გაწვრთნას
    # მართავს მოდელის პარამეტრებსა და ოპტიმიზაციას
    # აგრეგირებს გრადიენტებს მუშაკებისგან
    # ანაწილებს განახლებულ პარამეტრებს მუშაკებზე
    ports:
      - "2222:2222"  # პორტი მუშაკებთან კომუნიკაციისთვის
    volumes:
      - ./data:/data  # მონაცემთა ნაკრების დისკის დამონტაჟება
      - ./output:/output  # შედეგებისა და შემოწმების წერტილების შესანახად დამონტაჟება
    environment:
      - TF_CONFIG={"cluster":{"ps":["parameter-server:2222"],"worker":["worker-0:2223","worker-1:2223"]},"task":{"type":"ps","index":0}}
    networks:
      - training-network  # გამოყოფილი ქსელი გაწვრთნის კომუნიკაციისთვის
    deploy:
      resources:
        limits:
          cpus: '4.0'
          memory: 8G  # პარამეტრების სერვერები ხშირად CPU/RAM-ინტენსიურია
      restart_policy:
        condition: on-failure
        max_attempts: 3

  worker-0:
    image: my-ml-training:latest
    command: ["python", "distributed_train.py", "--job_name=worker", "--task_index=0"]
    # მუშაკი 0 ასრულებს გაწვრთნის გამოთვლებს
    # ამუშავებს მონაცემთა ბაჩებს და ითვლის გრადიენტებს
    # უკავშირდება პარამეტრების სერვერს
    # შეუძლია მონაცემთა ნაკრების ან მოდელის ნაწილის დამუშავება
    depends_on:
      - parameter-server  # უზრუნველყოფს, რომ პარამეტრების სერვერი პირველი დაიწყოს
    ports:
      - "2223:2223"  # მუშაკის საკომუნიკაციო პორტი
    volumes:
      - ./data:/data  # მხოლოდ წაკითხვის უფლებით წვდომა გაწვრთნის მონაცემებზე
    environment:
      - TF_CONFIG={"cluster":{"ps":["parameter-server:2222"],"worker":["worker-0:2223","worker-1:2223"]},"task":{"type":"worker","index":0}}
    networks:
      - training-network
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1  # ირჩევს ერთ GPU-ს
              capabilities: [gpu]  # რთავს GPU-ს შესაძლებლობებს
        limits:
          cpus: '8.0'
          memory: 16G  # მუშაკებს სჭირდებათ საკმარისი მეხსიერება ბაჩებისთვის
      restart_policy:
        condition: on-failure

  worker-1:
    image: my-ml-training:latest
    command: ["python", "distributed_train.py", "--job_name=worker", "--task_index=1"]
    # მუშაკი 1 ამუშავებს მონაცემების სხვა ნაწილს
    # მუშაობს პარალელურად მუშაკ-0-თან
    # უზრუნველყოფს დამატებით გამოთვლით სიმძლავრეს
    # უზრუნველყოფს მონაცემთა პარალელიზმს მრავალ GPU-ზე
    depends_on:
      - parameter-server
    ports:
      - "2224:2223"  # სხვადასხვა ჰოსტის პორტი კონფლიქტების თავიდან ასაცილებლად
    volumes:
      - ./data:/data
    environment:
      - TF_CONFIG={"cluster":{"ps":["parameter-server:2222"],"worker":["worker-0:2223","worker-1:2223"]},"task":{"type":"worker","index":1}}
    networks:
      - training-network
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
        limits:
          cpus: '8.0'
          memory: 16G
      restart_policy:
        condition: on-failure

networks:
  training-network:
    driver: bridge
    # გამოყოფილი ქსელი ოპტიმიზაციას უკეთებს კონტეინერებს შორის კომუნიკაციას
    # იზოლირებს გაწვრთნის ტრაფიკს სხვა სერვისებისგან
    # შეიძლება კონფიგურირდეს მაღალი გამტარუნარიანობის, დაბალი შეყოვნების კომუნიკაციისთვის

MLOps-ის ინტეგრაცია

ML პაიპლაინების ორკესტრაცია

პაიპლაინის კომპონენტები

  • მონაცემთა მომზადების კონტეინერები
    • მონაცემთა ვალიდაცია და გასუფთავება
    • ფორმატის კონვერტაცია და ნორმალიზაცია
    • ნიშნების ამოღება ნედლი მონაცემებიდან
    • მონაცემთა ნაკრების დაყოფა (train/validation/test)
    • მონაცემთა აუგმენტაცია გაწვრთნისთვის
    • მაგალითი: Apache Beam-ის ან Luigi-ის კონტეინერები
  • ნიშნების ინჟინერიის სერვისები
    • ნიშნების ტრანსფორმაციის პაიპლაინები
    • ნიშნების შერჩევის ალგორითმები
    • განზომილების შემცირება
    • ნიშნების კოდირება და ნორმალიზაცია
    • ნიშნების საცავთან ინტეგრაცია
    • მაგალითი: Feast-ის ან მორგებული ნიშნების სერვისები
  • მოდელის გაწვრთნის სამუშაოები
    • ჰიპერპარამეტრების ოპტიმიზაცია
    • მოდელის მორგება და ვალიდაცია
    • კროს-ვალიდაციის შესრულება
    • შემოწმების წერტილების მართვა
    • განაწილებული გაწვრთნის კოორდინაცია
    • მაგალითი: კონტეინერები TensorFlow-ით, PyTorch-ით და ა.შ.
  • შეფასების მუშაკები
    • მოდელის წარმადობის შეფასება
    • მეტრიკების გამოთვლა და ვალიდაცია
    • A/B შედარება საბაზისო მოდელებთან
    • ზღურბლის განსაზღვრა
    • სატესტო მონაცემთა ნაკრების შეფასება
    • მაგალითი: მორგებული კონტეინერები, რომლებიც აწარმოებენ შეფასების სკრიპტებს
  • გაშვების სერვისები
    • მოდელის შეფუთვა პროდაქშენისთვის
    • სერვისის ინფრასტრუქტურის დაყენება
    • კანარის გაშვების დამუშავება
    • ვერსიონირებისა და დაბრუნების მხარდაჭერა
    • ინტეგრაცია API გეითვეებთან
    • მაგალითი: KServe-ის ან TensorFlow Serving-ის კონტეინერები
  • მონიტორინგის კომპონენტები
    • მონაცემთა დრიფტის აღმოჩენა
    • მოდელის წარმადობის თვალყურის დევნება
    • რესურსების გამოყენების მონიტორინგი
    • პროგნოზების ლოგირება და ანალიზი
    • დეგრადაციაზე შეტყობინებების გენერირება
    • მაგალითი: Prometheus-ის ექსპორტერები და Grafana-ს დაფები

სამუშაო პროცესის ორკესტრაცია

# Argo Workflow-ის მაგალითი ML პაიპლაინისთვის
apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  name: ml-training-pipeline
  # განსაზღვრავს დასახელებულ ML გაწვრთნის პაიპლაინს
  # გამოჩნდება Argo UI-ში ამ იდენტიფიკატორით
  # შეიძლება გაშვებულ იქნას ხელით ან მოვლენებით
spec:
  entrypoint: ml-pipeline
  # მთავარი შესვლის წერტილი სამუშაო პროცესისთვის
  # განსაზღვრავს, სად იწყება შესრულება
  
  # არასავალდებულო სამუშაო პროცესის მასშტაბით პარამეტრები
  # ttlStrategy განსაზღვრავს, რამდენ ხანს შეინახოს სამუშაო პროცესი დასრულების შემდეგ
  ttlStrategy:
    secondsAfterCompletion: 86400  # 24 საათი
  
  # არასავალდებულო დისკის მოთხოვნები მუდმივი საცავისთვის
  volumeClaimTemplates:
  - metadata:
      name: workdir
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 10Gi
  
  templates:
  - name: ml-pipeline
    # მთავარი პაიპლაინის შაბლონი, რომელიც ახდენს ყველა ნაბიჯის ორკესტრაციას
    steps:
    - - name: data-preparation
        # პირველი ნაბიჯი: მონაცემების მომზადება და ვალიდაცია
        # აწარმოებს მონაცემთა გასუფთავებას, ნორმალიზაციასა და დაყოფას
        # აწარმოებს დადასტურებულ მონაცემთა ნაკრებს გაწვრთნისთვის
        template: data-prep
        # data-prep-ის დეტალური იმპლემენტაცია განსაზღვრულია სხვაგან
        
    - - name: model-training
        # მეორე ნაბიჯი: ML მოდელის გაწვრთნა
        # იყენებს მომზადებულ მონაცემებს მოდელის პარამეტრების მოსარგებად
        # გამოაქვს გაწვრთნილი მოდელის არტეფაქტები
        template: train
        arguments:
          parameters:
          - name: data-path
            # დინამიური პარამეტრი წინა ნაბიჯიდან
            # საშუალებას იძლევა მომზადებული მონაცემების მდებარეობის გადაცემას
            value: "{{steps.data-preparation.outputs.parameters.data-path}}"
        
    - - name: model-evaluation
        # მესამე ნაბიჯი: მოდელის წარმადობის შეფასება
        # ითვლის მეტრიკებს ვალიდაციის მონაცემებზე
        # განსაზღვრავს, აკმაყოფილებს თუ არა მოდელი ხარისხის ზღურბლებს
        template: evaluate
        arguments:
          parameters:
          - name: model-path
            # მითითება გაწვრთნილ მოდელზე წინა ნაბიჯიდან
            value: "{{steps.model-training.outputs.parameters.model-path}}"
        
    - - name: model-deployment
        # მეოთხე ნაბიჯი: მოდელის გაშვება პროდაქშენში
        # სრულდება მხოლოდ იმ შემთხვევაში, თუ შეფასების ქულა საკმარისია
        # ამუშავებს მოდელის სერვისის ინფრასტრუქტურას
        template: deploy
        arguments:
          parameters:
          - name: model-path
            # გასაშვები მოდელის მდებარეობა
            value: "{{steps.model-training.outputs.parameters.model-path}}"
          - name: evaluation-result
            # შეფასების მეტრიკა, რომელიც ჩაირთვება გაშვების მეტამონაცემებში
            value: "{{steps.model-evaluation.outputs.parameters.result}}"
        # პირობითი შესრულება მოდელის ხარისხის მიხედვით
        # უშვებს მხოლოდ იმ შემთხვევაში, თუ სიზუსტე აღემატება 85%-ს
        when: "{{steps.model-evaluation.outputs.parameters.result}} > 0.85"
        
  # დამატებითი შაბლონები განსაზღვრავდნენ data-prep-ის, train-ის, evaluate-ისა და deploy-ის ნაბიჯების იმპლემენტაციის დეტალებს
  - name: data-prep
    container:
      image: my-registry/data-processor:v1
      command: [python, data_prep.py]
      # იმპლემენტაციის დეტალები...
      
  - name: train
    container:
      image: my-registry/model-trainer:v1
      # იმპლემენტაციის დეტალები...
      
  - name: evaluate
    container:
      image: my-registry/model-evaluator:v1
      # იმპლემენტაციის დეტალები...
      
  - name: deploy
    container:
      image: my-registry/model-deployer:v1
      # იმპლემენტაციის დეტალები...

რესურსების მართვა

# GPU-ს გამოყოფა Docker-ში
docker run --gpus all -it tensorflow/tensorflow:latest-gpu python -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"
# ჩამოთვლის ყველა ხელმისაწვდომ GPU-ს კონტეინერის შიგნით
# ამოწმებს, შეუძლია თუ არა TensorFlow-ს GPU-ების დანახვა
# ადასტურებს NVIDIA Container Toolkit-ის სწორ დაყენებას
# სასარგებლოა GPU-ს ხილვადობის პრობლემების გამართვისთვის

# კონკრეტული GPU-ს შერჩევა
docker run --gpus '"device=1,2"' -it pytorch/pytorch:latest python -c "import torch; print(torch.cuda.device_count())"
# ირჩევს კონკრეტულ GPU-ებს ინდექსით (მოწყობილობები 1 და 2)
# სასარგებლოა მრავალ-მოიჯარიან გარემოში
# საშუალებას იძლევა რესურსების დეტალურ განაწილებას
# ხელს უშლის კონტეინერს ყველა ხელმისაწვდომი GPU-ს გამოყენებაში
# ალტერნატიული სინტაქსი: --gpus '"device=1,capabilities=compute,utility"'

# GPU მეხსიერების ლიმიტები (NVIDIA MPS-ით)
docker run --gpus all --env NVIDIA_MPS_ACTIVE=1 --env CUDA_MPS_ACTIVE_THREAD_PERCENTAGE=20 -it tensorflow/tensorflow:latest-gpu
# რთავს NVIDIA Multi-Process Service-ს (MPS)
# საშუალებას აძლევს მრავალ კონტეინერს უფრო ეფექტურად გაიზიარონ GPU რესურსები
# აკონტროლებს გამოყოფილი GPU გამოთვლითი რესურსების პროცენტს
# აუმჯობესებს GPU-ს გამოყენებას მცირე დატვირთვებისთვის
# სასარგებლოა მრავალი მოდელის სერვისირებისთვის ერთსა და იმავე GPU-ზე

ექსპერიმენტების თვალყურის დევნება

კონტეინერზე დაფუძნებული ექსპერიმენტების მართვა

  • MLflow-ის კონტეინერები თვალყურის დევნებისთვის
    • ღია კოდის პლატფორმა ML-ის სასიცოცხლო ციკლის სამართავად
    • ექსპერიმენტების თვალყურის დევნება და შედარება
    • მოდელის რეესტრი და ვერსიონირება
    • ცენტრალიზებული მეტრიკებისა და არტეფაქტების საცავი
    • REST API შედეგებზე პროგრამული წვდომისთვის
    • მაგალითი: ghcr.io/mlflow/mlflow:latest
  • Weights & Biases-ის ინტეგრაცია
    • ღრუბელზე დაფუძნებული ექსპერიმენტების თვალყურის დევნების სერვისი
    • რეალურ დროში გაწვრთნის ვიზუალიზაცია
    • ჰიპერპარამეტრების მნიშვნელობის ანალიზი
    • ერთობლივი ექსპერიმენტების მართვა
    • მოდელისა და მონაცემთა ნაკრების ვერსიონირება
    • მაგალითი: wandb/local თვით-ჰოსტირებული ოპციისთვის
  • TensorBoard-ის გაშვება
    • TensorFlow-ის ვიზუალიზაციის ხელსაწყოების ნაკრები
    • გაწვრთნის მეტრიკების ვიზუალიზაცია
    • გრაფის ვიზუალიზაცია ნერვული ქსელებისთვის
    • ჩაშენების პროექციები და ნიშნების ანალიზი
    • მოდელის პროფაილირებისა და გამართვის ხელსაწყოები
    • მაგალითი: tensorflow/tensorflow:latest მოიცავს TensorBoard-ს
  • მორგებული მეტრიკების შეგროვება
    • სპეციალიზებული მეტრიკების შეგროვების API-ები
    • წარმადობის მრიცხველები აპარატურის გამოყენებისთვის
    • დომენ-სპეციფიკური შეფასების მეტრიკები
    • A/B ტესტირების ფრეიმვორქები
    • რეალურ დროში შეტყობინებები მეტრიკების ზღურბლებზე
    • მაგალითი: მორგებული Flask API კონტეინერები მეტრიკებისთვის
  • ექსპერიმენტების ვერსიონირება
    • Git-ის ინტეგრაცია კოდის ვერსიონირებისთვის
    • გარემოს სნეპშოტები განმეორებადობისთვის
    • კონფიგურაციის მართვა (Hydra-თი ან მსგავსით)
    • პარამეტრების ვერსიონირება და შედარება
    • ექსპერიმენტული წარმომავლობის თვალყურის დევნება
    • მაგალითი: DVC მონაცემთა ვერსიების კონტროლისთვის ექსპერიმენტებით

დაყენების მაგალითი

version: '3.8'
services:
  mlflow:
    image: ghcr.io/mlflow/mlflow:latest
    ports:
      - "5000:5000"    # ვებ UI და API პორტი
    volumes:
      - ./mlflow:/mlflow    # მუდმივი საცავი ექსპერიმენტის მონაცემებისთვის
    command: ["mlflow", "server", "--host", "0.0.0.0", "--backend-store-uri", "sqlite:///mlflow/mlflow.db", "--default-artifact-root", "/mlflow/artifacts"]
    # იყენებს SQLite მონაცემთა ბაზას მეტამონაცემების შესანახად
    # აკონფიგურირებს ლოკალურ ფაილურ სისტემას არტეფაქტების შესანახად
    # შეიძლება მასშტაბირდეს გარე მონაცემთა ბაზებით, როგორიცაა PostgreSQL
    # ჰოსტი 0.0.0.0 საშუალებას იძლევა გარე კავშირების
    environment:
      - MLFLOW_S3_ENDPOINT_URL=http://minio:9000    # არასავალდებულო ობიექტების საცავი
      - AWS_ACCESS_KEY_ID=minioadmin              # S3-თან თავსებადი საცავისთვის
      - AWS_SECRET_ACCESS_KEY=minioadmin          # S3-თან თავსებადი საცავისთვის
    networks:
      - ml-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5000/api/2.0/mlflow/experiments/list"]
      interval: 30s
      timeout: 10s
      retries: 3
  
  minio:
    image: minio/minio:latest
    ports:
      - "9000:9000"    # API პორტი
      - "9001:9001"    # კონსოლის პორტი
    volumes:
      - ./minio-data:/data
    command: server /data --console-address ":9001"
    environment:
      - MINIO_ROOT_USER=minioadmin
      - MINIO_ROOT_PASSWORD=minioadmin
    networks:
      - ml-network
  
  notebook:
    build: ./notebooks
    ports:
      - "8888:8888"    # Jupyter notebook-ის ინტერფეისი
    volumes:
      - ./notebooks:/home/jovyan/work    # Notebook-ის საწყისი ფაილები
      - ./data:/home/jovyan/data         # მონაცემთა ნაკრებზე წვდომა
    environment:
      - MLFLOW_TRACKING_URI=http://mlflow:5000    # MLflow-თან დაკავშირება
      - PYTHONPATH=/home/jovyan/work              # ლოკალური მოდულების იმპორტისთვის
      - WANDB_API_KEY=${WANDB_API_KEY:-}          # არასავალდებულო W&B ინტეგრაცია
      - JUPYTER_ENABLE_LAB=yes                    # JupyterLab-ის ინტერფეისის ჩართვა
    depends_on:
      - mlflow
    networks:
      - ml-network
    restart: unless-stopped
    command: start-notebook.sh --NotebookApp.token='' --NotebookApp.password=''

networks:
  ml-network:
    driver: bridge

ჰიპერპარამეტრების ოპტიმიზაცია

გაშვების არქიტექტურები

Edge-ზე გაშვება

  • ოპტიმიზირებული კონტეინერები edge მოწყობილობებისთვის
    • მინიმიზირებული კონტეინერის ზომა შეზღუდული საცავისთვის
    • პლატფორმა-სპეციფიკური ბილდები (ARM, x86, RISC-V)
    • სპეციალიზებული საბაზისო იმიჯები (Alpine, Distroless)
    • სტატიკური დაკავშირება დამოკიდებულებების შესამცირებლად
    • მაგალითი: FROM arm32v7/python:3.9-slim Raspberry Pi-ზე გასაშვებად
  • მოდელის კვანტიზაცია და გასხვლა
    • Int8/FP16 კვანტიზაცია შემცირებული მეხსიერების კვალისთვის
    • წონების გასხვლა მოდელის მცირე ზომისთვის
    • ცოდნის დისტილაცია კომპაქტური სტუდენტური მოდელებისთვის
    • გაწვრთნის შემდგომი ოპტიმიზაციის ტექნიკები
    • მაგალითი: TensorFlow Lite-ის მოდელები 75%-იანი ზომის შემცირებით
  • გაშვების დროის ოპტიმიზაცია
    • აპარატურა-სპეციფიკური აჩქარება (NEON, AVX)
    • მეხსიერების მიბმა ეფექტური ჩატვირთვისთვის
    • ნაკადებისა და პროცესების ოპტიმიზაცია
    • ბაჩის ზომის რეგულირება შეყოვნებისა და გამტარუნარიანობისთვის
    • მაგალითი: ONNX Runtime მორგებული შესრულების პროვაიდერებით
  • რესურს-შეზღუდული გარემო
    • CPU/RAM/საცავის შეზღუდვების მართვა
    • თერმული და ენერგიის მოხმარების მოსაზრებები
    • ოფლაინ მუშაობის შესაძლებლობები
    • შეუფერხებელი დეგრადაცია რესურსების წნეხის ქვეშ
    • მაგალითი: კონტეინერი, კონფიგურირებული --memory=512m --cpus=0.5-ით
  • განახლების სტრატეგიები edge მოდელებისთვის
    • დელტა განახლებები გამტარუნარიანობის მინიმიზაციისთვის
    • A/B მოდელის გაშვება ვალიდაციისთვის
    • დაბრუნების მექანიზმები წარუმატებელი განახლებებისთვის
    • ვერსიის თავსებადობის ვერიფიკაცია
    • მაგალითი: კონტეინერის იმიჯის ფენები ეფექტური განახლებისთვის

ღრუბელში გაშვება

  • მასშტაბირებადი დასკვნის API-ები
    • RESTful და gRPC API ინტერფეისები
    • მდგომარეობის არმქონე დიზაინი ჰორიზონტალური მასშტაბირებისთვის
    • ასინქრონული დამუშავება ბაჩის მოთხოვნებისთვის
    • კლიენტის ბიბლიოთეკები მრავალი ენისთვის
    • მაგალითი: KServe ან TorchServe API Gateway-ის უკან
  • ავტომასშტაბირებადი მოდელის სერვერები
    • ჰორიზონტალური პოდების ავტომასშტაბირება CPU/მეხსიერების/მორგებული მეტრიკების საფუძველზე
    • პროგნოზის მოთხოვნის რიგზე დაფუძნებული მასშტაბირება
    • მინიმალური რეპლიკები საბაზისო წარმადობისთვის
    • GPU-ს გამოყენებაზე დაფუძნებული მასშტაბირების პოლიტიკა
    • მაგალითი: Kubernetes HPA მორგებული მეტრიკებით Prometheus-იდან
  • დატვირთვის დაბალანსების სტრატეგიები
    • Round-robin მდგომარეობის არმქონე დასკვნისთვის
    • სესიის აფინურობა მდგომარეობის მქონე მოდელებისთვის
    • წონიანი განაწილება ინსტანციის სიმძლავრის მიხედვით
    • შეყოვნებაზე დაფუძნებული მარშრუტიზაცია გლობალური გაშვებებისთვის
    • მაგალითი: ღრუბლოვანი დატვირთვის ბალანსერი ჯანმრთელობის შემოწმებით
  • მაღალი ხელმისაწვდომობის კონფიგურაციები
    • მრავალ-ზონიანი და მრავალ-რეგიონული გაშვებები
    • ავტომატური შეცდომის გადაცემის მექანიზმები
    • ზედმეტი მოდელის სერვერის ინსტანციები
    • მდგომარეობის რეპლიკაცია საჭიროების შემთხვევაში
    • მაგალითი: მრავალ-რეგიონული Kubernetes კლასტერები PodDisruptionBudget-ით
  • ღრუბლოვან-მშობლიური ინტეგრაციები
    • მართვადი Kubernetes სერვისები (EKS, GKE, AKS)
    • სერვერ-გარეშე დასკვნა (AWS Lambda, Cloud Run, Azure Functions)
    • ღრუბლოვანი მონიტორინგისა და ლოგირების ინტეგრაცია
    • იდენტობისა და წვდომის მართვის ინტეგრაცია
    • მაგალითი: AWS SageMaker ავტომასშტაბირებადი დასკვნის ენდფოინთებით

წარმადობის ოპტიმიზაცია

# წარმადობაზე-ოპტიმიზირებული Dockerfile დასკვნისთვის
FROM python:3.10-slim

# წარმადობის ბიბლიოთეკების დაყენება
RUN apt-get update && apt-get install -y --no-install-recommends \
    libopenblas-dev \
    libomp-dev \
    && rm -rf /var/lib/apt/lists/*
# libopenblas-dev: ოპტიმიზირებული BLAS იმპლემენტაცია წრფივი ალგებრის ოპერაციებისთვის
# libomp-dev: OpenMP-ის გაშვების დრო პარალელური დამუშავებისთვის
# apt-ის ქეშის გასუფთავება ამცირებს იმიჯის ზომას

# ოპტიმიზირებული პაკეტების დაყენება
RUN pip install --no-cache-dir \
    numpy==1.24.* \
    onnxruntime-gpu==1.15.* \
    onnx==1.14.* \
    optimum==1.11.*
# numpy: დაფიქსირებული ვერსია სტაბილურობისა და თავსებადობისთვის
# onnxruntime-gpu: აპარატურულად-აჩქარებული დასკვნის ძრავა
# onnx: Open Neural Network Exchange ფორმატის მხარდაჭერა
# optimum: Hugging Face-ის ოპტიმიზაციის ხელსაწყოების ნაკრები
# --no-cache-dir ამცირებს იმიჯის ზომას

# მოდელისა და აპლიკაციის კოპირება
COPY ./model /app/model
COPY ./src /app/src
WORKDIR /app
# მოდელისა და კოდის ცალკე კოპირება უკეთესი ფენების ქეშირების საშუალებას იძლევა
# მოდელები უფრო იშვიათად იცვლება, ვიდრე კოდი ბევრ სცენარში

# ოპტიმიზაციის გარემოს ცვლადების დაყენება
ENV OMP_NUM_THREADS=4 \
    OMP_WAIT_POLICY=ACTIVE \
    OPENBLAS_NUM_THREADS=4 \
    ONNXRUNTIME_CUDA_DEVICE_ID=0
# OMP_NUM_THREADS: აკონტროლებს ნაკადების პარალელიზმს OpenMP-სთვის
# OMP_WAIT_POLICY=ACTIVE: ინარჩუნებს ნაკადებს აქტიურს უფრო სწრაფი რეაგირებისთვის
# OPENBLAS_NUM_THREADS: აკონტროლებს ნაკადებს წრფივი ალგებრის ოპერაციებში
# ONNXRUNTIME_CUDA_DEVICE_ID: ირჩევს კონკრეტულ GPU-ს დასკვნისთვის

# წარმადობის მონიტორინგის შესაძლებლობების დამატება
RUN pip install --no-cache-dir prometheus_client==0.17.* py-spy==0.3.*
# prometheus_client: აჩენს მეტრიკებს მონიტორინგისთვის
# py-spy: დაბალი დანახარჯების პროფაილირება Python-ის პროცესებისთვის

# მეხსიერების ოპტიმიზაციების კონფიგურაცია
ENV MALLOC_TRIM_THRESHOLD_=65536 \
    PYTHONMALLOC=malloc \
    PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:128
# MALLOC_TRIM_THRESHOLD_: აკონტროლებს მეხსიერების დეალოკაციის ქცევას
# PYTHONMALLOC=malloc: იყენებს სისტემის ალლოკატორს Python-ის ნაცვლად
# PYTORCH_CUDA_ALLOC_CONF: ოპტიმიზაციას უკეთებს GPU მეხსიერების ფრაგმენტაციას

# ოპტიმიზირებული სერვერის გაშვება მონიტორინგით
CMD ["python", "src/serve_optimized.py"]
# შესვლის წერტილი აწარმოებს ოპტიმიზირებულ სერვისის კოდს
# განიხილეთ gunicorn-ის ან uvicorn-ის გამოყენება პროდაქშენის HTTP სერვერებისთვის

რეალური ML გამოყენების შემთხვევები

გაფართოებული თემები

მრავალ-კვანძიანი გაწვრთნა

  • კონტეინერის ორკესტრაცია განაწილებული გაწვრთნისთვის
    • Kubernetes გაწვრთნის პოდების კვანძებში სამართავად
    • მორგებული ოპერატორები ML დატვირთვებისთვის (KubeFlow, Ray)
    • რესურსების განაწილების ოპტიმიზაცია ჰეტეროგენული კლასტერებისთვის
    • გაწვრთნის სამუშაოს დაგეგმვა და პრიორიტეტიზაცია
    • მაგალითი: Kubernetes StatefulSets-ები დალაგებული პოდების შესაქმნელად
  • პარამეტრების სერვერები და მუშაკები
    • არქიტექტურული შაბლონები განაწილებული ოპტიმიზაციისთვის
    • დანაწევრებული პარამეტრების სერვერები დიდი მოდელებისთვის
    • ასინქრონული და სინქრონული პარამეტრების განახლებები
    • საკომუნიკაციო ტოპოლოგიის ოპტიმიზაცია
    • მაგალითი: TensorFlow tf.distribute.ParameterServerStrategy
  • ქსელის ოპტიმიზაცია მონაცემთა გადაცემისთვის
    • RDMA/RoCE მაღალსიჩქარიანი GPU კომუნიკაციისთვის
    • გრადიენტის შეკუმშვის ტექნიკები გამტარუნარიანობის შესამცირებლად
    • ტოპოლოგიაზე-დამოკიდებული პოდების განთავსება
    • მორგებული კონტეინერის ქსელის პლაგინები
    • მაგალითი: NVIDIA NCCL InfiniBand-ით GPU კომუნიკაციისთვის
  • შემოწმების წერტილების მართვა
    • განაწილებული შემოწმების წერტილების კოორდინაცია
    • ინკრემენტული შემოწმების წერტილების სტრატეგიები
    • ღრუბლოვანი საცავის ინტეგრაცია გამძლეობისთვის
    • შემოწმების წერტილების ვალიდაცია და დაზიანების აღმოჩენა
    • მაგალითი: განაწილებული TensorFlow CheckpointManager
  • შეცდომის აღდგენის სტრატეგიები
    • შეწყვეტაზე-დამოკიდებული გაწვრთნის პროცესები
    • მუშაკის ავტომატური ჩანაცვლება
    • ელასტიური გაწვრთნის ჯგუფის მართვა
    • თანდათანობითი მასშტაბირება მინიმალური ხელახალი გამოთვლებით
    • მაგალითი: PyTorch Elastic შეცდომებისადმი მდგრადი გაწვრთნისთვის

ფედერაციული სწავლება

  • კონტეინერზე დაფუძნებული ფედერაციული სწავლების კვანძები
    • თვითკმარი გაწვრთნის გარემო edge მოწყობილობებზე
    • მინიმალური გაშვების დროის დამოკიდებულებები მრავალფეროვანი გაშვებებისთვის
    • სტანდარტიზებული API-ები მოდელისა და განახლებების გაცვლისთვის
    • რესურს-შეზღუდული კონტეინერის ოპტიმიზაცია
    • მაგალითი: TensorFlow Federated-ის კლიენტის კონტეინერები
  • უსაფრთხო აგრეგაციის სტრატეგიები
    • კრიპტოგრაფიული პროტოკოლები კონტეინერიზებულ სერვისებში
    • უსაფრთხო მრავალ-მხრივი გამოთვლების კონტეინერები
    • ნულოვანი ცოდნის მტკიცებულების სისტემები
    • ზღურბლური კრიპტოგრაფიის იმპლემენტაციები
    • მაგალითი: PySyft-ის კონტეინერები უსაფრთხო აგრეგაციისთვის
  • კონფიდენციალურობის დაცვის ტექნიკები
    • დიფერენციალური კონფიდენციალურობის იმპლემენტაციის კონტეინერები
    • ლოკალური და გლობალური კონფიდენციალურობის ბიუჯეტის მართვა
    • კონფიდენციალურობის დამცავი წინასწარი დამუშავების პაიპლაინები
    • ანონიმიზაციის სერვისის კონტეინერები
    • მაგალითი: TensorFlow Privacy კონფიგურირებადი DP პარამეტრებით
  • Edge-ღრუბლის კოორდინაცია
    • ასინქრონული განახლების მექანიზმები
    • კავშირის მართვა წყვეტილი ხელმისაწვდომობისთვის
    • გამტარუნარიანობაზე-დამოკიდებული სინქრონიზაციის სტრატეგიები
    • მრავალ-იარუსიანი აგრეგაციის იერარქიები
    • მაგალითი: MQTT-ზე დაფუძნებული კომუნიკაცია მსუბუქი კოორდინაციისთვის
  • მოდელის განახლების სინქრონიზაცია
    • FedAvg და გაფართოებული აგრეგაციის ალგორითმები
    • წონების განსხვავების მონიტორინგი
    • კონფლიქტის მოგვარება ერთდროული განახლებებისთვის
    • ვერსიების კონტროლი მოდელის იტერაციებისთვის
    • მაგალითი: Flower ფრეიმვორქი ფედერაციული სწავლების ორკესტრაციისთვის

საუკეთესო პრაქტიკები

პრობლემების მოგვარების სახელმძღვანელო

ხშირი პრობლემები

  • GPU არ არის აღმოჩენილი კონტეინერში
    • NVIDIA Container Toolkit-ი არ არის დაყენებული ან სწორად კონფიგურირებული
    • არასწორი --gpus ფლაგის გამოყენება ან GPU-ს შესაძლებლობების არარსებობა
    • დრაივერის/CUDA-ს ვერსიის შეუთავსებლობა
    • GPU-ს ხილვადობის პრობლემები ჩადგმულ ვირტუალიზაციაში
    • ნებართვების პრობლემები GPU მოწყობილობებზე წვდომისას
    • შეცდომის მაგალითი: "could not select device driver with capabilities: [[gpu]]"
  • მეხსიერების ამოწურვის შეცდომები გაწვრთნისას
    • ბაჩის ზომა ძალიან დიდია ხელმისაწვდომი GPU მეხსიერებისთვის
    • მეხსიერების გაჟონვა ტენზორების არასწორად გათავისუფლების გამო
    • არასაკმარისი კონტეინერის მეხსიერების ლიმიტები
    • ფრაგმენტირებული GPU მეხსიერება ხანგრძლივი გაწვრთნის შემდეგ
    • მრავალი პროცესი, რომლებიც კონკურენციას უწევენ ერთსა და იმავე GPU-ს
    • შეცდომის მაგალითი: "CUDA out of memory. Tried to allocate 2.00 GiB"
  • მოდელის ჩატვირთვის შეცდომები
    • სერიალიზაციის ფორმატის ვერსიების შეუთავსებლობა
    • დაკარგული მოდელის ფაილები ან არასწორი გზები
    • ფრეიმვორქის ვერსიების შეუსაბამობა შენახვასა და ჩატვირთვას შორის
    • დაზიანებული მოდელის ფაილები შეწყვეტილი შენახვების გამო
    • არასაკმარისი ნებართვები მოდელის დირექტორიებისთვის
    • შეცდომის მაგალითი: "Error loading model: KeyError: 'unexpected key in state_dict'"
  • წარმადობის დეგრადაცია
    • CPU-ს შენელება თერმული პრობლემების გამო
    • რესურსების კონკურენცია სხვა კონტეინერებთან
    • არაეფექტური მონაცემთა ჩატვირთვა, რომელიც ქმნის პრობლემებს
    • ქსელის გაჯერება განაწილებულ გაწვრთნაში
    • არაოპტიმალური კონტეინერის რესურსების ლიმიტები
    • სიმპტომის მაგალითი: გაწვრთნის იტერაციები თანდათან ნელდება
  • მონაცემებზე წვდომის პრობლემები
    • არაეფექტური დისკის დამონტაჟება ან ქსელური საცავი
    • მონაცემთა ქეშირების სტრატეგიების არარსებობა
    • თანმიმდევრული მონაცემთა წვდომის შაბლონები
    • არასათანადო ბუფერის ზომები I/O ოპერაციებისთვის
    • კონტეინერის ქსელის შეზღუდვები
    • სიმპტომის მაგალითი: მაღალი ლოდინის დრო I/O პროფაილირებაში

დიაგნოსტიკა

# GPU-ს ხილვადობის შემოწმება
docker run --gpus all nvidia/cuda:11.8.0-base-ubuntu22.04 nvidia-smi
# აჩვენებს ყველა ხელმისაწვდომ GPU-სა და მათ გამოყენებას
# ამოწმებს, რომ NVIDIA Container Toolkit-ი მუშაობს
# აჩვენებს დრაივერის ვერსიასა და CUDA-ს თავსებადობას
# აჩვენებს მიმდინარე GPU მეხსიერების გამოყენებას
# აუცილებელი პირველი ნაბიჯი GPU-ს პრობლემების მოსაგვარებლად

# მეხსიერების პრობლემების გამართვა
docker stats
# რეალურ დროში კონტეინერის რესურსების გამოყენების მეტრიკები
# აჩვენებს CPU-ს, მეხსიერების, I/O-სა და ქსელის გამოყენებას
# გეხმარებათ იმ კონტეინერების იდენტიფიცირებაში, რომლებიც უახლოვდებიან რესურსების ლიმიტებს
# აკონტროლეთ გაწვრთნის დროს მეხსიერების ზრდის შაბლონების აღმოსაჩენად
# დაამატეთ --no-stream დროის კონკრეტული მომენტის სნეპშოტისთვის

# კონტეინერის წარმადობის პროფაილირება
docker run --cap-add=SYS_PTRACE --security-opt seccomp=unconfined -it my-ml-image:latest
# დამატებითი შესაძლებლობები ღრმა პროფაილირებისთვის
# საშუალებას აძლევს ხელსაწყოებს, როგორიცაა strace, perf და py-spy, იმუშაონ
# რთავს core dump-ებს კრახების გამართვისთვის
# იძლევა ხილვადობას სისტემურ გამოძახებებსა და პროცესის ქცევაზე
# გამოყენების მაგალითი კონტეინერის შიგნით: py-spy top --pid 1

# კონტეინერის ლოგების შემოწმება
docker logs ml-training-container
# აჩვენებს stdout/stderr გამოტანას კონტეინერიდან
# დაამატეთ --tail=100 მხოლოდ ბოლო ლოგების სანახავად
# გამოიყენეთ -f ლოგების რეალურ დროში თვალყურის დევნებისთვის
# მოძებნეთ შეცდომის შეტყობინებები და სტეკის კვალი
# დაამატეთ --timestamps სხვა მოვლენებთან კორელაციისთვის

# ინტერაქტიული გამართვა
docker exec -it ml-serving-container /bin/bash
# ხსნის ინტერაქტიულ shell-ს გაშვებულ კონტეინერში
# საშუალებას იძლევა ფაილური სისტემისა და პროცესების პირდაპირ შემოწმებას
# შეუძლია დიაგნოსტიკური ბრძანებების გაშვება კონტეინერის გარემოში
# წვდომა ფრეიმვორქ-სპეციფიკურ გამართვის ხელსაწყოებზე
# გამართვის ბრძანებების მაგალითი კონტეინერის შიგნით:
#   python -c "import torch; print(torch.cuda.is_available())"
#   ps aux | grep python
#   ls -la /app/models
#   cat /proc/1/limits
#   df -h

# GPU-ს პროფაილირება NVIDIA-ს ხელსაწყოებით
docker run --gpus all -it --rm --pid=host nvidia/cuda:11.8.0-base-ubuntu22.04 nvidia-smi pmon -c 10
# აკონტროლეთ GPU პროცესები ყველა კონტეინერში
# აჩვენებს GPU-ს გამოყენებას თითოეული პროცესისთვის
# ადგენს, რომელი კონტეინერები იყენებენ GPU რესურსებს
# გეხმარებათ რესურსების კონკურენციის პრობლემების აღმოჩენაში
# სასარგებლოა მრავალ-მოიჯარიანი GPU გარემოებისთვის

# ფრეიმვორქ-სპეციფიკური გამართვა
docker exec ml-training-container python -c "import tensorflow as tf; tf.debugging.set_log_device_placement(True); tf.constant(1)"
# აწარმოებს დიაგნოსტიკურ კოდს კონტეინერის შიგნით
# აჩვენებს მოწყობილობის განთავსების გადაწყვეტილებებს ფრეიმვორქის მიერ
# ამოწმებს, შეუძლია თუ არა ფრეიმვორქს შესაბამის აპარატურაზე წვდომა
# იზოლირებს ფრეიმვორქ-სპეციფიკურ კონფიგურაციის პრობლემებს
# შეიძლება ადაპტირდეს PyTorch-ისთვის, JAX-ისთვის ან სხვა ფრეიმვორქებისთვის
კონტენტის ნდობა და იმიჯის ხელმოწერა
ისწავლეთ როგორ დანერგოთ Docker-ის კონტენტის ნდობა და იმიჯის ხელმოწერა უსაფრთხო პროგრამული უზრუნველყოფის მიწოდების ჯაჭვებისთვის
Docker-ი Edge Computing-ში
ისწავლეთ როგორ დანერგოთ Docker-ი edge computing გარემოში ქსელის კიდეზე ეფექტური კონტეინერიზებული აპლიკაციებისთვის