Getting Started With Qiskit on IBM Cloud: Your First Quantum ML Experiment

Quantum computing represents one of the most significant paradigm shifts in computational science, promising exponential speedups for specific classes of problems. For software engineers and technical decision-makers, understanding how to leverage quantum computing for machine learning applications is becoming increasingly important. In this comprehensive guide, we’ll walk through setting up Qiskit on IBM Cloud and conducting your first quantum machine learning experiment.

Why Quantum Machine Learning Matters

Quantum machine learning (QML) combines quantum computing principles with classical machine learning algorithms to solve problems that are intractable for classical computers. The potential advantages include:

• Exponential speedup for specific optimization problems
• Enhanced feature spaces through quantum feature maps
• Improved generalization in high-dimensional spaces
• Novel algorithm architectures impossible in classical computing

According to recent benchmarks, quantum-enhanced ML algorithms have shown 2-3x improvement in convergence rates for certain optimization problems compared to their classical counterparts.

Setting Up Your IBM Quantum Experience Account

Before diving into code, you’ll need access to IBM’s quantum computing resources:

1. Create an IBM Quantum Account: Visit IBM Quantum Experience and sign up for a free account
2. Generate API Token: Navigate to “Account” → “Advanced” → “Generate API Token”
3. Install Qiskit: Use pip to install the Qiskit ecosystem

pip install qiskit qiskit-machine-learning qiskit-ibm-runtime

Building Your First Quantum Circuit

Let’s start by creating a simple quantum circuit that demonstrates superposition and entanglement—two fundamental quantum phenomena:

import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_histogram
from qiskit_aer import AerSimulator

# Create a 2-qubit quantum circuit
qc = QuantumCircuit(2, 2)

# Apply Hadamard gate to create superposition
qc.h(0)

# Apply CNOT gate to create entanglement
qc.cx(0, 1)

# Measure both qubits
qc.measure([0, 1], [0, 1])

# Display the circuit
print("Quantum Circuit:")
print(qc.draw())

# Simulate the circuit
simulator = AerSimulator()
compiled_circuit = transpile(qc, simulator)
result = simulator.run(compiled_circuit, shots=1000).result()
counts = result.get_counts()

print("\nMeasurement Results:")
print(counts)
plot_histogram(counts)

This circuit creates a Bell state, demonstrating quantum entanglement where measuring one qubit instantly determines the state of the other.

Quantum Feature Maps for Machine Learning

Quantum feature maps transform classical data into quantum states, enabling quantum-enhanced machine learning. Here’s how to implement a basic feature map:

from qiskit.circuit.library import ZZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel

# Create a quantum feature map for 2-dimensional data
feature_dim = 2
feature_map = ZZFeatureMap(feature_dimension=feature_dim, reps=2)

# Create quantum kernel
quantum_kernel = QuantumKernel(feature_map=feature_map, quantum_instance=AerSimulator())

# Sample data points
x = np.array([0.6, 0.8])
y = np.array([0.8, 0.6])

# Compute quantum kernel matrix
kernel_matrix = quantum_kernel.evaluate(x_vec=x, y_vec=y)
print(f"Quantum Kernel Value: {kernel_matrix}")

Implementing Quantum Support Vector Machine

Let’s build a complete quantum support vector machine (QSVM) for classification:

import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from qiskit_machine_learning.algorithms import QSVM
from qiskit.utils import algorithm_globals

# Set random seed for reproducibility
algorithm_globals.random_seed = 42

# Generate synthetic dataset
X, y = make_classification(
    n_samples=100, 
    n_features=2, 
    n_redundant=0, 
    n_informative=2,
    n_clusters_per_class=1,
    flip_y=0.1,
    random_state=42
)

# Scale features to [0, 1] range
scaler = MinMaxScaler(feature_range=(0, 1))
X_scaled = scaler.fit_transform(X)

# Split dataset
X_train, X_test, y_train, y_test = train_test_split(
    X_scaled, y, test_size=0.3, random_state=42
)

# Create quantum feature map
feature_map = ZZFeatureMap(feature_dimension=2, reps=2)

# Initialize QSVM
qsvm = QSVM(quantum_kernel=QuantumKernel(feature_map=feature_map))

# Train the model
qsvm.fit(X_train, y_train)

# Evaluate performance
train_score = qsvm.score(X_train, y_train)
test_score = qsvm.score(X_test, y_test)

print(f"Training Accuracy: {train_score:.3f}")
print(f"Test Accuracy: {test_score:.3f}")

Running on Real Quantum Hardware

While simulators are useful for development, running on actual quantum hardware provides valuable insights into real-world performance:

from qiskit_ibm_runtime import QiskitRuntimeService, Session, Options
from qiskit_ibm_runtime import Sampler

# Initialize IBM Quantum service
service = QiskitRuntimeService(
    channel="ibm_quantum",
    token="YOUR_API_TOKEN_HERE"
)

# Get available backends
backends = service.backends()
print("Available backends:")
for backend in backends:
    print(f"- {backend.name}: {backend.num_qubits} qubits")

# Select a backend
backend = service.least_busy(min_num_qubits=5)
print(f"\nSelected backend: {backend.name}")

# Configure runtime options
options = Options()
options.resilience_level = 1
options.optimization_level = 3

# Run on real hardware
with Session(service=service, backend=backend) as session:
    sampler = Sampler(session=session, options=options)
    
    # Transpile circuit for the specific backend
    transpiled_circuit = transpile(qc, backend)
    
    # Run the job
    job = sampler.run(transpiled_circuit, shots=1000)
    result = job.result()
    
    print("\nHardware Results:")
    print(result.quasi_dists[0])

Performance Analysis and Benchmarking

Understanding quantum hardware performance is crucial for practical applications. Let’s analyze key metrics:

import time
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

def benchmark_quantum_circuit(n_qubits, depth):
    """Benchmark quantum circuit execution time and fidelity"""
    
    # Create random quantum circuit
    qc = QuantumCircuit(n_qubits)
    for _ in range(depth):
        for qubit in range(n_qubits):
            qc.h(qubit)
            if qubit < n_qubits - 1:
                qc.cx(qubit, qubit + 1)
    qc.measure_all()
    
    # Time simulation
    start_time = time.time()
    simulator = AerSimulator()
    result = simulator.run(qc, shots=1000).result()
    execution_time = time.time() - start_time
    
    return {
        'n_qubits': n_qubits,
        'depth': depth,
        'execution_time': execution_time,
        'circuit_size': qc.size(),
        'gate_count': qc.count_ops()
    }

# Run benchmarks
benchmark_results = []
for n_qubits in [2, 4, 8, 16]:
    for depth in [5, 10, 20]:
        result = benchmark_quantum_circuit(n_qubits, depth)
        benchmark_results.append(result)
        print(f"Qubits: {n_qubits}, Depth: {depth}, Time: {result['execution_time']:.3f}s")

Real-World Application: Quantum-Enhanced Portfolio Optimization

Let’s apply quantum machine learning to a practical financial problem:

import pandas as pd
from qiskit_finance.applications.optimization import PortfolioOptimization
from qiskit_optimization import QuadraticProgram
from qiskit_algorithms import QAOA
from qiskit_algorithms.optimizers import COBYLA

# Sample financial data
stocks = ['AAPL', 'GOOGL', 'MSFT', 'AMZN']
returns = np.array([0.12, 0.08, 0.15, 0.10])  # Expected returns
covariance = np.array([
    [0.04, 0.02, 0.01, 0.03],
    [0.02, 0.06, 0.01, 0.02],
    [0.01, 0.01, 0.05, 0.01],
    [0.03, 0.02, 0.01, 0.07]
])

# Create portfolio optimization problem
portfolio = PortfolioOptimization(
    expected_returns=returns,
    covariances=covariance,
    risk_factor=0.5,
    budget=2  # Select 2 out of 4 stocks
)

# Convert to quadratic program
qp = portfolio.to_quadratic_program()

# Solve using QAOA
optimizer = COBYLA(maxiter=100)
qaoa = QAOA(optimizer=optimizer, quantum_instance=AerSimulator())
result = qaoa.solve(qp)

print("Optimal Portfolio Selection:")
for i, selected in enumerate(result.x):
    if selected:
        print(f"- {stocks[i]}")
print(f"Expected Return: {result.fval:.3f}")

Error Mitigation and Noise Handling

Quantum computers are inherently noisy. Implementing error mitigation techniques is essential for reliable results:

from qiskit.primitives import Sampler
from qiskit_aer.noise import NoiseModel
from qiskit_ibm_runtime import Options

def apply_error_mitigation(circuit, backend):
    """Apply error mitigation techniques for improved results"""
    
    options = Options()
    options.resilience_level = 2  # Enable Z2 symmetry and measurement error mitigation
    options.optimization_level = 3  # Maximum optimization
    
    with Session(service=service, backend=backend) as session:
        sampler = Sampler(session=session, options=options)
        job = sampler.run(circuit, shots=1000)
        result = job.result()
        
    return result

# Compare results with and without error mitigation
print("Comparing results with different resilience levels...")

Best Practices for Quantum ML Development

Based on our experience, here are key recommendations for successful quantum ML projects:

1. Start Small and Scale Gradually

• Begin with 2-4 qubit problems
• Validate results against classical baselines
• Gradually increase complexity as you gain confidence

2. Implement Hybrid Approaches

• Combine classical pre/post-processing with quantum cores
• Use quantum circuits for specific subproblems
• Maintain classical fallbacks for production systems

3. Monitor Resource Usage

• Track quantum circuit depth and gate counts
• Monitor execution times across different backends
• Set reasonable expectations for current hardware limitations

4. Focus on Quantum-Ready Problems

• Optimization and sampling problems
• Quantum chemistry simulations
• Machine learning with structured data

Performance Metrics and Current Limitations

Understanding the current state of quantum hardware is crucial for setting realistic expectations:

Metric	Current State	Near-term Goal
Qubit Count	100-400	1,000+
Gate Fidelity	99.5-99.9%	99.99%
Coherence Time	100-500μs	1ms+
Circuit Depth	50-100 gates	1,000+ gates

Conclusion and Next Steps

Quantum machine learning on IBM Cloud with Qiskit provides a powerful platform for exploring quantum-enhanced algorithms. While current hardware has limitations, the rapid pace of advancement makes this an exciting time to get involved.

Key takeaways for technical teams:

1. Start with simulators for algorithm development and validation
2. Graduate to real hardware for understanding noise and error characteristics
3. Focus on hybrid approaches that leverage both classical and quantum advantages
4. Monitor the ecosystem as new hardware and algorithms emerge monthly

Recommended next steps:

• Explore Qiskit’s application modules for finance, chemistry, and optimization
• Join the IBM Quantum Challenge to test your skills
• Contribute to open-source quantum projects
• Stay updated with the latest research in quantum machine learning

Quantum computing is no longer just theoretical—it’s a practical tool that forward-thinking engineering teams should understand and experiment with today. By starting your quantum journey with Qiskit on IBM Cloud, you’re positioning your organization at the forefront of this transformative technology.

---

This guide provides a foundation for quantum machine learning experimentation. As the field evolves rapidly, continue exploring advanced topics like variational quantum algorithms, quantum neural networks, and error-corrected quantum computing.