Kvantové simulátory a hostitelské aplikaceQuantum simulators and host applications

Co se naučíteWhat You'll Learn

  • Jak se spouštějí kvantové algoritmyHow quantum algorithms are executed
  • Jaké kvantové simulátory jsou součástí této verzeWhat quantum simulators are included in this release
  • Jak napsat ovladač v C# pro váš kvantový algoritmusHow to write a C# driver for your quantum algorithm

Spouštěcí model sady Quantum Development KitThe Quantum Development Kit Execution Model

V článku Jak napsat kvantový program jsme spustili kvantový algoritmus tak, že jsme předali objekt QuantumSimulator metodě Run třídy algoritmu.In Writing a quantum program, we executed our quantum algorithm by passing a QuantumSimulator object to the algorithm class's Run method. Třída QuantumSimulator provádí kvantový algoritmus úplnou simulací kvantového stavového vektoru, což je ideální pro spouštění a testování programu Teleport.The QuantumSimulator class executes the quantum algorithm by fully simulating the quantum state vector, which is perfect for running and testing Teleport. Další informace o kvantových stavových vektorech najdete v článku Průvodce koncepty.See the Concepts guide for more on quantum state vectors.

Ke spuštění kvantového algoritmu se dají použít i jiné cílové počítače.Other target machines may be used to run a quantum algorithm. Počítač odpovídá za poskytnutí implementací kvantových primitiv pro daný algoritmus.The machine is responsible for providing implementations of quantum primitives for the algorithm. Mezi ně patří primitivní operace, jako je H, CNOT a M (měření), a také nástroje pro správu a sledování qubitů.This includes primitive operations such as H, CNOT, and Measure, as well as qubit management and tracking. Různé třídy kvantových počítačů představují různé modely spuštění pro stejný kvantový algoritmus.Different classes of quantum machines represent different execution models for the same quantum algorithm.

Každý typ kvantového počítače může zajišťovat odlišnou implementaci těchto primitiv.Each type of quantum machine may provide different implementations of these primitives. Například trasovací simulátor kvantového počítače, zahrnutý ve vývojové sadě, neprovádí vůbec žádnou simulaci.For instance, the quantum computer trace simulator included in the development kit doesn't do any simulation at all. Místo toho sleduje hradla, qubity a další prostředky použité v algoritmu.Rather, it tracks gate, qubit, and other resource usage for the algorithm.

Kvantové počítačeQuantum Machines

V budoucnu budeme definovat další třídy kvantových počítačů s podporou jiných typů simulace a s podporou spouštění algoritmů na topologických kvantových počítačích.In the future, we will define additional quantum machine classes to support other types of simulation and to support execution on topological quantum computers. Díky tomu, že umožňujeme neměnnost algoritmů při změnách implementace samotného počítače, usnadňujeme testování a ladění algoritmů v simulaci a následné spouštění na reálném hardwaru s jistotou, že se algoritmus nezměnil.Allowing the algorithm to stay constant while varying the underlying machine implementation makes it easy to test and debug an algorithm in simulation and then run it on real hardware with confidence that the algorithm hasn't changed.

Co je zahrnuto v této verziWhat's Included in this Release

Tato vydaná verze kvantové vývojové sady zahrnuje několik tříd kvantových počítačů.This release of the quantum developer kit includes several quantum machine classes. Všechny jsou definovány v oboru názvů Microsoft.Quantum.Simulation.Simulators.All of them are defined in the Microsoft.Quantum.Simulation.Simulators namespace.

Vytvoření hostitelské aplikaceWriting a host application

V článku Jak napsat kvantový program jsme pro náš teleportovací algoritmus napsali jednoduchý ovladač v jazyce C#.In Writing a quantum program, we wrote a simple C# driver for our teleport algorithm. Ovladač C# má 4 hlavní úkoly:A C# driver has 4 main purposes:

  • Sestavení cílového počítačeConstructing the target machine
  • Výpočet všech argumentů vyžadovaných pro kvantový algoritmusComputing any arguments required for the quantum algorithm
  • Spuštění kvantového algoritmu v simulátoruRunning the quantum algorithm using the simulator
  • Zpracování výsledku operaceProcessing the result of the operation

Teď se podíváme na každý krok podrobněji.Here we'll discuss each step in more detail.

Sestavení cílového počítačeConstructing the Target Machine

Kvantové počítače jsou instancemi normálních tříd .NET, takže jsou vytvořeny vyvoláním jejich konstruktoru stejně jako u jakékoli jiné třídy .NET.Quantum machines are instances of normal .NET classes, so they are created by invoking their constructor, just like any .NET class. Některé simulátory, včetně QuantumSimulator, implementují rozhraní .NET System.IDisposable, a proto je třeba je zabalit do příkazu C# using.Some simulators, including the QuantumSimulator, implement the .NET System.IDisposable interface, and so should be wrapped in a C# using statement.

Výpočet argumentů pro algoritmusComputing Arguments for the Algorithm

V našem příkladu Teleport jsme vypočítali některé poměrně umělé argumenty, které předáme našemu kvantovému algoritmu.In our Teleport example, we computed some relatively artificial arguments to pass to our quantum algorithm. Častěji ale kvantový algoritmus vyžaduje mnoho vstupních dat a je jednodušší poskytnout mu je z klasického ovladače.More typically, however, there is significant data required by the quantum algorithm, and it is easiest to provide it from the classical driver.

Například u chemických simulací vyžaduje kvantový algoritmus velké tabulky integrálů molekulárních orbitálních interakcí.For instance, when doing chemical simulations, the quantum algorithm requires a large table of molecular orbital interaction integrals. Obecně se načítají ze souboru, který je k dispozici při spuštění algoritmu.Generally these are read in from a file that is provided when running the algorithm. Protože jazyk Q# nemá mechanismy pro přístup k systému souborů, je shromáždění takovýchto dat a jejich předání metodě Run kvantového algoritmu úlohou pro klasický ovladač.Since Q# does not have a mechanism for accessing the file system, this sort of data is best collected by the classical driver and then passed to the quantum algorithm's Run method.

Další případ, kdy klasický ovladač hraje klíčovou roli, je u variačních metod.Another case where the classical driver plays a key role is in variational methods. V této třídě algoritmů se kvantový stav připravuje na základě klasických parametrů, a teprve tento stav se pak použije k výpočtu požadované výsledné hodnoty.In this class of algorithms, a quantum state is prepared based on some classical parameters, and that state is used to compute some value of interest. Parametry se pak upraví na základě určitého gradientního algoritmu nebo strojového učení a kvantový výpočet se spustí znovu.The parameters are adjusted based on some type of hill climbing or machine learning algorithm and the quantum algorithm run again. V takových případech je nejlepší implementovat samotný gradientní algoritmus čistě klasicky a volat ho z klasického ovladače. Výsledky gradientního algoritmu se pak předají k dalšímu výpočtu kvantovému algoritmu.For such algorithms, the hill climbing algorithm itself is best implemented as a purely classical function that is called by the classical driver; the results of the hill climbing are then passed to the next execution of the quantum algorithm.

Spuštění kvantového algoritmuRunning the Quantum Algorithm

Tato část je obecně velmi přímočará.This part is generally very straightforward. Každá operace Q# se zkompiluje do třídy, která poskytuje statickou metodu Run.Each Q# operation is compiled into a class that provides a static Run method. Argumenty se této metodě předávají jako zploštěná řazená kolekce argumentů samotné operace, plus dodatečný první argument, který specifikuje požadovaný simulátor.The arguments to this method are given by the flattened argument tuple of the operation itself, plus an additional first argument which is the simulator to execute with. Pro operaci, která očekává pojmenovanou řazenou kolekci členů typu (a: String, (b: Double, c: Double)) bude mít její zploštěný protějšek typ (String a, Double b, Double c).For an operation that expects the named tuple of type (a: String, (b: Double, c: Double)) its flattened counterpart is of type (String a, Double b, Double c).

Při předávání argumentů metodě Run je třeba brát v úvahu určité detaily:There are some subtleties when passing arguments to a Run method:

  • Pole musí být vždy zabalena v objektu Microsoft.Quantum.Simulation.Core.QArray<T>.Arrays must be wrapped in a Microsoft.Quantum.Simulation.Core.QArray<T> object. Třída QArray má konstruktor, kterému je možné předat jakoukoli uspořádanou kolekci vhodných objektů (IEnumerable<T>).A QArray class has a constructor that can take any ordered collection (IEnumerable<T>) of appropriate objects.
  • Prázdná řazená kolekce členů, () v jazyce Q#, je v C# reprezentována výrazem QVoid.Instance.The empty tuple, () in Q#, is represented by QVoid.Instance in C#.
  • Neprázdné řazené kolekce členů jsou reprezentovány jako .NET instance ValueTuple.Non-empty tuples are represented as .NET ValueTuple instances.
  • Uživatelem definované typy se v Q# předávají jako jejich základní typy.Q# user-defined types are passed as their base type.
  • Chcete-li metodě Run předat operaci nebo funkci, musíte získat instanci třídy operace nebo funkce pomocí metody Get<> simulátoru.To pass an operation or a function to a Run method, you have to obtain an instance of the operation's or function's class, using the simulator's Get<> method.

Zpracování výsledkůProcessing the Results

Výsledek kvantového výpočtu je vrácen v návratové hodnotě metody Run.The results of the quantum algorithm are returned from the Run method. Metoda Run se spouští asynchronně a proto vrací instanci třídy Task<TResult>.The Run method executes asynchronously thus it returns an instance of Task<TResult>. Samotné výsledky operace je možné získat několika způsoby.There are multiple ways to get the actual operation's results. Nejjednodušší je použít z třídy Task vlastnost Result:The simplest is by using the Task's Result property:

    var res = BellTest.Run(sim, 1000, initial).Result;

ale fungovat budou i jiné techniky, třeba použití metody Wait nebo klíčového slova C# await.but other techniques, like using the Wait method or C# await keyword will also work.

Stejně jako u argumentů jsou v Q# řazené kolekce členů reprezentovány jako instance ValueTuple a pole jako instance QArray.As with arguments, Q# tuples are represented as ValueTuple instances and Q# arrays are represented as QArray instances. Uživatelem definované typy se vracejí jako jejich základní typy.User-defined types are returned as their base types. Prázdná řazená kolekce členů () se vrací jako instance třídy QVoid.The empty tuple, (), is returned as an instance of the QVoid class.

Mnoho kvantových algoritmů vyžaduje k získání smysluplné odpovědi podstatné zpracování výsledků.Many quantum algorithms require substantial post-processing to derive useful answers. Například kvantová část Shorova algoritmu je jen začátkem náročného výpočtu, který najde samotný rozklad čísla.For instance, the quantum part of Shor's algorithm is just the beginning of a computation that finds the factors of a number.

Ve většině případů je jednodušší a snazší tento typ výpočtů provádět v klasickém ovladači.In most cases, it is simplest and easiest to do this sort of post-processing in the classical driver. Pouze klasický ovladač může tyto výsledky zobrazit uživateli a zapsat je na disk.Only the classical driver can report results to the user or write them to disk. Klasický ovladač bude mít také přístup k analytickým knihovnám a dalším matematickým funkcím, které nejsou v Q# dostupné.The classical driver will have access to analytical libraries and other mathematical functions that are not exposed in Q#.

SelháníFailures

Když se při provádění operace narazí na příkaz fail jazyka Q#, vyvolá se výjimka ExecutionFailException.When the Q# fail statement is reached during the execution of an operation, an ExecutionFailException is thrown.

Vzhledem k použití třídy System.Task v metodě Run se výjimka vyvolaná v důsledku příkazu fail zabalí do objektu System.AggregateException.Due to the use of System.Task in the Run method, the exception thrown as a result of a fail statement will be wrapped into a System.AggregateException. Chcete-li zjistit skutečnou příčinu selhání, je třeba iterovat přes
InnerExceptions objektu AggregateException, například:
To find the actual reason for the failure, you need to iterate into the AggregateException InnerExceptions, for example:


            try
            {
                using(var sim = new QuantumSimulator())
                {
                    /// call your operations here...
                }
            }
            catch (AggregateException e)
            {
                // Unwrap AggregateException to get the message from Q# fail statement.
                // Go through all inner exceptions.
                foreach (Exception inner in e.InnerExceptions)
                {
                    // If the exception of type ExecutionFailException
                    if (inner is ExecutionFailException failException)
                    {
                        // Print the message it contains
                        Console.WriteLine($" {failException.Message}");
                    }
                }
            }

Další klasické jazykyOther Classical Languages

Uvedené příklady jsou sice v C#, F# a Pythonu, ale Quantum Development Kit podporuje psaní klasických hostitelů i v jiných jazycích.While the samples we have provided are in C#, F#, and Python, the Quantum Development Kit also supports writing classical host programs in other languages. Například když budete chtít napsat hostitelský program ve Visual Basicu, není to žádný problém.For example, if you want to write a host program in Visual Basic, it should work just fine.