Programs as Weights

https://docs.programasweights.com/
Admin
Programs as Weights is a platform that compiles natural language descriptions into tiny neural...
Tokens:9,164
Snippets:131
Trust Score:4.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install ProgramAsWeights

Source: https://docs.programasweights.com/

Install the library using pip.

```bash
$pip install programasweights
```

--------------------------------

### Install ProgramAsWeights

Source: https://docs.programasweights.com/hub/aa4e3f80ea4f77463747

Install the library using pip with the provided extra index URL.

```bash
pip install programasweights --extra-index-url https://pypi.programasweights.com/simple/
```

--------------------------------

### Worked Example: Log Monitoring

Source: https://docs.programasweights.com/agents

An example demonstrating how to use PAW functions to classify log output, including compilation with examples and reuse.

```APIDOC
## Worked Example: Log Monitoring

### Description
This example shows how PAW functions can be used to classify log output. It demonstrates compiling a program with specific examples from logs and then reusing the compiled function locally.

### Example
```python
# Compile a program to classify log lines into 'ALERT' or 'QUIET'
program = paw.compile("""
Classify log lines. Return ONLY one word: ALERT or QUIET.

Input: [step 100] loss=0.05 lr=0.0001
Output: QUIET

Input: [Checkpoint] Saved model at step 1000
Output: ALERT

Input: Traceback (most recent call last):
Output: ALERT

Input: Training complete. Final loss: 0.11
Output: ALERT
""")

# Reuse the function using the compiled program's ID
fn = paw.function(program.id)

# Classify sample log lines
print(f"Log: [step 200] loss=0.04 -> Classification: {fn('[step 200] loss=0.04')}")
print(f"Log: [Checkpoint] Saved model -> Classification: {fn('[Checkpoint] Saved model')}")
print(f"Log: Traceback (most recent call last): -> Classification: {fn('Traceback (most recent call last):')}")
```

### Notes
This pattern is efficient as the compilation step is performed only once, and the resulting function can be reused multiple times. A full tool with file watching, truncation, and stall detection is available in the examples directory (`examples/paw_monitor.py`).
```

--------------------------------

### Install ProgramAsWeights SDK

Source: https://docs.programasweights.com/

Provides installation instructions for the ProgramAsWeights Python SDK and the browser SDK.

```Shell
pip install programasweights
```

```Shell
npm install @programasweights/web
```

--------------------------------

### Community Program Examples

Source: https://docs.programasweights.com/

These examples show input-output pairs for community-shared ProgramAsWeights programs, illustrating their capabilities.

```Text
Input: how does compilation work
Output: A 4B compiler generates a LoRA adapter and pseudo-program from your spec.
```

```Text
Input: what models are available
Output: Qwen3 0.6B for accuracy and GPT-2 124M for browser deployment.
```

```Text
Input: how fast is it
Output: About 100ms per call.
```

```Text
Input: how do I install it
Output: pip install programasweights for Python, npm install @programasweights/web for browser.
```

```Text
Input: how big are the programs
Output: About 22 MB for Qwen3 programs and 5 MB for GPT-2 programs.
```

```Text
Input: what is the license
Output: MIT license, free and open source.
```

```Text
Input: what can I use PAW for
Output: Fuzzy search, format repair, classification, extraction, log triage, and intent routing.
```

```Text
Input: what does PAW stand for
Output: ProgramAsWeights.
```

```Text
Input: what is a LoRA adapter
Output: A small set of weights that specializes the base model for your specific task.
```

--------------------------------

### Install JavaScript SDK

Source: https://docs.programasweights.com/agents

Installs the Programasweights web SDK using npm. This SDK allows running programs in the browser via WebAssembly.

```bash
npm install @programasweights/web
```

--------------------------------

### Execute a Function with ProgramAsWeights

Source: https://docs.programasweights.com/hub/ba368f1779084809f5e3

Import the library and use it to execute a function with a given input. Requires the 'programasweights' library to be installed.

```python
import programasweights as paw

fn = paw.function("ba368f1779084809f5e3")
result = fn("your input here")
print(result)
```

--------------------------------

### PAW Log Monitor Example Session

Source: https://docs.programasweights.com/agents

An example session output from the `paw_monitor.py` script, showing log lines being classified as 'QUIET' or 'ALERT' with timestamps and line counts.

```bash
$ python paw_monitor.py --log training.log --poll 10
[monitor] Loading PAW function 3a8f...
[monitor] Watching: training.log

[14:02:15] QUIET | +12 lines | [step 200] loss=0.04 lr=0.0001
[14:02:25] QUIET | +8 lines  | Loading batch 1024...
[14:05:10] ALERT | +3 lines
  | [Checkpoint] Saved model at step 1000
  | Training complete. Final loss: 0.11
```

--------------------------------

### Compile a Classifier for Logs (PAW Example)

Source: https://docs.programasweights.com/agents

This example demonstrates compiling a PAW function to classify log lines into 'ALERT' or 'QUIET' categories using provided input/output examples. The compiled function's ID is saved to a file.

```python
import programasweights as paw
p = paw.compile('''
Classify log lines. Return ONLY: ALERT or QUIET.

Input: [step 100] loss=0.05
Output: QUIET

Input: [Checkpoint] Saved model
Output: ALERT

Input: Traceback (most recent call last):
Output: ALERT
''')
print(p.id)
```

--------------------------------

### Monitor Logs with PAW

Source: https://docs.programasweights.com/agents

Compile a program with few-shot examples to classify log output, then reuse the program ID for local inference.

```python
program = paw.compile("""
Classify log lines. Return ONLY one word: ALERT or QUIET.

Input: [step 100] loss=0.05 lr=0.0001
Output: QUIET

Input: [Checkpoint] Saved model at step 1000
Output: ALERT

Input: Traceback (most recent call last):
Output: ALERT

Input: Training complete. Final loss: 0.11
Output: ALERT
""")

fn = paw.function(program.id)  # reuse with saved program.id
fn("[step 200] loss=0.04")           # "QUIET"
fn("[Checkpoint] Saved model")       # "ALERT"
```

--------------------------------

### Compile and Load Python Function

Source: https://docs.programasweights.com/agents

Compiles a spec and loads it as a function in Python. Ensure your spec includes explicit output constraints and relevant input/output examples for better performance.

```python
fn = paw.compile_and_load("""
Classify user intent. Return ONLY one of: search, create, delete, other.

Input: Find the latest report
Output: search

Input: Make a new folder
Output: create

Input: Remove old backups
Output: delete
""")
```

--------------------------------

### List Available Compilers in PAW

Source: https://docs.programasweights.com/agents

Call `paw.list_compilers()` to get a list of currently supported compiler names that can be explicitly passed to `paw.compile` or `paw.compile_and_load`.

```python
paw.list_compilers()
```

--------------------------------

### Compile a ProgramAsWeights Specification

Source: https://docs.programasweights.com/

This command-line instruction shows how to compile a natural language specification into a ProgramAsWeights program.

```Shell
paw compile --spec "..."
```

--------------------------------

### Execute a ProgramAsWeights Function

Source: https://docs.programasweights.com/

Demonstrates running a compiled ProgramAsWeights function with a sample input. The output is a classification based on the natural language spec.

```Python
f("I love this!") → "positive"
```

--------------------------------

### Use Pre-compiled Function

Source: https://docs.programasweights.com/docs

Load and use a pre-compiled function from the ProgramAsWeights library. The base model and adapter download automatically on first use and run locally thereafter.

```python
import programasweights as paw

# Load by name (downloads once, runs locally after that)
fn = paw.function("email-triage")

# Call it like any Python function
result = fn("Meeting moved to 3pm, need your signature today")
print(result)  # "immediate"

result = fn("Department newsletter: spring picnic next Friday")
print(result)  # "wait"
```

--------------------------------

### Listing Programs, Versions, and Compilers

Source: https://docs.programasweights.com/agents

APIs to list available programs, their version history, and the compilers that can be used.

```APIDOC
## Listing Programs, Versions, and Compilers

### Description
Retrieve lists of programs, their version histories, and available compilers.

### Method
`paw.list_versions(slug: str) -> List[str]`
`paw.list_programs(sort: str = "recent", per_page: int = 20) -> List[Program]`
`paw.list_compilers() -> List[str]`

### Parameters
#### `paw.list_versions` Parameters
- **slug** (str) - Required - The slug of the program to list versions for.

#### `paw.list_programs` Parameters
- **sort** (str) - Optional - How to sort the programs (e.g., "recent"). Defaults to "recent".
- **per_page** (int) - Optional - Number of programs to return per page. Defaults to 20.

### Request Example (List Versions)
```python
versions = paw.list_versions("da03/my-classifier")
```

### Request Example (List Programs)
```python
programs = paw.list_programs(sort="recent", per_page=20)  # requires auth
```

### Request Example (List Compilers)
```python
compilers = paw.list_compilers()
```

### Response (Versions)
- A list of version strings for the specified program slug.

### Response (Programs)
- A list of Program objects, each containing details like id, slug, status, etc.

### Response (Compilers)
- A list of available compiler names (strings).
```

--------------------------------

### Program Compilation and Function Loading

Source: https://docs.programasweights.com/agents

Demonstrates how to compile a natural language specification into a Program object and then load it as an executable function. It also shows how to load existing programs using their ID, slug, or versioned slug.

```APIDOC
## Program Compilation and Function Loading

### Description
Compile a natural language specification into a Program object, which can then be used to create an executable function. Functions can also be loaded directly using their program ID, slug, or a versioned slug.

### Method
`paw.compile(spec: str, compiler: Optional[str] = None, slug: Optional[str] = None, public: bool = True) -> Program`
`paw.function(program: Union[Program, str], offline: bool = False) -> Callable`
`paw.compile_and_load(spec: str, compiler: Optional[str] = None, slug: Optional[str] = None, public: bool = True) -> Callable`

### Parameters
#### `paw.compile` Parameters
- **spec** (str) - Required - The natural language specification for the program.
- **compiler** (Optional[str]) - Optional - The compiler to use. Defaults to the server's default.
- **slug** (Optional[str]) - Optional - A URL-safe handle for the program (requires authentication).
- **public** (bool) - Optional - Whether to list the program on the public hub. Defaults to True.

#### `paw.function` Parameters
- **program** (Union[Program, str]) - Required - A Program object, program ID, slug, or versioned slug.
- **offline** (bool) - Optional - If True, skips server checks. Defaults to False.

### Request Example (Compilation)
```python
program = paw.compile(
    spec='Classify the sentiment of the text.',
    public=True
)
```

### Request Example (Loading Function)
```python
# Load from Program object
fn_from_program = paw.function(program)

# Load from program ID
fn_from_id = paw.function("a6b454023d41ac9ca845")

# Load from slug
fn_from_slug = paw.function("da03/my-classifier")

# Load from versioned slug
fn_from_versioned_slug = paw.function("da03/my-classifier@v2")

# Load offline
fn_offline = paw.function("da03/my-classifier", offline=True)
```

### Request Example (Compile and Load)
```python
fn = paw.compile_and_load("Classify the sentiment of the text.")
```

### Response (Program Object)
- **id** (str) - The unique identifier of the compiled program.
- **slug** (str) - The URL-safe handle of the program.
- **status** (str) - The compilation status.
- **version** (str) - The version of the compiled program.
- **version_action** (str) - The action associated with the version.
- **timings** (dict) - Compilation timings.
- **error** (Optional[str]) - Error message if compilation failed.

### Response (Function Execution)
- **result** (str) - The output of the function execution.

### Function Execution
```python
result: str = fn(input_text: str, max_tokens=None, temperature=0.0)
```

#### Function Parameters
- **input_text** (str) - Required - The input text to process.
- **max_tokens** (Optional[int]) - Optional - Maximum number of tokens to generate.
- **temperature** (float) - Optional - Controls randomness. Defaults to 0.0.
```

--------------------------------

### Execute a remote function with ProgramAsWeights

Source: https://docs.programasweights.com/hub/3985c929921616e70058

Initializes a function reference using a unique ID and executes it with a string input.

```python
import programasweights as paw

fn = paw.function("3985c929921616e70058")
result = fn("your input here")
print(result)
```

--------------------------------

### Authentication

Source: https://docs.programasweights.com/agents

How to authenticate with the Programasweights service.

```APIDOC
## Authentication

### Description
Authenticate with the Programasweights service to access authenticated endpoints like listing programs.

### Method
`paw.login()`

### Request Example
```python
paw.login()
```

### Notes
This method typically handles authentication, potentially by opening a browser or using environment variables.
```

--------------------------------

### Basic Function Usage in Python

Source: https://docs.programasweights.com/hub/aa4e3f80ea4f77463747

Import the library and use a function by providing its ID and input.

```python
import programasweights as paw

fn = paw.function("aa4e3f80ea4f77463747")
result = fn("your input here")
print(result)
```

--------------------------------

### Embed Compact Programs in Webpages

Source: https://docs.programasweights.com/

This JavaScript snippet illustrates how to embed compact ProgramAsWeights programs that run client-side via WebAssembly.

```JavaScript
Embed in any webpage with 3 lines of JS.
```

--------------------------------

### Compile and Version Python Programs

Source: https://docs.programasweights.com/agents

Demonstrates compiling Python programs with versioning using slugs. Recompiling with the same slug creates a new version. Functions can be resolved to the latest or a specific pinned version.

```python
p1 = paw.compile("Count words v1", slug="word-counter")  # v1
p2 = paw.compile("Count words v2", slug="word-counter")  # v2 (auto-bumps)

fn = paw.function("da03/word-counter")     # resolves to main (latest)
fn = paw.function("da03/word-counter@v1")  # pinned to v1

versions = paw.list_versions("da03/word-counter")  # all versions
```

--------------------------------

### Chaining Functions

Source: https://docs.programasweights.com/agents

Demonstrates how to chain multiple PAW functions together to create more complex workflows.

```APIDOC
## Chaining Functions

### Description
Multiple PAW functions can be composed for multi-step tasks by using regular Python logic to pass the output of one function as the input to another.

### Example
```python
# Compile two functions: one for classification, one for fixing bugs
classifier = paw.compile_and_load("Classify the bug type. Return ONLY one of: off-by-one, type-error, other")
fixer = paw.compile_and_load("Fix the bug described in the first line. Return only the corrected code.")

# Example code snippet to analyze
code_snippet = "def add(a, b):
    return a - b # Should be a + b"

# Use the classifier function
label = classifier(code_snippet)

# Use the fixer function only if the label is not 'other'
if label != "other":
    fix = fixer(f"{label}: {code_snippet}")
    print(f"Original code: {code_snippet}")
    print(f"Fixed code: {fix}")
else:
    print("No fix needed or classification failed.")
```

### Notes
This approach allows for building sophisticated pipelines by leveraging the power of both PAW's function execution and Python's control flow.
```

--------------------------------

### Load and Run a Compiled Neural Function

Source: https://docs.programasweights.com/

Load a compiled neural function by its name and execute it with an input string. This function runs locally after being downloaded.

```Python
import programasweights as paw

# Load a compiled neural function by name
f = paw.function("email-triage")

# Runs locally — no internet needed after download
result = f("Thesis defense moved to 3pm, need your signature today")
print(result)  # "immediate"
```

--------------------------------

### Compile and Load PAW Function in One Step

Source: https://docs.programasweights.com/agents

Compile and load a PAW function directly from a natural language specification in a single step.

```python
import programasweights as paw

# Or compile and load in one step
fn = paw.compile_and_load("Classify sentiment as positive or negative")
fn("I love this!")  # "positive"
```

--------------------------------

### Use a Pre-compiled PAW Function

Source: https://docs.programasweights.com/agents

Load a pre-compiled PAW function for common tasks like email triage. The function is downloaded once and runs locally thereafter.

```python
import programasweights as paw

# Use a pre-compiled function (downloads once, runs locally forever)
fn = paw.function("email-triage")
fn("Urgent: server is down!")  # "immediate"
fn("Newsletter: spring picnic")  # "wait"
```

--------------------------------

### Compile and Execute PAW Functions

Source: https://docs.programasweights.com/agents

Basic usage for compiling specifications, loading functions, and managing program metadata.

```python
program = paw.compile(
    spec,                               # natural language specification (str)
    compiler=None,                      # omit to use the current server default (today: paw-4b-qwen3-0.6b)
    slug=None,                          # URL-safe handle (requires auth)
    public=True,                        # list on public hub
)
# Returns: Program(id, slug, status, version, version_action, timings, error)

fn = paw.function(program)              # accepts Program object, hash ID, or slug
fn = paw.function("a6b454023d41ac9ca845")
fn = paw.function("da03/my-classifier")
fn = paw.function("da03/my-classifier@v2")  # pinned version
fn = paw.function("da03/my-classifier", offline=True)  # skip server check

result: str = fn(input_text: str, max_tokens=None, temperature=0.0)

fn = paw.compile_and_load(spec)

versions = paw.list_versions("da03/my-classifier")  # version history
programs = paw.list_programs(sort="recent", per_page=20)  # requires auth
compilers = paw.list_compilers()  # discover available compilers at runtime

paw.login()
```

--------------------------------

### Compile a PAW Function from Description

Source: https://docs.programasweights.com/agents

Compile a custom PAW function from a natural language description. The compiled function can then be loaded and used.

```python
import programasweights as paw

# Compile your own from a description
program = paw.compile(
    "Fix malformed JSON: repair missing quotes and trailing commas"
)
fn = paw.function(program.id)
fn("{name: 'Alice',}")  # '{"name":"Alice"}'
```

--------------------------------

### Load and Run JavaScript Function

Source: https://docs.programasweights.com/agents

Loads a pre-compiled function from the PAW API and executes it with an input string in JavaScript. The browser SDK resolves slugs and downloads assets client-side.

```javascript
import paw from '@programasweights/web';

const fn = await paw.function('email-triage-browser');
const result = await fn('Urgent: server is down!');
// result: "immediate"
```

--------------------------------

### Execute Log Triage Function

Source: https://docs.programasweights.com/hub/0043acb81814157e229e

Initializes a remote function using a specific ID and executes it with provided input.

```python
import programasweights as paw

fn = paw.function("0043acb81814157e229e")
result = fn("your input here")
print(result)
```

--------------------------------

### Set API Key Environment Variable

Source: https://docs.programasweights.com/agents

Sets the PAW API key as an environment variable for authentication. This is optional but recommended for higher rate limits and program naming.

```bash
export PAW_API_KEY=paw_sk_...
```

--------------------------------

### Run PAW Log Monitor

Source: https://docs.programasweights.com/agents

This command runs the PAW log monitor script, which watches a specified log file and classifies new lines using a pre-compiled PAW function identified by `.paw_monitor_id`.

```bash
python paw_monitor.py --log /path/to/training.log
```

--------------------------------

### Compile Custom Function

Source: https://docs.programasweights.com/docs

Compile a custom neural function on the server by describing the desired behavior in English. The compiled program can then be used like any other function. Specify a compiler for different runtime sizes.

```python
import programasweights as paw

# Compile on the server (~3 seconds)
program = paw.compile("Fix malformed JSON: repair missing quotes and trailing commas")
# Use compiler="paw-4b-gpt2" when you want the smaller browser-compatible runtime

# Use the compiled program
fn = paw.function(program.id)
result = fn("{name: 'Alice', age: 30,}")
print(result)  # '{"name":"Alice","age":30}'
```

--------------------------------

### Chain Multiple PAW Functions

Source: https://docs.programasweights.com/agents

Compose multiple PAW functions using standard Python control flow to handle multi-step tasks.

```python
classifier = paw.compile_and_load("Classify the bug type. Return ONLY one of: off-by-one, type-error, other")
fixer = paw.compile_and_load("Fix the bug described in the first line. Return only the corrected code.")

label = classifier(code_snippet)
if label != "other":
    fix = fixer(f"{label}: {code_snippet}")
```
Tokens:
Raw