Visualization API Reference

Complete API documentation for Q-Memetic AI visualization capabilities.

NoosphereVisualizer Class

Main class for creating interactive visualizations of memetic landscapes.

Constructor

class NoosphereVisualizer:
    def __init__(
        self,
        theme: str = "dark",
        color_palette: str = "viridis",
        interactive: bool = True,
        engine_config: Optional[Dict[str, Any]] = None
    ) -> None:
        """
        Initialize noosphere visualizer.

        Args:
            theme: Visualization theme ("dark", "light", "custom")
            color_palette: Color palette for visualizations
            interactive: Enable interactive features
            engine_config: Optional engine configuration
        """

Properties

Property	Type	Description
theme	str	Current visualization theme
color_palette	str	Active color palette
interactive	bool	Interactive mode enabled
current_layout	str	Current layout algorithm
animation_enabled	bool	Animation features enabled
export_format	str	Default export format

Core Visualization Methods

Network Visualizations

def visualize_entanglement_network(
    self,
    network: EntanglementNetwork,
    layout: str = "force_directed",
    node_size_by: str = "degree",
    edge_width_by: str = "strength",
    highlight_communities: bool = True,
    **kwargs
) -> VisualizationResult:
    """
    Create interactive entanglement network visualization.

    Args:
        network: Entanglement network to visualize
        layout: Layout algorithm ("force_directed", "circular", "hierarchical")
        node_size_by: Property for node sizing
        edge_width_by: Property for edge width
        highlight_communities: Color nodes by community
        **kwargs: Additional visualization parameters

    Returns:
        VisualizationResult: Visualization object and metadata
    """

def plot_network_evolution(
    self,
    network_history: List[EntanglementNetwork],
    time_points: Optional[List[float]] = None,
    animation_speed: float = 1.0
) -> AnimatedVisualization:
    """
    Create animated visualization of network evolution.

    Args:
        network_history: Sequence of network states
        time_points: Optional timestamps for each state
        animation_speed: Animation playback speed

    Returns:
        AnimatedVisualization: Animated network visualization
    """

Example:

from qmemetic_ai.visualization.noosphere import NoosphereVisualizer

# Initialize visualizer
viz = NoosphereVisualizer(
    theme="dark",
    color_palette="plasma",
    interactive=True
)

# Visualize entanglement network
network_viz = viz.visualize_entanglement_network(
    network=entanglement_network,
    layout="force_directed",
    node_size_by="centrality",
    edge_width_by="strength",
    highlight_communities=True,
    min_edge_strength=0.3,
    max_nodes_displayed=200
)

# Display visualization
network_viz.show()

# Save visualization
network_viz.save("network_visualization.html")

Evolution Visualizations

def plot_evolution_landscape(
    self,
    evolution_result: EvolutionResult,
    fitness_surface: bool = True,
    trajectory_overlay: bool = True,
    generation_markers: bool = True
) -> VisualizationResult:
    """
    Visualize evolution fitness landscape.

    Args:
        evolution_result: Results from evolution process
        fitness_surface: Show 3D fitness surface
        trajectory_overlay: Show evolution trajectory
        generation_markers: Mark generation points

    Returns:
        VisualizationResult: Evolution landscape visualization
    """

def animate_evolution_process(
    self,
    evolution_history: List[List[Meme]],
    fitness_history: List[List[float]],
    speed: float = 1.0
) -> AnimatedVisualization:
    """
    Create animated visualization of evolution process.

    Args:
        evolution_history: Population history by generation
        fitness_history: Fitness history by generation
        speed: Animation speed multiplier

    Returns:
        AnimatedVisualization: Animated evolution process
    """

Population Analysis

def plot_population_diversity(
    self,
    populations: List[List[Meme]],
    diversity_metrics: List[str] = None,
    time_series: bool = True
) -> VisualizationResult:
    """
    Visualize population diversity over time.

    Args:
        populations: Sequence of populations
        diversity_metrics: Diversity measures to plot
        time_series: Show as time series plot

    Returns:
        VisualizationResult: Diversity visualization
    """

def create_fitness_distribution(
    self,
    population: List[Meme],
    distribution_type: str = "histogram",
    overlay_statistics: bool = True
) -> VisualizationResult:
    """
    Create fitness distribution visualization.

    Args:
        population: Meme population to analyze
        distribution_type: Type of distribution plot
        overlay_statistics: Show statistical overlays

    Returns:
        VisualizationResult: Fitness distribution plot
    """

Example:

# Evolution landscape
landscape_viz = viz.plot_evolution_landscape(
    evolution_result=evolution_result,
    fitness_surface=True,
    trajectory_overlay=True
)

# Animated evolution
animation = viz.animate_evolution_process(
    evolution_history=generation_populations,
    fitness_history=generation_fitness,
    speed=2.0
)

# Population diversity
diversity_viz = viz.plot_population_diversity(
    populations=generation_populations,
    diversity_metrics=["shannon", "simpson", "semantic"],
    time_series=True
)

# Show all visualizations
landscape_viz.show()
animation.play()
diversity_viz.show()

Semantic Visualizations

Concept Maps

def create_concept_map(
    self,
    memes: List[Meme],
    clustering_method: str = "hierarchical",
    max_concepts: int = 50,
    connection_threshold: float = 0.7
) -> VisualizationResult:
    """
    Create interactive concept map visualization.

    Args:
        memes: Memes to include in concept map
        clustering_method: Method for grouping concepts
        max_concepts: Maximum number of concepts to display
        connection_threshold: Minimum similarity for connections

    Returns:
        VisualizationResult: Interactive concept map
    """

def plot_semantic_embedding(
    self,
    memes: List[Meme],
    reduction_method: str = "umap",
    dimensions: int = 2,
    color_by: str = "cluster",
    **kwargs
) -> VisualizationResult:
    """
    Visualize semantic embeddings in reduced dimensions.

    Args:
        memes: Memes to visualize
        reduction_method: Dimensionality reduction method
        dimensions: Target dimensions (2 or 3)
        color_by: Property for coloring points
        **kwargs: Additional parameters

    Returns:
        VisualizationResult: Semantic embedding visualization
    """

Knowledge Graphs

def build_knowledge_graph(
    self,
    memes: List[Meme],
    relation_types: List[str] = None,
    include_metadata: bool = True,
    layout_algorithm: str = "force_directed"
) -> VisualizationResult:
    """
    Build interactive knowledge graph from memes.

    Args:
        memes: Source memes for knowledge graph
        relation_types: Types of relations to include
        include_metadata: Include metadata as graph properties
        layout_algorithm: Graph layout algorithm

    Returns:
        VisualizationResult: Interactive knowledge graph
    """

def visualize_topic_evolution(
    self,
    meme_sequences: List[List[Meme]],
    topic_model: Any,
    time_points: Optional[List[str]] = None
) -> VisualizationResult:
    """
    Visualize evolution of topics over time.

    Args:
        meme_sequences: Meme sequences by time period
        topic_model: Trained topic model
        time_points: Optional time point labels

    Returns:
        VisualizationResult: Topic evolution visualization
    """

Example:

# Concept map
concept_map = viz.create_concept_map(
    memes=evolved_memes,
    clustering_method="dbscan",
    max_concepts=30,
    connection_threshold=0.8
)

# Semantic embedding
embedding_viz = viz.plot_semantic_embedding(
    memes=evolved_memes,
    reduction_method="tsne",
    dimensions=3,
    color_by="fitness",
    perplexity=30
)

# Knowledge graph
knowledge_graph = viz.build_knowledge_graph(
    memes=evolved_memes,
    relation_types=["similarity", "entanglement", "evolution"],
    include_metadata=True
)

concept_map.show()
embedding_viz.show()
knowledge_graph.show()

Statistical Visualizations

Performance Metrics

def plot_performance_metrics(
    self,
    metrics_history: Dict[str, List[float]],
    metric_names: Optional[List[str]] = None,
    normalize: bool = True
) -> VisualizationResult:
    """
    Plot performance metrics over time.

    Args:
        metrics_history: Historical metric values
        metric_names: Subset of metrics to plot
        normalize: Normalize metrics to [0,1] range

    Returns:
        VisualizationResult: Performance metrics plot
    """

def create_correlation_matrix(
    self,
    memes: List[Meme],
    properties: List[str],
    method: str = "pearson"
) -> VisualizationResult:
    """
    Create correlation matrix heatmap.

    Args:
        memes: Memes to analyze
        properties: Properties to correlate
        method: Correlation method

    Returns:
        VisualizationResult: Correlation matrix heatmap
    """

Comparative Analysis

def compare_populations(
    self,
    populations: Dict[str, List[Meme]],
    comparison_metrics: List[str],
    visualization_type: str = "radar"
) -> VisualizationResult:
    """
    Compare multiple populations across metrics.

    Args:
        populations: Named populations to compare
        comparison_metrics: Metrics for comparison
        visualization_type: Type of comparison plot

    Returns:
        VisualizationResult: Population comparison visualization
    """

def benchmark_algorithms(
    self,
    algorithm_results: Dict[str, EvolutionResult],
    benchmark_metrics: List[str]
) -> VisualizationResult:
    """
    Benchmark and compare algorithm performance.

    Args:
        algorithm_results: Results from different algorithms
        benchmark_metrics: Metrics for benchmarking

    Returns:
        VisualizationResult: Algorithm benchmark visualization
    """

Example:

# Performance metrics
metrics = {
    "fitness": [0.3, 0.5, 0.7, 0.8, 0.9],
    "diversity": [0.9, 0.8, 0.7, 0.6, 0.5],
    "novelty": [0.6, 0.7, 0.8, 0.8, 0.9]
}

performance_viz = viz.plot_performance_metrics(
    metrics_history=metrics,
    normalize=True
)

# Population comparison
populations = {
    "Random Search": random_population,
    "Genetic Algorithm": ga_population,
    "Memetic Algorithm": ma_population
}

comparison_viz = viz.compare_populations(
    populations=populations,
    comparison_metrics=["fitness", "diversity", "convergence_speed"],
    visualization_type="box_plot"
)

performance_viz.show()
comparison_viz.show()

Specialized Visualization Classes

NetworkAnalyzer

class NetworkAnalyzer:
    """Specialized network analysis and visualization."""

    def __init__(self, visualizer: NoosphereVisualizer):
        self.visualizer = visualizer
        self.analysis_cache = {}

    def analyze_network_topology(
        self,
        network: EntanglementNetwork
    ) -> Dict[str, Any]:
        """
        Comprehensive network topology analysis.

        Args:
            network: Network to analyze

        Returns:
            Dict[str, Any]: Topology analysis results
        """

    def plot_degree_distribution(
        self,
        network: EntanglementNetwork,
        log_scale: bool = True
    ) -> VisualizationResult:
        """Plot degree distribution with power-law fitting."""

    def visualize_community_structure(
        self,
        network: EntanglementNetwork,
        algorithm: str = "louvain"
    ) -> VisualizationResult:
        """Visualize community structure in network."""

    def plot_network_resilience(
        self,
        network: EntanglementNetwork,
        attack_strategies: List[str]
    ) -> VisualizationResult:
        """Analyze and plot network resilience to attacks."""

EvolutionAnalyzer

class EvolutionAnalyzer:
    """Specialized evolution analysis and visualization."""

    def __init__(self, visualizer: NoosphereVisualizer):
        self.visualizer = visualizer
        self.fitness_landscapes = {}

    def analyze_convergence_patterns(
        self,
        evolution_results: List[EvolutionResult]
    ) -> Dict[str, Any]:
        """
        Analyze convergence patterns across multiple runs.

        Args:
            evolution_results: Results from multiple evolution runs

        Returns:
            Dict[str, Any]: Convergence analysis
        """

    def plot_fitness_landscape(
        self,
        fitness_function: Callable,
        parameter_ranges: Dict[str, Tuple[float, float]],
        resolution: int = 50
    ) -> VisualizationResult:
        """Create 3D fitness landscape visualization."""

    def visualize_genetic_diversity(
        self,
        population_history: List[List[Meme]],
        diversity_measures: List[str]
    ) -> VisualizationResult:
        """Visualize genetic diversity over generations."""

    def plot_selection_pressure(
        self,
        evolution_result: EvolutionResult
    ) -> VisualizationResult:
        """Visualize selection pressure effects."""

Example:

# Network analysis
network_analyzer = NetworkAnalyzer(viz)

topology_analysis = network_analyzer.analyze_network_topology(network)
degree_dist = network_analyzer.plot_degree_distribution(network)
community_viz = network_analyzer.visualize_community_structure(network)

# Evolution analysis
evolution_analyzer = EvolutionAnalyzer(viz)

convergence_analysis = evolution_analyzer.analyze_convergence_patterns(
    [result1, result2, result3]
)

landscape_viz = evolution_analyzer.plot_fitness_landscape(
    fitness_function=custom_fitness,
    parameter_ranges={"x": (-5, 5), "y": (-5, 5)}
)

diversity_viz = evolution_analyzer.visualize_genetic_diversity(
    population_history=generation_populations,
    diversity_measures=["hamming", "semantic", "structural"]
)

CognitiveVisualizer

class CognitiveVisualizer:
    """Visualizations for cognitive models and user preferences."""

    def __init__(self, visualizer: NoosphereVisualizer):
        self.visualizer = visualizer

    def plot_cognitive_profile(
        self,
        cognitive_fingerprint: CognitiveFingerprint,
        radar_chart: bool = True
    ) -> VisualizationResult:
        """
        Visualize cognitive fingerprint profile.

        Args:
            cognitive_fingerprint: User cognitive profile
            radar_chart: Use radar chart format

        Returns:
            VisualizationResult: Cognitive profile visualization
        """

    def visualize_user_preferences(
        self,
        user_profiles: List[CognitiveFingerprint],
        clustering_method: str = "kmeans"
    ) -> VisualizationResult:
        """Visualize and cluster user preference patterns."""

    def plot_personalization_impact(
        self,
        before_personalization: List[Meme],
        after_personalization: List[Meme],
        user_profile: CognitiveFingerprint
    ) -> VisualizationResult:
        """Visualize impact of personalization on meme content."""

Interactive Features

Dashboard Creation

def create_interactive_dashboard(
    self,
    engine: MemeticEngine,
    layout: str = "grid",
    components: Optional[List[str]] = None
) -> InteractiveDashboard:
    """
    Create comprehensive interactive dashboard.

    Args:
        engine: Q-Memetic AI engine instance
        layout: Dashboard layout style
        components: Components to include

    Returns:
        InteractiveDashboard: Interactive dashboard object
    """

class InteractiveDashboard:
    """Interactive dashboard for real-time monitoring."""

    def add_network_view(self, network: EntanglementNetwork) -> None:
        """Add network visualization panel."""

    def add_evolution_monitor(self, evolver: GeneticEvolver) -> None:
        """Add evolution monitoring panel."""

    def add_population_stats(self, population: List[Meme]) -> None:
        """Add population statistics panel."""

    def add_real_time_metrics(self, metrics: Dict[str, float]) -> None:
        """Add real-time metrics display."""

    def serve(self, port: int = 8050, debug: bool = False) -> None:
        """Serve dashboard on web interface."""

Real-time Updates

def enable_real_time_updates(
    self,
    update_frequency: float = 1.0,
    auto_refresh: bool = True
) -> None:
    """
    Enable real-time visualization updates.

    Args:
        update_frequency: Update frequency in seconds
        auto_refresh: Automatically refresh visualizations
    """

def stream_evolution_data(
    self,
    evolution_stream: Iterator[EvolutionUpdate],
    buffer_size: int = 100
) -> StreamingVisualization:
    """
    Create streaming visualization for live evolution data.

    Args:
        evolution_stream: Stream of evolution updates
        buffer_size: Size of data buffer

    Returns:
        StreamingVisualization: Live streaming visualization
    """

Example:

# Create interactive dashboard
dashboard = viz.create_interactive_dashboard(
    engine=engine,
    layout="tabbed",
    components=["network", "evolution", "statistics", "cognitive"]
)

# Add components
dashboard.add_network_view(entanglement_network)
dashboard.add_evolution_monitor(evolver)
dashboard.add_population_stats(current_population)

# Enable real-time updates
viz.enable_real_time_updates(
    update_frequency=2.0,
    auto_refresh=True
)

# Serve dashboard
dashboard.serve(port=8080, debug=True)
print("Dashboard available at http://localhost:8080")

Export and Sharing

Export Options

def export_visualization(
    self,
    visualization: VisualizationResult,
    format: str = "html",
    file_path: Optional[str] = None,
    **export_options
) -> str:
    """
    Export visualization to various formats.

    Args:
        visualization: Visualization to export
        format: Export format ("html", "png", "pdf", "svg", "json")
        file_path: Optional output file path
        **export_options: Format-specific options

    Returns:
        str: Path to exported file
    """

def create_visualization_report(
    self,
    visualizations: List[VisualizationResult],
    report_title: str,
    include_analysis: bool = True
) -> str:
    """
    Create comprehensive visualization report.

    Args:
        visualizations: List of visualizations to include
        report_title: Title for the report
        include_analysis: Include automated analysis

    Returns:
        str: Path to generated report
    """

Sharing and Collaboration

def share_visualization(
    self,
    visualization: VisualizationResult,
    sharing_platform: str,
    permissions: Dict[str, str] = None
) -> str:
    """
    Share visualization on specified platform.

    Args:
        visualization: Visualization to share
        sharing_platform: Platform for sharing
        permissions: Access permissions

    Returns:
        str: Sharing URL
    """

def collaborative_annotation(
    self,
    visualization: VisualizationResult,
    enable_comments: bool = True,
    enable_highlights: bool = True
) -> CollaborativeVisualization:
    """
    Enable collaborative features for visualization.

    Args:
        visualization: Base visualization
        enable_comments: Allow comments
        enable_highlights: Allow highlighting

    Returns:
        CollaborativeVisualization: Enhanced collaborative visualization
    """

Example:

# Export visualizations
network_export = viz.export_visualization(
    visualization=network_viz,
    format="html",
    file_path="network_analysis.html",
    include_controls=True,
    standalone=True
)

evolution_export = viz.export_visualization(
    visualization=evolution_viz,
    format="pdf",
    file_path="evolution_report.pdf",
    dpi=300,
    width=1200,
    height=800
)

# Create comprehensive report
report_path = viz.create_visualization_report(
    visualizations=[network_viz, evolution_viz, diversity_viz],
    report_title="Q-Memetic AI Analysis Report",
    include_analysis=True
)

print(f"Report generated: {report_path}")

Customization and Themes

Theme Management

class ThemeManager:
    """Manage visualization themes and styling."""

    def create_custom_theme(
        self,
        name: str,
        color_scheme: Dict[str, str],
        font_settings: Dict[str, Any],
        layout_options: Dict[str, Any]
    ) -> Theme:
        """Create custom visualization theme."""

    def apply_theme(
        self,
        theme: Union[str, Theme],
        visualizations: List[VisualizationResult]
    ) -> None:
        """Apply theme to visualizations."""

    def get_theme_preview(self, theme: Union[str, Theme]) -> VisualizationResult:
        """Generate theme preview."""

Custom Layouts

def create_custom_layout(
    self,
    layout_name: str,
    layout_function: Callable,
    parameters: Dict[str, Any]
) -> None:
    """
    Register custom layout algorithm.

    Args:
        layout_name: Name for the layout
        layout_function: Layout computation function
        parameters: Layout parameters
    """

def apply_custom_styling(
    self,
    visualization: VisualizationResult,
    css_styles: str,
    javascript_code: Optional[str] = None
) -> VisualizationResult:
    """
    Apply custom CSS and JavaScript to visualization.

    Args:
        visualization: Target visualization
        css_styles: Custom CSS styling
        javascript_code: Optional JavaScript code

    Returns:
        VisualizationResult: Styled visualization
    """

Example:

# Create custom theme
theme_manager = ThemeManager()

custom_theme = theme_manager.create_custom_theme(
    name="research_theme",
    color_scheme={
        "primary": "#2E86AB",
        "secondary": "#A23B72",
        "background": "#F18F01",
        "text": "#C73E1D"
    },
    font_settings={
        "family": "Roboto",
        "size": 12,
        "weight": "normal"
    },
    layout_options={
        "spacing": 1.2,
        "margins": {"top": 50, "bottom": 50, "left": 80, "right": 80}
    }
)

# Apply custom theme
theme_manager.apply_theme(custom_theme, [network_viz, evolution_viz])

# Custom styling
styled_viz = viz.apply_custom_styling(
    visualization=network_viz,
    css_styles="""
        .node { stroke-width: 2px; }
        .edge { opacity: 0.6; }
        .legend { font-size: 14px; }
    """,
    javascript_code="""
        // Custom interaction behaviors
        nodes.on('click', function(d) {
            console.log('Node clicked:', d);
        });
    """
)

Performance Optimization

Efficient Rendering

def optimize_for_large_datasets(
    self,
    max_nodes: int = 1000,
    level_of_detail: bool = True,
    progressive_loading: bool = True
) -> None:
    """
    Optimize visualizations for large datasets.

    Args:
        max_nodes: Maximum nodes to render simultaneously
        level_of_detail: Use level-of-detail rendering
        progressive_loading: Enable progressive data loading
    """

def enable_gpu_acceleration(
    self,
    renderer: str = "webgl",
    fallback: bool = True
) -> None:
    """
    Enable GPU acceleration for visualizations.

    Args:
        renderer: GPU rendering engine
        fallback: Fall back to CPU if GPU unavailable
    """

Memory Management

def manage_visualization_memory(
    self,
    cache_size: int = 100,
    cleanup_frequency: int = 10
) -> None:
    """
    Manage memory usage for visualizations.

    Args:
        cache_size: Maximum visualizations to cache
        cleanup_frequency: Cleanup frequency in operations
    """

For complete integration examples and advanced usage patterns, see the Engine API and Examples Documentation.