🐍 Python SDK v1.5.2

가장 인기있는 양자 컴퓨팅 라이브러리 - NumPy, Pandas, Matplotlib와 완벽 호환

설치

pip 설치

Bashpip install cqm-quantum

개발 버전 설치

Bashpip install git+https://github.com/cqmdesk/quantum-sdk-python.git

의존성 포함 설치

Bashpip install cqm-quantum[visualization,ml]

빠른 시작

기본 예제

Pythonfrom cqm import QuantumCircuit, Simulator
import numpy as np

# 2큐비트 Bell 상태 생성
qc = QuantumCircuit(2)
qc.h(0)              # Hadamard gate on qubit 0
qc.cx(0, 1)          # CNOT gate (control: 0, target: 1)
qc.measure_all()

# 시뮬레이터 실행
sim = Simulator()
result = sim.run(qc, shots=1000)

print(result.get_counts())
# Output: {'00': 502, '11': 498}

Jupyter Notebook에서 사용

Pythonfrom cqm import QuantumCircuit, Simulator
from cqm.visualization import plot_histogram, plot_bloch_multivector

qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.h(2)
qc.measure_all()

sim = Simulator()
result = sim.run(qc, shots=1024)

# 결과 시각화
plot_histogram(result.get_counts())
plot_bloch_multivector(result.get_statevector())

주요 기능

1. 양자 회로 생성

Pythonimport numpy as np
from cqm import QuantumCircuit

qc = QuantumCircuit(4)  # 4큐비트 회로

# 기본 게이트
qc.h(0)                    # Hadamard
qc.x(1)                    # Pauli-X (NOT)
qc.y(2)                    # Pauli-Y
qc.z(3)                    # Pauli-Z

# 회전 게이트
qc.rx(np.pi/4, 0)          # X축 회전
qc.ry(np.pi/2, 1)          # Y축 회전
qc.rz(np.pi, 2)            # Z축 회전

# 제어 게이트
qc.cx(0, 1)                # CNOT
qc.cz(1, 2)                # Controlled-Z
qc.ccx(0, 1, 2)            # Toffoli (CCX)

# 기타
qc.swap(0, 1)              # SWAP
qc.measure(0, 0)           # 측정

2. 시뮬레이션 옵션

Pythonfrom cqm import Simulator, SimulatorOptions

# 기본 시뮬레이션
sim = Simulator()
result = sim.run(qc, shots=1000)

# 고급 옵션
sim = Simulator(
    backend='statevector',
    optimization_level=2,
    seed_simulator=42
)

result = sim.run(qc, shots=10000, memory=True)

# 결과 확인
counts = result.get_counts()
statevector = result.get_statevector()
probabilities = result.get_probabilities()
memory = result.get_memory()  # 각 샷의 개별 측정값

3. NumPy 통합

Pythonimport numpy as np
from cqm import QuantumCircuit

# NumPy 배열로 회로 제어
angles = np.linspace(0, 2*np.pi, 10)
results = []

for angle in angles:
    qc = QuantumCircuit(1)
    qc.ry(angle, 0)
    qc.measure_all()
    
    result = sim.run(qc, shots=1000)
    results.append(result.get_counts())

# NumPy 배열로 변환
prob_0 = np.array([r.get('0', 0)/1000 for r in results])

4. Pandas 데이터 분석

Pythonimport pandas as pd
from cqm import QuantumCircuit, Simulator

sim = Simulator()
data = []

# 여러 회로 실행
for n_qubits in range(2, 6):
    qc = QuantumCircuit(n_qubits)
    for i in range(n_qubits):
        qc.h(i)
    qc.measure_all()
    
    result = sim.run(qc, shots=1000)
    
    data.append({
        'qubits': n_qubits,
        'states': len(result.get_counts()),
        'entropy': result.get_entropy()
    })

df = pd.DataFrame(data)
print(df)

API 레퍼런스

QuantumCircuit

메서드	파라미터	설명
h(qubit)	qubit: int	Hadamard 게이트 적용
x(qubit)	qubit: int	Pauli-X 게이트 적용
cx(control, target)	control, target: int	CNOT 게이트 적용
rx(angle, qubit)	angle: float, qubit: int	X축 회전 게이트
measure(qubit, cbit)	qubit, cbit: int	단일 큐비트 측정
measure_all()	없음	전체 큐비트 측정

Simulator

메서드	반환 타입	설명
run(circuit, shots)	Result	회로 실행
run_batch(circuits, shots)	List[Result]	여러 회로 일괄 실행

Result

메서드	반환 타입	설명
get_counts()	Dict[str, int]	측정 결과 카운트
get_statevector()	np.ndarray	상태 벡터
get_probabilities()	np.ndarray	확률 분포

고급 예제

양자 푸리에 변환 (QFT)

Pythonimport numpy as np
from cqm import QuantumCircuit

def qft(circuit, qubits):
    """Quantum Fourier Transform"""
    n = len(qubits)
    
    for i in range(n):
        circuit.h(qubits[i])
        
        for j in range(i + 1, n):
            angle = np.pi / (2 ** (j - i))
            circuit.cp(angle, qubits[j], qubits[i])
    
    # Swap qubits
    for i in range(n // 2):
        circuit.swap(qubits[i], qubits[n - i - 1])

# 사용 예제
qc = QuantumCircuit(4)
qft(qc, [0, 1, 2, 3])
qc.measure_all()

Grover 알고리즘

Pythonimport numpy as np
from cqm import QuantumCircuit, Simulator

def grover_oracle(circuit, target):
    """Oracle for Grover's algorithm"""
    # target 문자열에 해당하는 상태를 마킹
    for i, bit in enumerate(target):
        if bit == '0':
            circuit.x(i)
    
    circuit.h(len(target) - 1)
    circuit.mcx(list(range(len(target) - 1)), len(target) - 1)
    circuit.h(len(target) - 1)
    
    for i, bit in enumerate(target):
        if bit == '0':
            circuit.x(i)

def grover_diffusion(circuit, n):
    """Diffusion operator"""
    for i in range(n):
        circuit.h(i)
        circuit.x(i)
    
    circuit.h(n - 1)
    circuit.mcx(list(range(n - 1)), n - 1)
    circuit.h(n - 1)
    
    for i in range(n):
        circuit.x(i)
        circuit.h(i)

# 2큐비트 Grover 검색
n = 2
target = '11'  # 찾고자 하는 상태

qc = QuantumCircuit(n)

# 초기화
for i in range(n):
    qc.h(i)

# Grover 반복 (최적 횟수)
iterations = int(np.pi / 4 * np.sqrt(2**n))
for _ in range(iterations):
    grover_oracle(qc, target)
    grover_diffusion(qc, n)

qc.measure_all()

sim = Simulator()
result = sim.run(qc, shots=1000)
print(result.get_counts())  # '11'이 높은 확률로 나타남

변분 양자 고유값 풀이기 (VQE)

Pythonimport numpy as np
from cqm import QuantumCircuit, Simulator
from scipy.optimize import minimize

def vqe_circuit(params):
    """Parametrized quantum circuit"""
    qc = QuantumCircuit(2)
    
    qc.ry(params[0], 0)
    qc.ry(params[1], 1)
    qc.cx(0, 1)
    qc.ry(params[2], 0)
    qc.ry(params[3], 1)
    
    return qc

def compute_expectation(params, hamiltonian):
    """Compute expectation value"""
    qc = vqe_circuit(params)
    
    sim = Simulator(backend='statevector')
    result = sim.run(qc, shots=1)
    
    statevector = result.get_statevector()
    expectation = np.real(
        np.conj(statevector) @ hamiltonian @ statevector
    )
    
    return expectation

# 해밀토니안 정의 (예: H2 분자)
hamiltonian = np.array([
    [-1.0523, 0, 0, 0.3979],
    [0, -0.4804, 0.3979, 0],
    [0, 0.3979, -0.4804, 0],
    [0.3979, 0, 0, -1.0523]
])

# 최적화
initial_params = np.random.rand(4) * 2 * np.pi
result = minimize(
    compute_expectation, 
    initial_params,
    args=(hamiltonian,),
    method='COBYLA'
)

print(f"Ground state energy: {result.fun}")
print(f"Optimal parameters: {result.x}")

양자 기계학습

Pythonimport numpy as np
from cqm import QuantumCircuit, Simulator
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

class QuantumClassifier:
    def __init__(self, n_qubits=4):
        self.n_qubits = n_qubits
        self.params = np.random.rand(n_qubits * 2) * 2 * np.pi
        self.sim = Simulator()
    
    def feature_map(self, x):
        """Encode classical data into quantum state"""
        qc = QuantumCircuit(self.n_qubits)
        for i in range(self.n_qubits):
            qc.ry(x[i % len(x)] * np.pi, i)
        return qc
    
    def variational_circuit(self, qc):
        """Variational layer"""
        for i in range(self.n_qubits):
            qc.ry(self.params[i], i)
        
        for i in range(self.n_qubits - 1):
            qc.cx(i, i + 1)
        
        for i in range(self.n_qubits):
            qc.ry(self.params[self.n_qubits + i], i)
    
    def predict(self, X):
        predictions = []
        
        for x in X:
            qc = self.feature_map(x)
            self.variational_circuit(qc)
            qc.measure_all()
            
            result = self.sim.run(qc, shots=100)
            counts = result.get_counts()
            
            # 측정 결과의 패리티로 분류
            prob_0 = sum(v for k, v in counts.items() if k.count('0') > self.n_qubits/2)
            predictions.append(1 if prob_0 > 50 else 0)
        
        return np.array(predictions)

# 데이터 생성 및 학습
X, y = make_classification(n_samples=100, n_features=4, n_classes=2)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

qclf = QuantumClassifier(n_qubits=4)
y_pred = qclf.predict(X_test)

accuracy = np.mean(y_pred == y_test)
print(f"Accuracy: {accuracy:.2%}")

시각화

Pythonfrom cqm.visualization import (
    plot_histogram,
    plot_bloch_multivector,
    plot_state_city,
    circuit_drawer
)

# 히스토그램
plot_histogram(result.get_counts())

# 블로흐 구
plot_bloch_multivector(result.get_statevector())

# State city
plot_state_city(result.get_statevector())

# 회로 다이어그램
circuit_drawer(qc, output='mpl')

문의 및 지원

• 📖 문서: docs.cqmdesk.com/sdk/python
• 💬 Discord: discord.gg/cqmdesk
• 🐛 이슈: GitHub Issues
• 📧 이메일: sdk@cqmdesk.com
• 📦 PyPI: pypi.org/project/cqm-quantum