Optimize with the CLI

Select code to optimize

Weco can optimize code in any programming language (a GPU kernel, an ML model, a prompt, and so on) — either a single file (--source) or up to 10 files together (--sources).

For example, a simple PyTorch module:

# File: module.py

import torch
import torch.nn as nn

class Model(nn.Module):
    """
    Model that performs a matrix multiplication, division, summation, and scaling.
    """

    def __init__(self, input_size, hidden_size, scaling_factor):
        super(Model, self).__init__()
        self.weight = nn.Parameter(torch.randn(hidden_size, input_size))
        self.scaling_factor = scaling_factor

    def forward(self, x):
        x = torch.matmul(x, self.weight.T)
        x = x / 2
        x = torch.sum(x, dim=1, keepdim=True)
        x = x * self.scaling_factor
        return x

Define the goal of the optimization

You need an evaluation script that:

1. Evaluates the code you picked in Step 1 with a quantitative metric.
2. Prints the metric name and value to the console (like speedup: 2.5) so Weco can read it.

# File: evaluate.py

# Load the baseline model and the optimized model...
# Prepare test data...

# Evaluate performance
baseline_time = benchmark(baseline_model, test_inputs)
optimized_time = benchmark(optimized_model, test_inputs)
speedup = baseline_time / optimized_time

# Print the metric for Weco to read
print(f"speedup: {speedup}")

Run Weco on your code

weco run --source <path-to-your-code-to-optimize> \
     --eval-command <command-to-run-the-evaluation-script> \
     --metric <metric-name> \
     --goal <maximize/minimize> \
     --steps <number-of-optimization-iterations> \
     --additional-instructions <additional-instructions-for-the-LLM-to-follow>

weco run --source <path-to-your-code-to-optimize> ^
     --eval-command <command-to-run-the-evaluation-script> ^
     --metric <metric-name> ^
     --goal <maximize/minimize> ^
     --steps <number-of-optimization-iterations> ^
     --additional-instructions <additional-instructions-for-the-LLM-to-follow>

weco run --source <path-to-your-code-to-optimize> `
     --eval-command <command-to-run-the-evaluation-script> `
     --metric <metric-name> `
     --goal <maximize/minimize> `
     --steps <number-of-optimization-iterations> `
     --additional-instructions <additional-instructions-for-the-LLM-to-follow>

Weco iteratively optimizes the file(s) specified by --source (or --sources). At each iteration it:

1. Generates a new version of the code and writes it to the file(s).
2. Runs the evaluation script specified by --eval-command to measure performance.
3. Checks whether the metric specified by --metric improved, and proposes further changes.

After all iterations (--steps) complete, the file holds the best-performing version found.

If your code spans multiple files, pass them all and Weco makes coordinated changes across file boundaries:

weco run --sources model.py utils.py config.py \
     --eval-command "python evaluate.py" \
     --metric accuracy \
     --goal maximize

For the full set of commands and options, see the CLI Reference.

Inspect and share the results

Besides the status in your terminal, you can watch the optimization in the dashboard in real time and share the results with your team. See Watch, share & manage runs.