Monitor simulation

Flower te permet de surveiller les ressources du système pendant l’exécution de ta simulation. De plus, le moteur de simulation de Flower est puissant et te permet de décider comment allouer les ressources par manière de client et de limiter l’utilisation totale. Les informations sur la consommation des ressources peuvent t’aider à prendre des décisions plus intelligentes et à accélérer le temps d’exécution.

Les instructions spécifiques supposent que tu utilises macOS et que le gestionnaire de paquets Homebrew est installé.

Téléchargements

brew install prometheus grafana

Prometheus est utilisé pour la collecte de données, tandis que Grafana te permettra de visualiser les données collectées. Ils sont tous deux bien intégrés à Ray que Flower utilise sous le capot.

Écrase les fichiers de configuration (selon ton appareil, il se peut qu’il soit installé sur un chemin différent).

Si tu es sur un Mac M1, il devrait l’être :

/opt/homebrew/etc/prometheus.yml
/opt/homebrew/etc/grafana/grafana.ini

Sur les appareils Mac Intel de la génération précédente, ce devrait être le cas :

/usr/local/etc/prometheus.yml
/usr/local/etc/grafana/grafana.ini

Ouvre les fichiers de configuration respectifs et modifie-les. Selon ton appareil, utilise l’une des deux commandes suivantes :

# M1 macOS
open /opt/homebrew/etc/prometheus.yml

# Intel macOS
open /usr/local/etc/prometheus.yml

puis supprime tout le texte du fichier et colle une nouvelle configuration Prometheus que tu vois ci-dessous. Tu peux adapter les intervalles de temps à tes besoins :

global:
  scrape_interval: 1s
  evaluation_interval: 1s

scrape_configs:
# Scrape from each ray node as defined in the service_discovery.json provided by ray.
- job_name: 'ray'
  file_sd_configs:
  - files:
    - '/tmp/ray/prom_metrics_service_discovery.json'

Maintenant, après avoir édité la configuration de Prometheus, fais de même avec les fichiers de configuration de Grafana. Ouvre ces derniers à l’aide de l’une des commandes suivantes, comme précédemment :

# M1 macOS
open / opt / homebrew / etc / grafana / grafana.ini

# Intel macOS
open / usr / local / etc / grafana / grafana.ini

Ton éditeur de terminal devrait s’ouvrir et te permettre d’appliquer la configuration suivante comme précédemment.

[security]
allow_embedding = true

[auth.anonymous]
enabled = true
org_name = Main Org.
org_role = Viewer

[paths]
provisioning = /tmp/ray/session_latest/metrics/grafana/provisioning

Félicitations, tu viens de télécharger tous les logiciels nécessaires au suivi des métriques, maintenant, démarrons-le.

Suivi des mesures

Avant de lancer ta simulation Flower, tu dois démarrer les outils de surveillance que tu viens d’installer et de configurer.

brew services start prometheus
brew services start grafana

Tu dois inclure l’argument suivant dans ton code Python lorsque tu démarres une simulation.

fl.simulation.start_simulation(
    # ...
    # all the args you used before
    # ...
    ray_init_args={"include_dashboard": True}
)

Maintenant, tu es prêt à commencer ta charge de travail.

Peu de temps après le début de la simulation, tu devrais voir les journaux suivants dans ton terminal :

2023-01-20 16:22:58,620       INFO [worker.py:1529](http://worker.py:1529/) -- Started a local Ray instance. View the dashboard at http://127.0.0.1:8265

You can look at everything at http://127.0.0.1:8265 .

Il s’agit d’un tableau de bord Ray. Tu peux naviguer vers Metrics (sur le panneau de gauche, l’option la plus basse).

Ou alors, tu peux simplement les voir dans Grafana en cliquant sur le coin supérieur droit, « View in Grafana ». Sache que le tableau de bord Ray n’est accessible que pendant la simulation. Une fois la simulation terminée, tu ne peux utiliser Grafana que pour explorer les métriques. Tu peux démarrer Grafana en te rendant sur http://localhost:3000/`.

After you finish the visualization, stop Prometheus and Grafana. This is important as they will otherwise block, for example port 3000 on your machine as long as they are running.

brew services stop prometheus
brew services stop grafana

Allocation des ressources

Tu dois comprendre le fonctionnement de la bibliothèque Ray pour allouer efficacement les ressources du système aux clients de simulation de ton côté.

Au départ, la simulation (que Ray gère sous le capot) démarre par défaut avec toutes les ressources disponibles sur le système, qu’elle partage entre les clients. Cela ne signifie pas qu’elle les divise de manière égale entre tous, ni que l’apprentissage du modèle se fait sur tous les clients simultanément. Tu en apprendras plus à ce sujet dans la suite de ce blog. Tu peux vérifier les ressources du système en exécutant ce qui suit :

import ray

ray.available_resources()

Dans Google Colab, le résultat que tu obtiens peut ressembler à ceci :

{'memory': 8020104807.0,
 'GPU': 1.0,
 'object_store_memory': 4010052403.0,
 'CPU': 2.0,
 'accelerator_type:T4': 1.0,
 'node:172.28.0.2': 1.0}

Cependant, tu peux écraser les valeurs par défaut. Lorsque tu démarres une simulation, fais ce qui suit (tu n’as pas besoin de les écraser toutes) :

num_cpus = 2
num_gpus = 1
ram_memory = 16_000 * 1024 * 1024  # 16 GB
fl.simulation.start_simulation(
    # ...
    # all the args you were specifying before
    # ...
    ray_init_args={
        "include_dashboard": True,  # we need this one for tracking
        "num_cpus": num_cpus,
        "num_gpus": num_gpus,
        "memory": ram_memory,
    }
)

Spécifions également la ressource pour un seul client.

# Total resources for simulation
num_cpus = 4
num_gpus = 1
ram_memory = 16_000 * 1024 * 1024  # 16 GB

# Single client resources
client_num_cpus = 2
client_num_gpus = 1

fl.simulation.start_simulation(
    # ...
    # all the args you were specifying before
    # ...
    ray_init_args={
        "include_dashboard": True,  # we need this one for tracking
        "num_cpus": num_cpus,
        "num_gpus": num_gpus,
        "memory": ram_memory,
    },
    # The argument below is new
    client_resources={
        "num_cpus": client_num_cpus,
        "num_gpus": client_num_gpus,
    },
)

Ray ne démarrera un nouveau client que lorsqu’il disposera de toutes les ressources nécessaires (de manière à ce qu’ils fonctionnent en parallèle) lorsque les ressources le permettront.

In the example above, only one client will be run, so your clients won’t run concurrently. Setting client_num_gpus = 0.5 would allow running two clients and therefore enable them to run concurrently. Be careful not to require more resources than available. If you specified client_num_gpus = 2, the simulation wouldn’t start (even if you had 2 GPUs but decided to set 1 in ray_init_args).

FAQ

Q : Je ne vois aucune mesure enregistrée.

R : Il se peut que le délai ne soit pas correctement défini. Le paramètre se trouve dans le coin supérieur droit (« Dernières 30 minutes » par défaut). Modifie le délai pour qu’il corresponde à la période pendant laquelle la simulation s’est déroulée.

Q : Je vois s’afficher « Serveur Grafana non détecté. Vérifie que le serveur Grafana fonctionne et actualise cette page » après avoir accédé à l’onglet Métriques dans Ray Dashboard.

R : Grafana n’est probablement pas en cours d’exécution. Vérifie les services en cours d’exécution

brew services list

Q: I see « This site can’t be reached » when going to http://127.0.0.1:8265.

R : Soit la simulation est déjà terminée, soit tu dois encore démarrer Prometheus.

Ressources

Ray Dashboard: https://docs.ray.io/en/latest/ray-observability/getting-started.html

Ray Metrics: https://docs.ray.io/en/latest/cluster/metrics.html