@wentorai/research-plugins 1.0.0

package/skills/analysis/dataviz/interactive-viz-guide/SKILL.md

@@ -0,0 +1,287 @@
+---
+name: interactive-viz-guide
+description: "Interactive data visualization with Plotly, ECharts, and D3"
+metadata:
+  openclaw:
+    emoji: "sparkle"
+    category: "analysis"
+    subcategory: "dataviz"
+    keywords: ["interactive visualization", "dynamic chart", "Plotly", "ECharts", "data visualization"]
+    source: "wentor-research-plugins"
+---
+
+# Interactive Visualization Guide
+
+Create interactive, publication-ready visualizations using Plotly, ECharts, Altair, and Bokeh for academic papers, presentations, and supplementary materials.
+
+## When to Use Interactive Visualizations
+
+| Scenario | Static | Interactive |
+|----------|--------|-------------|
+| Journal PDF figure | Preferred | Not supported |
+| Supplementary materials | Optional | Excellent |
+| Conference poster (digital) | Common | Increasingly popular |
+| Presentation slides | Standard | Engaging |
+| Online appendix / project website | Limited | Ideal |
+| Exploratory data analysis | Quick | Detailed exploration |
+
+## Plotly (Python)
+
+Plotly produces interactive HTML charts with hover tooltips, zoom, pan, and export capabilities.
+
+### Scatter Plot with Hover Details
+
+```python
+import plotly.express as px
+import pandas as pd
+
+# Example: visualize paper citations vs. year
+df = pd.DataFrame({
+    "title": ["Paper A", "Paper B", "Paper C", "Paper D", "Paper E"],
+    "year": [2019, 2020, 2021, 2022, 2023],
+    "citations": [150, 320, 89, 450, 210],
+    "field": ["NLP", "CV", "NLP", "RL", "CV"],
+    "venue": ["ACL", "CVPR", "EMNLP", "NeurIPS", "ICCV"]
+})
+
+fig = px.scatter(
+    df, x="year", y="citations",
+    color="field", size="citations",
+    hover_data=["title", "venue"],
+    title="Citation Counts by Year and Field",
+    labels={"citations": "Citation Count", "year": "Publication Year"}
+)
+fig.update_layout(
+    template="plotly_white",
+    font=dict(size=14),
+    width=800, height=500
+)
+fig.write_html("citations_interactive.html")
+fig.show()
+```
+
+### Grouped Bar Chart
+
+```python
+import plotly.graph_objects as go
+
+methods = ["Baseline", "Method A", "Method B", "Ours"]
+accuracy = [82.1, 85.3, 87.0, 89.4]
+f1_score = [79.8, 83.1, 85.2, 87.9]
+
+fig = go.Figure(data=[
+    go.Bar(name="Accuracy", x=methods, y=accuracy,
+           text=[f"{v}%" for v in accuracy], textposition="auto"),
+    go.Bar(name="F1 Score", x=methods, y=f1_score,
+           text=[f"{v}%" for v in f1_score], textposition="auto")
+])
+fig.update_layout(
+    barmode="group",
+    title="Model Performance Comparison",
+    yaxis_title="Score (%)",
+    yaxis_range=[70, 95],
+    template="plotly_white"
+)
+fig.write_html("comparison.html")
+```
+
+### Heatmap (Confusion Matrix)
+
+```python
+import plotly.figure_factory as ff
+import numpy as np
+
+z = [[85, 5, 3, 7],
+     [4, 90, 2, 4],
+     [6, 3, 88, 3],
+     [5, 2, 7, 86]]
+labels = ["Class A", "Class B", "Class C", "Class D"]
+
+fig = ff.create_annotated_heatmap(
+    z, x=labels, y=labels,
+    colorscale="Blues",
+    showscale=True
+)
+fig.update_layout(
+    title="Confusion Matrix",
+    xaxis_title="Predicted",
+    yaxis_title="Actual"
+)
+fig.write_html("confusion_matrix.html")
+```
+
+## Altair (Python - Declarative)
+
+Altair uses Vega-Lite grammar for concise, declarative visualization.
+
+```python
+import altair as alt
+import pandas as pd
+
+# Interactive scatter with selection
+df = pd.DataFrame({
+    "x": range(100),
+    "y": [v**2 + 10 for v in range(100)],
+    "category": ["A" if i % 3 == 0 else "B" if i % 3 == 1 else "C" for i in range(100)]
+})
+
+selection = alt.selection_point(fields=["category"], bind="legend")
+
+chart = alt.Chart(df).mark_circle(size=60).encode(
+    x="x:Q",
+    y="y:Q",
+    color="category:N",
+    opacity=alt.condition(selection, alt.value(1), alt.value(0.2)),
+    tooltip=["x", "y", "category"]
+).add_params(
+    selection
+).properties(
+    width=600, height=400,
+    title="Interactive Scatter with Legend Selection"
+).interactive()  # Enable zoom/pan
+
+chart.save("altair_scatter.html")
+```
+
+## ECharts (JavaScript)
+
+Apache ECharts is a powerful JavaScript charting library ideal for web dashboards and complex visualizations.
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="https://cdn.jsdelivr.net/npm/echarts@5/dist/echarts.min.js"></script>
+</head>
+<body>
+  <div id="chart" style="width: 800px; height: 500px;"></div>
+  <script>
+    const chart = echarts.init(document.getElementById('chart'));
+
+    const option = {
+      title: { text: 'Research Output by Year', left: 'center' },
+      tooltip: {
+        trigger: 'axis',
+        axisPointer: { type: 'shadow' }
+      },
+      legend: { data: ['Papers', 'Citations'], top: 30 },
+      xAxis: {
+        type: 'category',
+        data: ['2019', '2020', '2021', '2022', '2023']
+      },
+      yAxis: [
+        { type: 'value', name: 'Papers' },
+        { type: 'value', name: 'Citations' }
+      ],
+      series: [
+        {
+          name: 'Papers',
+          type: 'bar',
+          data: [12, 15, 18, 22, 28],
+          itemStyle: { color: '#3B82F6' }
+        },
+        {
+          name: 'Citations',
+          type: 'line',
+          yAxisIndex: 1,
+          data: [45, 120, 280, 450, 680],
+          itemStyle: { color: '#EF4444' },
+          smooth: true
+        }
+      ],
+      dataZoom: [{ type: 'slider', start: 0, end: 100 }]
+    };
+
+    chart.setOption(option);
+    window.addEventListener('resize', () => chart.resize());
+  </script>
+</body>
+</html>
+```
+
+## Network Visualization
+
+### Plotly Network Graph
+
+```python
+import plotly.graph_objects as go
+import networkx as nx
+
+# Create a citation network
+G = nx.karate_club_graph()
+pos = nx.spring_layout(G, seed=42)
+
+# Edge traces
+edge_x, edge_y = [], []
+for edge in G.edges():
+    x0, y0 = pos[edge[0]]
+    x1, y1 = pos[edge[1]]
+    edge_x.extend([x0, x1, None])
+    edge_y.extend([y0, y1, None])
+
+edge_trace = go.Scatter(x=edge_x, y=edge_y, mode="lines",
+                        line=dict(width=0.5, color="#888"), hoverinfo="none")
+
+# Node traces
+node_x = [pos[n][0] for n in G.nodes()]
+node_y = [pos[n][1] for n in G.nodes()]
+node_degree = [G.degree(n) for n in G.nodes()]
+
+node_trace = go.Scatter(
+    x=node_x, y=node_y, mode="markers",
+    marker=dict(size=[d*3 for d in node_degree], color=node_degree,
+                colorscale="Viridis", showscale=True,
+                colorbar=dict(title="Connections")),
+    text=[f"Node {n}: {G.degree(n)} connections" for n in G.nodes()],
+    hoverinfo="text"
+)
+
+fig = go.Figure(data=[edge_trace, node_trace],
+                layout=go.Layout(title="Citation Network",
+                                 showlegend=False,
+                                 xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+                                 yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)))
+fig.write_html("network.html")
+```
+
+## Exporting for Publication
+
+### Static Export from Plotly
+
+```python
+# Export as high-res static image for journals
+fig.write_image("figure.pdf", width=1200, height=800, scale=2)  # Vector PDF
+fig.write_image("figure.png", width=1200, height=800, scale=3)  # 300 DPI PNG
+fig.write_image("figure.svg", width=1200, height=800)            # Vector SVG
+
+# Requires: pip install kaleido
+```
+
+### Embedding in Jupyter Notebooks
+
+```python
+# Plotly renders natively in Jupyter
+fig.show()
+
+# For Altair in Jupyter
+chart  # Just display the chart object
+
+# For ECharts in Jupyter, use pyecharts
+from pyecharts.charts import Bar
+from pyecharts import options as opts
+
+bar = (Bar()
+    .add_xaxis(["2019", "2020", "2021", "2022", "2023"])
+    .add_yaxis("Papers", [12, 15, 18, 22, 28])
+    .set_global_opts(title_opts=opts.TitleOpts(title="Research Output")))
+bar.render_notebook()
+```
+
+## Best Practices
+
+1. **Start with a static version**: Ensure your visualization works as a static figure first; interactivity is an enhancement, not a replacement.
+2. **Meaningful tooltips**: Show relevant context on hover (paper title, exact values, metadata), not just coordinates.
+3. **Responsive design**: Use percentage-based sizing or `window.addEventListener('resize')` for ECharts.
+4. **Accessibility**: Provide text alternatives, use colorblind-friendly palettes, and ensure keyboard navigation.
+5. **Performance**: For datasets over 10,000 points, use WebGL renderers (Plotly's `scattergl`, Deck.gl) or server-side aggregation.
+6. **Reproducibility**: Save the data alongside the visualization so others can recreate it.

package/skills/analysis/dataviz/network-visualization-guide/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: network-visualization-guide
+description: "Visualize networks, graphs, citation maps, and relational data"
+metadata:
+  openclaw:
+    emoji: "spider_web"
+    category: "analysis"
+    subcategory: "dataviz"
+    keywords: ["network visualization", "graph visualization", "citation network", "NetworkX", "social network", "node-link diagram"]
+    source: "wentor-research-plugins"
+---
+
+# Network Visualization Guide
+
+A skill for visualizing networks, graphs, and relational data in research. Covers NetworkX for analysis, layout algorithms, publication-quality styling, and tools for citation networks, social networks, and knowledge graphs.
+
+## Network Basics
+
+### When to Use Network Visualization
+
+```
+Network visualization is appropriate when your data involves relationships:
+  - Citation networks (papers citing other papers)
+  - Co-authorship networks (researchers who collaborate)
+  - Social networks (individuals connected by interactions)
+  - Biological networks (protein interactions, gene regulation)
+  - Knowledge graphs (concepts linked by relationships)
+  - Trade/flow networks (countries, organizations, resources)
+```
+
+### Key Concepts
+
+```
+Nodes (vertices): The entities in your network
+Edges (links):    The relationships between entities
+Directed:         Edges have direction (A -> B)
+Undirected:       Edges are bidirectional (A -- B)
+Weighted:         Edges have a strength or value
+```
+
+## Building Networks with NetworkX
+
+### Creating and Analyzing a Network
+
+```python
+import networkx as nx
+
+
+def build_citation_network(citations: list[tuple]) -> dict:
+    """
+    Build and analyze a citation network.
+
+    Args:
+        citations: List of (citing_paper, cited_paper) tuples
+    """
+    G = nx.DiGraph()
+    G.add_edges_from(citations)
+
+    metrics = {
+        "n_nodes": G.number_of_nodes(),
+        "n_edges": G.number_of_edges(),
+        "density": nx.density(G),
+        "most_cited": sorted(
+            G.in_degree(), key=lambda x: x[1], reverse=True
+        )[:10],
+        "most_citing": sorted(
+            G.out_degree(), key=lambda x: x[1], reverse=True
+        )[:10],
+        "connected_components": nx.number_weakly_connected_components(G)
+    }
+
+    # PageRank (importance measure)
+    pagerank = nx.pagerank(G)
+    metrics["top_pagerank"] = sorted(
+        pagerank.items(), key=lambda x: x[1], reverse=True
+    )[:10]
+
+    return metrics
+```
+
+### Visualizing with Matplotlib
+
+```python
+import matplotlib.pyplot as plt
+
+
+def plot_network(G: nx.Graph, layout: str = "spring",
+                 node_size_attr: str = None,
+                 title: str = "Network") -> None:
+    """
+    Create a publication-quality network visualization.
+
+    Args:
+        G: NetworkX graph object
+        layout: Layout algorithm (spring, kamada_kawai, circular, spectral)
+        node_size_attr: Node attribute to scale node sizes by
+        title: Plot title
+    """
+    layouts = {
+        "spring": nx.spring_layout(G, k=1.5, seed=42),
+        "kamada_kawai": nx.kamada_kawai_layout(G),
+        "circular": nx.circular_layout(G),
+        "spectral": nx.spectral_layout(G)
+    }
+    pos = layouts.get(layout, nx.spring_layout(G, seed=42))
+
+    # Node sizes based on degree if no attribute specified
+    if node_size_attr and nx.get_node_attributes(G, node_size_attr):
+        sizes = [G.nodes[n].get(node_size_attr, 10) * 50 for n in G.nodes]
+    else:
+        degrees = dict(G.degree())
+        sizes = [degrees[n] * 50 + 20 for n in G.nodes]
+
+    fig, ax = plt.subplots(figsize=(12, 10))
+
+    nx.draw_networkx_edges(G, pos, alpha=0.2, edge_color="gray", ax=ax)
+    nx.draw_networkx_nodes(G, pos, node_size=sizes,
+                           node_color="steelblue", alpha=0.7, ax=ax)
+
+    # Label only high-degree nodes
+    threshold = sorted(dict(G.degree()).values(), reverse=True)[:10][-1]
+    labels = {n: n for n, d in G.degree() if d >= threshold}
+    nx.draw_networkx_labels(G, pos, labels, font_size=8, ax=ax)
+
+    ax.set_title(title, fontsize=14)
+    ax.axis("off")
+    plt.tight_layout()
+    plt.savefig("network.pdf", bbox_inches="tight", dpi=300)
+```
+
+## Layout Algorithm Selection
+
+### Choosing the Right Layout
+
+| Layout | Best For | Properties |
+|--------|---------|------------|
+| Spring (Fruchterman-Reingold) | General purpose | Clusters emerge naturally |
+| Kamada-Kawai | Small-medium networks | Minimizes edge crossings |
+| Circular | Comparing connectivity | All nodes equidistant from center |
+| Spectral | Community structure | Based on graph Laplacian eigenvectors |
+| Hierarchical (Sugiyama) | DAGs, trees | Top-down layered layout |
+| Force Atlas 2 | Large networks | Gravity-based, good for Gephi |
+
+## Specialized Tools
+
+### Beyond Python
+
+```
+Gephi:
+  - Interactive exploration of large networks
+  - Force Atlas 2 layout, community detection
+  - Export publication-quality SVG/PDF
+  - Best for exploratory analysis
+
+VOSviewer:
+  - Bibliometric networks (co-citation, co-authorship)
+  - Reads Web of Science and Scopus exports directly
+  - Density and overlay visualizations
+  - Standard tool in bibliometrics research
+
+Cytoscape:
+  - Biological network visualization
+  - Extensive plugin ecosystem for bioinformatics
+  - Pathway analysis and enrichment
+
+D3.js:
+  - Interactive web-based network diagrams
+  - Full customization via JavaScript
+  - Best for interactive publications
+```
+
+## Publication Tips
+
+### Making Networks Readable
+
+```
+1. Reduce visual clutter:
+   - Filter: Show only edges above a weight threshold
+   - Aggregate: Collapse clusters into supernodes
+   - Prune: Remove isolates and low-degree nodes
+
+2. Use visual encoding meaningfully:
+   - Node size = importance (degree, PageRank, citation count)
+   - Node color = community/category
+   - Edge width = relationship strength
+   - Edge color = relationship type
+
+3. Always include:
+   - A legend explaining visual encodings
+   - Network statistics (N nodes, M edges, density)
+   - Description of the layout algorithm used
+   - Scale context (what does a node/edge represent?)
+```
+
+For networks with more than 500 nodes, static visualization becomes difficult to read. Consider interactive visualizations for supplementary materials, or show a filtered/aggregated view in the main paper with the full network available online.