Chargement...
À quoi sert chaque bouton de l'interface, et comment régler les paramètres quantiques (layers, shots, k…).
Les boutons en haut de l'éditeur, de gauche à droite. Sur téléphone, ils passent sur plusieurs lignes.
Revient à la page précédente (en général la liste des workflows du projet).
Sur petit écran, la palette de nœuds est masquée pour laisser la place au canevas. Ce bouton l'ouvre ; sur ordinateur elle est toujours visible à gauche.
Le titre est un champ modifiable : cliquez dessus, tapez le nouveau nom puis Entrée (ou cliquez ailleurs). Le nom est enregistré immédiatement, sans passer par « Save Changes ».
Affiche l'état de chaque nœud sur le canevas (en attente, en cours, réussi avec sa durée, en échec avec l'erreur) et ouvre à gauche un panneau « Debug — Node States » : cliquez sur un nœud de la liste pour voir sa configuration, sa sortie ou son erreur, et exporter sa sortie en CSV.
Run Live active ce mode tout seul. Le désactiver efface les états affichés — y compris le code quantique du bouton </>, qu'il faudra régénérer par une nouvelle exécution.
Décrivez en français ce que vous voulez automatiser (« chaque lundi, lire mes tickets Jira, prioriser avec QAOA et envoyer un résumé par e-mail »). L'assistant propose un workflow ; s'il est valide, vous pouvez l'ajouter au canevas.
Les nœuds générés sont ajoutés à côté de ceux déjà présents (rien n'est effacé). Nécessite qu'un modèle d'IA soit disponible pour votre compte (Réglages → Connecteurs).
Trois questions — type de problème, phase (test ou production), taille (≤ 12 ou > 12 qubits) — et il recommande l'algorithme à mettre dans le nœud « Algorithm selector », le backend, et le coût estimé d'un run.
Comment faire
C'est un aide-mémoire à règles fixes : il ne lit pas vos données et ne modifie pas le workflow. Le backend proposé est le simulateur en phase de test ou au-delà de 12 qubits, IonQ sinon. Attention pour « Chimie » : dans les workflows, VQE résout le même problème de sélection de lignes que QAOA (avec un autre circuit) ; il n'y a pas de nœud de calcul moléculaire.
Un bac à sable pour poser à la main un petit problème d'optimisation binaire : chaque variable vaut 0 ou 1 ; la case (i, i) de la matrice est le gain/coût de la variable i, la case (i, j) celui d'avoir i et j à 1 en même temps. Choisissez Minimiser ou Maximiser puis « Résoudre » : vous obtenez la meilleure affectation et son énergie (valeur de l'objectif).
Comment faire
Le calcul est classique et exact : avec au plus 10 variables, toutes les combinaisons sont essayées. L'outil est indépendant du workflow — pour optimiser vos propres données, utilisez le nœud Algorithm selector (qaoa), qui construit lui-même ce type de problème à partir de vos lignes.
Cherche les meilleurs réglages (layers, shots) du nœud Algorithm selector sur les données de ce workflow, sans dépasser un budget. Il essaie jusqu'à 10 combinaisons, de la moins chère à la plus chère (de 1 couche / 200 tirs à 5 couches / 5 000 tirs), et garde celle dont le résultat se rapproche le plus de la référence classique (puis celle qui mesure le plus souvent la meilleure solution). La progression s'affiche en direct ; « Appliquer au nœud » reporte le meilleur réglage dans les params du nœud (pensez à enregistrer).
Comment faire
Fonctionne avec qaoa, qbsolv, vqe, tsp et scheduling, sur la dernière version enregistrée. Seuls le nœud et les nœuds placés avant lui s'exécutent : rien n'est exporté ni envoyé. Les calculs tournent sur le simulateur ; le coût affiché est celui qu'auraient ces circuits sur le backend choisi (rien n'est facturé). « Optimisation continue » relance la recherche chaque nuit à 3 h (budget estimé 2 €, backend du nœud Simulator/Backend) et vous notifie si elle trouve mieux ; l'historique liste les recherches manuelles et nocturnes.
Apparaît seulement si le workflow contient un nœud « Simulator/Backend ». Cliquez pour voir, par nœud backend, le nombre de tirs, de qubits et le coût estimé, puis le total. Le badge passe à l'orange au-delà d'environ 5 €.
Estimation indicative fondée sur des tarifs publics approximatifs (1 crédit = 0,01 €). Le simulateur est gratuit. Le calcul utilise le nombre de tirs du nœud Backend et le nombre de qubits d'un éventuel Constructeur de circuit.
Lance l'exécution réelle, nœud par nœud, avec le suivi en direct : les nœuds se colorent (jaune en cours, vert réussi, rouge en échec) et un panneau à droite affiche le déroulé et les résultats. « Stop » interrompt l'exécution.
Les modifications non enregistrées sont enregistrées automatiquement avant l'exécution (le serveur exécute la version enregistrée). Le bouton est grisé tant que le workflow contient des erreurs (affichées en bas du canevas).
Fil de discussion attaché au workflow, visible par les membres du projet. Ctrl+Entrée pour envoyer.
Liste les versions du workflow. « Enregistrer une version » crée un point de sauvegarde avec un message ; « Comparer » montre les différences entre deux versions, nœud par nœud ; « Restaurer » revient à une version (l'état actuel est d'abord sauvegardé, vous ne perdez rien).
Ouvre une page où vous choisissez deux exécutions passées du workflow pour comparer leurs résultats côte à côte — utile pour voir l'effet d'un changement de paramètres.
Active une URL secrète : toute requête POST envoyée dessus (par Jira, GitHub, un CRM, un script…) exécute le workflow. Le corps JSON reçu est disponible pour les nœuds sous la clé webhook-trigger.
L'URL contient un jeton : ne la partagez qu'avec le système qui doit l'appeler. « Régénérer le token » invalide l'ancienne URL ; « Désactiver » coupe le déclencheur.
Ouvre un panneau à droite avec un bouton « Lancer un test à blanc » : il parcourt la dernière version enregistrée dans l'ordre d'exécution, sans rien exécuter (aucun appel externe, aucun calcul, aucune écriture), et liste les étapes avec leur configuration. Pratique pour vérifier l'ordre et les réglages avant un vrai run.
Enregistre les nœuds, les liens et leurs réglages. Grisé si le workflow contient des erreurs ou si vous êtes en lecture seule. Tant que vous n'avez pas enregistré, un brouillon est gardé dans votre navigateur.
Votre rôle dans le projet ne permet pas de modifier ce workflow : vous pouvez le consulter et voir ses exécutions, pas l'enregistrer.
La zone centrale où l'on assemble le workflow.
La palette de gauche liste les nœuds par catégorie (Données, Transformation, Logique, Quantique, IA, Sortie…). Cliquez sur un nœud pour l'ajouter, ou glissez-le à l'endroit voulu du canevas. Une recherche en haut filtre la liste. La description complète de chaque nœud est dans Aide → Documentation des nœuds.
Tirez un lien depuis le point à droite d'un nœud vers le point à gauche du suivant. Les données (les lignes) circulent dans le sens des liens ; chaque nœud reçoit les sorties de ceux qui le précèdent.
Cliquez sur un nœud pour ouvrir ses propriétés à droite et remplir ses champs. Les champs obligatoires manquants sont signalés en bas du canevas (« n erreur(s) à corriger »).
Sur les nœuds « Algorithm selector » et « Circuit builder », ce bouton affiche le programme quantique en Qiskit (Python) : onglet « Circuit (Qiskit) » avec les vraies valeurs de la dernière exécution, onglet « Simulation exécutée (moteur) » avec le code qui a réellement tourné, boutons Copier et .py.
Pour un Algorithm selector, le code n'existe qu'après une exécution (Run Live) dans la session en cours. Au-delà d'environ 12 qubits, un badge orange indique que le circuit ne peut pas être simulé sur un ordinateur ordinaire.
La corbeille du nœud, ou la touche Suppr / Retour arrière quand il est sélectionné. Ses liens sont supprimés avec lui.
Ctrl+Z annule la dernière modification du canevas, Ctrl+Y (ou Ctrl+Maj+Z) la rétablit. Sans effet pendant la saisie dans un champ, où le Ctrl+Z du champ s'applique.
Glissez le bord d'un panneau latéral (palette, propriétés, debug, aperçu, exécution) pour l'élargir ; double-cliquez sur le bord pour revenir à la largeur par défaut. La largeur est mémorisée.
Quand d'autres membres du projet ont le workflow ouvert, leur curseur et leurs modifications de nœuds apparaissent en direct.
À la création d'un workflow, l'onglet « Modèles » propose des workflows par domaine à adapter, et l'onglet « Démo (données incluses) » des workflows prêts à lancer avec un jeu de données intégré.
Dans le panneau d'exécution en direct et sur la page d'une exécution (Projet → Exécutions).
Affiche les lignes en sortie du nœud, avec les colonnes ajoutées par l'algorithme (ex. qaoa_selected, qaoa_rank, tsp_order, sched_start, qml_prediction…). Boutons pour télécharger les lignes en CSV ou en Excel, et « Sortie brute (JSON) » pour tout le détail.
« Quantique (mesuré) » : la décision vient de mesures d'un circuit. « Méthode classique » : aucun circuit n'a été mesuré (la raison est indiquée). « Calculé à partir de vos données » ou « Circuit de démonstration » dit si vos lignes ont été utilisées. Puis : circuit, qubits, tirs, nombre de circuits mesurés pour un grand problème découpé, et les chaînes de bits les plus mesurées.
La probabilité qu'une mesure donne la meilleure solution, comparée à celle d'un tirage au hasard. Plus l'écart est grand, plus le circuit a « appris » le problème.
Le même problème est aussi résolu par une méthode classique (énumération exacte ou recuit simulé). Le résultat dit si la solution quantique est identique, de qualité égale, meilleure ou moins bonne (et de combien).
Sur la page d'une exécution d'optimisation de portefeuille : rendement attendu, volatilité et ratio de Sharpe de la solution classique et de la solution QAOA, côte à côte.
Sur une exécution en échec, l'IA lit l'erreur, la configuration du nœud fautif et un extrait de ses données d'entrée, puis propose une cause et, si elle en trouve un fiable, un correctif. « Appliquer le correctif et relancer » modifie le nœud et relance le workflow.
Nécessite un modèle d'IA disponible. Vérifiez le correctif proposé avant de l'appliquer : il modifie la configuration enregistrée du nœud.
Sur la page d'une exécution : le nombre d'enregistrements à chaque étape, les doublons retirés, les champs anonymisés et les lignes valides / invalides — pour savoir d'où vient chaque chiffre du résultat.
Le champ « params » du nœud Algorithm selector reçoit un objet JSON, par exemple { "k": 10, "layers": 3, "shots": 2000 }. Tous les paramètres sont facultatifs : sans eux, les valeurs par défaut ci-dessous s'appliquent et les colonnes sont détectées automatiquement. Une valeur hors limites est ramenée dans la plage autorisée ; un paramètre inconnu est ignoré sans message.
Ce qu'il faut comprendre avant tout le reste.
shotsDéfaut : 2000Valeurs : 100 – 100 000Pour : qaoa, qbsolv, vqe, tsp, scheduling, grover, qpe
Nombre de tirs : combien de fois le circuit est exécuté puis mesuré. Un circuit quantique donne un résultat aléatoire ; on le répète pour voir quelles réponses reviennent le plus souvent. Plus de tirs = statistiques plus fiables (on a plus de chances de croiser la meilleure solution), mais sur un vrai processeur quantique le coût est proportionnel. Sur le simulateur c'est gratuit ; 1 000 à 4 000 suffisent en général.
layersDéfaut : 3Valeurs : 1 – 8 (tsp : 1 – 4)Pour : qaoa, qbsolv, vqe, tsp, scheduling
Nombre de couches (la « profondeur » p de QAOA) : combien de fois le circuit alterne « appliquer le coût du problème » et « mélanger les solutions ». Chaque couche ajoute deux angles que l'optimiseur ajuste. Plus de couches = le circuit peut concentrer davantage la probabilité sur la meilleure solution, mais l'entraînement est plus long et, sur du vrai matériel, le bruit augmente avec la profondeur. 2 à 4 est un bon point de départ.
optimizerDéfaut : defaultValeurs : default, cobyla, nelder-mead, powell, spsaPour : qaoa, qbsolv, vqe, tsp, scheduling
Méthode classique qui règle les angles du circuit entre deux exécutions. default : la méthode propre à chaque solveur (recherche locale à pas décroissant pour QAOA, descente exacte angle par angle pour VQE). cobyla, nelder-mead, powell : méthodes sans gradient de SciPy. spsa : approximation stochastique du gradient, robuste au bruit de mesure — l'optimiseur usuel sur matériel réel.
maxIters= maxIterationsDéfaut : selon l'optimiseurValeurs : 4 – 100 000Pour : qaoa, qbsolv, vqe, tsp, scheduling
Plafond du nombre d'exécutions du circuit pour régler ses angles (réparti entre les points de départ). Plus bas = plus rapide mais angles moins bien réglés.
seedDéfaut : aléatoireValeurs : entierPour : qaoa, qbsolv, vqe, grover, qpe, montecarlo
Graine du générateur aléatoire. Fixez-la (ex. 42) pour obtenir exactement le même résultat d'une exécution à l'autre — utile pour comparer l'effet d'un autre paramètre.
Retient exactement k lignes en maximisant le bénéfice, en limitant le coût et en évitant de prendre trop de lignes d'un même groupe. Ajoute aux lignes les colonnes qaoa_selected (ou vqe_selected), _frequency et _rank. qaoa et qbsolv font exactement la même chose ; au-delà d'une douzaine de lignes, le problème est découpé en circuits de 10 qubits résolus l'un après l'autre (à la manière de QBSolv). vqe résout le même problème avec un autre circuit (rotations de Givens) ; layers y est le nombre de couches de ce circuit.
k= selectDéfaut : un tiers des lignesValeurs : 1 – (lignes − 1)Combien de lignes retenir. La contrainte est respectée par construction : chaque mesure du circuit contient exactement k lignes.
benefit= benefitColumnsDéfaut : rôles priority / weight / volume, sinon « score », sinon toutes les colonnes numériquesValeurs : nom(s) de colonne, séparés par des virgulesCe qu'on gagne à retenir une ligne. Chaque colonne est ramenée entre 0 et 1, puis on fait la moyenne.
lowerIsBetterDéfaut : aucuneValeurs : nom(s) de colonneParmi les colonnes de bénéfice, celles où une petite valeur est meilleure (délai, risque…) : elles sont inversées.
costDéfaut : rôle cost du Data MapperValeurs : nom de colonneCe que coûte une ligne (budget, durée…). Normalisé entre 0 et 1.
costWeightDéfaut : 0.5Valeurs : 0 – 5Poids du coût face au bénéfice (λ). 0 = le coût est ignoré ; 1 = un point de coût pèse autant qu'un point de bénéfice ; au-delà, le coût domine.
groupDéfaut : rôle group du Data MapperValeurs : nom de colonneCatégorie de chaque ligne (équipe, région, secteur…), utilisée pour la diversité.
diversityWeightDéfaut : 0.3 s'il y a une colonne de groupe, sinon 0Valeurs : 0 – 5Pénalité (μ) pour chaque paire de lignes retenues dans le même groupe. Plus elle est forte, plus la sélection est répartie entre les groupes. C'est ce terme qui rend le problème vraiment « quantique » (quadratique) : sans lui, un simple tri suffirait.
n_assets, risk_aversion, methodDéfaut : 5 ; 0.5 ; qaoaValeurs : 2 – 16 ; ≥ 0 ; qaoa, vqe, groverUniquement si le nœud n'a aucune donnée en amont : il optimise alors un portefeuille d'exemple de n_assets actifs générés par le moteur (le résultat le signale), par QAOA, par VQE (circuit RY + CNOT) ou par recherche adaptative de Grover. Dès que des lignes arrivent, ces paramètres sont ignorés.
Chaque ligne est une commande (16 au maximum). Le circuit choisit les commandes à charger sans dépasser la capacité en poids (et en volume si elle est donnée), en maximisant α·marge + (1−α)·priorité, chaque critère étant divisé par sa valeur maximale. Le nombre de commandes chargées découle des capacités. Colonnes lues : paramètres weight / volume / margin / priority, sinon les rôles weight, volume, value, priority, sinon une colonne dont le nom contient poids/weight/kg, volume/m3, marge/margin/profit, priorit/urgen. Ajoute load_selected et load_frequency. Algorithme : QAOA à mixeur de Grover, dont chaque tirage respecte les capacités ; référence classique : recherche exhaustive sur les 2^n chargements. Cette étape n'est pas envoyée à un QPU.
capacityWeightDéfaut : —Valeurs : > 0Capacité en poids du véhicule (obligatoire), dans l'unité de la colonne de poids.
capacityVolumeDéfaut : aucuneValeurs : > 0Capacité en volume ; absente, le volume n'est pas contraint.
alphaDéfaut : 0.5Valeurs : 0 – 1Poids de la marge ; 1 − α va à la priorité. 0,5 = équilibré, 0,15 = urgence prioritaire.
layersDéfaut : 3Valeurs : 1 – 8Profondeur du circuit QAOA ; 6 concentre davantage les tirages sur le meilleur chargement.
shotsDéfaut : 2000Valeurs : 100 – 100 000Tirs du circuit ; la réponse est le meilleur chargement mesuré.
Calcule l'ordre de passage le plus court entre les lignes, à partir de colonnes de coordonnées détectées automatiquement : x / y, ou lon (lng, longitude) / lat (latitude). Ajoute la colonne tsp_order. Jusqu'à 2 000 lignes ; au-delà de 4 villes la tournée est améliorée par fenêtres de 4 à 5 villes, chacune résolue par un circuit.
methodDéfaut : qaoaValeurs : qaoa, vqe, saqaoa : QAOA sur les permutations. vqe : part de l'ordre courant et applique des rotations exp(−iθ·T) où T échange deux positions ; les angles minimisent la longueur moyenne (chaque mesure reste une tournée valide). sa : recuit simulé classique, sans circuit (le résultat l'indique).
layersDéfaut : 3 (plafonné à 4)Valeurs : 1 – 4Profondeur du circuit QAOA de chaque fenêtre.
shotsDéfaut : 2000Valeurs : 100 – 100 000Tirs par circuit.
Chaque ligne est une tâche. La durée est lue dans une colonne dont le nom contient duration, durée, minutes, hours, heures ou _min (sinon 1 par tâche, valeurs ramenées entre 1 et 100) ; la priorité dans le rôle priority ou une colonne « priorit… » / « urgen… ». Ajoute sched_start, sched_end et sched_resource. Jusqu'à 5 000 tâches. Les dépendances entre tâches ne sont pas gérées.
nResourcesDéfaut : 3Valeurs : 1 – 64Nombre de ressources (machines, personnes…) en parallèle, de capacité 1 chacune.
layersDéfaut : 3Valeurs : 1 – 8Profondeur du circuit QAOA.
shotsDéfaut : 2000Valeurs : 100 – 100 000Tirs par circuit.
Recherche les lignes qui vérifient un critère avec l'algorithme de Grover, qui amplifie leur probabilité d'être mesurées. Ajoute grover_marked, grover_hits et grover_found.
conditionDéfaut : aucuneValeurs : expression, comme le nœud FiltreCritère de recherche, ex. item.amount > 1000 && item.status === "open".
targetCount= kDéfaut : 10 % des lignesValeurs : 1 – 25 % des lignesSans condition : on cherche les targetCount meilleures lignes selon les colonnes de bénéfice (mêmes règles que benefit ci-dessus).
iterations + forceIterationsDéfaut : nombre optimal calculéValeurs : 0 – 2000Pour imposer le nombre d'itérations de Grover (ex. { "iterations": 3, "forceIterations": true }). Sans forceIterations, la valeur est ignorée. Trop d'itérations fait redescendre la probabilité de succès.
shotsDéfaut : 2000Valeurs : 100 – 100 000Tirs.
Estime une phase φ entre 0 et 1 avec l'algorithme d'estimation de phase quantique. Par défaut, φ est la moyenne d'une colonne ramenée sur son intervalle [min, max] ; le résultat est aussi redonné dans l'unité de la colonne.
phaseDéfaut : —Valeurs : 0 ≤ φ < 1Phase à estimer directement, sans passer par les données.
columnDéfaut : première colonne numériqueValeurs : nom de colonneColonne dont la moyenne sert de phase.
precisionBitsDéfaut : 6Valeurs : 1 – 16Nombre de qubits de lecture : la précision est de 1 / 2^precisionBits (6 bits ≈ 0,016).
shotsDéfaut : 2000Valeurs : 100 – 100 000Tirs.
Charge la distribution d'une colonne dans un circuit et en estime l'espérance, la VaR et la CVaR par estimation d'amplitude quantique. Ajoute mc_in_tail (la ligne est dans la queue de distribution, ≤ VaR). Le nombre de tirs est déterminé par l'algorithme : shots n'est pas utilisé.
columnDéfaut : colonne nommée pnl, return(s), rendement, loss ou perte, sinon la première numériqueValeurs : nom de colonneSérie dont on charge l'histogramme.
confidenceDéfaut : 0.95Valeurs : 0.5 – 0.999Niveau de confiance de la VaR / CVaR.
nQubitsDéfaut : log2(nombre de lignes), entre 3 et 8Valeurs : 2 – 12Finesse de la discrétisation : la distribution est découpée en 2^nQubits intervalles.
methodDéfaut : quantumValeurs : quantum, classical, qmcquantum : estimation d'amplitude quantique. classical : Monte Carlo pseudo-aléatoire. qmc : quasi-Monte Carlo (points de Sobol brouillés), dont l'erreur décroît plus vite avec le nombre de tirages. classical et qmc tirent dans la distribution de la colonne (ou la loi normale mean / std s'il n'y a pas de colonne).
nSimulationsDéfaut : 10000Valeurs : 100 – 1 000 000Nombre de tirages des méthodes classical et qmc.
mean, stdDéfaut : 0 ; 1Valeurs : nombres (std > 0)Loi normale utilisée seulement s'il n'y a aucune colonne numérique.
Entraîne un classifieur binaire (deux classes) sur jusqu'à 150 lignes réparties dans le jeu, puis classe toutes les lignes (jusqu'à 20 000). Utilise au plus 8 colonnes de caractéristiques, numériques ou texte (le texte est encodé). Ajoute qml_label, qml_prediction et qml_probability. Le résultat est lu exactement sur le vecteur d'état : shots n'est pas utilisé.
targetColDéfaut : obligatoireValeurs : nom de colonneColonne à prédire. Si elle a deux valeurs, la plus grande est la classe positive ; si elle est numérique, la coupure est la médiane ; si c'est du texte, la classe positive est la valeur de la première ligne.
nQubitsDéfaut : min(4, nombre de caractéristiques)Valeurs : 1 – 8Nombre de qubits du circuit, un par caractéristique encodée.
nLayersDéfaut : 2Valeurs : 1 – 6Nombre de couches entraînables du circuit.
epochsDéfaut : 80 (≤ 50 lignes d'entraînement), sinon 30Valeurs : 1 – 200Nombre de passes d'entraînement. Plus = meilleur ajustement mais plus long, et risque de sur-apprentissage.
entanglementDéfaut : linearValeurs : linear, circular, full, nonePaires de qubits reliées par des CNOT à chaque couche : chaîne de voisins, anneau, toutes les paires, ou aucune.
optimizerDéfaut : spsaValeurs : spsa, gradientMéthode d'entraînement : SPSA (deux évaluations par pas, robuste au bruit) ou gradient par décalage de paramètres (exact, plus coûteux).
learningRateDéfaut : 0.01Valeurs : 0 – 1Taille des pas d'entraînement.
Dans beaucoup d'outils, la contrainte « exactement k éléments » est ajoutée au coût sous forme de pénalité, qu'il faut régler à la main. Ici ce n'est pas nécessaire : le circuit part d'une superposition de toutes les sélections valides et son mélangeur ne fait qu'échanger une ligne retenue contre une ligne écartée, si bien que chaque mesure respecte la contrainte (même principe pour les tournées et les plannings). Le paramètre « penalty » n'a donc pas d'objet et a été retiré des modèles : pour influencer le résultat, utilisez k, costWeight et diversityWeight.
Placé après un Algorithm selector, ce nœud reprend et affiche la mesure du circuit de l'algorithme (exécuté sur le simulateur du moteur). Après un Constructeur de circuit, il exécute ce circuit. Avec un backend réel, il envoie le circuit en amont au processeur quantique. Sans rien en amont, il exécute un petit circuit de démonstration (paire de Bell), signalé comme tel.
backendDéfaut : simulatorValeurs : simulator, ibm_qpu, ionq, rigetti, aws_braket, pasqalsimulator = simulateur gratuit du moteur. Les autres valeurs envoient le circuit au fournisseur choisi avec le connecteur renseigné (sans connecteur, le nœud indique « identifiants manquants » sans rien exécuter). Exception : sur IBM, une machine « fake_… » (ex. fake_torino) est une copie locale d'une vraie puce IBM, avec ses portes, ses connexions et son bruit calibré, utilisable sans compte.
shotsDéfaut : 100Valeurs : 1 – 10 000 sur le simulateurNombre de tirs pour le circuit exécuté par ce nœud (Constructeur de circuit, démo, ou circuit d'algorithme envoyé à un QPU réel). Le nombre de tirs de la simulation d'un Algorithm selector se règle dans ses propres params.
deviceDéfaut : choisi par le fournisseurValeurs : ex. ibm_torino, fake_torino, qpu.forte-1, Ankaa-3, FRESNEL, ARN BraketMachine précise. Vide : celle du connecteur, sinon la moins chargée (IBM), le simulateur d'IonQ, Ankaa-3 (Rigetti), le simulateur SV1 d'Amazon (Braket), FRESNEL (Pasqal).
connectorIdDéfaut : —Valeurs : identifiant de connecteurLe connecteur QPU contenant vos identifiants (Réglages → Connecteurs). Obligatoire pour un QPU réel.
errorMitigationDéfaut : falseValeurs : oui / nonQPU réel uniquement : twirling de Pauli et découplage dynamique sur IBM Quantum, débiaisage sur IonQ (à partir de 500 tirs). Non disponible chez les autres fournisseurs (le résultat l'indique).
Envoi d'un algorithme sur un QPU : le moteur reprend le circuit de l'Algorithm selector (le dernier, pour un problème découpé) ; le mélangeur, simulé par son exponentielle exacte, y est écrit en évolution de Suzuki-Trotter d'ordre 2 (l'écart est mesuré et affiché). Jusqu'à 12 qubits environ ; au-delà de 5 000 CNOT, rien n'est envoyé (le bruit actuel rendrait le résultat aléatoire). La décision de l'algorithme (lignes retenues, tournée…) reste celle du simulateur ; la mesure du matériel s'affiche à côté de la distribution idéale. Un travail encore en file d'attente au bout de 4 minutes peut être récupéré plus tard avec le bouton « Récupérer le résultat ».
Formulaire « Nouveau scénario » d'un projet. Les scénarios fonctionnent sur un problème d'exemple généré à partir de ces paramètres (pas sur vos données) — pour vos propres données, passez par un workflow. Le résultat affiche le circuit (bouton </>) et, si vous demandez un vrai processeur, sa mesure.
num_assetsNombre d'actifsPris en compteTaille du portefeuille d'exemple (20 au plus : un qubit par actif).
risk_factorFacteur de risquePris en compte0 = cherche le rendement, 1 = évite le risque (converti en aversion au risque de 0,1 à 10,1).
optimizerOptimiseurPris en compteQAOA ; VQE (circuit RY + CNOT entraîné) ; Grover (recherche adaptative de Grover, qui abaisse un seuil de coût tour après tour).
depthProfondeurPris en compteNombre de couches du circuit QAOA ou VQE (8 au plus).
shotsShotsPris en compteTirs par circuit (Grover mesure une fois par tour).
num_citiesNombre de villesPris en compteToutes les villes sont traitées ; au-delà de 6, la tournée est construite et améliorée par des circuits de 4 à 5 villes.
methodMéthodePris en compteQAOA ; VQE (rotations de transpositions depuis l'ordre courant) ; recuit simulé (classique, sans circuit).
max_iterationsItérations maxPris en comptePlafond d'exécutions de circuit pour régler les angles (QAOA, VQE), ou de mouvements pour le recuit simulé.
num_qubitsNombre de qubitsPris en compteFixe la taille du problème d'exemple (tickets × agents ≈ qubits, 16 au plus).
optimization_levelNiveau d'optimisationPris en compteNombre de couches du circuit QAOA (1 à 5).
backendBackendPris en compteIBM Quantum ou AWS Braket : le circuit est aussi envoyé au vrai processeur via votre connecteur ; sans connecteur, il est seulement simulé (le résultat l'indique).
shotsShotsPris en compteTirs par circuit (simulateur et matériel).
error_mitigationAtténuation d'erreursEn partieAppliquée sur IBM Quantum (twirling de Pauli + découplage dynamique). Sans objet sur le simulateur, qui n'a pas de bruit, et non disponible sur AWS Braket.
num_scenariosNombre de scénariosPris en compteNombre de tirages pour les méthodes classique et QMC ; pour l'estimation d'amplitude, fixe la finesse (log2 des scénarios, 12 qubits au plus).
confidence_levelNiveau de confiancePris en compteNiveau de la VaR / CVaR.
methodMéthodePris en compteAmplitude Estimation (quantique) ; QMC (quasi-Monte Carlo, suites de Sobol) ; Classique (Monte Carlo pseudo-aléatoire).
use_real_deviceMatériel réelPris en compteEnvoie aussi le circuit d'estimation d'amplitude au processeur de votre connecteur QPU ; sans connecteur, il est seulement simulé.
num_featuresNombre de caractéristiquesPris en compteColonnes du jeu d'exemple.
num_classesNombre de classesPris en compte2 : un classifieur. Au-delà : un circuit par classe (un-contre-tous) ; la classe prédite est la plus probable, et la précision est comparée au hasard.
ansatzAnsatzPris en compteMotif d'intrication : Strongly Entangling = toutes les paires, Basic = anneau, Hardware Efficient = chaîne de voisins.
num_layersCouchesPris en compteCouches entraînables du circuit.
epochsÉpoquesPris en comptePasses d'entraînement.
learning_rateTaux d'apprentissagePris en compteTaille des pas de l'optimiseur.
num_qubitsNombre de qubitsPris en compteNombre de variables d'un QUBO d'exemple (16 au plus), résolu par QAOA mesuré ; la solution exacte est donnée à côté.
shotsShotsPris en compteTirs du circuit.
custom_circuitFormat du circuitPris en compteLangage du code rendu : Qiskit, Cirq ou PennyLane (même circuit).