Passer au contenu principal

Apprentissage Automatique Acceleré par Matériel

Cette fonctionnalité vous permet d'utiliser un GPU pour accélérer les tâches d'apprentissage automatique, telles que la recherche intelligente et la reconnaissance faciale, tout en réduisant la charge du processeur. Étant donné que cette fonctionnalité est nouvelle, elle est encore expérimentale et peut ne pas fonctionner sur tous les systèmes.

info

Vous n'avez pas besoin de recommencer les tâches d'apprentissage automatique après avoir activé l'accélération matérielle. Le dispositif d'accélération sera utilisé pour toutes les tâches exécutées après son activation.

Backends Pris en Charge​

  • ARM NN (Mali)
  • CUDA (GPU NVIDIA avec compute capability 5.2 ou supérieur)
  • ROCm (GPU AMD)
  • OpenVINO (GPU Intel tels que Iris Xe et Arc)
  • RKNN (Rockchip)

Limitations​

  • Les instructions et configurations ici sont spécifiques à Docker Compose. D'autres moteurs de conteneur peuvent nécessiter des configurations différentes.
  • Seuls les serveurs Linux et Windows (via WSL2) sont pris en charge.
  • ARM NN est uniquement pris en charge sur les appareils dotés de GPU Mali. Les autres appareils Arm ne sont pas pris en charge.
  • Certains modèles peuvent ne pas être compatibles avec certains backends. CUDA est le plus fiable.
  • La latence de recherche n'est pas améliorée par ARM NN en raison de problèmes de compatibilité des modèles empêchant son utilisation. Cependant, les tâches de recherche intelligente utilisent effectivement ARM NN.

Prérequis​

ARM NN​

  • Assurez-vous d'avoir le pilote noyau Linux approprié installé
    • Ce pilote est généralement préinstallé sur les images Linux du fabricant de l'appareil
  • /dev/mali0 doit être disponible sur le serveur hôte
    • Vous pouvez confirmer cela en exécutant ls /dev pour vérifier son existence
  • Vous devez avoir le firmware propriétaire libmali.so (éventuellement avec un fichier de firmware supplémentaire)
    • L'emplacement et la façon d'obtenir ce fichier dépendent de l'appareil et du fabricant, mais généralement, le fabricant de l'appareil fournit également ces fichiers
    • Le fichier hwaccel.ml.yml suppose que son chemin est /usr/lib/libmali.so, donc mettez à jour si nécessaire s'il se trouve ailleurs
    • Le fichier hwaccel.ml.yml suppose un fichier supplémentaire /lib/firmware/mali_csffw.bin, donc mettez à jour si votre pilote d'appareil ne nécessite pas ce fichier
  • Facultatif : configurez votre fichier .env, consultez variables d'environnement pour les paramètres spécifiques à ARM NN
    • En particulier, le paramètre MACHINE_LEARNING_ANN_FP16_TURBO peut améliorer considérablement les performances au coût d'une précision légèrement réduite

CUDA​

  • Le GPU doit avoir une capacité de calcul de 5.2 ou supérieure.
  • Le serveur doit avoir le pilote officiel NVIDIA installé.
  • Le pilote installé doit être >= 545 (il doit prendre en charge CUDA 12.3).
  • Sur Linux (à l'exception de WSL2), vous devez également avoir le NVIDIA Container Toolkit installé.

ROCm​

  • Le GPU doit être pris en charge par ROCm. S'il n'est pas officiellement pris en charge, vous pouvez essayer d'utiliser la variable environnementale HSA_OVERRIDE_GFX_VERSION: HSA_OVERRIDE_GFX_VERSION=<une version prise en charge, ex. 10.3.0>. Si cela ne fonctionne pas, vous devrez probablement également définir HSA_USE_SVM=0.
  • L'image ROCm est assez volumineuse et nécessite au moins 35 GiB d'espace disque libre. Cependant, la récupération des mises à jour ultérieures du service via Docker ne nécessitera généralement que quelques centaines de mégaoctets car le reste sera mis en cache.
  • Ce backend est nouveau et peut rencontrer certains problèmes. Par exemple, la consommation d'énergie du GPU peut être plus élevée que d'habitude après avoir exécuté une inférence, même si le service d'apprentissage automatique est au repos. Dans ce cas, la consommation reviendra à la normale après 5 minutes d'inactivité (configurable avec le paramètre MACHINE_LEARNING_MODEL_TTL).

OpenVINO​

  • Les GPU intégrés sont plus susceptibles de rencontrer des problèmes que les GPU discrets, notamment pour les processeurs plus anciens ou les serveurs avec une faible RAM.
  • Assurez-vous que la version du noyau du serveur est suffisamment récente pour utiliser le dispositif à des fins d'accélération matérielle.
  • Attendez-vous à une utilisation accrue de la RAM lorsque vous utilisez OpenVINO par rapport au traitement CPU.

RKNN​

  • Vous devez posséder un SoC Rockchip pris en charge : seuls les RK3566, RK3568, RK3576 et RK3588 sont actuellement pris en charge.
  • Assurez-vous d'avoir le pilote noyau Linux approprié installé
    • Ce pilote est généralement préinstallé sur les images Linux du fabricant de l'appareil
  • Le pilote RKNPU version V0.9.8 ou supérieure doit être disponible sur le serveur hôte
    • Vous pouvez confirmer cela en exécutant cat /sys/kernel/debug/rknpu/version pour vérifier la version
  • Facultatif : configurez votre fichier .env, consultez variables d'environnement pour les paramètres spécifiques à RKNN
    • En particulier, définir MACHINE_LEARNING_RKNN_THREADS sur 2 ou 3 peut dramatiquement améliorer les performances pour les RK3576 et RK3588 par rapport au paramètre par défaut de 1, au détriment de multiplier la quantité de RAM utilisée par chaque modèle par ce montant.

Configuration​

  1. Si vous ne l'avez pas déjà, téléchargez le dernier fichier hwaccel.ml.yml et assurez-vous qu'il se trouve dans le même dossier que le docker-compose.yml.
  2. Dans le fichier docker-compose.yml sous immich-machine-learning, décommentez la section extends et changez cpu pour le backend approprié.
  3. Toujours dans immich-machine-learning, ajoutez l'un des backends [armnn, cuda, rocm, openvino, rknn] à la section image à la fin de la ligne.
  4. Redéployez le conteneur immich-machine-learning avec ces paramètres mis à jour.

Confirmation de l'Utilisation du Dispositif​

Vous pouvez confirmer que le dispositif est reconnu et utilisé en vérifiant son utilisation. Il existe de nombreux outils pour afficher cela, tels que nvtop pour NVIDIA ou Intel, intel_gpu_top pour Intel, et radeontop pour AMD.

Vous pouvez également vérifier les logs du conteneur immich-machine-learning. Lorsqu'un travail de recherche intelligente ou de détection faciale commence, ou lorsque vous effectuez une recherche avec texte dans Immich, vous devriez voir soit un log indiquant les Available ORT providers contenant le fournisseur pertinent (par exemple CUDAExecutionProvider dans le cas de CUDA), soit une entrée de log Loaded ANN model sans erreurs dans le cas de ARM NN.

Fichier Compose Unique​

Certaines plateformes, comme Unraid et Portainer, ne prennent pas en charge plusieurs fichiers Compose à l'heure où ces lignes sont écrites. En alternative, vous pouvez "inliner" les contenus pertinents du fichier hwaccel.ml.yml directement dans le service immich-machine-learning.

Par exemple, la section cuda dans ce fichier est la suivante :

deploy:
  resources:
    reservations:
      devices:
        - driver: nvidia
          count: 1
          capabilities:
            - gpu

Vous pouvez ajouter ceci au service immich-machine-learning au lieu d'étendre depuis le fichier hwaccel.ml.yml :

immich-machine-learning:
  container_name: immich_machine_learning
  # Notez le `-cuda` à la fin
  image: ghcr.io/immich-app/immich-machine-learning:${IMMICH_VERSION:-release}-cuda
  # Notez l'absence de section `extends`
  deploy:
    resources:
      reservations:
        devices:
          - driver: nvidia
            count: 1
            capabilities:
              - gpu
  volumes:
    - model-cache:/cache
  env_file:
    - .env
  restart: always

Une fois cela fait, vous pouvez redéployer le conteneur immich-machine-learning.

Multi-GPU​

Si vous souhaitez utiliser plusieurs GPU NVIDIA ou Intel, vous pouvez définir la variable environnementale MACHINE_LEARNING_DEVICE_IDS avec une liste des identifiants de dispositifs séparés par des virgules et définir MACHINE_LEARNING_WORKERS au nombre de dispositifs listés. Vous pouvez exécuter une commande telle que nvidia-smi -L ou glxinfo -B pour voir les dispositifs actuellement disponibles et leurs identifiants correspondants.

Par exemple, si vous avez les dispositifs 0 et 1, définissez les valeurs comme suit :

MACHINE_LEARNING_DEVICE_IDS=0,1
MACHINE_LEARNING_WORKERS=2

Dans cet exemple, le service d'apprentissage automatique engendrera deux travailleurs, dont l'un attribuera des modèles au dispositif 0 et l'autre au dispositif 1. Différentes demandes seront traitées par un travailleur ou l'autre.

Cette approche peut également être utilisée pour spécifier simplement un dispositif particulier. Par exemple, définir MACHINE_LEARNING_DEVICE_IDS=1 garantira que le dispositif 1 est toujours utilisé à la place du dispositif 0.

Notez que vous devez augmenter les concurrences des tâches pour augmenter l'utilisation globale et répartir plus efficacement le travail sur plusieurs GPU. De plus, chaque GPU doit être capable de charger tous les modèles. Il n'est pas possible de distribuer un seul modèle sur plusieurs GPU ayant individuellement une mémoire vidéo insuffisante, ou de déléguer un modèle spécifique à un GPU particulier.

Conseils​

  • Si vous rencontrez une erreur lors de l'exécution d'un modèle, essayez un modèle différent pour voir si le problème est spécifique au modèle.
  • Vous pourriez vouloir augmenter la concurrence au-delà du paramètre par défaut pour une utilisation plus élevée. Cependant, gardez à l'esprit que cela augmentera également la consommation de VRAM.
  • Les modèles plus grands tirent davantage parti de l'accélération matérielle, à condition que vous disposiez de la VRAM nécessaire.
  • Comparé à ARM NN, RKNPU présente :
    • Un support plus étendu des modèles (y compris pour la recherche, qu'ARM NN n'accélère pas)
    • Une génération de chaleur moindre
    • Une précision légèrement réduite (RKNPU utilise toujours FP16, tandis qu'ARM NN utilise par défaut une précision plus élevée FP32 sauf si MACHINE_LEARNING_ANN_FP16_TURBO est activé)
    • Une vitesse variable (testé sur RK3588) :
      • Si MACHINE_LEARNING_RKNN_THREADS est à la valeur par défaut de 1, RKNPU aura un débit nettement inférieur pour les tâches d'apprentissage automatique par rapport à ARM NN dans la plupart des cas, mais une latence similaire (comme lors d'une recherche)
      • Si MACHINE_LEARNING_RKNN_THREADS est défini sur 3, il sera quelque peu plus rapide qu'ARM NN avec FP32, mais légèrement plus lent qu'ARM NN si MACHINE_LEARNING_ANN_FP16_TURBO est activé
      • Lorsque d'autres tâches utilisent également le GPU (comme le transcodage), RKNPU a un avantage significatif par rapport à ARM NN car il utilise le NPU autrement inactif au lieu de se concurrencer pour utiliser le GPU
    • Une utilisation de RAM moindre si MACHINE_LEARNING_RKNN_THREADS est à la valeur par défaut de 1, mais nettement plus élevée si supérieure à 1 (ce qui est nécessaire pour utiliser pleinement le NPU et donc être comparable en vitesse à ARM NN)