Obtenir les ressources disponibles

Aperçu

Détectez les ressources informatiques disponibles et générez des recommandations stratégiques pour les tâches de calcul scientifique. Cette skill identifie automatiquement les capacités CPU, la disponibilité GPU (NVIDIA CUDA, AMD ROCm, Apple Silicon Metal), les contraintes mémoire et l'espace disque pour aider à prendre des décisions éclairées concernant les approches informatiques.

Quand utiliser cette skill

Utilisez cette skill de manière proactive avant toute tâche informatique intensive :

Avant l'analyse de données : Déterminez si les datasets peuvent être chargés en mémoire ou nécessitent un traitement hors-mémoire
Avant l'entraînement de modèles : Vérifiez si l'accélération GPU est disponible et quel backend utiliser
Avant le traitement parallèle : Identifiez le nombre optimal de workers pour joblib, multiprocessing ou Dask
Avant les opérations sur fichiers volumineux : Vérifiez l'espace disque suffisant et les stratégies de stockage appropriées
À l'initialisation du projet : Comprenez les capacités de base pour prendre des décisions architecturales

Scénarios d'exemple :

« Aide-moi à analyser ce dataset de génomique de 50 Go » → Utilisez d'abord cette skill pour déterminer si Dask/Zarr sont nécessaires
« Entraîne un réseau de neurones sur ces données » → Utilisez cette skill pour détecter les GPU disponibles et les backends
« Traite 10 000 fichiers en parallèle » → Utilisez cette skill pour déterminer le nombre optimal de workers
« Exécute une simulation informatiquement intensive » → Utilisez cette skill pour comprendre les contraintes de ressources

Fonctionnement de cette skill

Détection des ressources

La skill exécute scripts/detect_resources.py pour détecter automatiquement :

Informations CPU
- Nombre de cœurs physiques et logiques
- Architecture et modèle du processeur
- Informations de fréquence CPU
Informations GPU
- GPUs NVIDIA : Détection via nvidia-smi, signale la VRAM, la version du driver, la capacité de calcul
- GPUs AMD : Détection via rocm-smi
- Apple Silicon : Détecte les puces M1/M2/M3/M4 avec support Metal et mémoire unifiée
Informations mémoire
- RAM totale et disponible
- Pourcentage d'utilisation mémoire actuel
- Disponibilité de l'espace swap
Informations d'espace disque
- Espace disque total et disponible pour le répertoire de travail
- Pourcentage d'utilisation actuel
Informations du système d'exploitation
- Type d'OS (macOS, Linux, Windows)
- Version et release de l'OS
- Version Python

Format de sortie

La skill génère un fichier .claude_resources.json dans le répertoire de travail actuel contenant :

{
  "timestamp": "2025-10-23T10:30:00",
  "os": {
    "system": "Darwin",
    "release": "25.0.0",
    "machine": "arm64"
  },
  "cpu": {
    "physical_cores": 8,
    "logical_cores": 8,
    "architecture": "arm64"
  },
  "memory": {
    "total_gb": 16.0,
    "available_gb": 8.5,
    "percent_used": 46.9
  },
  "disk": {
    "total_gb": 500.0,
    "available_gb": 200.0,
    "percent_used": 60.0
  },
  "gpu": {
    "nvidia_gpus": [],
    "amd_gpus": [],
    "apple_silicon": {
      "name": "Apple M2",
      "type": "Apple Silicon",
      "backend": "Metal",
      "unified_memory": true
    },
    "total_gpus": 1,
    "available_backends": ["Metal"]
  },
  "recommendations": {
    "parallel_processing": {
      "strategy": "high_parallelism",
      "suggested_workers": 6,
      "libraries": ["joblib", "multiprocessing", "dask"]
    },
    "memory_strategy": {
      "strategy": "moderate_memory",
      "libraries": ["dask", "zarr"],
      "note": "Consider chunking for datasets > 2GB"
    },
    "gpu_acceleration": {
      "available": true,
      "backends": ["Metal"],
      "suggested_libraries": ["pytorch-mps", "tensorflow-metal", "jax-metal"]
    },
    "large_data_handling": {
      "strategy": "disk_abundant",
      "note": "Sufficient space for large intermediate files"
    }
  }
}

Recommandations stratégiques

La skill génère des recommandations sensibles au contexte :

Recommandations de traitement parallèle :

Haut parallélisme (8+ cœurs) : Utilisez Dask, joblib ou multiprocessing avec workers = cœurs - 2
Parallélisme modéré (4-7 cœurs) : Utilisez joblib ou multiprocessing avec workers = cœurs - 1
Séquentiel (< 4 cœurs) : Préférez le traitement séquentiel pour éviter les frais généraux

Recommandations de stratégie mémoire :

Mémoire limitée (< 4 Go disponibles) : Utilisez Zarr, Dask ou H5py pour le traitement hors-mémoire
Mémoire modérée (4-16 Go disponibles) : Utilisez Dask/Zarr pour les datasets > 2 Go
Mémoire abondante (> 16 Go disponibles) : Pouvez charger la plupart des datasets directement en mémoire

Recommandations d'accélération GPU :

GPUs NVIDIA détectés : Utilisez PyTorch, TensorFlow, JAX, CuPy ou RAPIDS
GPUs AMD détectés : Utilisez PyTorch-ROCm ou TensorFlow-ROCm
Apple Silicon détecté : Utilisez PyTorch avec backend MPS, TensorFlow-Metal ou JAX-Metal
Aucun GPU détecté : Utilisez des bibliothèques optimisées pour CPU

Recommandations de gestion des données volumineuses :

Disque limité (< 10 Go) : Utilisez des stratégies de streaming ou de compression
Disque modéré (10-100 Go) : Utilisez les formats Zarr, H5py ou Parquet
Disque abondant (> 100 Go) : Pouvez créer librement de gros fichiers intermédiaires

Instructions d'utilisation

Étape 1 : Exécuter la détection des ressources

Exécutez le script de détection au démarrage de toute tâche informatique intensive :

python scripts/detect_resources.py

Arguments optionnels :

-o, --output <path> : Spécifiez un chemin de sortie personnalisé (défaut : .claude_resources.json)
-v, --verbose : Imprimez les informations complètes sur les ressources vers stdout

Étape 2 : Lire et appliquer les recommandations

Après avoir exécuté la détection, lisez le fichier .claude_resources.json généré pour informer les décisions informatiques :

# Exemple : Utilisez les recommandations dans le code
import json

with open('.claude_resources.json', 'r') as f:
    resources = json.load(f)

# Vérifiez la stratégie de traitement parallèle
if resources['recommendations']['parallel_processing']['strategy'] == 'high_parallelism':
    n_jobs = resources['recommendations']['parallel_processing']['suggested_workers']
    # Utilisez joblib, Dask ou multiprocessing avec n_jobs workers

# Vérifiez la stratégie mémoire
if resources['recommendations']['memory_strategy']['strategy'] == 'memory_constrained':
    # Utilisez Dask, Zarr ou H5py pour le traitement hors-mémoire
    import dask.array as da
    # Chargez les données par chunks

# Vérifiez la disponibilité GPU
if resources['recommendations']['gpu_acceleration']['available']:
    backends = resources['recommendations']['gpu_acceleration']['backends']
    # Utilisez la bibliothèque GPU appropriée en fonction du backend disponible

Étape 3 : Prendre des décisions éclairées

Utilisez les informations de ressources et les recommandations pour faire des choix stratégiques :

Pour le chargement de données :

memory_available_gb = resources['memory']['available_gb']
dataset_size_gb = 10

if dataset_size_gb > memory_available_gb * 0.5:
    # Le dataset est volumineux par rapport à la mémoire, utilisez Dask
    import dask.dataframe as dd
    df = dd.read_csv('large_file.csv')
else:
    # Le dataset tient en mémoire, utilisez pandas
    import pandas as pd
    df = pd.read_csv('large_file.csv')

Pour le traitement parallèle :

from joblib import Parallel, delayed

n_jobs = resources['recommendations']['parallel_processing'].get('suggested_workers', 1)

results = Parallel(n_jobs=n_jobs)(
    delayed(process_function)(item) for item in data
)

Pour l'accélération GPU :

import torch

if 'CUDA' in resources['gpu']['available_backends']:
    device = torch.device('cuda')
elif 'Metal' in resources['gpu']['available_backends']:
    device = torch.device('mps')
else:
    device = torch.device('cpu')

model = model.to(device)

Dépendances

Le script de détection nécessite les packages Python suivants :

uv pip install psutil

Toutes les autres fonctionnalités utilisent les modules de la bibliothèque standard Python (json, os, platform, subprocess, sys, pathlib).

Support des plateformes

macOS : Support complet incluant la détection GPU Apple Silicon (M1/M2/M3/M4)
Linux : Support complet incluant la détection GPU NVIDIA (nvidia-smi) et AMD (rocm-smi)
Windows : Support complet incluant la détection GPU NVIDIA

Bonnes pratiques

Exécutez tôt : Lancez la détection des ressources au début des projets ou avant les tâches informatiques majeures
Réexécutez périodiquement : Les ressources système changent au fil du temps (utilisation mémoire, espace disque)
Vérifiez avant de monter en charge : Vérifiez les ressources avant d'augmenter le nombre de workers parallèles ou les tailles de données
Documentez les décisions : Conservez le fichier .claude_resources.json dans les répertoires de projet pour documenter les décisions sensibles aux ressources
Utilisez avec versioning : Les différentes machines ont des capacités différentes ; les fichiers de ressources aident à maintenir la portabilité

Dépannage

GPU non détecté :

Assurez-vous que les drivers GPU sont installés (nvidia-smi, rocm-smi ou system_profiler pour Apple Silicon)
Vérifiez que les utilitaires GPU sont dans le PATH système
Vérifiez que le GPU n'est pas utilisé par d'autres processus

L'exécution du script échoue :

Assurez-vous que psutil est installé : uv pip install psutil
Vérifiez la compatibilité de la version Python (Python 3.6+)
Vérifiez que le script a les permissions d'exécution : chmod +x scripts/detect_resources.py

Lectures mémoire inexactes :

Les lectures mémoire sont des snapshots ; la mémoire disponible réelle change constamment
Fermez les autres applications avant la détection pour une lecture précise de la mémoire « disponible »
Envisagez d'exécuter la détection plusieurs fois et de faire la moyenne des résultats

get-available-resources