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
Tu peux tout regarder sur 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/`.
Après avoir terminé la visualisation, arrête Prometheus et Grafana. C’est important car sinon ils bloqueront, par exemple, le port 3000 sur ta machine tant qu’ils seront en cours d’exécution.
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.
Dans l’exemple ci-dessus, un seul client sera exécuté, donc tes clients ne fonctionneront pas simultanément. En définissant client_num_gpus = 0.5, tu pourras exécuter deux clients et donc les faire fonctionner simultanément. Fais attention à ne pas demander plus de ressources que celles disponibles. Si tu as spécifié client_num_gpus = 2, la simulation ne démarrera pas (même si tu as 2 GPU mais que tu as décidé d’en définir 1 dans 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 : Je vois « This site can’t be reached » quand je vais sur 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