weco 0.2.18__tar.gz → 0.2.20__tar.gz

{weco-0.2.18 → weco-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: weco
-Version: 0.2.18
+Version: 0.2.20
 Summary: Documentation for `weco`, a CLI for using Weco AI's code optimizer.
 Author-email: Weco AI Team <contact@weco.ai>
 License: MIT
@@ -29,6 +29,9 @@ Dynamic: license-file
 [![docs](https://img.shields.io/website?url=https://docs.weco.ai/&label=docs)](https://docs.weco.ai/)
 [![PyPI version](https://badge.fury.io/py/weco.svg)](https://badge.fury.io/py/weco)
 [![AIDE](https://img.shields.io/badge/AI--Driven_Exploration-arXiv-orange?style=flat-square&logo=arxiv)](https://arxiv.org/abs/2502.13138)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/WecoAI/weco-cli/blob/main/examples/hello-kernel-world/colab_notebook_walkthrough.ipynb)
+
+`pip install weco`
 
 </div>
 
@@ -98,9 +101,8 @@ pip install torch
 weco run --source optimize.py \
      --eval-command "python evaluate.py --solution-path optimize.py --device cpu" \
      --metric speedup \
-     --maximize true \
+     --goal maximize \
      --steps 15 \
-     --model gemini-2.5-pro-exp-03-25 \
      --additional-instructions "Fuse operations in the forward method while ensuring the max float deviation remains small. Maintain the same format of the code."
 ```
 
@@ -108,18 +110,27 @@ weco run --source optimize.py \
 
 ---
 
-**Arguments for `weco run`:**
-
-| Argument                    | Description                                                                                                                                                               | Required |
-| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------- |
-| `--source`                  | Path to the source code file that will be optimized (e.g., `optimize.py`).                                                                                                | Yes      |
-| `--eval-command`            | Command to run for evaluating the code in `--source`. This command should print the target `--metric` and its value to the terminal (stdout/stderr). See note below.      | Yes      |
-| `--metric`                  | The name of the metric you want to optimize (e.g., 'accuracy', 'speedup', 'loss'). This metric name should match what's printed by your `--eval-command`.                 | Yes      |
-| `--maximize`                | Whether to maximize (`true`) or minimize (`false`) the metric.                                                                                                            | Yes      |
-| `--steps`                   | Number of optimization steps (LLM iterations) to run.                                                                                                                     | Yes      |
-| `--model`                   | Model identifier for the LLM to use (e.g., `gpt-4o`, `claude-3.5-sonnet`). Recommended models to try include `o3-mini`, `claude-3-haiku`, and `gemini-2.5-pro-exp-03-25`. | Yes      |
-| `--additional-instructions` | (Optional) Natural language description of specific instructions OR path to a file containing detailed instructions to guide the LLM.                                     | No       |
-| `--log-dir`                 | (Optional) Path to the directory to log intermediate steps and final optimization result. Defaults to `.runs/`.                                                           | No       |
+### Arguments for `weco run`
+
+**Required:**
+
+| Argument            | Description                                                                                                                                                                                  |
+| :------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `-s, --source`      | Path to the source code file that will be optimized (e.g., `optimize.py`).                                                                                                                   |
+| `-c, --eval-command`| Command to run for evaluating the code in `--source`. This command should print the target `--metric` and its value to the terminal (stdout/stderr). See note below.                        |
+| `-m, --metric`      | The name of the metric you want to optimize (e.g., 'accuracy', 'speedup', 'loss'). This metric name should match what's printed by your `--eval-command`.                                    |
+| `-g, --goal`   | `maximize`/`max` to maximize the `--metric` or `minimize`/`min` to minimize it. |
+
+<br>
+
+**Optional:**
+
+| Argument                       | Description                                                                                                                                                                                                                | Default |
+| :----------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------ |
+| `-n, --steps`                  | Number of optimization steps (LLM iterations) to run.                                                                                                                                                                      | 100 |
+| `-M, --model`                  | Model identifier for the LLM to use (e.g., `gpt-4o`, `claude-3.5-sonnet`).                                                                                                                                                 | `o4-mini` when `OPENAI_API_KEY` is set; `claude-3-7-sonnet-20250219` when `ANTHROPIC_API_KEY` is set; `gemini-2.5-pro-exp-03-25` when `GEMINI_API_KEY` is set (priority: `OPENAI_API_KEY` > `ANTHROPIC_API_KEY` > `GEMINI_API_KEY`). |
+| `-i, --additional-instructions`| Natural language description of specific instructions **or** path to a file containing detailed instructions to guide the LLM.                                                                                             | `None` |
+| `-l, --log-dir`                | Path to the directory to log intermediate steps and final optimization result.                                                                                                                                             | `.runs/` |
 
 ---
 

{weco-0.2.18 → weco-0.2.20}/README.md

@@ -6,6 +6,9 @@
 [![docs](https://img.shields.io/website?url=https://docs.weco.ai/&label=docs)](https://docs.weco.ai/)
 [![PyPI version](https://badge.fury.io/py/weco.svg)](https://badge.fury.io/py/weco)
 [![AIDE](https://img.shields.io/badge/AI--Driven_Exploration-arXiv-orange?style=flat-square&logo=arxiv)](https://arxiv.org/abs/2502.13138)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/WecoAI/weco-cli/blob/main/examples/hello-kernel-world/colab_notebook_walkthrough.ipynb)
+
+`pip install weco`
 
 </div>
 
@@ -75,9 +78,8 @@ pip install torch
 weco run --source optimize.py \
      --eval-command "python evaluate.py --solution-path optimize.py --device cpu" \
      --metric speedup \
-     --maximize true \
+     --goal maximize \
      --steps 15 \
-     --model gemini-2.5-pro-exp-03-25 \
      --additional-instructions "Fuse operations in the forward method while ensuring the max float deviation remains small. Maintain the same format of the code."
 ```
 
@@ -85,18 +87,27 @@ weco run --source optimize.py \
 
 ---
 
-**Arguments for `weco run`:**
-
-| Argument                    | Description                                                                                                                                                               | Required |
-| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------- |
-| `--source`                  | Path to the source code file that will be optimized (e.g., `optimize.py`).                                                                                                | Yes      |
-| `--eval-command`            | Command to run for evaluating the code in `--source`. This command should print the target `--metric` and its value to the terminal (stdout/stderr). See note below.      | Yes      |
-| `--metric`                  | The name of the metric you want to optimize (e.g., 'accuracy', 'speedup', 'loss'). This metric name should match what's printed by your `--eval-command`.                 | Yes      |
-| `--maximize`                | Whether to maximize (`true`) or minimize (`false`) the metric.                                                                                                            | Yes      |
-| `--steps`                   | Number of optimization steps (LLM iterations) to run.                                                                                                                     | Yes      |
-| `--model`                   | Model identifier for the LLM to use (e.g., `gpt-4o`, `claude-3.5-sonnet`). Recommended models to try include `o3-mini`, `claude-3-haiku`, and `gemini-2.5-pro-exp-03-25`. | Yes      |
-| `--additional-instructions` | (Optional) Natural language description of specific instructions OR path to a file containing detailed instructions to guide the LLM.                                     | No       |
-| `--log-dir`                 | (Optional) Path to the directory to log intermediate steps and final optimization result. Defaults to `.runs/`.                                                           | No       |
+### Arguments for `weco run`
+
+**Required:**
+
+| Argument            | Description                                                                                                                                                                                  |
+| :------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `-s, --source`      | Path to the source code file that will be optimized (e.g., `optimize.py`).                                                                                                                   |
+| `-c, --eval-command`| Command to run for evaluating the code in `--source`. This command should print the target `--metric` and its value to the terminal (stdout/stderr). See note below.                        |
+| `-m, --metric`      | The name of the metric you want to optimize (e.g., 'accuracy', 'speedup', 'loss'). This metric name should match what's printed by your `--eval-command`.                                    |
+| `-g, --goal`   | `maximize`/`max` to maximize the `--metric` or `minimize`/`min` to minimize it. |
+
+<br>
+
+**Optional:**
+
+| Argument                       | Description                                                                                                                                                                                                                | Default |
+| :----------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------ |
+| `-n, --steps`                  | Number of optimization steps (LLM iterations) to run.                                                                                                                                                                      | 100 |
+| `-M, --model`                  | Model identifier for the LLM to use (e.g., `gpt-4o`, `claude-3.5-sonnet`).                                                                                                                                                 | `o4-mini` when `OPENAI_API_KEY` is set; `claude-3-7-sonnet-20250219` when `ANTHROPIC_API_KEY` is set; `gemini-2.5-pro-exp-03-25` when `GEMINI_API_KEY` is set (priority: `OPENAI_API_KEY` > `ANTHROPIC_API_KEY` > `GEMINI_API_KEY`). |
+| `-i, --additional-instructions`| Natural language description of specific instructions **or** path to a file containing detailed instructions to guide the LLM.                                                                                             | `None` |
+| `-l, --log-dir`                | Path to the directory to log intermediate steps and final optimization result.                                                                                                                                             | `.runs/` |
 
 ---
 

{weco-0.2.18 → weco-0.2.20}/examples/cuda/README.md

@@ -21,7 +21,7 @@ Run the following command to start the optimization process:
 weco run --source optimize.py \
          --eval-command "python evaluate.py --solution-path optimize.py" \
          --metric speedup \
-         --maximize true \
+         --goal maximize \
          --steps 30 \
          --model gemini-2.5-pro-exp-03-25 \
          --additional-instructions guide.md
@@ -32,7 +32,7 @@ weco run --source optimize.py \
 *   `--source optimize.py`: The initial PyTorch self-attention code to be optimized with CUDA.
 *   `--eval-command "python evaluate.py --solution-path optimize.py"`: Runs the evaluation script, which compiles (if necessary) and benchmarks the CUDA-enhanced code in `optimize.py` against a baseline, printing the `speedup`.
 *   `--metric speedup`: The optimization target metric.
-*   `--maximize true`: Weco aims to increase the speedup.
+*   `--goal maximize`: Weco aims to increase the speedup.
 *   `--steps 30`: The number of optimization iterations.
 *   `--model gemini-2.5-pro-exp-03-25`: The LLM used for code generation.
 *   `--additional-instructions guide.md`: Points Weco to a file containing detailed instructions for the LLM on how to write the CUDA kernels, handle compilation (e.g., using `torch.utils.cpp_extension`), manage data types, and ensure correctness.

weco-0.2.20/examples/hello-kernel-world/colab_notebook_walkthrough.ipynb

@@ -0,0 +1,310 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Hello Kernel World 🔥"
+      ],
+      "metadata": {
+        "id": "RO1o5fS5W8xc"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "<p align=\"left\">\n",
+        "  <img src=\"https://raw.githubusercontent.com/WecoAI/weco-cli/main/assets/example-optimization.gif\"\n",
+        "       alt=\"Optimization demo\"\n",
+        "       width=\"720\">\n",
+        "</p>\n",
+        "\n",
+        "## 🖥️ Weco CLI Resources\n",
+        "\n",
+        "- 📖 [CLI Reference](https://docs.weco.ai/cli/cli-reference) - Explore our docs for an in-depth look at what the tool can do\n",
+        "- ✨ [Examples](https://docs.weco.ai/examples) - Explore automated R&D across kernel engineering, ML engineering and prompt engineering"
+      ],
+      "metadata": {
+        "id": "yorBWlqGuC7-"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Setup Dependencies"
+      ],
+      "metadata": {
+        "id": "5BQGGqbJW2Eq"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Install requirements\n",
+        "%pip install -q weco ipywidgets numpy torch\n",
+        "\n",
+        "# Enable custom widgets\n",
+        "from google.colab import output\n",
+        "output.enable_custom_widget_manager()"
+      ],
+      "metadata": {
+        "id": "89doT3fbWcGi"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now we need to determine what `DEVICE` we can run this on, a CPU or GPU..."
+      ],
+      "metadata": {
+        "id": "gYxLwOXzfmiF"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import torch\n",
+        "from rich import print as rprint\n",
+        "\n",
+        "# Check if you're connected to a GPU (it's free!)\n",
+        "if not torch.cuda.is_available():\n",
+        "    DEVICE = \"cpu\"\n",
+        "    rprint(\n",
+        "        \"\"\"\n",
+        "[bold yellow]⚠️  GPU is not enabled.[/bold yellow] The notebook will fall back to [bold]CPU[/bold], but [italic]performance may be lower[/italic].\n",
+        "\n",
+        "[bold]👉 To enable GPU (FREE):[/bold]\n",
+        "• Go to [green]Runtime > Change runtime type[/green]\n",
+        "• Set [bold]'Hardware Accelerator'[/bold] to [bold green]'GPU'[/bold green]\n",
+        "• Click [bold]Save[/bold] and [bold]rerun all cells[/bold]\n",
+        "\n",
+        "[dim]Continuing with CPU for now...[/dim]\n",
+        "\"\"\"\n",
+        "    )\n",
+        "else:\n",
+        "    DEVICE = \"cuda\"\n",
+        "    rprint(\"[bold green]✅ GPU is enabled.[/bold green] Proceeding with [bold green]CUDA[/bold green]...\")"
+      ],
+      "metadata": {
+        "id": "PFAn_bzAXLGO"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Download the example files from CLI repo\n",
+        "!wget https://github.com/WecoAI/weco-cli/archive/refs/heads/main.zip -O repo.zip\n",
+        "!unzip -j repo.zip \"weco-cli-main/examples/hello-kernel-world/*\" -d .\n",
+        "!rm repo.zip"
+      ],
+      "metadata": {
+        "id": "dFGClqxpzwyM"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Google AI Studio has a free API usage quota. Create a key [here](https://aistudio.google.com/apikey) to use `weco` for free!"
+      ],
+      "metadata": {
+        "id": "PGlEsI78bMtN"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import os\n",
+        "\n",
+        "# Pass your API key below\n",
+        "os.environ[\"GEMINI_API_KEY\"] = \"\"\n",
+        "# os.environ[\"OPENAI_API_KEY\"] = \"\"\n",
+        "# os.environ[\"ANTHROPIC_API_KEY\"] = \"\"\n",
+        "\n",
+        "\n",
+        "if not any([os.environ.get(key) for key in [\"GEMINI_API_KEY\", \"OPENAI_API_KEY\", \"ANTHROPIC_API_KEY\"]]):\n",
+        "    rprint(\n",
+        "\"[bold red]❌ No API keys found.[/bold red]\\n\"\n",
+        "\"\\n\"\n",
+        "\"Please set one of the following environment variables:\\n\"\n",
+        "\"  • [cyan]GEMINI_API_KEY[/cyan]\\n\"\n",
+        "\"  • [cyan]OPENAI_API_KEY[/cyan]\\n\"\n",
+        "\"  • [cyan]ANTHROPIC_API_KEY[/cyan]\\n\"\n",
+        "\"\\n\"\n",
+        "\"Setup your [cyan]GEMINI_API_KEY[/cyan] for free - [underline white]https://aistudio.google.com/apikey[/underline white] !\"\n",
+        "    )\n",
+        "else:\n",
+        "    rprint(\"[bold green]✅ API keys found.[/bold green]\\n\\nWe'll only be able to know if they are correct once the optimization starts.\")"
+      ],
+      "metadata": {
+        "id": "b4XuOeNzYTdp"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Let's Start Optimizing!"
+      ],
+      "metadata": {
+        "id": "sbvA8oQceOt5"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now that we've got our dependecies, GPU and LLM API key sorted out, let's take a look at what code we're optimizing!\n",
+        "\n",
+        "Earlier, we downloaded two files:\n",
+        "1. An evaluation script to help score *how good a solution is* (`evaluate.py`)\n",
+        "2. A snippet of code we'd like to optimize (`optimize.py`)\n",
+        "\n",
+        "Let's take a look at what the code we want to optimize looks like..."
+      ],
+      "metadata": {
+        "id": "4OjXTBkjc4Id"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from IPython.display import display, HTML\n",
+        "from pygments import highlight\n",
+        "from pygments.lexers import PythonLexer\n",
+        "from pygments.formatters import HtmlFormatter\n",
+        "\n",
+        "def view_code_block(path: str):\n",
+        "    with open(path) as f:\n",
+        "        display(HTML(highlight(f.read(), PythonLexer(), HtmlFormatter(full=True, style=\"monokai\"))))\n",
+        "\n",
+        "view_code_block(\"optimize.py\")"
+      ],
+      "metadata": {
+        "id": "rUTxqxWgcC34"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Real-world code is often more complex but this is a good place to start. You can find more advanced examples [here](https://docs.weco.ai/examples), however, we'd recommend starting with this notebook as the optimization setup is the exact same, no matter the complexity!"
+      ],
+      "metadata": {
+        "id": "5C5dvasXdmNw"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "It's simple to start optimizing any piece of code! You just need to set:\n",
+        "1. Path to source code - we can point this to our `optimize.py`\n",
+        "2. Command to run evaluation - notice how we are using the `DEVICE` we setup earlier\n",
+        "3. The metric we are optimizing for - in this case, the evaluation script (`evaluate.py`) prints the `'speedup'` achieved to the terminal\n",
+        "4. Whether you want to maximize or minimize the metric you mentioned above - in our case, we want to make this code faster!\n",
+        "5. Number of steps to optimize for - we'll keep it low to avoid any rate limits being hit on your free Gemini API key\n",
+        "6. Additional context - anything information you think should guide the optimization process"
+      ],
+      "metadata": {
+        "id": "YfDg-pP9fAdC"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Now let's get straight into it. Keep an eye on the `Best Solution` panel!\n",
+        "\n",
+        "Note that you can track the optimization in the logs directory (`.runs/`) and on our dashboard (links shown in the `Summary` panel)."
+      ],
+      "metadata": {
+        "id": "TbG_3nwEhs5G"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import sys, weco.cli as weco_cli\n",
+        "\n",
+        "# When running in a terminal, you can use this instead:\n",
+        "# weco run --source optimize.py \\\n",
+        "#      --eval-command f\"python evaluate.py --solution-path optimize.py --device {DEVICE}\" \\\n",
+        "#      --metric speedup \\\n",
+        "#      --goal maximize \\\n",
+        "#      --steps 10 \\\n",
+        "#      --additional-instructions \"Fuse operations in the forward method while ensuring the max float deviation remains small.\"\n",
+        "\n",
+        "sys.argv = [\n",
+        "    \"weco\", \"run\",\n",
+        "    \"--source\", \"optimize.py\",\n",
+        "    \"--eval-command\", f\"python evaluate.py --solution-path optimize.py --device {DEVICE}\",\n",
+        "    \"--metric\", \"speedup\",\n",
+        "    \"--goal\", \"maximize\",\n",
+        "    \"--steps\", \"10\",\n",
+        "    \"--additional-instructions\", \"Fuse operations in the forward method while ensuring the max float deviation remains small.\"\n",
+        "]\n",
+        "\n",
+        "try: weco_cli.main()\n",
+        "except SystemExit: pass"
+      ],
+      "metadata": {
+        "id": "17YZ2euZplDJ"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Let's take a look at what our optimized code looks like (`optimize.py`)!"
+      ],
+      "metadata": {
+        "id": "990ueX_JsO_1"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "view_code_block(\"optimize.py\")"
+      ],
+      "metadata": {
+        "id": "9dqfzXkajQKs"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "Happy Optimizing from the [Weco](https://www.weco.ai/) Team!\n",
+        "\n",
+        "If you'd like to learn more about what Weco can do, here are some spots to check out:\n",
+        "- 📖 [CLI Reference](https://docs.weco.ai/cli/cli-reference) - Explore our docs for an in-depth look at what the tool can do\n",
+        "- ✨ [Examples](https://docs.weco.ai/examples) - Explore automated R&D across kernel engineering, ML engineering and prompt engineering"
+      ],
+      "metadata": {
+        "id": "17oICow9yjn8"
+      }
+    }
+  ]
+}

{weco-0.2.18 → weco-0.2.20}/examples/prompt/README.md

@@ -24,10 +24,10 @@ This example uses `gpt-4o-mini` via the OpenAI API by default. Ensure your `OPEN
    weco --source optimize.py \
         --eval-command "python eval.py" \
         --metric accuracy \
-        --maximize true \
+        --goal maximize \
         --steps 40 \
         --model gemini-2.5-flash-preview-04-17 \
-        --addtional-instructions prompt_guide.md
+        --additional-instructions prompt_guide.md
    ```
 
 During each evaluation round you will see log lines similar to the following.

{weco-0.2.18 → weco-0.2.20}/examples/spaceship-titanic/README.md

@@ -20,7 +20,7 @@ Run the following command to start optimizing the model:
 weco run --source evaluate.py \
          --eval-command "python evaluate.py --data-dir ./data" \
          --metric accuracy \
-         --maximize true \
+         --goal maximize \
          --steps 20 \
          --model o4-mini \
          --additional-instructions "Improve feature engineering, model choice and hyper-parameters."
@@ -34,7 +34,7 @@ weco run --source evaluate.py \
     *   [optional] `--data-dir`: path to the train and test data.
     *   [optional] `--seed`: Seed for reproduce the experiment.
 *   `--metric accuracy`: The target metric Weco should optimize.
-*   `--maximize true`: Weco aims to increase the accuracy.
+*   `--goal maximize`: Weco aims to increase the accuracy.
 *   `--steps 10`: The number of optimization iterations.
 *   `--model gemini-2.5-pro-exp-03-25`: The LLM driving the optimization.
 *   `--additional-instructions "Improve feature engineering, model choice and hyper-parameters."`: A simple instruction for model improvement or you can put the path to [`comptition_description.md`](./competition_description.md) within the repo to feed the agent more detailed information.

{weco-0.2.18 → weco-0.2.20}/examples/triton/README.md

@@ -19,7 +19,7 @@ Run the following command to start the optimization process:
 weco run --source optimize.py \
          --eval-command "python evaluate.py --solution-path optimize.py" \
          --metric speedup \
-         --maximize true \
+         --goal maximize \
          --steps 30 \
          --model gemini-2.5-pro-exp-03-25 \
          --additional-instructions "Use triton to optimize the code while ensuring a small max float diff. Maintain the same code format."
@@ -30,7 +30,7 @@ weco run --source optimize.py \
 *   `--source optimize.py`: The PyTorch self-attention implementation to be optimized.
 *   `--eval-command "python evaluate.py --solution-path optimize.py"`: Executes the evaluation script, which benchmarks the `optimize.py` code against a baseline and prints the `speedup`.
 *   `--metric speedup`: The target metric for optimization.
-*   `--maximize true`: Weco should maximize the speedup.
+*   `--goal maximize`: The agent should maximize the speedup.
 *   `--steps 30`: The number of optimization iterations.
 *   `--model gemini-2.5-pro-exp-03-25`: The LLM driving the optimization.
 *   `--additional-instructions "..."`: Provides specific guidance to the LLM, instructing it to use Triton, maintain numerical accuracy ("small max float diff"), and preserve the code structure.

{weco-0.2.18 → weco-0.2.20}/pyproject.toml

@@ -8,7 +8,7 @@ name = "weco"
 authors = [{ name = "Weco AI Team", email = "contact@weco.ai" }]
 description = "Documentation for `weco`, a CLI for using Weco AI's code optimizer."
 readme = "README.md"
-version = "0.2.18"
+version = "0.2.20"
 license = { text = "MIT" }
 requires-python = ">=3.8"
 dependencies = ["requests", "rich", "packaging"]