Rapport de stages

# Exemple : vérification convergence loss
import matplotlib.pyplot as plt
import numpy as np

# Charger logs d'entraînement
epochs = [1, 10, 50, 100, 200]
train_loss = [2.31, 1.85, 0.97, 0.52, 0.31]
val_loss = [2.28, 1.92, 1.18, 0.94, 0.87]

plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.semilogy(epochs, train_loss, 'b-o', label='Train')
plt.semilogy(epochs, val_loss, 'r-s', label='Val')
plt.xlabel('Époque'); plt.ylabel('Loss'); plt.legend()
plt.title('Convergence de la fonction de coût')

# Vérifier absence d'overfitting
plt.subplot(1, 2, 2)
gap = np.array(train_loss) - np.array(val_loss)
plt.plot(epochs, gap, 'g-^')
plt.xlabel('Époque'); plt.ylabel('Gap train-val')
plt.title('Écart train/validation')
plt.tight_layout()

#!/usr/bin/env python3
# test_convergence.py
import numpy as np
import matplotlib.pyplot as plt

def manufactured_solution(x, y):
    """Solution exacte u = sin(πx)*sin(πy)"""
    return np.sin(np.pi * x) * np.sin(np.pi * y)

def source_term(x, y):
    """Terme source f = -Δu = 2π²sin(πx)sin(πy)"""
    return 2 * np.pi**2 * np.sin(np.pi * x) * np.sin(np.pi * y)

def solve_poisson(h):
    """Résout -Δu = f avec maillage de pas h"""
    # Implémentation du solveur (DF, EF, etc.)
    # Retourne u_h, erreur_L2, erreur_H1
    pass

# Test de convergence
h_values = [0.1, 0.05, 0.025, 0.0125]
errors_L2 = []
errors_H1 = []

for h in h_values:
    u_h, err_L2, err_H1 = solve_poisson(h)
    errors_L2.append(err_L2)
    errors_H1.append(err_H1)
    print(f"h={h:6.3f}, L2={err_L2:.2e}, H1={err_H1:.2e}")

# Calcul des ordres
orders_L2 = []
orders_H1 = []
for i in range(1, len(h_values)):
    order_L2 = np.log(errors_L2[i-1]/errors_L2[i]) / np.log(h_values[i-1]/h_values[i])
    order_H1 = np.log(errors_H1[i-1]/errors_H1[i]) / np.log(h_values[i-1]/h_values[i])
    orders_L2.append(order_L2)
    orders_H1.append(order_H1)
    print(f"Ordre L2: {order_L2:.2f}, Ordre H1: {order_H1:.2f}")

# Graphique
plt.loglog(h_values, errors_L2, 'bo-', label='L² error')
plt.loglog(h_values, errors_H1, 'rs-', label='H¹ error')
plt.loglog(h_values, [h**2 for h in h_values], 'k--', label='h²')
plt.loglog(h_values, h_values, 'k:', label='h')
plt.xlabel('h'); plt.ylabel('Erreur'); plt.legend()
plt.title('Test de convergence'); plt.grid(True)

project/
├─ configs/exp.yaml
├─ data/              # (ou DVC si utilisé)
├─ images/ml.sif      # image Apptainer locale (optionnel)
├─ scripts/
│  ├─ train.sh        # lance entraînement (local/HPC)
│  ├─ strong_scaling.sh
│  └─ weak_scaling.sh
├─ slurm/
│  ├─ train_cpu.sbatch
│  └─ train_gpu.sbatch
├─ tools/
│  ├─ log_metrics.py  # append CSV
│  └─ parse_sacct.sh  # récupère métriques Slurm
└─ results/
   ├─ runs.csv
   └─ logs/

#!/usr/bin/env bash
#SBATCH -J train_cpu
#SBATCH -A <account>              # compte projet
#SBATCH -p <partition>            # ex: cpu, long, normal
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=32
#SBATCH --time=02:00:00
#SBATCH -o results/logs/%x-%j.out
#SBATCH -e results/logs/%x-%j.err

set -euo pipefail

# Paramètres expérience
EXP_ID=${EXP_ID:-"EXP-$(date +%Y%m%d-%H%M%S)"}
CONFIG=${CONFIG:-"configs/exp.yaml"}
DATA_DIR=${DATA_DIR:-"$PWD/data"}
RESULTS=${RESULTS:-"$PWD/results"}
CSV=${CSV:-"$RESULTS/runs.csv"}
CONTAINER=${CONTAINER:-"$PWD/images/ml.sif"}  # ou "docker://ghcr.io/<org>/<img>:<tag>"

mkdir -p "$RESULTS/logs"

START_TS=$(date +%s)

# Exemple Apptainer (CPU)
srun apptainer exec \
  --bind "$DATA_DIR:/workspace/data","$RESULTS:/workspace/results" \
  "$CONTAINER" \
  bash -lc "python -m project.train --config $CONFIG --device cpu"

END_TS=$(date +%s)
T_TOTAL=$(( END_TS - START_TS ))

# Récupère métriques Slurm
tools/parse_sacct.sh "$SLURM_JOB_ID" > "$RESULTS/logs/${EXP_ID}-${SLURM_JOB_ID}.sacct"

# Journalise
python tools/log_metrics.py \
  --csv "$CSV" \
  --exp-id "$EXP_ID" \
  --resources "nodes=${SLURM_NNODES};ntasks_per_node=${SLURM_NTASKS_PER_NODE}" \
  --t-total "$T_TOTAL" \
  --container "$CONTAINER" \
  --config "$CONFIG" \
  --notes "cpu-run"

#!/usr/bin/env bash
#SBATCH -J train_gpu
#SBATCH -A <account>
#SBATCH -p <partition>            # ex: gpu
#SBATCH --nodes=1
#SBATCH --gres=gpu:1
#SBATCH --cpus-per-task=16
#SBATCH --time=02:00:00
#SBATCH -o results/logs/%x-%j.out
#SBATCH -e results/logs/%x-%j.err

set -euo pipefail

EXP_ID=${EXP_ID:-"EXP-$(date +%Y%m%d-%H%M%S)"}
CONFIG=${CONFIG:-"configs/exp.yaml"}
DATA_DIR=${DATA_DIR:-"$PWD/data"}
RESULTS=${RESULTS:-"$PWD/results"}
CSV=${CSV:-"$RESULTS/runs.csv"}
CONTAINER=${CONTAINER:-"$PWD/images/ml.sif"}

mkdir -p "$RESULTS/logs"

START_TS=$(date +%s)

# Exemple Apptainer (GPU)
srun apptainer exec --nv \
  --bind "$DATA_DIR:/workspace/data","$RESULTS:/workspace/results" \
  "$CONTAINER" \
  bash -lc "python -m project.train --config $CONFIG --device cuda"

END_TS=$(date +%s)
T_TOTAL=$(( END_TS - START_TS ))

tools/parse_sacct.sh "$SLURM_JOB_ID" > "$RESULTS/logs/${EXP_ID}-${SLURM_JOB_ID}.sacct"

python tools/log_metrics.py \
  --csv "$CSV" \
  --exp-id "$EXP_ID" \
  --resources "nodes=${SLURM_NNODES};gpu=1;cpus_per_task=${SLURM_CPUS_PER_TASK}" \
  --t-total "$T_TOTAL" \
  --container "$CONTAINER" \
  --config "$CONFIG" \
  --notes "gpu-run"

#!/usr/bin/env bash
set -euo pipefail
for N in 1 2 4 8; do
  EXP_ID="SS-N${N}-$(date +%Y%m%d-%H%M%S)"
  sbatch --nodes=$N --export=ALL,EXP_ID=$EXP_ID,CONFIG=configs/exp.yaml slurm/train_cpu.sbatch
done

#!/usr/bin/env bash
set -euo pipefail
# Associer (N, taille_données) pour garder charge par ressource ~constante
declare -a NS=(1 2 4 8)
declare -a DS=("10k" "20k" "40k" "80k")
for i in "${!NS[@]}"; do
  N=${NS[$i]}; D=${DS[$i]}
  EXP_ID="WS-N${N}-D${D}-$(date +%Y%m%d-%H%M%S)"
  sbatch --nodes=$N --export=ALL,EXP_ID=$EXP_ID,CONFIG=configs/exp_${D}.yaml slurm/train_cpu.sbatch
done

#!/usr/bin/env bash
# Usage: tools/parse_sacct.sh <jobid>
JOB=$1
sacct -j "$JOB" --format=JobID,Elapsed,MaxRSS,MaxVMSize,TotalCPU,AllocTRES%30,State -P

#!/usr/bin/env python3
import argparse, csv, os, subprocess, hashlib, json, time

p = argparse.ArgumentParser()
p.add_argument("--csv", required=True)
p.add_argument("--exp-id", required=True)
p.add_argument("--resources", default="")
p.add_argument("--t-total", type=float, required=True)
p.add_argument("--container", required=True)
p.add_argument("--config", required=True)
p.add_argument("--notes", default="")
args = p.parse_args()

def git_commit():
    try:
        return subprocess.check_output(["git","rev-parse","--short","HEAD"]).decode().strip()
    except Exception:
        return "NA"

def file_sha256(path):
    if not os.path.exists(path): return "NA"
    h=hashlib.sha256()
    with open(path,"rb") as f:
        for chunk in iter(lambda: f.read(1<<20), b""): h.update(chunk)
    return h.hexdigest()

row = {
  "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
  "exp_id": args.exp_id,
  "git_commit": git_commit(),
  "container": args.container,
  "container_sha256": file_sha256(args.container) if args.container.endswith(".sif") else "NA",
  "config": args.config,
  "config_sha256": file_sha256(args.config),
  "resources": args.resources,
  "t_total_s": args.t_total,
  "notes": args.notes
}

file_exists = os.path.exists(args.csv)
os.makedirs(os.path.dirname(args.csv), exist_ok=True)
with open(args.csv, "a", newline="") as f:
    w = csv.DictWriter(f, fieldnames=list(row.keys()))
    if not file_exists: w.writeheader()
    w.writerow(row)
print(json.dumps(row, indent=2))

timestamp,exp_id,git_commit,container,container_sha256,config,config_sha256,resources,t_total_s,notes
2025-09-09 09:15:02,SS-N1-20250909-091502,abc1234,images/ml.sif,sha256:...,configs/exp.yaml,sha256:...,nodes=1;ntasks_per_node=32,1200,cpu-run
2025-09-09 09:48:31,SS-N2-20250909-094831,abc1234,images/ml.sif,sha256:...,configs/exp.yaml,sha256:...,nodes=2;ntasks_per_node=32,640,cpu-run

# tools/compute_scaling.py (exemple)
import pandas as pd, sys
df = pd.read_csv("results/runs.csv")
# Filtrer la campagne strong scaling:
ss = df[df["exp_id"].str.contains("SS-N")]
# Extraire N depuis "resources" (ex: nodes=4;ntasks_per_node=32)
def get_nodes(s):
    for kv in s.split(";"):
        if kv.startswith("nodes="): return int(kv.split("=")[1])
    return 1
ss["N"] = ss["resources"].apply(get_nodes)
T1 = ss.loc[ss["N"]==1, "t_total_s"].min()
ss["S"] = T1 / ss["t_total_s"]
ss["E"] = ss["S"] / ss["N"]
print(ss[["exp_id","N","t_total_s","S","E"]].sort_values("N"))