← Back to Skills Marketplace
anonymouscodemaker

ELPA

by AnonymousCodeMaker · GitHub ↗ · v1.0.0 · MIT-0
cross-platform ⚠ suspicious
257
Downloads
0
Stars
0
Active Installs
1
Versions
Install in OpenClaw
/install elpa
Description
Orchestrate real ELPA-style ensemble forecasting workflows by triggering external sub-model training jobs (for example PyTorch/Prophet/TiDE/transformers), th...
README (SKILL.md)

ELPA

Overview

This skill does not train toy adapters. It triggers real sub-model training commands from your own training codebases and then builds ELPA routing/weights from real validation errors.

Default model pool is intentionally larger than 4 and can be expanded freely.

Workflow

  1. Prepare a training config JSON (see assets/elpa_train_template.json).
  2. Dry-run the command plan to verify all sub-model commands.
  3. Execute real sub-model training when resources are available.
  4. Prepare validation error inputs per model.
  5. Build ELPA ensemble policy JSON from those errors.

1) Prepare Config

Create a config based on assets/elpa_train_template.json.

  • Put your real training entrypoints in each model train_cmd.
  • Keep each model tagged as online or offline.
  • Add as many models as needed; ELPA is not limited to 4.

2) Dry-Run Plan (No Training)

python3 scripts/elpa_orchestrator.py \
  --config assets/elpa_train_template.json \
  --run-dir .runtime/elpa_run \
  --manifest-out .runtime/elpa_run/train_manifest.json

This prints and records the commands that would run, without training.

3) Execute Real Training

python3 scripts/elpa_orchestrator.py \
  --config /path/to/your_train_config.json \
  --run-dir .runtime/elpa_run \
  --manifest-out .runtime/elpa_run/train_manifest.json \
  --execute

Use this only in an environment that has the required ML dependencies and hardware.

4) Build ELPA Integration Policy

After each sub-model produces validation errors, run:

python3 scripts/elpa_integrator.py \
  --config /path/to/your_integrate_config.json \
  --output .runtime/elpa_run/elpa_policy.json

The output includes:

  • scores for each model from validation errors
  • online_weights and offline_weights
  • best_online_model and best_offline_model
  • ELPA control fields (beta, dirty_interval, amplitude_window, mutant_epsilon)

Model Scaling

To support more models, append model blocks in your config with:

  • unique name
  • group as online or offline
  • real train_cmd

No script changes are needed for adding models.

Files

  • scripts/elpa_orchestrator.py: real sub-model training command planner/executor
  • scripts/elpa_integrator.py: ELPA score/weight builder from validation errors
  • assets/elpa_train_template.json: >4-model real training template
  • assets/elpa_integrate_template.json: ELPA integration template
  • references/config-schema.md: config field reference and placeholders
Usage Guidance
This skill is coherent for orchestrating real training, but it will execute whatever shell commands appear in the JSON config. Only use configs and train_cmd templates from trusted sources. Recommended precautions: - Always run a dry-run first and inspect the generated manifest and train_cmd strings before using --execute. - Use a dedicated, sandboxed environment (container or isolated VM) with controlled dataset and filesystem access for execution. - Set run-dir to a directory you control and review stdout/stderr logs for secrets or unexpected output. - Inspect any per-model "env" entries in configs to ensure they don't inject sensitive credentials into subprocesses. - Avoid running this skill with configs obtained from untrusted third parties; validate templates and placeholders to prevent accidental execution of destructive commands (e.g., via shell metacharacters).
Capability Analysis
Type: OpenClaw Skill Name: elpa Version: 1.0.0 The skill bundle contains a script, scripts/elpa_orchestrator.py, which executes arbitrary shell commands constructed from a JSON configuration file using subprocess.run(shell=True). While this is consistent with the stated purpose of orchestrating ML training workflows, the use of unsanitized string formatting to build shell commands represents a significant command injection vulnerability. No evidence of intentional malice, data exfiltration, or unauthorized network activity was found.
Capability Assessment
Purpose & Capability
Name/description match the code and assets: the orchestrator builds a plan and (optionally) runs real sub-model training commands and the integrator computes weights from validation errors. No unrelated credentials, binaries, or external services are requested.
Instruction Scope
SKILL.md instructs the agent to dry-run and optionally execute training commands from a user-supplied JSON config; the code reads those configs, renders command templates, writes manifests and logs, and reads CSVs for errors. This stays within the described purpose but implies execution of arbitrary shell commands from the config — expected for this tool, but a significant operational risk if configs are untrusted.
Install Mechanism
Instruction-only with included Python scripts; there is no install spec, no external downloads, and no package installation steps. Files are written under the chosen run-dir; nothing is pulled from external hosts.
Credentials
The skill declares no required environment variables or credentials. Per-model configs may include an "env" object which the orchestrator will merge into the subprocess environment — this is appropriate for training jobs but means the config can inject environment values into executed processes.
Persistence & Privilege
The skill does not request always:true and does not attempt to modify other skills. It writes manifests, logs, and model directories under the run-dir (default .runtime/elpa_runs/<timestamp> or user-specified path), which is expected behavior for an orchestrator.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install elpa
  3. After installation, invoke the skill by name or use /elpa
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v1.0.0
- Initial release of the elpa skill, enabling orchestration of real ELPA-style ensemble forecasting workflows. - Supports triggering external sub-model training jobs using your own training scripts for frameworks like PyTorch, Prophet, and transformers. - Automatically computes ELPA ensemble weights and policies from real sub-model validation errors. - Provides scalable model pool support—no hard limit on the number of models. - Includes templates, orchestration scripts, and integration tools for production-ready ensemble pipelines.
Metadata
Slug elpa
Version 1.0.0
License MIT-0
All-time Installs 0
Active Installs 0
Total Versions 1
Frequently Asked Questions

What is ELPA?

Orchestrate real ELPA-style ensemble forecasting workflows by triggering external sub-model training jobs (for example PyTorch/Prophet/TiDE/transformers), th... It is an AI Agent Skill for Claude Code / OpenClaw, with 257 downloads so far.

How do I install ELPA?

Run "/install elpa" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is ELPA free?

Yes, ELPA is completely free, licensed under MIT-0. You can download, install and use it at no cost.

Which platforms does ELPA support?

ELPA is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created ELPA?

It is built and maintained by AnonymousCodeMaker (@anonymouscodemaker); the current version is v1.0.0.

💬 Comments