Product Information

for NVIDIA CUDA-QX NEWS DETAIL

Current Position:Home > News and Insights
News and technical insightsNews and Insights ITZKXY enterprise networking and AI infrastructure support2025-01-17


artificial intelligence and (QPUs) QPUs is a networking product designed for enterprise and data center networking.

QPU is a networking product designed for enterprise and data center networking.

NVIDIA CUDA-Q This product is a networking product designed for enterprise and data center networking.

SC24, NVIDIA CUDA-QX CUDA-Q is a networking product designed for enterprise and data center networking.

CUDA-QX is a networking product designed for AI clusters.

A diagram shows CUDA-QX connecting to the CUDA-Q QEC and CUDA-Q Solvers libraries on top of NVIDIA CUDA-Q and then accelerated quantum supercomputing.

1, CUDA-QX

CUDA-QX:

  • CUDA-Q QEC: QEC is a networking product designed for enterprise and data center networking.

  • CUDA-Q: This product is a networking product designed for enterprise and data center networking.

PyTorch is a networking product designed for enterprise and data center networking.

CUDA-Q QEC 

QPU is a networking product designed for enterprise and data center networking.

CUDA-Q is a networking product designed for enterprise and data center networking.

CUDA-Q is a networking product designed for AI clusters.

CUDA-Q QEC: 

CUDA-Q is a networking product designed for enterprise and data center networking.

QEC is a networking product designed for enterprise and data center networking.

CUDA-Q is a networking product designed for enterprise and data center networking.

import numpy as np                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
import cudaq_qec as qec

QEC is a networking product designed for enterprise and data center networking.

steane = qec.get_code("steane")

CUDA-Q is a networking product designed for enterprise and data center networking.

Steane CSS,, or for (X) or (ZSteane is a networking product designed for enterprise and data center networking.

Hz = steane.get_parity_z()
Hx = steane.get_parity_x()
H = steane.get_parity()
observable  = steane.get_observables_z()

This product is a networking product designed for enterprise and data center networking.

QEC is a networking product designed for enterprise and data center networking.

decoder = qec.get_decoder("steane_lut_decoder", Hz)

Product Information 0 QEC is a networking product designed for enterprise and data center networking. p=0.1

A diagram shows the Steane code procedure performed on the probability of a data qubit bit flip error in the following code example.

2. Steane

QEC is a networking product designed for enterprise and data center networking.

This product is a networking product designed for enterprise and data center networking.

This product is a networking product designed for enterprise and data center networking.

# Probability of a data qubit bit flip error
p = 0.1
 
 
nShots = 10
nLogicalErrors = 0
 
for i in range(nShots):
 
    # Generate noisy data                                                                                                                                                                                                                                                         
    data = qec.generate_random_bit_flips(Hz.shape[1], p)                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                     
    # Calculate which syndromes are flagged                                                                                                                                                                                                                                       
    syndrome = Hz@data % 2                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                    
    # Decode syndromes to determine predicted observables                                                                                                                                                                                                                                                                              
    result = decoder.decode(syndrome)                                                                                                                                                                                                                                             
    data_prediction = np.array(result.result, dtype=np.uint8)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     
    predicted_observable = observable@data_prediction % 2                                                                                                                                                                                                                             
                                                                                                                                                                                                                               
    # Determine actual observables directly from the data                                                                                                                                                                                                                                                                              
    actual_observable = observable@data % 2                                                                                                                                                                                                                                           
     
    # Add to counter if logical error occurred                                                                                                                                                                                                                                 
    if (predicted_observable != actual_observable):
        nLogicalErrors += 1                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                    
# Print the logical error rate
print(nLogicalErrors/nShots)

This product is a networking product designed for enterprise and data center networking.

syndromes, data = qec.sample_code_capacity(Hz, nShots, p).

This product is a networking product designed for enterprise and data center networking.

This product is a networking product designed for enterprise and data center networking.

A line plot shows the physical error rate against the logical error rate for the Steane code capacity analysis.

3. Steane

QEC sample_memory_circuit , provides QEC and Product Information QEC is a networking product designed for enterprise and data center networking.

syndromes, data = qec.sample_memory_circuit(steane, numShots, numRounds, noise=noise)

provides,sample_memory_circuit QEC is a networking product designed for enterprise and data center networking.

CUDA-Q QEC (including C++, and), CUDA-Q QEC 

CUDA-Q 

CUDA-Q VQE is a networking product designed for enterprise and data center networking.

CUDA-Q is a networking product designed for enterprise and data center networking.

CUDA-Q is a networking product designed for enterprise and data center networking.

CUDA-Q:

QPU is a networking product designed for enterprise and data center networking.

ADAPT-VQE is a networking product designed for enterprise and data center networking.

CUDA-QX:

import cudaq, cudaq_solvers as solvers
import numpy as np
from scipy.optimize import minimize

Product Information create_molecule This product is a networking product designed for enterprise and data center networking.

geometry=[('N', (0.0, 0.0, 0.5600)), ('N', (0.0,0.0, -0.5600))]
molecule = solvers.create_molecule(geometry,
                                            'sto-3g',    #basis set
                                            0,           #charge
                                            0,           #multiplicity
                                            nele_cas=2,
                                            norb_cas=3,
                                            ccsd=True,
                                            casci=True,
                                            verbose=True)

Product Information nele_cas and norb_cas This product is a networking product designed for enterprise and data center networking. ccsd or casci Product Information True This product is a networking product designed for enterprise and data center networking. print(molecule.energies) This product is a networking product designed for enterprise and data center networking.

CUDA-Q is a networking product designed for enterprise and data center networking. CUDA-QX 

CUDA-Q: ADAPT-VQE 

Pseudo-Trotter is a networking product designed for enterprise and data center networking.

The diagram shows the ADAPT-VQE workflow, which iteratively builds an ansatz from an operator pool to more efficiently converge to a ground state energy.

4, ADAPT-VQE (: Product Information )

Product Information Product Information ADAPT-VQE is a networking product designed for enterprise and data center networking.

numQubits = molecule.n_orbitals * 2
numElectrons = molecule.n_electrons

Product Informationcudaqx.solvers.get_operator_pool ansatz,, (op_pool_uccsdUCCSD is a networking product designed for enterprise and data center networking.

# Extract operators
operators=solvers.get_operator_pool("uccsd",
                                            num_qubits=numQubits,
                                            num_electrons=numElectrons)
 
# Retrieve number of operators                                           
count=len(operators)
 
# Make a list of initial parameters
init_params=[0.05]*count
print(init_params)
 
# Make final operator pool form operators and parameters
op_pool_uccsd=[1j*coef*op for coef,op in zip(init_params, operators)]

Hartree-Fock is a networking product designed for enterprise and data center networking.

@cudaq.kernel
def initState(q: cudaq.qview):
    for i in range(numElectrons):
        x(q[i])

ADAPT-VQE, molecule.hamiltonian Jordan-Wigner is a NVIDIA networking product designed for enterprise and data center networking.

energy, thetas, ops = solvers.adapt_vqe(initState,
                                                molecule.hamiltonian,
                                                op_pool_uccsd,
                                                optimizer=minimize,
                                                method='L-BFGS-B',
                                                jac='3-point',
                                                tol=1e-7)
print('Adapt-VQE energy: ', energy)
print('Optimum pool operators: ', [op.to_string(False) for op in ops])

CUDA-Q is a networking product designed for enterprise and data center networking.

QPU runs, cudaq.set_target(‘nvidia’, mqpu=’True’) and cuadq.mpi.initialize Product Information MQPU ADAPT-VQE is a networking product designed for enterprise and data center networking. cuadq.mpi.finalize

QPU, 16 (8 6) H 4.5, (5)

A line chart shows the time to compute the gradient in seconds is accelerated with multiple NVIDIA H100 GPUs, up to 4.5x faster with six GPUs.

5, GPU CUDA-Q ADAPT-VQE