Référence de l'API Kipu Quantum Iskay Quantum Optimizer

Qiskit Functions
Qiskit Functions — des outils prêts à l'emploi développés par des organisations partenaires — permettent d'abstraire certaines étapes du processus de développement logiciel afin de simplifier et d'accélérer la découverte d'algorithmes et le développement d'applications à grande échelle. Cliquez ici pour consulter le guide de cette fonction Qiskit.
Guide des fonctions Qiskit d'Iskay Quantum Optimizer

Entrées

`problem`

Type: Dict[str, float]

Les coefficients du problème d'optimisation formulé sous forme de QUBO/HUBO ou au format spin. Pour plus d'informations sur la description du problème, consultez la section « Formats de problèmes acceptés ».

Obligatoire : oui
Exemple:{"()": -21.0, "(0, 4)": 0.5,"(0, 2)": 0.5,"(0, 1)": 0.5,"(1, 3)": 0.5}

`problem_type`

Type: str

Précisez si les coefficients du problème sont au format binaire (QUBO/HUBO) ou au format spin. Les deux possibilités sont "spin" ou "binary". Pour plus d'informations sur la description du problème, consultez la section « Formats de problèmes acceptés ».

Obligatoire : oui
Exemple:"spin"

`backend_name`

Type: str

Nom du backend sur lequel effectuer la requête

Obligatoire : oui
Exemple:"ibm_fez"

Options

Type: Dict[str, Any]

Options permettant de gérer les paramètres matériels, comme le nombre de prises. Les options de cette fonction sont définies sous la forme d'un dictionnaire imbriqué. Consultez la liste complète des options et leurs valeurs par défaut.

Obligatoire : Non
Exemple:{"shots": 5000, "num_iterations": 3, "use_session": True, "seed_transpiler": 42}

Formats de problèmes acceptés

Les problem``problem_type arguments et codent un problème d'optimisation de la forme

\begin{align} \min_{(x_1, x_2, \ldots, x_n) \in D} C(x_1, x_2, \ldots, x_n) \nonumber \end{align}

où

C(x_1, ... , x_n) = a + \sum_{i} b_i x_i + \sum_{i, j} c_{i, j} x_i x_j + ... + \sum_{k_1, ..., k_m} g_{k_1, ..., k_m} x_{k_1} ... x_{k_m}

En choisissant problem_type = "binary", vous indiquez que la fonction de coût est au binary format, ce qui signifie que $D = \{0, 1\}^{n}$ , c'est-à-dire que la fonction de coût est écrite sous forme QUBO/HUBO.
D'autre part, en choisissant problem_type = "spin", la fonction de coût s'écrit sous la forme d'Ising, où l' $D = \{-1, 1\}^{n}$

Les coefficients du problème doivent être encodés dans un dictionnaire comme suit :

\begin{align} \nonumber &\texttt{\{} \\ \nonumber &\texttt{"()"}&: \quad &a, \\ \nonumber &\texttt{"(i,)"}&: \quad &b_i, \\ \nonumber &\texttt{"(i, j)"}&: \quad &c_{i, j}, \\ \nonumber &\quad \vdots \\ \nonumber &\texttt{"(} k_1, ..., k_m \texttt{)"} &: \quad &g_{k_1, ..., k_m}, \\ \nonumber &\texttt{\}} \end{align}

Veuillez noter que les clés du dictionnaire doivent être des chaînes de caractères contenant un tuple valide d'entiers distincts.

Liste des options

Iskay offre des possibilités de réglage fin grâce à des paramètres optionnels. Bien que les paramètres par défaut conviennent à la plupart des cas, vous pouvez personnaliser le comportement en fonction de besoins spécifiques :

`shots`

Type: `int`

Valeur par défaut: 10000

Nombre de mesures quantiques par itération (plus ce chiffre est élevé, plus la précision est grande)

`num_iterations`

Type: `int`

Valeur par défaut: 10

Nombre d'itérations de l'algorithme (un nombre plus élevé d'itérations peut améliorer la qualité de la solution)

`use_session`

Type: `bool`

Valeur par défaut: True

Utilisez les sessions « IBM » pour réduire les temps d'attente

`seed_transpiler`

Type: `int`

Valeur par défaut: None

Ensemble destiné à la compilation reproductible de circuits quantiques.

Optimisation de la graine : notez que seed_transpiler est défini sur None par défaut. Cela permet au transpileur d'effectuer son processus d'optimisation automatique. Dans ce cas None, le système lancera un essai avec plusieurs valeurs de départ et sélectionnera celle qui produit la meilleure profondeur de circuit, en exploitant pleinement la puissance du max_trials paramètre pour chaque niveau de transpilation.

`direct_qubit_mapping`

Type: `bool`

Valeur par défaut: False

Mettre en correspondance directe les qubits virtuels avec les num_qubits physiques

`job_tags`

Type: `List[str]`

Valeur par défaut: None

Balises personnalisées pour le suivi des tâches

`preprocessing_level`

Type: `int`

Valeur par défaut: 0

Intensité du prétraitement du problème (0-3).

Niveaux de prétraitement (0-3) : particulièrement importants pour les problèmes de grande envergure qui ne peuvent actuellement pas tenir dans les temps de cohérence du matériel. Des niveaux de prétraitement plus élevés permettent d'obtenir des circuits moins profonds grâce à des approximations lors de la transposition du problème :

Niveau 0 : Circuits précis et plus longs
Niveau 1 : Bon équilibre entre précision et approximation, en ne retenant que les portes dont les angles se situent dans le décile inférieur
Niveau 2 : Approximation légèrement plus précise, consistant à exclure les portes dont les angles se situent dans le 20e centile inférieur et à utiliser approximation_degree=0.95 lors de la transpilation
Niveau 3 : Niveau d'approximation maximal, en supprimant les portes du 30e centile inférieur et en utilisant approximation_degree=0.90 lors de la transpilation

`postprocessing_level`

Type: `int`

Valeur par défaut: 2

Niveau de précision de la solution (0-2).

Niveaux de post-traitement (0-2) : permet de contrôler l'intensité de l'optimisation classique, en compensant les erreurs de permutation de bits à l'aide d'un nombre variable de passes gloutonnes d'une recherche locale :

Niveau 0 : 1 passage
Niveau 1 : 2 passages
Niveau 2 : 3 passages

`transpilation_level`

Type: `int`

Valeur par défaut: 0

Essais d'optimisation du transpileur (0-5).

Niveaux de transpilation (0-5) : permet de contrôler les essais d'optimisation avancés du transpileur pour la compilation des circuits quantiques. Cela peut entraîner une augmentation de la charge de gestion classique et, dans certains cas, cela peut ne pas modifier la profondeur du circuit. La valeur par 2 défaut permet généralement d'obtenir le circuit le plus petit et est relativement rapide.

Niveau 0 : Optimisation du circuit DCQO décomposé (disposition, routage, planification)
Niveau 1 : Optimisation du PauliEvolutionGate circuit DCQO décomposé ( max_trials=10 )
Niveau 2 : Optimisation du PauliEvolutionGate circuit DCQO décomposé ( max_trials=15 )
Niveau 3 : Optimisation du PauliEvolutionGate circuit DCQO décomposé ( max_trials=20 )
Niveau 4 : Optimisation du PauliEvolutionGate circuit DCQO décomposé ( max_trials=25 )
Niveau 5 : Optimisation du PauliEvolutionGate circuit DCQO décomposé ( max_trials=50 )

`transpile_only`

Type: `bool`

Valeur par défaut: False

Disponible pour les utilisateurs qui souhaitent analyser l'optimisation des circuits sans lancer l'exécution complète de l'algorithme quantique. Utile pour l'analyse de circuits, les études d'optimisation de la profondeur et la compréhension des effets de la transpilation avant de passer à l'exécution complète.

Performances au niveau de la transpilation

Augmenter le nombre de max_trials en attribuant des valeurs plus élevées à transpilation_level allongera inévitablement le temps de transpilation, mais cela ne modifiera pas forcément le circuit final : cela dépend fortement de la structure et de la complexité spécifiques du circuit. Pour certains circuits ou problèmes, cependant, la différence entre 10 essais (niveau 1) et 50 essais (niveau 5) peut être considérable; il peut donc s'avérer essentiel d'explorer ces paramètres pour parvenir à trouver une solution.

Sortie

Type: `Dict[str, Any]`

Solution et métadonnées. La structure varie en fonction de transpile_only l'option choisie.

Dictionnaire des résultats

La structure du dictionnaire de résultats dépend du mode d'exécution :

`solution`

Type: `Dict[str, int]`

La solution sous forme de table triée, où les clés sont des indices de variables (sous forme de chaînes de caractères) classés par ordre numérique, et où les valeurs sont les valeurs correspondantes des variables (1/-1 pour les problèmes de spin, 1/0 pour les problèmes binaires).

Mode : Standard
Exemple:{'0': -1, '1': -1, '2': -1, '3': 1, '4': 1}

`solution_info`

Type: `Dict[str, Any]`

Informations détaillées sur la solution.

Mode : Standard
Exemple:{'bitstring': '11100', 'cost': -13.8, 'seed_transpiler': 42, 'mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}}
Exécution standard : lorsque le paramètre facultatif est transpile_only=False spécifié, voir le dictionnaire ci-dessous.

`bitstring`

Type: `str`

La représentation sous forme de chaîne de bits bruts de la solution.

`cost`

Type: `float`

Le rapport coût/efficacité énergétique de la solution.

`seed_transpiler`

Type: `int`

La graine aléatoire utilisée pour le transpileur qui a généré ce résultat.

`mapping`

Type: `Dict[int, int]`

La correspondance initiale entre les qubits et les variables utilisée dans le calcul.

`qpu_time`

Type: `float`, optional

Le temps d'exécution de la QPU en secondes.

Notes sur le mappage des variables

Le solution dictionnaire est dérivé de la chaîne de bits de la solution, en utilisant mapping l'objet pour indexer les variables.
Lorsque problem_type=spin nous utilisons l' $1 \rightarrow -1, \quad 0 \rightarrow 1$ d'affectation.
Les clés du dictionnaire de solutions sont des indices de variables classés par ordre numérique sous forme de chaînes de caractères.

`prob_type`

Type: `str`

Le type de problème d'optimisation (spin ou binary)

Mode : Standard
Exemple:'spin'

`transpilation_info`

Type: `Dict[str, Any]`

Analyse du circuit et détails de la transcompilation.

Mode : Transpilation uniquement
Exemple:{'best_seed': 42, 'transpilation_time_seconds': 50.06, 'transpiled_circuit': {'depth': 576, 'gate_count': 4177, 'num_qubits': 156, 'width': 176, 'operations': {'sx': 1325, 'rx': 891, 'cz': 783, 'rz': 650, 'rzz': 466, 'x': 42, 'measure': 20}}}
Analyse de la transpilation : lorsque le paramètre facultatif transpile_only=Trueest utilisé, consultez le dictionnaire ci-dessous :

`best_seed`

Type: `int`

La graine optimale identifiée pour la transplantation.

`transpilation_time_seconds`

Type: `float`

Durée du processus de transpilation.

`transpiled_circuit`

Type: `Dict`

Analyse de circuit comprenant les éléments suivants :

depth

Type: `int`

Épaisseur du circuit (nombre de couches)

gate_count

Type: `int`

Nombre total de portes dans le circuit.

num_qubits

Type: `int`

Nombre de qubits utilisés.

width

Type: `int`

Largeur du circuit.

operations

Type: `Dict[str, int]`

Nombre de chaque type de porte utilisé.

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.