@wentorai/research-plugins 1.1.0 → 1.2.0

package/skills/domains/ai-ml/kolmogorov-arnold-networks-guide/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: kolmogorov-arnold-networks-guide
+description: "Papers and tutorials on KAN learnable activation networks"
+metadata:
+  openclaw:
+    emoji: "📐"
+    category: "domains"
+    subcategory: "ai-ml"
+    keywords: ["KAN", "Kolmogorov-Arnold", "learnable activations", "spline networks", "neural architecture", "interpretability"]
+    source: "https://github.com/mintisan/awesome-kan"
+---
+
+# Kolmogorov-Arnold Networks (KAN) Guide
+
+## Overview
+
+Kolmogorov-Arnold Networks (KANs) are a novel neural network architecture that places learnable activation functions on edges (weights) instead of fixed activations on nodes. Based on the Kolmogorov-Arnold representation theorem, KANs use B-spline functions as learnable edge activations, achieving better accuracy and interpretability than MLPs with fewer parameters in certain domains. This collection tracks the rapidly growing KAN literature.
+
+## Core Concept
+
+```
+Traditional MLP:
+  x → [fixed activation(linear transform)] → y
+  Activations on nodes, weights on edges
+
+KAN:
+  x → [learnable spline functions on edges] → sum → y
+  Each edge learns its own activation function (B-spline)
+
+Kolmogorov-Arnold Theorem:
+  f(x₁,...,xₙ) = Σ Φᵢ(Σ φᵢⱼ(xⱼ))
+  Any multivariate continuous function = composition of
+  univariate functions and addition
+```
+
+## Key Papers
+
+```bibtex
+@article{liu2024kan,
+  title={KAN: Kolmogorov-Arnold Networks},
+  author={Liu, Ziming and Wang, Yixuan and Vaidya, Sachin and
+          Ruehle, Fabian and Halverson, James and
+          Solja{\v{c}}i{\'c}, Marin and Hou, Thomas Y. and
+          Tegmark, Max},
+  journal={arXiv:2404.19756},
+  year={2024}
+}
+```
+
+## Implementation
+
+```python
+# Using pykan (official implementation)
+# pip install pykan
+
+from kan import KAN
+import torch
+
+# Create a KAN model
+model = KAN(
+    width=[2, 5, 1],    # Input: 2, Hidden: 5, Output: 1
+    grid=5,               # Spline grid resolution
+    k=3,                  # Spline order (cubic)
+)
+
+# Training data
+x = torch.randn(1000, 2)
+y = torch.sin(x[:, 0]) + torch.cos(x[:, 1])
+y = y.unsqueeze(1)
+
+# Train
+dataset = {"train_input": x[:800], "train_label": y[:800],
+           "test_input": x[800:], "test_label": y[800:]}
+model.train(dataset, steps=100, lr=0.01)
+
+# Visualize learned functions
+model.plot()
+
+# Prune and simplify
+model = model.prune()
+model.plot()
+```
+
+## KAN vs MLP Comparison
+
+```python
+# Comparison on function approximation
+from kan import KAN
+import torch.nn as nn
+
+# KAN: learnable activations on edges
+kan_model = KAN(width=[2, 5, 1], grid=5, k=3)
+# Parameters: ~150 (spline coefficients)
+
+# MLP: fixed activations on nodes
+class MLP(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(2, 50),
+            nn.ReLU(),
+            nn.Linear(50, 50),
+            nn.ReLU(),
+            nn.Linear(50, 1),
+        )
+    def forward(self, x):
+        return self.net(x)
+
+mlp_model = MLP()
+# Parameters: ~2,700
+
+# KAN advantages:
+# - Fewer parameters for same accuracy
+# - Interpretable (visualize learned functions)
+# - Better for scientific discovery (symbolic regression)
+# - Grid refinement for progressive accuracy
+
+# MLP advantages:
+# - Faster training
+# - Better scaling to high dimensions
+# - More mature tooling and optimization
+```
+
+## Extensions and Variants
+
+| Variant | Innovation | Application |
+|---------|-----------|-------------|
+| **KAN 2.0** | MultKAN with multiplication nodes | Improved scaling |
+| **Temporal KAN** | Time-series adaptation | Forecasting |
+| **ConvKAN** | KAN + convolutions | Image processing |
+| **GraphKAN** | KAN on graph structures | Graph learning |
+| **FourierKAN** | Fourier basis instead of splines | Periodic functions |
+| **WavKAN** | Wavelet-based activations | Signal processing |
+| **BSRBF-KAN** | B-spline + radial basis | Function approximation |
+
+## Scientific Applications
+
+```python
+# KAN for symbolic regression (discovering equations)
+from kan import KAN
+
+# Generate data from unknown equation: f(x,y) = x*exp(y)
+import torch
+x = torch.rand(1000, 2) * 2
+y = x[:, 0:1] * torch.exp(x[:, 1:2])
+
+dataset = {"train_input": x[:800], "train_label": y[:800],
+           "test_input": x[800:], "test_label": y[800:]}
+
+model = KAN(width=[2, 1, 1], grid=10, k=3)
+model.train(dataset, steps=200)
+
+# Symbolic fitting — discover the equation
+model.auto_symbolic()
+# Output: f(x₁, x₂) = x₁ * exp(x₂)
+# KAN can discover symbolic expressions from data
+```
+
+## Research Landscape
+
+```markdown
+### Key Research Directions
+1. **Scaling** — Making KANs work at LLM scale
+2. **Efficiency** — Reducing spline computation overhead
+3. **Theory** — Understanding approximation guarantees
+4. **Architecture search** — Optimal KAN topologies
+5. **Hybrid models** — Combining KAN and MLP strengths
+6. **Domain applications** — Physics, chemistry, biology
+7. **Interpretability** — Extracting symbolic knowledge
+```
+
+## Use Cases
+
+1. **Scientific discovery**: Extract equations from experimental data
+2. **Function approximation**: High-accuracy low-parameter models
+3. **Interpretable ML**: Understand what the network learned
+4. **Physics-informed**: Embed physical constraints in activations
+5. **Education**: Teach alternative neural network architectures
+
+## References
+
+- [awesome-kan](https://github.com/mintisan/awesome-kan)
+- [KAN Paper](https://arxiv.org/abs/2404.19756)
+- [pykan Implementation](https://github.com/KindXiaoming/pykan)
+- [KAN 2.0 Paper](https://arxiv.org/abs/2408.10205)

package/skills/domains/ai-ml/npcpy-research-guide/SKILL.md

@@ -0,0 +1,137 @@
+---
+name: npcpy-research-guide
+description: "All-in-one Python library for NLP, agents, and knowledge graphs"
+metadata:
+  openclaw:
+    emoji: "🎭"
+    category: "domains"
+    subcategory: "ai-ml"
+    keywords: ["npcpy", "NLP", "agents", "knowledge graph", "all-in-one", "Python library"]
+    source: "https://github.com/NPC-Worldwide/npcpy"
+---
+
+# npcpy Research Guide
+
+## Overview
+
+npcpy is an all-in-one Python library that combines NLP, agent orchestration, and knowledge graph capabilities in a single package. It provides tools for text processing, entity extraction, agent creation, graph-based reasoning, and research automation. Designed as a Swiss Army knife for AI researchers who need quick access to diverse NLP and agent capabilities without juggling many dependencies.
+
+## Installation
+
+```bash
+pip install npcpy
+```
+
+## Core Modules
+
+### NLP Processing
+
+```python
+from npcpy import NLP
+
+nlp = NLP()
+
+# Text processing pipeline
+doc = nlp.process(
+    "Transformers have revolutionized NLP since Vaswani et al. "
+    "introduced the attention mechanism in 2017."
+)
+
+# Named entities
+for entity in doc.entities:
+    print(f"[{entity.type}] {entity.text}")
+# [METHOD] Transformers
+# [PERSON] Vaswani
+# [CONCEPT] attention mechanism
+# [DATE] 2017
+
+# Key phrases
+print(doc.key_phrases)
+# ["attention mechanism", "Transformers", "NLP"]
+
+# Sentiment / stance
+print(doc.sentiment)  # positive
+```
+
+### Agent Creation
+
+```python
+from npcpy import Agent, Tool
+
+# Create a research agent
+agent = Agent(
+    name="research_assistant",
+    llm_provider="anthropic",
+    tools=[
+        Tool("web_search", description="Search the web"),
+        Tool("paper_search", description="Search academic papers"),
+        Tool("calculator", description="Math calculations"),
+    ],
+)
+
+# Run a task
+result = agent.run(
+    "Find the top 5 most cited papers on few-shot learning "
+    "from 2023 and summarize their approaches."
+)
+print(result.output)
+```
+
+### Knowledge Graphs
+
+```python
+from npcpy import KnowledgeGraph
+
+kg = KnowledgeGraph()
+
+# Extract knowledge from text
+kg.extract_from_text(
+    "BERT uses masked language modeling for pre-training. "
+    "GPT uses autoregressive language modeling. "
+    "Both are based on the Transformer architecture."
+)
+
+# Query the graph
+results = kg.query("What models use Transformer architecture?")
+# ["BERT", "GPT"]
+
+# Visualize
+kg.visualize("knowledge_graph.html")
+
+# Export
+kg.export("kg.json")
+```
+
+## Research Workflows
+
+```python
+from npcpy import ResearchWorkflow
+
+workflow = ResearchWorkflow(llm_provider="anthropic")
+
+# Literature search + synthesis
+report = workflow.literature_review(
+    topic="prompt engineering techniques",
+    num_papers=20,
+    synthesis_style="academic",
+)
+report.save("review.md")
+
+# Paper analysis
+analysis = workflow.analyze_paper("paper.pdf")
+print(analysis.summary)
+print(analysis.methodology)
+print(analysis.key_findings)
+```
+
+## Use Cases
+
+1. **Quick NLP**: Text processing without heavy setup
+2. **Agent prototyping**: Rapid agent creation and testing
+3. **Knowledge extraction**: Build KGs from research text
+4. **Research automation**: Literature search and synthesis
+5. **Teaching**: Demonstrate NLP/agent concepts
+
+## References
+
+- [npcpy GitHub](https://github.com/NPC-Worldwide/npcpy)

package/skills/domains/ai-ml/responsible-ai-guide/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: responsible-ai-guide
+description: "Resources for trustworthy, fair, and ethical AI research"
+metadata:
+  openclaw:
+    emoji: "⚖️"
+    category: "domains"
+    subcategory: "ai-ml"
+    keywords: ["responsible AI", "AI ethics", "fairness", "trustworthy AI", "AI safety", "bias"]
+    source: "https://github.com/AthenaCore/AwesomeResponsibleAI"
+---
+
+# Responsible AI Guide
+
+## Overview
+
+A comprehensive collection of resources for building trustworthy, fair, and ethical AI systems. Covers fairness metrics, bias detection and mitigation, explainability methods, privacy-preserving techniques, robustness testing, and governance frameworks. Essential reading for researchers working on AI safety, alignment, and deploying models in high-stakes domains.
+
+## Topic Taxonomy
+
+```
+Responsible AI
+├── Fairness
+│   ├── Bias detection (data, model, outcome)
+│   ├── Fairness metrics (demographic parity, equalized odds)
+│   ├── Bias mitigation (pre/in/post-processing)
+│   └── Intersectional fairness
+├── Explainability
+│   ├── Feature attribution (SHAP, LIME, IG)
+│   ├── Concept-based (TCAV, concept bottleneck)
+│   ├── Counterfactual explanations
+│   └── Mechanistic interpretability
+├── Privacy
+│   ├── Differential privacy
+│   ├── Federated learning
+│   ├── Membership inference attacks
+│   └── Machine unlearning
+├── Robustness
+│   ├── Adversarial attacks/defenses
+│   ├── Distribution shift
+│   ├── Uncertainty quantification
+│   └── Out-of-distribution detection
+├── Safety & Alignment
+│   ├── RLHF and preference learning
+│   ├── Constitutional AI
+│   ├── Red teaming
+│   └── Guardrails and filters
+└── Governance
+    ├── Model cards
+    ├── Datasheets for datasets
+    ├── AI impact assessments
+    └── Regulatory compliance (EU AI Act)
+```
+
+## Key Tools
+
+| Tool | Category | Purpose |
+|------|----------|---------|
+| **Fairlearn** | Fairness | Bias assessment + mitigation |
+| **AI Fairness 360** | Fairness | IBM fairness toolkit |
+| **SHAP** | Explainability | Shapley value explanations |
+| **Captum** | Explainability | PyTorch interpretability |
+| **Opacus** | Privacy | Differential privacy for PyTorch |
+| **ART** | Robustness | Adversarial robustness toolbox |
+| **Alibi** | Explainability | ML model explanations |
+
+## Fairness Assessment
+
+```python
+from fairlearn.metrics import MetricFrame
+from sklearn.metrics import accuracy_score, recall_score
+
+# Assess fairness across demographic groups
+metrics = MetricFrame(
+    metrics={
+        "accuracy": accuracy_score,
+        "recall": recall_score,
+    },
+    y_true=y_test,
+    y_pred=y_pred,
+    sensitive_features=demographics,
+)
+
+print("Overall:")
+print(metrics.overall)
+print("\nBy group:")
+print(metrics.by_group)
+print("\nDifference (max - min):")
+print(metrics.difference())
+```
+
+## Reading Roadmap
+
+```markdown
+### Foundations
+1. "Fairness and Machine Learning" (Barocas, Hardt, Narayanan)
+2. "Datasheets for Datasets" (Gebru et al., 2021)
+3. "Model Cards for Model Reporting" (Mitchell et al., 2019)
+
+### Fairness
+4. "On Fairness and Calibration" (Pleiss et al., 2017)
+5. "Fairness Through Awareness" (Dwork et al., 2012)
+
+### Explainability
+6. "A Unified Approach to Interpreting Model Predictions" (SHAP)
+7. "Why Should I Trust You?" (LIME, Ribeiro et al., 2016)
+
+### Safety
+8. "Constitutional AI" (Bai et al., 2022)
+9. "Red Teaming Language Models" (Perez et al., 2022)
+10. "Scaling Monosemanticity" (Anthropic, 2024)
+```
+
+## Use Cases
+
+1. **Bias auditing**: Check models for demographic biases
+2. **Compliance**: EU AI Act and regulatory requirements
+3. **Model documentation**: Model cards and impact assessments
+4. **Research ethics**: Ethical considerations for AI research
+5. **Course material**: Teach responsible AI principles
+
+## References
+
+- [AwesomeResponsibleAI](https://github.com/AthenaCore/AwesomeResponsibleAI)
+- [Fairlearn](https://fairlearn.org/)
+- [EU AI Act](https://artificialintelligenceact.eu/)

package/skills/domains/ai-ml/vmas-simulator-guide/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: vmas-simulator-guide
+description: "Vectorized multi-agent reinforcement learning simulator"
+metadata:
+  openclaw:
+    emoji: "🎮"
+    category: "domains"
+    subcategory: "ai-ml"
+    keywords: ["multi-agent RL", "VMAS", "simulator", "reinforcement learning", "vectorized", "cooperative"]
+    source: "https://github.com/proroklab/VectorizedMultiAgentSimulator"
+---
+
+# VMAS: Vectorized Multi-Agent Simulator Guide
+
+## Overview
+
+VMAS is a vectorized simulator for multi-agent reinforcement learning (MARL) that runs thousands of parallel environments on GPU via PyTorch. It provides a diverse set of 2D cooperative, competitive, and mixed scenarios for benchmarking multi-agent algorithms. Orders of magnitude faster than CPU-based simulators, enabling rapid research iteration on multi-agent coordination problems.
+
+## Installation
+
+```bash
+pip install vmas
+```
+
+## Quick Start
+
+```python
+import vmas
+
+# Create vectorized environment
+env = vmas.make_env(
+    scenario="simple_spread",
+    num_envs=1024,         # Parallel environments
+    num_agents=3,
+    device="cuda",         # GPU acceleration
+    continuous_actions=True,
+)
+
+# Environment loop
+obs = env.reset()
+for step in range(100):
+    # Random actions for demonstration
+    actions = [env.action_space[i].sample()
+               for i in range(env.n_agents)]
+
+    obs, rewards, dones, infos = env.step(actions)
+    # obs: list of [num_envs, obs_dim] tensors
+    # rewards: list of [num_envs] tensors
+```
+
+## Scenarios
+
+| Scenario | Type | Agents | Description |
+|----------|------|--------|-------------|
+| **simple_spread** | Cooperative | 3 | Cover N landmarks |
+| **simple_tag** | Competitive | 4 | Predator-prey |
+| **transport** | Cooperative | 4 | Move package to goal |
+| **wheel** | Cooperative | 4 | Coordination on wheel |
+| **flocking** | Cooperative | 5+ | Reynolds flocking |
+| **discovery** | Cooperative | 3 | Explore and discover |
+| **navigation** | Mixed | N | Multi-agent navigation |
+
+## Integration with MARL Libraries
+
+```python
+# With TorchRL
+from torchrl.envs import VmasEnv
+
+env = VmasEnv(
+    scenario="simple_spread",
+    num_envs=512,
+    device="cuda",
+)
+
+# With RLlib
+from ray.rllib.env import MultiAgentEnv
+# VMAS provides RLlib-compatible wrapper
+
+# With CleanRL / custom training
+import torch
+
+env = vmas.make_env("transport", num_envs=2048, device="cuda")
+obs = env.reset()
+
+# All tensors on GPU — train directly without CPU transfer
+policy_output = policy_network(obs[0])  # Agent 0 observations
+```
+
+## Custom Scenarios
+
+```python
+from vmas import Scenario, Agent, World, Landmark
+
+class MyScenario(Scenario):
+    def make_world(self, batch_dim, device):
+        world = World(batch_dim=batch_dim, device=device)
+        world.add_agent(Agent(name="agent_0"))
+        world.add_agent(Agent(name="agent_1"))
+        world.add_landmark(Landmark(name="goal"))
+        return world
+
+    def reset_world(self, env, world):
+        # Randomize positions
+        for agent in world.agents:
+            agent.set_pos(torch.rand(env.batch_dim, 2) * 2 - 1)
+
+    def reward(self, agent, world):
+        # Distance to goal
+        goal = world.landmarks[0]
+        return -torch.linalg.norm(agent.state.pos - goal.state.pos,
+                                   dim=-1)
+
+# Register and use
+env = vmas.make_env(MyScenario(), num_envs=512)
+```
+
+## Use Cases
+
+1. **MARL research**: Benchmark multi-agent algorithms
+2. **Cooperative learning**: Study emergent coordination
+3. **Scalability testing**: GPU-accelerated parallel training
+4. **Custom scenarios**: Design domain-specific multi-agent tasks
+5. **Education**: Teach multi-agent RL concepts
+
+## References
+
+- [VMAS GitHub](https://github.com/proroklab/VectorizedMultiAgentSimulator)
+- [VMAS Paper](https://arxiv.org/abs/2207.03530)
+- [BenchMARL](https://github.com/facebookresearch/BenchMARL)