CUDA-Q de NVIDIA ara potencialitza l'emulació de GPU dins de QiliSDK, ampliant l'enfocament multimodal únic de Qilimanjaro a través de backends clàssics i quàntics, des de CPU i GPU fins a QPU analògiques i digitals.
La majoria del programari quàntic s'executa en un sol tipus de maquinari quàntic, utilitzant el paradigma digital o analògic, o en emuladors de CPU/GPU. QiliSDK els abasta tots. S'executa a través d'una varietat de backends: CPU, GPU, QPUs digitals (dQPU) i les QPUs analògiques de Qilimanjaro (aQPU). Aquesta és la multimodalitat des de la qual Qilimanjaro està construint, i la visió que hi ha al darrere: que la coexistència de modalitats serà el futur de la supercomputació.
QiliSDK és el marc de Python de Qilimanjaro per desenvolupar, executar i emular algoritmes quàntics digitals i analògics. El seu disseny modular facilita la creació de prototips de circuits, la construcció d'Hamiltonians, el disseny de fluxos de treball variacionals i models de reservori quàntics, i la seva implementació en plataformes locals o remotes, clàssiques o quàntiques. El mateix programa d'alt nivell pot dirigir-se a una CPU d'ordinador portàtil, una GPU, una QPU digital o una QPU analògica de Qilimanjaro a través del núvol SpeQtrum i instal·lacions in situ.
Avui hi afegim un nou backend a aquest conjunt: un backend de GPU amb tecnologia NVIDIA CUDA-Q, construït per a l'emulació a escala de producció de fluxos de treball quàntics en maquinari clàssic, incloent l'emulació de vectors d'estat i xarxes de tensors. Res més al codi base canvia.
El fragment següent il·lustra com un usuari pot crear una evolució analògica i després enviar-la per a l'emulació de GPU:
from qilisdk.analog import Schedule, X, Y, Z
from qilisdk.backends import CudaBackend
from qilisdk.core import QTensor
from qilisdk.functionals import AnalogEvolution
from qilisdk.readout import Readout
Exemple senzill d'annealment quàntic #
nqubits = 2
driver = -sum(X(i) for i in range(nqubits))
problem = sum(Z(i)*Z(i+1) for i in range(nqubits-1))
analog_functional = AnalogEvolution(
schedule=Schedule.linear(driver, problem, total_time=10, dt=0.1),
initial_state=QTensor.uniform(nqubits))
analog_readout = Readout().with_expectation(observables=[problem])
# Execució en el backend de GPU CUDA-Q
cuda_backend = CudaBackend()
analog_result = cuda_backend.execute(analog_functional, analog_readout)
print(analog_result)
Això crea un exemple simple d'annealing quàntic: una rampa lineal entre un Hamiltonià inicial 
a un Hamiltonià final 
, aquí només per a dos qubits. Començant en l'estat fonamental de l'Hamiltonià inicial i fent una transició lenta a l'final, el teorema adiabàtic garanties que romanguem en l'estat fonamental, sempre que l'evolució sigui lenta en comparació amb la separació entre l'estat fonamental i el primer estat excitat. Això ens porta a l'estat fonamental de l'Hamiltonià del nostre problema, que és la solució que busquem. Aquí dóna correctament -1 com la nostra energia final, com seria d'esperar en intentar minimitzar Z0 Z1.
Emulació clàssica com a capa de desenvolupament
L'emulació clàssica és una part permanent de com treballen els equips quàntics. Abans d'executar res en maquinari real, els equips utilitzen l'emulació per prototipar circuits, estudiar el comportament del sistema, caracteritzar el soroll i establir els punts de referència amb què es mesuren els resultats quàntics. També s'encarrega del costat clàssic dels fluxos de treball híbrids, el pre- i postprocessament que envolta cada trucada quàntica. Construir sense ella no és una opció realista en cap etapa del desenvolupament.
Per què les GPU de NVIDIA brillen per emular fluxos de treball quàntics en sistemes clàssics
La pregunta aleshores és com executar aquesta emulació de manera eficient. Emular un flux de treball quàntic en un ordinador clàssic significa fer un seguiment de l'estat quàntic complet, la mida del qual creix exponencialment amb el nombre de qubits. En una CPU, això es manté pràctic fins a uns 25 qubits abans que la memòria i l'ample de banda esdevinguin límits rígids; més enllà, els temps d'execució pugen de segons a hores. Les GPU, amb els seus amplis busos de memòria, la seva aritmètica massivament paral·lela i les seves topologies NVLink multi-GPU, són l'estat de l'art actual per a aquest tipus de càrregues de treball. Aquestes empenyen la frontera pràctica del vector d'estat fins als 30 qubits en un sol node, i molt més enllà quan intervenen mètodes de xarxa tensorial o de memòria distribuïda. CUDA-Q de NVIDIA és, avui dia, la manera més productiva d'aprofitar aquestes GPU: un model net basat en nuclis que es mapeja directament sobre el maquinari de NVIDIA, motors d'estat vectorial i de xarxa tensorial ben provats, i execució multi-GPU i multi-node de sèrie.
CUDA-Q com la capa de GPU
CUDA-Q de NVIDIA és, avui dia, la manera més eficient d'adreçar les GPU per a l'emulació quàntica. Exposa un model net basat en nuclis que s'assigna directament al maquinari de NVIDIA. CUDA-Q també integra motors d'estat vectorial i de xarxa tensorial ben provats, admet l'execució multi-GPU i multi-node, i és adoptat activament per l'ecosistema més ampli de programari quàntic. En resum, CUDA-Q és una plataforma de desenvolupament quàntic de codi obert que orquestra el maquinari i el programari necessaris per executar simulacions útils a gran escala. computació quàntica CUDA-Q agilitza el desenvolupament d'aplicacions híbrides i promou la productivitat i l'escalabilitat en la computació quàntica. Ofereix un model de programació unificat dissenyat per a un entorn híbrid, és a dir, CPU, GPU i QPU treballant plegats. CUDA-Q inclou suport per a la programació en Python i en C++.
En lloc de reinventar la integració de GPU, QiliSDK empaqueta CUDA-Q com a backend, de manera que els usuaris obtenen un rendiment de nivell NVIDIA sense haver d'escriure codi CUDA-Q ells mateixos.
Backend CUDA-Q a QiliSDK
QiliSDK exposa CUDA-Q a través d'una única classe: CudaBackend. En el moment de la construcció, l'usuari tria un mètode d'emulació i, opcionalment, hi adjunta un model de soroll.
Figura 1: Diagrama de la integració de la classe CudaBackend a QiliSDK que inclou destinacions del backend CUDA-Q i el model de soroll.
El backend, llavors, auto-configura el CUDA-Q subjacent: per vector d'estat emulació que utilitza el Nvidia objectiu amb precisió fp32 o fp64 quan es detecta una GPU, nvidia-mgpu quan hi ha diverses GPU disponibles, o es recupera a la CPU en cas contrari; xarxa tensorial Rutes cap a CUDA-Q tensornet motor per a la contracció completa de xarxes tensors; i estat de producte de matriu rutes a la tensornet-mps objectiu, que aprofita l'estructura 1D MPS amb truncament de dimensió de bon per mantenir circuits poc profunds o de baixa entanglemenc barats; i els fluxos de treball analògics canvien CUDA-Q al seu dinàmica objectiu. El mateix objecte CudaBackend cobreix, per tant, els motors d'estat vectorial d'un sol GPU, d'emulació agrupada de diversos GPU, de xarxa tensorial i d'estat de producte matricial, i la dinàmica de sistemes oberts.
Per circuits digitals, CudaBackend construeix un cudaq.Kernel, transpila portes multientretesades a la seva forma nativa i assigna cada porta QiliSDK a través de funcions de gestió dedicades al seu equivalent CUDA-Q, acabant ja sigui mostrejant eficientment de l'estat o retornant l'estat complet final del sistema. Per flossos analògics compila els Hamiltonians dependents del temps de l'horari en CUDA-Q SumaOperador, els mapes dels operadors de Pauli directament sobre girar.x/y/z/i, i s'executa cudaq.evolve sobre la quadrícula de temps de l'horari.
Si l'usuari vol una emulació sorollosa, pot proporcionar un QiliSDK NoiseModel, que es converteix en un cudaq.NoiseModel`: els canals flip de bit, flip de fase i despolaritzadors es mapegen a les seves contraparts natives eficients de CUDA-Q, mentre que els canals més expressius basats en Kraus i Lindblad es mapegen als canals de soroll generals de CUDA-Q. El soroll es pot registrar globalment, per tipus de porta, per qubit o per parella (porta, qubit). També hi ha disponibles pertorbacions de paràmetres i errors d'assignació de lectura (és a dir, p01/p10), i es gestionen com a pre/post processament.
Per resumir, l'usuari pot escriure el seu flux de treball quàntic com a codi QiliSDK d'alt nivell, que després es converteix automàticament en una representació optimitzada que es pot executar de manera eficient en GPU NVIDIA.
Rendiment de QiliSDK CudaBackend
El backend Cuda de QiliSDK es escala eficientment des d'un sol GPU a l'execució multi-GPU, com il·lustren els següents punts de referència. Considerem el mateix cas que en l'exemple anterior: una tasca d'annealing d'un Hamiltonian X a un Hamiltonian ZZ. Ho fem dividint l'evolució en 100 passos i, a continuació, prenent 1.000 mostres de l'estat final. Tot i que es tracta d'una evolució analògica, es pot emular en maquinari digital utilitzant la trotzerització. En primer lloc, trotzeritzant i, a continuació, emulant mitjançant els diversos mètodes d'emulació digitals de CudaBackend, observem un gran rendiment d'escalabilitat tant en configuracions d'una sola GPU com de múltiples GPU.
Figura 2: Resultats de benchmarking per a una tasca de recuit senzilla, que mostra el temps necessari per realitzar l’evolució en funció del nombre de qubits del problema. Els resultats mostren com el CudaBackend de QiliSDK pot aprofitar múltiples GPU NVIDIA per escalar eficientment les emulacions fins a 30 qubits.
Per aprofitar al màxim la pila de programari CUDA-Q, es pot utilitzar el backend NVIDIA Dynamics per realitzar l'evolució directament. Seguir aquest enfocament ofereix un rendiment significativament millor que l'emulació digital de Trotterització:
Figura 3: BResultats de benchmarking per a una tasca senzilla d'annealing, que mostren el temps necessari per realitzar l'evolució en funció del nombre de qubits del problema. CudaBackend de QiliSDK utilitzant Dynamics supera significativament les evolucions digitals trotteritzades.
Portant el rendiment de CUDA-Q a QiliSDK
QiliSDK ara executa circuits digitals, fluxos de treball quàntics analògics i tot el que hi ha al mig en una única base de codi, a través de backends de CPU, GPU i QPU. La integració CUDA-Q afegeix acceleració de GPU a aquest conjunt sense requerir cap canvi en els programes existents. El mateix codi que s'executa en un portàtil també s'executa en un clúster de múltiples GPU.
Aquesta és la pila cap a la qual Qilimanjaro està construint: una en què els límits entre l'execució clàssica i quàntica els gestiona el programari, no l'usuari.
