Skip to content

Visualization

Comprehensive visualization tools for quantum GANs, from training monitoring to result analysis and quantum circuit visualization.

🎨 Overview

QGANS Pro provides extensive visualization capabilities:

  • Training Monitoring: Real-time loss curves and metric tracking
  • Sample Visualization: Generated data comparison and quality assessment
  • Quantum Circuit Visualization: Circuit diagrams and quantum state analysis
  • Performance Analytics: Computational efficiency and convergence analysis
  • Interactive Dashboards: Web-based monitoring and exploration

📊 Training Visualization

Real-time Training Monitor

Monitor training progress with live updates:

from qgans_pro.utils import TrainingVisualizer
import matplotlib.pyplot as plt

# Initialize training visualizer
visualizer = TrainingVisualizer(
    update_frequency=10,  # Update every 10 batches
    save_path='./training_plots'
)

# Add to training loop
qgan = QuantumGAN(generator, discriminator)
for epoch in range(epochs):
    for batch_idx, (real_data, _) in enumerate(dataloader):
        # Training step
        losses = qgan.train_step(real_data)

        # Update visualizer
        visualizer.update(
            epoch=epoch,
            batch=batch_idx,
            generator_loss=losses['g_loss'],
            discriminator_loss=losses['d_loss'],
            gradient_penalty=losses['gp_loss']
        )

        # Display live plots
        if batch_idx % visualizer.update_frequency == 0:
            visualizer.show_live_plots()

Loss Curve Analysis

Create detailed loss analysis plots:

from qgans_pro.utils import LossAnalyzer

# Analyze training losses
loss_analyzer = LossAnalyzer()

# Load training logs
training_logs = qgan.get_training_logs()

# Create comprehensive loss plots
fig, axes = loss_analyzer.plot_training_curves(
    logs=training_logs,
    metrics=['g_loss', 'd_loss', 'gp_loss', 'fid_score'],
    smoothing=0.9  # Apply exponential smoothing
)

# Add convergence analysis
loss_analyzer.add_convergence_analysis(axes, training_logs)

# Save plots
plt.savefig('training_analysis.png', dpi=300, bbox_inches='tight')
plt.show()

Gradient Flow Visualization

Monitor gradient health during training:

from qgans_pro.utils import GradientVisualizer

# Initialize gradient visualizer
grad_viz = GradientVisualizer()

# Hook into model gradients
grad_viz.register_hooks(generator)
grad_viz.register_hooks(discriminator)

# Training loop with gradient monitoring
for epoch in range(epochs):
    # ... training code ...

    # Visualize gradients every 50 epochs
    if epoch % 50 == 0:
        grad_viz.plot_gradient_flow(
            title=f'Gradient Flow - Epoch {epoch}',
            save_path=f'gradients_epoch_{epoch}.png'
        )

🖼️ Sample Visualization

Display generated samples in organized grids:

from qgans_pro.utils import SampleVisualizer

# Initialize sample visualizer
sample_viz = SampleVisualizer()

# Generate samples
generated_samples = qgan.generate_samples(64)

# Create sample grid
fig = sample_viz.create_sample_grid(
    samples=generated_samples,
    nrow=8,
    title='Quantum GAN Generated Samples',
    normalize=True
)

# Add comparison with real samples
real_samples = next(iter(dataloader))[0][:64]
comparison_fig = sample_viz.create_comparison_grid(
    real_samples=real_samples,
    generated_samples=generated_samples,
    title='Real vs Generated Comparison'
)

plt.show()

Progressive Generation Visualization

Show how generation quality improves over training:

# Track samples throughout training
sample_tracker = []

for epoch in range(epochs):
    # ... training code ...

    # Save samples every 10 epochs
    if epoch % 10 == 0:
        samples = qgan.generate_samples(16)
        sample_tracker.append({
            'epoch': epoch,
            'samples': samples
        })

# Create progression animation
sample_viz.create_progression_animation(
    sample_tracker=sample_tracker,
    save_path='generation_progression.gif',
    fps=2
)

Quality Heatmaps

Visualize generation quality across different regions:

from qgans_pro.utils import QualityHeatmap

# Create quality heatmap
quality_viz = QualityHeatmap()

# Analyze spatial quality distribution
quality_map = quality_viz.compute_quality_map(
    generated_samples=generated_samples,
    real_samples=real_samples,
    metric='lpips',
    grid_size=(10, 10)
)

# Visualize quality heatmap
quality_viz.plot_quality_heatmap(
    quality_map=quality_map,
    title='Generation Quality Heatmap',
    colormap='viridis'
)

⚛️ Quantum Circuit Visualization

Circuit Diagrams

Visualize quantum circuits used in your models:

from qgans_pro.utils import QuantumVisualizer

# Initialize quantum visualizer
quantum_viz = QuantumVisualizer(backend='qiskit')

# Visualize generator circuit
generator_circuit = quantum_generator.get_circuit()
quantum_viz.draw_circuit(
    circuit=generator_circuit,
    output='mpl',  # matplotlib output
    title='Quantum Generator Circuit',
    save_path='generator_circuit.png'
)

# Visualize discriminator circuit
discriminator_circuit = quantum_discriminator.get_circuit()
quantum_viz.draw_circuit(
    circuit=discriminator_circuit,
    output='text',  # text-based diagram
    title='Quantum Discriminator Circuit'
)

Quantum State Visualization

Visualize quantum states during generation:

# Visualize quantum state evolution
state_evolution = quantum_generator.get_state_evolution()

quantum_viz.plot_state_evolution(
    states=state_evolution,
    representation='bloch_sphere',
    animate=True,
    save_path='state_evolution.gif'
)

# Plot quantum state distribution
quantum_viz.plot_state_distribution(
    final_state=state_evolution[-1],
    basis='computational',
    title='Final Quantum State Distribution'
)

Circuit Depth Analysis

Analyze circuit complexity and optimization:

from qgans_pro.utils import CircuitAnalyzer

# Analyze circuit properties
circuit_analyzer = CircuitAnalyzer()

analysis = circuit_analyzer.analyze_circuit(generator_circuit)

# Visualize circuit metrics
circuit_analyzer.plot_circuit_metrics(
    analysis=analysis,
    metrics=['depth', 'gate_count', 'cx_count', 'expressibility'],
    save_path='circuit_analysis.png'
)

# Create optimization suggestions
optimization_report = circuit_analyzer.suggest_optimizations(
    circuit=generator_circuit,
    target_depth=10
)

📈 Performance Visualization

Computational Efficiency

Monitor computational performance:

from qgans_pro.utils import PerformanceVisualizer

# Initialize performance visualizer
perf_viz = PerformanceVisualizer()

# Profile training performance
performance_data = qgan.profile_training(
    dataloader=dataloader,
    n_epochs=5,
    enable_profiling=True
)

# Visualize performance metrics
perf_viz.plot_performance_metrics(
    data=performance_data,
    metrics=['throughput', 'memory_usage', 'circuit_time'],
    save_path='performance_analysis.png'
)

# Create efficiency comparison
perf_viz.compare_efficiency(
    quantum_times=performance_data['quantum_times'],
    classical_times=performance_data['classical_times'],
    title='Quantum vs Classical Efficiency'
)

Convergence Analysis

Visualize training convergence patterns:

from qgans_pro.utils import ConvergenceVisualizer

# Analyze convergence behavior
conv_viz = ConvergenceVisualizer()

convergence_metrics = conv_viz.analyze_convergence(
    training_logs=training_logs,
    window_size=100
)

# Plot convergence analysis
conv_viz.plot_convergence_analysis(
    metrics=convergence_metrics,
    include_trends=True,
    save_path='convergence_analysis.png'
)

🎯 Interactive Dashboards

Web-based Training Dashboard

Create interactive training monitoring:

from qgans_pro.utils import TrainingDashboard

# Initialize web dashboard
dashboard = TrainingDashboard(
    port=8080,
    auto_refresh=True,
    refresh_interval=30  # seconds
)

# Start dashboard server
dashboard.start_server()

# Add to training loop
for epoch in range(epochs):
    # ... training code ...

    # Update dashboard
    dashboard.update_metrics({
        'epoch': epoch,
        'g_loss': g_loss,
        'd_loss': d_loss,
        'fid_score': fid_score,
        'samples': latest_samples
    })

# Dashboard accessible at http://localhost:8080

Model Comparison Dashboard

Compare multiple models interactively:

from qgans_pro.utils import ComparisonDashboard

# Initialize comparison dashboard
comp_dashboard = ComparisonDashboard()

# Add models to comparison
comp_dashboard.add_model(
    name='Quantum GAN',
    model=quantum_gan,
    results=quantum_results
)

comp_dashboard.add_model(
    name='Classical GAN',
    model=classical_gan,
    results=classical_results
)

# Launch interactive comparison
comp_dashboard.launch(
    metrics=['fid', 'is', 'quantum_fidelity'],
    sample_comparison=True
)

🎨 Custom Visualization

Custom Plot Themes

Create consistent styling across all plots:

from qgans_pro.utils import PlotTheme

# Set quantum-themed styling
quantum_theme = PlotTheme('quantum')
quantum_theme.apply()

# Custom color palettes
colors = quantum_theme.get_color_palette('quantum_states')

# Apply to all visualizations
plt.style.use(quantum_theme.get_style())

Advanced Plotting Functions

Create sophisticated visualizations:

from qgans_pro.utils import AdvancedPlots

advanced_plots = AdvancedPlots()

# 3D loss landscape
advanced_plots.plot_3d_loss_landscape(
    generator=generator,
    discriminator=discriminator,
    data_sample=sample_batch,
    resolution=50
)

# t-SNE visualization of latent space
advanced_plots.plot_latent_tsne(
    real_encodings=real_encodings,
    generated_encodings=generated_encodings,
    perplexity=30
)

# Quantum correlation matrix
advanced_plots.plot_quantum_correlations(
    quantum_states=quantum_states,
    measurement_basis='pauli'
)

📱 Export and Sharing

High-Quality Exports

Export publication-ready figures:

from qgans_pro.utils import FigureExporter

# Initialize exporter with publication settings
exporter = FigureExporter(
    dpi=300,
    format='pdf',
    style='publication'
)

# Export with metadata
exporter.export_figure(
    figure=training_curves_fig,
    filename='training_curves',
    metadata={
        'title': 'Quantum GAN Training Curves',
        'author': 'Krishna Bajpai',
        'experiment': 'Fashion-MNIST Quantum GAN'
    }
)

Interactive HTML Reports

Generate shareable HTML reports:

from qgans_pro.utils import HTMLReportGenerator

# Create interactive HTML report
report_gen = HTMLReportGenerator()

report = report_gen.create_report(
    title='Quantum GAN Experiment Results',
    sections=[
        'training_overview',
        'sample_gallery',
        'metric_analysis',
        'quantum_circuits'
    ],
    data={
        'training_logs': training_logs,
        'samples': generated_samples,
        'metrics': evaluation_results,
        'circuits': circuit_diagrams
    }
)

# Save interactive report
report_gen.save_report(report, 'experiment_report.html')

🔧 Configuration and Customization

Visualization Configuration

Customize visualization settings:

from qgans_pro.utils import VisualizationConfig

# Set global visualization preferences
viz_config = VisualizationConfig()
viz_config.set_defaults({
    'figure_size': (12, 8),
    'dpi': 150,
    'color_scheme': 'quantum',
    'font_size': 12,
    'save_format': 'png',
    'interactive': True
})

# Apply configuration globally
viz_config.apply_global_settings()

Custom Visualization Classes

Extend visualization capabilities:

from qgans_pro.utils import BaseVisualizer

class CustomQuantumVisualizer(BaseVisualizer):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

    def plot_quantum_advantage(self, quantum_results, classical_results):
        """Custom plot showing quantum advantage"""
        fig, ax = plt.subplots(1, 1, figsize=self.figure_size)

        # Custom plotting logic
        advantage_scores = self._calculate_advantage(
            quantum_results, classical_results
        )

        ax.bar(range(len(advantage_scores)), advantage_scores)
        ax.set_title('Quantum Advantage Analysis')
        ax.set_xlabel('Metric')
        ax.set_ylabel('Advantage Score')

        return fig

    def _calculate_advantage(self, quantum_results, classical_results):
        # Implement custom advantage calculation
        pass

# Use custom visualizer
custom_viz = CustomQuantumVisualizer()
advantage_plot = custom_viz.plot_quantum_advantage(
    quantum_results, classical_results
)

🚨 Best Practices

Performance Optimization

Optimize visualization performance:

# Use data sampling for large datasets
def sample_for_visualization(data, max_samples=10000):
    if len(data) > max_samples:
        indices = np.random.choice(len(data), max_samples, replace=False)
        return data[indices]
    return data

# Lazy loading for animations
def create_lazy_animation(data_generator, frames=100):
    def animate(frame):
        data = next(data_generator)
        return update_plot(data)

    return FuncAnimation(fig, animate, frames=frames, interval=100)

Memory Management

Handle large visualizations efficiently:

# Context manager for figure management
from contextlib import contextmanager

@contextmanager
def managed_figure(*args, **kwargs):
    fig = plt.figure(*args, **kwargs)
    try:
        yield fig
    finally:
        plt.close(fig)

# Use managed figures
with managed_figure(figsize=(12, 8)) as fig:
    # Create plots
    pass  # Figure automatically closed

Pro Tip

Use vector formats (PDF, SVG) for plots with text and lines, and raster formats (PNG, JPG) for complex images with many colors.

Performance

Interactive visualizations can be memory-intensive. Consider using data sampling or progressive loading for large datasets.