Simulation de routage de centre d'appels en Python

Simulation des stratégies de routage dans les centres d'appels : Code et métriques

Un modèle en temps discret permet de comparer des stratégies pour distribuer les appels entrants aux agents : Séquentiel (sondage séquentiel), Round Robin (round-robin), et Longest Idle (sélection par temps d'inactivité maximal). L'analyse se concentre sur les KPI (SLA, temps d'attente, longueur de file) et les métriques d'équité (indice de Gini, coefficient de variation).

Le modèle génère un flux d'appels de Poisson, simule les états des agents (inactif, occupé, hors ligne), et collecte des données pour visualiser la distribution de charge. Tous les paramètres sont centralisés dans config.py avec typage via dataclass et sérialisation JSON pour la reproductibilité.

Application du modèle en développement et test

Pour les développeurs, le modèle sert de bac à sable : prototyper des stratégies révèle les problèmes tôt sans charge réelle.

Les testeurs l'utilisent pour :

• Valider les simulations contre les données de production comme un jumeau numérique.
• Tests de stress : pics d'appels, pannes d'agents, détection de goulots d'étranglement.

Les clients (responsables de centres d'appels) exécutent des analyses what-if :

• Évaluation SLA sous changements de stratégie.
• Prévision de charge avec embauche d'agents.
• Comparaison d'équité à intensités de trafic variables.

Architecture du projet

Structure modulaire utilisant src-layout, compatible avec Colab et environnements locaux. Installation éditable via pyproject.toml avec découverte automatique de paquets et pytest.

Modules clés :

• src/ccsim/config.py : SimulationConfig avec seed, lambda_rate, num_agents, etc.
• src/ccsim/agents.py : classe Agent avec états et événements Poisson.
• src/ccsim/strategies.py : sous-classes RoutingStrategy pour extensibilité.
• src/ccsim/simulation.py : Boucle d'événements discrets et traitement.
• src/ccsim/metrics.py : Gini et CV pour appels et temps occupé.
• src/ccsim/visualization.py : Distributions KDE et dynamiques de file.
• main.py : Orchestration et sauvegarde dans runs/<timestamp>.
• tests/test_strategies.py : Vérifications de cas limites.

Exécution Colab : Génération depuis notebook, installation éditable, exécution main.py. Tests via pytest avec rapports HTML/JUnit.

Paramètres de simulation

SimulationConfig définit :

| Paramètre | Description |

|------------------------|------------------------------|

| seed | Initialisation RNG |

| lambda_rate | Intensité des appels (appels/sec) |

| num_agents | Nombre d'agents |

| num_calls | Nombre total d'appels |

| min_call_duration, max_call_duration | Plage de durée |

| agent_logout_prob, agent_login_prob | Stochasticité de disponibilité des agents |

| max_queue_size | Limite de file |

| service_level_threshold| Seuil SLA (sec) |

| max_simulation_steps | Limite d'étapes |

Exemple : lambda_rate [0.65, 0.75, 0.85] modélise charge faible/seuil/élevée. Le coefficient de variation met le mieux en évidence les différences d'équité.

Résultats de comparaison des stratégies

À lambda_rate=0.70, Séquentiel montre une utilisation inégale (graphiques KDE). Round Robin et Longest Idle sont plus proches de l'uniforme. À faible charge (0.65), les différences de distribution d'appels sont maximales ; en surcharge, elles convergent.

Graphiques : combined_busy_times_kde.png pour temps occupé, distributions d'appels par agent.

Points clés

• Le modèle compare Séquentiel, Round Robin, Longest Idle sur KPI et équité (Gini, CV).
• config.py flexible avec JSON pour scénarios what-if.
• Modulaire : nouvelles stratégies via héritage RoutingStrategy.
• Visualisation des dynamiques de file et distributions de charge KDE.
• Tests couvrent cas limites : file vide, pas d'agents.

Extensions du modèle

Ajouter :

• Agents hétérogènes (niveaux de compétence, plannings de travail).
• Routage basé sur les compétences et prédictif.
• Cyclicité du trafic, appels répétés.
• Agents robots, facteurs de fatigue.

— Editorial Team