openweights 0.1.0__tar.gz

openweights-0.1.0/.dockerignore

@@ -0,0 +1,8 @@
+.env*
+**/.env*
+cache/
+**/cache/
+.llm-cache/
+**/.llm-cache/
+node_modules/
+**/node_modules/

openweights-0.1.0/.env.example

@@ -0,0 +1,3 @@
+OPENWEIGHTS_API_KEY=<your_openweights_api_key>
+HF_ORG=longtermrisk
+OW_DEFAULT_API_KEY=<optional key that will be used by vllm API deployments>

openweights-0.1.0/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,27 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Relevant `job_id`, `run_id`, or `worker_id`:
+- eg job: ft-12345678
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.

openweights-0.1.0/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,12 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Urgency**: one sentence re how urgent this is
+**Description**
+Explain the feature you'd like to see

openweights-0.1.0/.github/workflows/ci.yaml

@@ -0,0 +1,99 @@
+name: "ci"
+on: # rebuild any PRs and main branch changes
+  pull_request:
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: ${{ github.repository_owner }}-${{ github.repository }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  FORCE_COLOR: "1"
+  PYTHONUNBUFFERED: "1"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Setup PDM
+        uses: pdm-project/setup-pdm@v4
+        with:
+          cache: false # project doesn't use pdm lock files
+          python-version: ${{ matrix.python-version }}
+      - name: Setup UV
+        uses: astral-sh/setup-uv@v5
+      - name: Configure PDM to use UV
+        run: pdm config use_uv true
+      - name: Cache Huggingface assets
+        uses: actions/cache@v4
+        with:
+          key: huggingface-${{ runner.os }}-${{ matrix.python-version }}-${{ hashFiles('**/pyproject.toml') }}
+          path: ~/.cache/huggingface
+          restore-keys: |
+            huggingface-${{ runner.os }}-${{ matrix.python-version }}-
+      - name: Install dependencies
+        run: pdm install --group dev --no-lock
+
+      # TODO: re-enable when we have pre-commit hooks
+      # - name: Install pre-commit hooks
+      #   run: pdm run pre-commit install
+      # - name: Ensure pre-commit hooks pass
+      #   run: pdm run pre-commit run --all-files
+
+      # TODO: tests don't currently pass due to missing torch dependency
+      # see: https://github.com/longtermrisk/openweights/actions/runs/13210898278/job/36883965796?pr=11#step:8:29 
+
+      # - name: Run tests
+      #   env:
+      #     HF_TOKEN: ${{ secrets.HF_TOKEN }}
+      #   run: pdm run python -m pytest tests
+
+  release:
+    needs: build
+    environment: pypi
+    permissions:
+      contents: write
+      id-token: write
+    # https://github.community/t/how-do-i-specify-job-dependency-running-in-another-workflow/16482
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main' && !contains(github.event.head_commit.message, 'chore')
+    runs-on: ubuntu-latest
+    concurrency: release
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: pdm-project/setup-pdm@v4
+        with:
+          cache: true
+          python-version: "3.12"
+      - name: build
+        run: pdm build
+      - name: Semantic Release
+        id: release
+        uses: python-semantic-release/python-semantic-release@v8.0.7
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+
+      # - name: Publish package distributions to PyPI
+      #   uses: pypa/gh-action-pypi-publish@release/v1
+      #   if: steps.release.outputs.released == 'true'  
+      - name: Publish package distributions to GitHub Releases
+        uses: python-semantic-release/upload-to-gh-release@main
+        if: steps.release.outputs.released == 'true'
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+
+      # TODO: build and deploy docs to gh-pages
+      # do this as part of the semantic release step to ensure version is bumped

openweights-0.1.0/.github/workflows/manual_publish.yaml

@@ -0,0 +1,24 @@
+name: "manual-publish"
+
+on:
+  workflow_dispatch:  # Allows manual triggering
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    
+    steps:
+      - uses: actions/checkout@v4
+      
+      - uses: pdm-project/setup-pdm@v4
+        with:
+          python-version: "3.12"
+          
+      - name: Build
+        run: pdm build
+        
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

openweights-0.1.0/.gitignore

@@ -0,0 +1,76 @@
+logs/
+openweights/dashboard/backend/backend.log
+openweights/dashboard/backend/backend.pid
+build-docker-in-runpod
+.env
+.env.dev
+.env.prod
+.env.ow-dev
+.env.ow-migrations
+openweights/dashboard/backend/.env.ow-dev
+openweights/dashboard/backend/.env.ow-migrations
+openweights/dashboard/frontend/.env.ow-dev
+openweights/dashboard/frontend/.env.ow-migrations
+artifacts/
+debug/
+example/.ipynb_checkpoints/
+example/Untitled1.ipynb
+dev.py
+planb/
+vulnerable-code/
+openweights/client/.llm-cache
+# yeaa
+cache
+# Bazel
+/bazel-*
+/bazel-bin
+/bazel-genfiles
+/bazel-out
+/bazel-testlogs
+/bazel-workspace
+
+# Bazel symlinks
+/bazel-*
+
+# Bazel disk cache
+.bazel-cache/
+
+# Bazel IntelliJ plugin
+.ijwb/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

openweights-0.1.0/.pdm-python

@@ -0,0 +1 @@
+/home/runner/work/openweights/openweights/.venv/bin/python

openweights-0.1.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Center on Longterm Risk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

openweights-0.1.0/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: openweights
+Version: 0.1.0
+Summary: An openai-like sdk for finetuning and batch inference
+License: MIT
+License-File: LICENSE.txt
+Requires-Python: >=3.11
+Requires-Dist: diskcache
+Requires-Dist: fastapi
+Requires-Dist: fire
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: huggingface-hub
+Requires-Dist: openai
+Requires-Dist: pyjwt
+Requires-Dist: python-dotenv
+Requires-Dist: runpod
+Requires-Dist: scp
+Requires-Dist: supabase
+Requires-Dist: uvicorn
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+This repo is research code and not 100% stable. Please use github issues or contact me via email (niels dot warncke at gmail dot com) or slack when you encounter issues.
+
+# OpenWeights
+An openai-like sdk for finetuning and batch inference. Manages runpod instances for you, or you can run a [worker](openweights/worker) on your own GPU.
+
+# Installation
+Clone the repo and run `pip install -e .`.
+Then add your `$OPENWEIGHTS_API_KEY` to the `.env`. You can create one via the [dashboard](https://ktf8znsjvlhidw-8124.proxy.runpod.net/).
+
+# Quickstart
+```python
+from openweights import OpenWeights
+client = OpenWeights()
+
+with open('tests/preference_dataset.jsonl', 'rb') as file:
+    file = client.files.create(file, purpose="preference")
+
+job = client.fine_tuning.create(
+    model='unsloth/llama-3-8b-Instruct',
+    training_file=file['id'],
+    loss='dpo'
+)
+```
+
+# Client-side usage:
+
+## Create a finetuning job
+
+```python
+from openweights import OpenWeights
+from dotenv import load_dotenv
+
+load_dotenv()
+client = OpenWeights()
+
+with open('tests/sft_dataset.jsonl', 'rb') as file:
+    file = client.files.create(file, purpose="conversations")
+
+job = client.fine_tuning.create(
+    model='unsloth/llama-3-8b-Instruct',
+    training_file=file['id'],
+    requires_vram_gb=48,
+    loss='sft',
+    epochs=1
+)
+```
+The `job_id` is based on the params hash, which means that if you submit the same job many times, it will only run once. If you resubmit a failed or canceled job, it will reset the job status to `pending`.
+
+More infos: [Fine-tuning Options](docs/finetuning.md) 
+
+## Do batch inference
+```python
+
+file = client.files.create(
+  file=open("mydata.jsonl", "rb"),
+  purpose="conversations"
+)
+
+job = client.inference.create(
+    model=model,
+    input_file_id=file['id'],
+    max_tokens=1000,
+    temperature=1,
+    min_tokens=600,
+)
+print(job)
+
+job = client.jobs.retrieve(job['id'])
+```
+Wait until job is finished, then get the output:
+
+```py
+output_file_id = job['outputs']['file']
+output = client.files.content(output_file_id).decode('utf-8')
+print(output)
+```
+
+## Custom jobs
+Maybe you'd like to use autoscaling with queues for workloads that are not currently supported. You can start a pod that is set up like a worker but doesn't start `openweights/worker/main.py` by running:
+```sh
+python openweights/cluster/start_runpod.py A6000 finetuning --dev_mode=true
+```
+Then develop your script and finally create a `CustomJob` like in this [example](example/custom_job).
+
+## Deploy a model as a temporary Openai-like API
+
+You can deploy models as openai-like APIs in one of the following ways (sorted from highest to lowest level of abstraction)
+- create chat completions via `ow.chat.completions.sync_create` or `.async_create` - this will deploy models when needed. This queues to-be-deployed models for 5 seconds and then deploys them via `ow.multi_deploy`. This client is optimized to not overload the vllm server it is talking to and caches requests on disk when a `seed` parameter is given.
+- pass a list of models to deploy to `ow.multi_deploy` - this takes a list of models or lora adapters, groups them by `base_model`, and deploys all lora adapters of the same base model on one API to save runpod resources. Calls `ow.deploy` for each single deployment job. [Example](example/multi_lora_deploy.py)
+- `ow.deploy` - takes a single model and optionally a list of lora adapters, then creates a job of type `api`. Returns a `openweights.client.temporary_api.TemporaryAPI` object. [Example](example/gradio_ui_with_temporary_api.py)
+
+API jobs can never complete, they stop either because they are canceled or failed. API jobs have a timeout 15 minutes in the future when they are being created, and while a `TemporaryAPI` is alive (after `api.up()` and before `api.down()` has been called), it resets the timeout every minute. This ensures that an API is alive while the process that created it is running, at that it will automatically shut down later - but not immediately so that during debugging you don't always have to wait for deployment.
+
+
+## Using `client.deploy(model)`
+```py
+from openweights import OpenWeights
+
+client = OpenWeights()
+
+model = 'unsloth/llama-3-8b-Instruct'
+with client.deploy(model) as openai:
+    completion = openai.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": "is 9.11 > 9.9?"}]
+    )
+    print(completion.choices[0].message)
+```
+
+More examples:
+- do a [hyperparameter sweep](example/hparams_sweep.py) and [visualize the results](example/analyze_hparam_sweep.ipynb)
+- [download artifacts](example/download.py) from a job and plot training
+- and [more](example/)

openweights-0.1.0/README.md

@@ -0,0 +1,113 @@
+This repo is research code and not 100% stable. Please use github issues or contact me via email (niels dot warncke at gmail dot com) or slack when you encounter issues.
+
+# OpenWeights
+An openai-like sdk for finetuning and batch inference. Manages runpod instances for you, or you can run a [worker](openweights/worker) on your own GPU.
+
+# Installation
+Clone the repo and run `pip install -e .`.
+Then add your `$OPENWEIGHTS_API_KEY` to the `.env`. You can create one via the [dashboard](https://ktf8znsjvlhidw-8124.proxy.runpod.net/).
+
+# Quickstart
+```python
+from openweights import OpenWeights
+client = OpenWeights()
+
+with open('tests/preference_dataset.jsonl', 'rb') as file:
+    file = client.files.create(file, purpose="preference")
+
+job = client.fine_tuning.create(
+    model='unsloth/llama-3-8b-Instruct',
+    training_file=file['id'],
+    loss='dpo'
+)
+```
+
+# Client-side usage:
+
+## Create a finetuning job
+
+```python
+from openweights import OpenWeights
+from dotenv import load_dotenv
+
+load_dotenv()
+client = OpenWeights()
+
+with open('tests/sft_dataset.jsonl', 'rb') as file:
+    file = client.files.create(file, purpose="conversations")
+
+job = client.fine_tuning.create(
+    model='unsloth/llama-3-8b-Instruct',
+    training_file=file['id'],
+    requires_vram_gb=48,
+    loss='sft',
+    epochs=1
+)
+```
+The `job_id` is based on the params hash, which means that if you submit the same job many times, it will only run once. If you resubmit a failed or canceled job, it will reset the job status to `pending`.
+
+More infos: [Fine-tuning Options](docs/finetuning.md) 
+
+## Do batch inference
+```python
+
+file = client.files.create(
+  file=open("mydata.jsonl", "rb"),
+  purpose="conversations"
+)
+
+job = client.inference.create(
+    model=model,
+    input_file_id=file['id'],
+    max_tokens=1000,
+    temperature=1,
+    min_tokens=600,
+)
+print(job)
+
+job = client.jobs.retrieve(job['id'])
+```
+Wait until job is finished, then get the output:
+
+```py
+output_file_id = job['outputs']['file']
+output = client.files.content(output_file_id).decode('utf-8')
+print(output)
+```
+
+## Custom jobs
+Maybe you'd like to use autoscaling with queues for workloads that are not currently supported. You can start a pod that is set up like a worker but doesn't start `openweights/worker/main.py` by running:
+```sh
+python openweights/cluster/start_runpod.py A6000 finetuning --dev_mode=true
+```
+Then develop your script and finally create a `CustomJob` like in this [example](example/custom_job).
+
+## Deploy a model as a temporary Openai-like API
+
+You can deploy models as openai-like APIs in one of the following ways (sorted from highest to lowest level of abstraction)
+- create chat completions via `ow.chat.completions.sync_create` or `.async_create` - this will deploy models when needed. This queues to-be-deployed models for 5 seconds and then deploys them via `ow.multi_deploy`. This client is optimized to not overload the vllm server it is talking to and caches requests on disk when a `seed` parameter is given.
+- pass a list of models to deploy to `ow.multi_deploy` - this takes a list of models or lora adapters, groups them by `base_model`, and deploys all lora adapters of the same base model on one API to save runpod resources. Calls `ow.deploy` for each single deployment job. [Example](example/multi_lora_deploy.py)
+- `ow.deploy` - takes a single model and optionally a list of lora adapters, then creates a job of type `api`. Returns a `openweights.client.temporary_api.TemporaryAPI` object. [Example](example/gradio_ui_with_temporary_api.py)
+
+API jobs can never complete, they stop either because they are canceled or failed. API jobs have a timeout 15 minutes in the future when they are being created, and while a `TemporaryAPI` is alive (after `api.up()` and before `api.down()` has been called), it resets the timeout every minute. This ensures that an API is alive while the process that created it is running, at that it will automatically shut down later - but not immediately so that during debugging you don't always have to wait for deployment.
+
+
+## Using `client.deploy(model)`
+```py
+from openweights import OpenWeights
+
+client = OpenWeights()
+
+model = 'unsloth/llama-3-8b-Instruct'
+with client.deploy(model) as openai:
+    completion = openai.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": "is 9.11 > 9.9?"}]
+    )
+    print(completion.choices[0].message)
+```
+
+More examples:
+- do a [hyperparameter sweep](example/hparams_sweep.py) and [visualize the results](example/analyze_hparam_sweep.ipynb)
+- [download artifacts](example/download.py) from a job and plot training
+- and [more](example/)

openweights-0.1.0/docs/finetuning.md

@@ -0,0 +1,144 @@
+# Fine-tuning Options
+
+OpenWeights supports several fine-tuning approaches for language models, all implemented using the Unsloth library for efficient training.
+
+## Supported Training Methods
+
+### 1. Supervised Fine-tuning (SFT)
+Standard supervised fine-tuning using conversation data. This is the most basic form of fine-tuning where the model learns to generate responses based on conversation history.
+
+```python
+from openweights import OpenWeights
+client = OpenWeights()
+
+# Upload a conversations dataset
+with open('conversations.jsonl', 'rb') as file:
+    file = client.files.create(file, purpose="conversations")
+
+# Start SFT training
+job = client.fine_tuning.create(
+    model='unsloth/llama-2-7b-chat',
+    training_file=file['id'],
+    loss='sft',
+    epochs=1,
+    learning_rate=2e-5
+)
+```
+
+The conversations dataset should be in JSONL format with each line containing a "messages" field:
+```json
+{"messages": [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": "What is machine learning?"},
+    {"role": "assistant", "content": "Machine learning is a branch of artificial intelligence..."}
+]}
+```
+
+### 2. Direct Preference Optimization (DPO)
+DPO is a method for fine-tuning language models from preference data without using reward modeling. It directly optimizes the model to prefer chosen responses over rejected ones.
+
+```python
+# Upload a preference dataset
+with open('preferences.jsonl', 'rb') as file:
+    file = client.files.create(file, purpose="preference")
+
+# Start DPO training
+job = client.fine_tuning.create(
+    model='unsloth/llama-2-7b-chat',
+    training_file=file['id'],
+    loss='dpo',
+    epochs=1,
+    learning_rate=1e-5,
+    beta=0.1  # Controls the strength of the preference optimization
+)
+```
+
+### 3. Offline Rejection Preference Optimization (ORPO)
+ORPO is similar to DPO but uses a different loss function that has been shown to be more stable in some cases.
+
+```python
+# Start ORPO training
+job = client.fine_tuning.create(
+    model='unsloth/llama-2-7b-chat',
+    training_file=file['id'],
+    loss='orpo',
+    epochs=1,
+    learning_rate=1e-5,
+    beta=0.1
+)
+```
+
+The preference dataset format for both DPO and ORPO should be:
+```json
+{
+    "prompt": [
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "What is the capital of France?"}
+    ],
+    "chosen": [
+        {"role": "assistant", "content": "The capital of France is Paris."}
+    ],
+    "rejected": [
+        {"role": "assistant", "content": "I think it's London, but I'm not sure."}
+    ]
+}
+```
+
+## Common Training Parameters
+
+All training methods support the following parameters:
+
+- `model`: The base model to fine-tune (string)
+- `training_file`: File ID of the training dataset (string)
+- `test_file`: Optional file ID of the test dataset (string)
+- `epochs`: Number of training epochs (int)
+- `learning_rate`: Learning rate or string expression (float or string)
+- `max_seq_length`: Maximum sequence length for training (int, default=2048)
+- `per_device_train_batch_size`: Training batch size per device (int, default=2)
+- `gradient_accumulation_steps`: Number of gradient accumulation steps (int, default=8)
+- `warmup_steps`: Number of warmup steps (int, default=5)
+
+### LoRA Parameters
+
+All training methods use LoRA (Low-Rank Adaptation) by default with these configurable parameters:
+
+- `r`: LoRA attention dimension (int, default=512)
+- `lora_alpha`: LoRA alpha parameter (int, default=16)
+- `lora_dropout`: LoRA dropout rate (float, default=0.0)
+- `target_modules`: List of modules to apply LoRA to (list of strings)
+- `merge_before_push`: Whether to merge LoRA weights into base model before pushing (bool, default=True)
+
+## Monitoring Training
+
+You can monitor training progress through the logged metrics:
+
+```python
+# Get training events
+events = client.events.list(job_id=job['id'])
+
+# Get the latest values for specific metrics
+latest = client.events.latest(['loss', 'learning_rate'], job_id=job['id'])
+```
+
+## Using the Fine-tuned Model
+
+After training completes, you can use the model for inference:
+
+```python
+# For merged models (merge_before_push=True)
+with client.deploy(job['outputs']['model']) as openai:
+    completion = openai.chat.completions.create(
+        model=job['outputs']['model'],
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+
+# For LoRA adapters (merge_before_push=False)
+with client.deploy(
+    model=job['params']['model'],
+    lora_adapters=[job['outputs']['model']]
+) as openai:
+    completion = openai.chat.completions.create(
+        model=job['params']['model'],
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+```