Skip to content

armgit / dspy

Public Imported from GitHub
0

DSPy: The framework for programming—not prompting—language models

Python

Style fixing for leftovers (#8228)

Chen Qian816484737772
diff --git a/dspy/clients/lm.py b/dspy/clients/lm.py
index ba48d9034..247db10b9 100644
--- a/dspy/clients/lm.py
+++ b/dspy/clients/lm.py
@@ -11,7 +11,7 @@ from asyncer import syncify
import dspy
from dspy.clients.cache import request_cache
from dspy.clients.openai import OpenAIProvider
-from dspy.clients.provider import Provider, TrainingJob, ReinforceJob
+from dspy.clients.provider import Provider, ReinforceJob, TrainingJob
from dspy.clients.utils_finetune import TrainDataFormat
from dspy.dsp.utils.settings import settings
from dspy.utils.callback import BaseCallback
@@ -211,7 +211,7 @@ class LM(BaseLM):
def reinforce(self, train_kwargs) -> ReinforceJob:
# TODO(GRPO Team): Should we return an initialized job here?
from dspy import settings as settings
-
+
err = f"Provider {self.provider} does not implement the reinforcement learning interface."
assert self.provider.reinforceable, err
diff --git a/dspy/clients/lm_local_arbor.py b/dspy/clients/lm_local_arbor.py
index e7bf1debc..9427a19d6 100644
--- a/dspy/clients/lm_local_arbor.py
+++ b/dspy/clients/lm_local_arbor.py
@@ -1,14 +1,13 @@
import time
-import requests
from datetime import datetime
-from typing import Any, Dict, List, Optional, Union, TypedDict, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, TypedDict, Union
import openai
+import requests
import dspy
-from dspy.clients.provider import TrainingJob, ReinforceJob, Provider
-from dspy.clients.utils_finetune import TrainDataFormat, TrainingStatus, GRPOGroup, save_data
-
+from dspy.clients.provider import Provider, ReinforceJob, TrainingJob
+from dspy.clients.utils_finetune import GRPOGroup, TrainDataFormat, TrainingStatus, save_data
if TYPE_CHECKING:
from dspy.clients.lm import LM
@@ -47,7 +46,7 @@ class ArborTrainingJob(TrainingJob):
class ArborReinforceJob(ReinforceJob):
- DEFAULT_TRAIN_KWARGS = {
+ DEFAULT_TRAIN_KWARGS = { # noqa: RUF012
"update_interval": 10,
"temperature": 0.9,
"beta": 0.04,
@@ -56,7 +55,7 @@ class ArborReinforceJob(ReinforceJob):
"learning_rate": 1e-6,
"gradient_accumulation_steps": 1,
# This is false by default in TRL, but I think it makes sense to be true for us
- "gradient_checkpointing": True,
+ "gradient_checkpointing": True,
"lr_scheduler_type": "constant_with_warmup",
"max_prompt_length": None,
"max_completion_length": None,
@@ -69,7 +68,7 @@ class ArborReinforceJob(ReinforceJob):
"logging_steps": 100,
# By default, none is the model's max context length
"max_context_length": None,
- "lora": False
+ "lora": False,
}
def __init__(self, lm: "LM", train_kwargs: GRPOTrainKwargs):
@@ -90,75 +89,81 @@ class ArborReinforceJob(ReinforceJob):
temperature = self.train_kwargs.get("temperature", self.DEFAULT_TRAIN_KWARGS["temperature"])
beta = self.train_kwargs.get("beta", self.DEFAULT_TRAIN_KWARGS["beta"])
num_iterations = self.train_kwargs.get("num_iterations", self.DEFAULT_TRAIN_KWARGS["num_iterations"])
- per_device_train_batch_size = self.train_kwargs.get("per_device_train_batch_size", self.DEFAULT_TRAIN_KWARGS["per_device_train_batch_size"])
+ per_device_train_batch_size = self.train_kwargs.get(
+ "per_device_train_batch_size", self.DEFAULT_TRAIN_KWARGS["per_device_train_batch_size"]
+ )
learning_rate = self.train_kwargs.get("learning_rate", self.DEFAULT_TRAIN_KWARGS["learning_rate"])
- gradient_accumulation_steps = self.train_kwargs.get("gradient_accumulation_steps", self.DEFAULT_TRAIN_KWARGS["gradient_accumulation_steps"])
- gradient_checkpointing = self.train_kwargs.get("gradient_checkpointing", self.DEFAULT_TRAIN_KWARGS["gradient_checkpointing"])
+ gradient_accumulation_steps = self.train_kwargs.get(
+ "gradient_accumulation_steps", self.DEFAULT_TRAIN_KWARGS["gradient_accumulation_steps"]
+ )
+ gradient_checkpointing = self.train_kwargs.get(
+ "gradient_checkpointing", self.DEFAULT_TRAIN_KWARGS["gradient_checkpointing"]
+ )
lr_scheduler_type = self.train_kwargs.get("lr_scheduler_type", self.DEFAULT_TRAIN_KWARGS["lr_scheduler_type"])
max_prompt_length = self.train_kwargs.get("max_prompt_length", self.DEFAULT_TRAIN_KWARGS["max_prompt_length"])
- max_completion_length = self.train_kwargs.get("max_completion_length", self.DEFAULT_TRAIN_KWARGS["max_completion_length"])
+ max_completion_length = self.train_kwargs.get(
+ "max_completion_length", self.DEFAULT_TRAIN_KWARGS["max_completion_length"]
+ )
bf16 = self.train_kwargs.get("bf16", self.DEFAULT_TRAIN_KWARGS["bf16"])
scale_rewards = self.train_kwargs.get("scale_rewards", self.DEFAULT_TRAIN_KWARGS["scale_rewards"])
- gradient_checkpointing_kwargs = self.train_kwargs.get("gradient_checkpointing_kwargs", self.DEFAULT_TRAIN_KWARGS["gradient_checkpointing_kwargs"])
+ gradient_checkpointing_kwargs = self.train_kwargs.get(
+ "gradient_checkpointing_kwargs", self.DEFAULT_TRAIN_KWARGS["gradient_checkpointing_kwargs"]
+ )
max_grad_norm = self.train_kwargs.get("max_grad_norm", self.DEFAULT_TRAIN_KWARGS["max_grad_norm"])
report_to = self.train_kwargs.get("report_to", self.DEFAULT_TRAIN_KWARGS["report_to"])
log_completions = self.train_kwargs.get("log_completions", self.DEFAULT_TRAIN_KWARGS["log_completions"])
logging_steps = self.train_kwargs.get("logging_steps", self.DEFAULT_TRAIN_KWARGS["logging_steps"])
- max_context_length = self.train_kwargs.get("max_context_length", self.DEFAULT_TRAIN_KWARGS["max_context_length"])
+ max_context_length = self.train_kwargs.get(
+ "max_context_length", self.DEFAULT_TRAIN_KWARGS["max_context_length"]
+ )
lora = self.train_kwargs.get("lora", self.DEFAULT_TRAIN_KWARGS["lora"])
api_base = self.lm.kwargs["api_base"]
suffix = "dspy"
finetune_model = ArborProvider._remove_provider_prefix(self.lm.model)
data = {
- 'model': finetune_model,
- 'suffix': suffix,
- 'num_generations': num_generations,
- 'update_interval': update_interval,
- 'temperature': temperature,
- 'beta': beta,
- 'num_iterations': num_iterations,
- 'per_device_train_batch_size': per_device_train_batch_size,
- 'learning_rate': learning_rate,
- 'gradient_accumulation_steps': gradient_accumulation_steps,
- 'gradient_checkpointing': gradient_checkpointing,
- 'lr_scheduler_type': lr_scheduler_type,
- 'max_prompt_length': max_prompt_length,
- 'max_completion_length': max_completion_length,
- 'bf16': bf16,
- 'scale_rewards': scale_rewards,
- 'gradient_checkpointing_kwargs': gradient_checkpointing_kwargs,
- 'max_grad_norm': max_grad_norm,
- 'report_to': report_to,
- 'log_completions': log_completions,
- 'logging_steps': logging_steps,
- 'max_context_length': max_context_length,
- 'lora': lora,
+ "model": finetune_model,
+ "suffix": suffix,
+ "num_generations": num_generations,
+ "update_interval": update_interval,
+ "temperature": temperature,
+ "beta": beta,
+ "num_iterations": num_iterations,
+ "per_device_train_batch_size": per_device_train_batch_size,
+ "learning_rate": learning_rate,
+ "gradient_accumulation_steps": gradient_accumulation_steps,
+ "gradient_checkpointing": gradient_checkpointing,
+ "lr_scheduler_type": lr_scheduler_type,
+ "max_prompt_length": max_prompt_length,
+ "max_completion_length": max_completion_length,
+ "bf16": bf16,
+ "scale_rewards": scale_rewards,
+ "gradient_checkpointing_kwargs": gradient_checkpointing_kwargs,
+ "max_grad_norm": max_grad_norm,
+ "report_to": report_to,
+ "log_completions": log_completions,
+ "logging_steps": logging_steps,
+ "max_context_length": max_context_length,
+ "lora": lora,
}
url = f"{api_base}fine_tuning/grpo/initialize"
- headers = {'Content-Type': 'application/json'}
- response = requests.post(
- url=url,
- headers=headers,
- json=data
- )
+ headers = {"Content-Type": "application/json"}
+ response = requests.post(url=url, headers=headers, json=data)
assert response.status_code == 200, f"Failed to initialize GRPO: {response}"
self.lm.model = ArborProvider._add_provider_prefix(finetune_model)
# self.provider_job_id = response.json().get("job_id") # TODO: To be updated
- def _run_grpo_step_one_group(self, train_group: GRPOGroup, train_data_format: Optional[Union[TrainDataFormat, str]] = None):
+ def _run_grpo_step_one_group(
+ self, train_group: GRPOGroup, train_data_format: Optional[Union[TrainDataFormat, str]] = None
+ ):
# TODO: Check that the data follows the intended format
api_base = self.lm.kwargs["api_base"]
# api_key = self.lm.kwargs["api_key"]
finetune_model = ArborProvider._remove_provider_prefix(self.lm.model)
- data = {
- 'model': finetune_model,
- 'update_inference_model': True,
- 'batch': train_group
- }
+ data = {"model": finetune_model, "update_inference_model": True, "batch": train_group}
url = f"{api_base}fine_tuning/grpo/step"
- headers = {'Content-Type': 'application/json'}
+ headers = {"Content-Type": "application/json"}
response = requests.post(url, headers=headers, json=data)
assert response.status_code == 200, f"Failed to run a GRPO step: {response.text}"
response = response.json()
@@ -175,38 +180,39 @@ class ArborReinforceJob(ReinforceJob):
# different step methods or changing our smallets data format to be the
# GRPO group.
# TODO: Support step on the server side
- assert train_data_format == TrainDataFormat.GRPO_CHAT, f"GRPO only supports the GRPO_CHAT data format. Got {train_data_format} instead."
+ assert (
+ train_data_format == TrainDataFormat.GRPO_CHAT
+ ), f"GRPO only supports the GRPO_CHAT data format. Got {train_data_format} instead."
for group in train_data:
self._run_grpo_step_one_group(group, train_data_format)
-
+
def update_model(self):
api_base = self.lm.kwargs["api_base"]
url = f"{api_base}fine_tuning/grpo/update_model"
- headers = {'Content-Type': 'application/json'}
+ headers = {"Content-Type": "application/json"}
response = requests.post(url, headers=headers)
- assert response.status_code == 200, f"Failed to update model: {response.text}"
+ assert response.status_code == 200, f"Failed to update model: {response.text}"
response = response.json()
current_model = response["current_model"]
self.lm.model = ArborProvider._add_provider_prefix(current_model)
-
- def save_checkpoint(self, checkpoint_name: str, score: float = None):
+
+ def save_checkpoint(self, checkpoint_name: str, score: Optional[float] = None):
api_base = self.lm.kwargs["api_base"]
url = f"{api_base}fine_tuning/grpo/checkpoint"
- headers = {'Content-Type': 'application/json'}
+ headers = {"Content-Type": "application/json"}
body = {"checkpoint_name": checkpoint_name}
response = requests.post(url, headers=headers, json=body)
assert response.status_code == 200, f"Failed to save checkpoint: {response.text}"
response = response.json()
- current_model = response["current_model"]
last_checkpoint = response["last_checkpoint"]
checkpoints = response["checkpoints"]
checkpoint_model_path = checkpoints[last_checkpoint]
self.checkpoints[last_checkpoint] = {
- 'model_path':checkpoint_model_path,
- 'score': score,
+ "model_path": checkpoint_model_path,
+ "score": score,
}
self.last_checkpoint = last_checkpoint
@@ -214,7 +220,7 @@ class ArborReinforceJob(ReinforceJob):
api_base = self.lm.kwargs["api_base"]
url = f"{api_base}fine_tuning/grpo/terminate"
- headers = {'Content-Type': 'application/json'}
+ headers = {"Content-Type": "application/json"}
response = requests.post(url, headers=headers)
assert response.status_code == 200, f"Failed to terminate GRPO: {response.text}"
@@ -238,7 +244,6 @@ class ArborReinforceJob(ReinforceJob):
class ArborProvider(Provider):
-
def __init__(self):
super().__init__()
self.finetunable = True
@@ -251,29 +256,23 @@ class ArborProvider(Provider):
model = ArborProvider._remove_provider_prefix(lm.model)
# TODO: Handle this on the server side
if model.startswith("huggingface/"):
- model = model[len("huggingface/"):]
+ model = model[len("huggingface/") :]
api_base = lm.kwargs["api_base"]
- api_key = lm.kwargs["api_key"]
launch_kwargs = launch_kwargs or lm.launch_kwargs
# Make request to launch endpoint
- response = requests.post(
- f"{api_base}chat/launch",
- json={"model": model, "launch_kwargs": launch_kwargs}
- )
+ response = requests.post(f"{api_base}chat/launch", json={"model": model, "launch_kwargs": launch_kwargs})
if response.status_code != 200:
raise Exception(f"Failed to launch model. Status code: {response.status_code}, Response: {response.text}")
print(f"Inference server for model {model} launched successfully")
-
@staticmethod
def kill(lm: "LM", launch_kwargs: Optional[Dict[str, Any]] = None):
api_base = lm.kwargs["api_base"]
- api_key = lm.kwargs["api_key"]
response = requests.post(
f"{api_base}chat/kill",
@@ -291,7 +290,7 @@ class ArborProvider(Provider):
if model.startswith("arbor:"):
model = model[6:]
return model
-
+
@staticmethod
def _add_provider_prefix(model: str) -> str:
if not model.startswith("openai/arbor:"):
@@ -303,17 +302,20 @@ class ArborProvider(Provider):
# TODO: We will delete this method once we start passing the LM object
# to finetune.
import dspy.settings as settings
+
if not hasattr(settings, "arbor_api_base"):
- raise ValueError("Arbor API base not set. Please set the `dspy.settings.arbor_api_base` to the URL for the Arbor server (e.g. 'http://localhost:8000/v1/').")
+ raise ValueError(
+ "Arbor API base not set. Please set the `dspy.settings.arbor_api_base` to the URL for the Arbor server (e.g. 'http://localhost:8000/v1/')."
+ )
return dspy.settings.arbor_api_base
@staticmethod
def finetune(
- job: ArborTrainingJob,
- model: str,
- train_data: List[Dict[str, Any]],
- train_data_format: Optional[TrainDataFormat],
- train_kwargs: Optional[Dict[str, Any]] = None
+ job: ArborTrainingJob,
+ model: str,
+ train_data: List[Dict[str, Any]],
+ train_data_format: Optional[TrainDataFormat],
+ train_kwargs: Optional[Dict[str, Any]] = None,
) -> str:
# TODO: We want to re-factor finetune so that it takes in an LM.
# Until then, we use the following to get the api information. The
@@ -440,11 +442,7 @@ class ArborProvider(Provider):
return provider_file.id
@staticmethod
- def _start_remote_training(
- train_file_id: str,
- model: str,
- train_kwargs: Dict[str, Any]
- ) -> str:
+ def _start_remote_training(train_file_id: str, model: str, train_kwargs: Dict[str, Any]) -> str:
train_kwargs = train_kwargs or {}
original_base_url = openai.base_url
openai.base_url = ArborProvider._get_arbor_base_api()
@@ -458,9 +456,9 @@ class ArborProvider(Provider):
@staticmethod
def wait_for_job(
- job: TrainingJob,
- training_kwargs: Dict[str, Any],
- poll_frequency: int = 20,
+ job: TrainingJob,
+ training_kwargs: Dict[str, Any],
+ poll_frequency: int = 20,
):
done = False
cur_event_id = None
@@ -468,7 +466,6 @@ class ArborProvider(Provider):
while not done:
# Report estimated time if not already reported
if not reported_estimated_time:
-
original_base_url = openai.base_url
openai.base_url = ArborProvider._get_arbor_base_api()
remote_job = openai.fine_tuning.jobs.retrieve(job.provider_job_id)
diff --git a/dspy/clients/provider.py b/dspy/clients/provider.py
index 1722a586e..a56b35502 100644
--- a/dspy/clients/provider.py
+++ b/dspy/clients/provider.py
@@ -35,7 +35,6 @@ class TrainingJob(Future):
raise NotImplementedError
-
class ReinforceJob:
def __init__(self, lm: "LM", train_kwargs: Optional[Dict[str, Any]] = None):
self.lm = LM
@@ -58,7 +57,7 @@ class ReinforceJob:
@abstractmethod
def update_model(self):
raise NotImplementedError
-
+
@abstractmethod
def save_checkpoint(self, checkpoint_name: str):
raise NotImplementedError
diff --git a/dspy/primitives/tool.py b/dspy/primitives/tool.py
index 0bd19d955..bf4a208f5 100644
--- a/dspy/primitives/tool.py
+++ b/dspy/primitives/tool.py
@@ -172,13 +172,9 @@ class Tool:
return convert_mcp_tool(session, tool)
-
def __repr__(self):
- return (
- f"Tool(name={self.name}, desc={self.desc}, args={self.args})"
- )
-
-
+ return f"Tool(name={self.name}, desc={self.desc}, args={self.args})"
+
def __str__(self):
desc = f", whose description is <desc>{self.desc}</desc>.".replace("\n", " ") if self.desc else "."
arg_desc = f"It takes arguments {self.args} in JSON format."
diff --git a/dspy/retrievers/embeddings.py b/dspy/retrievers/embeddings.py
index ded5b1532..bf75aa3ce 100644
--- a/dspy/retrievers/embeddings.py
+++ b/dspy/retrievers/embeddings.py
@@ -1,5 +1,7 @@
-import numpy as np
from typing import Any, List, Optional
+
+import numpy as np
+
from dspy.utils.unbatchify import Unbatchify
# TODO: Add .save and .load methods!
@@ -14,7 +16,7 @@ class Embeddings:
callbacks: Optional[List[Any]] = None,
cache: bool = False,
brute_force_threshold: int = 20_000,
- normalize: bool = True
+ normalize: bool = True,
):
assert cache is False, "Caching is not supported for embeddings-based retrievers"
@@ -44,7 +46,7 @@ class Embeddings:
pids = self._faiss_search(q_embeds, self.k * 10) if self.index else None
pids = np.tile(np.arange(len(self.corpus)), (len(queries), 1)) if pids is None else pids
-
+
return self._rerank_and_predict(q_embeds, pids)
def _build_faiss(self):
@@ -60,8 +62,10 @@ class Embeddings:
quantizer = faiss.IndexFlatL2(dim)
index = faiss.IndexIVFPQ(quantizer, dim, partitions, nbytes, 8)
- print(f"Training a {nbytes}-byte FAISS index with {partitions} partitions, based on "
- f"{len(self.corpus)} x {dim}-dim embeddings")
+ print(
+ f"Training a {nbytes}-byte FAISS index with {partitions} partitions, based on "
+ f"{len(self.corpus)} x {dim}-dim embeddings"
+ )
index.train(self.corpus_embeddings)
index.add(self.corpus_embeddings)
index.nprobe = min(16, partitions)
@@ -73,12 +77,12 @@ class Embeddings:
def _rerank_and_predict(self, q_embeds: np.ndarray, candidate_indices: np.ndarray):
candidate_embeddings = self.corpus_embeddings[candidate_indices]
- scores = np.einsum('qd,qkd->qk', q_embeds, candidate_embeddings)
+ scores = np.einsum("qd,qkd->qk", q_embeds, candidate_embeddings)
- top_k_indices = np.argsort(-scores, axis=1)[:, :self.k]
+ top_k_indices = np.argsort(-scores, axis=1)[:, : self.k]
top_indices = candidate_indices[np.arange(len(q_embeds))[:, None], top_k_indices]
- return [([self.corpus[idx] for idx in indices], [idx for idx in indices]) for indices in top_indices]
+ return [([self.corpus[idx] for idx in indices], [idx for idx in indices]) for indices in top_indices] # noqa: C416
def _normalize(self, embeddings: np.ndarray):
norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
diff --git a/dspy/teleprompt/simba.py b/dspy/teleprompt/simba.py
index 21461b84e..45fce7c69 100644
--- a/dspy/teleprompt/simba.py
+++ b/dspy/teleprompt/simba.py
@@ -30,21 +30,21 @@ class SIMBA(Teleprompter):
Initializes SIMBA.
Args:
- metric (Callable): A function that takes an Example and a prediction_dict
+ metric (Callable): A function that takes an Example and a prediction_dict
as input and returns a float.
bsize (int, optional): Mini-batch size. Defaults to 32.
- num_candidates (int, optional): Number of new candidate programs to produce
+ num_candidates (int, optional): Number of new candidate programs to produce
per iteration. Defaults to 6.
max_steps (int, optional): Number of optimization steps to run. Defaults to 8.
- max_demos (int, optional): Maximum number of demos a predictor can hold
+ max_demos (int, optional): Maximum number of demos a predictor can hold
before dropping some. Defaults to 4.
- demo_input_field_maxlen (int, optional): Maximum number of characters to keep
+ demo_input_field_maxlen (int, optional): Maximum number of characters to keep
in an input field when building a new demo. Defaults to 100,000.
- num_threads (int, optional): Number of threads for parallel execution.
+ num_threads (int, optional): Number of threads for parallel execution.
Defaults to None.
- temperature_for_sampling (float, optional): Temperature used for picking
+ temperature_for_sampling (float, optional): Temperature used for picking
programs during the trajectory-sampling step. Defaults to 0.2.
- temperature_for_candidates (float, optional): Temperature used for picking
+ temperature_for_candidates (float, optional): Temperature used for picking
the source program for building new candidates. Defaults to 0.2.
"""
self.metric = metric
@@ -296,8 +296,8 @@ class SIMBA(Teleprompter):
sys_scores = [outputs[i]["score"] for i in range(start, end)]
register_new_program(cand_sys, sys_scores)
- M = len(winning_programs) - 1 # noqa: N806
- N = self.num_candidates + 1 # noqa: N806
+ M = len(winning_programs) - 1 # noqa: N806
+ N = self.num_candidates + 1 # noqa: N806
if M < 1:
program_idxs = [0] * N
else: