simplify dspy.LM (#7940)

Author: chenmoneygithub

dspy/clients/base_lm.py

@@ -16,6 +16,22 @@ def __init__(self, model, model_type='chat', temperature=0.0, max_tokens=1000, c
     def __call__(self, prompt=None, messages=None, **kwargs):
         pass
 
+    def copy(self, **kwargs):
+        """Returns a copy of the language model with possibly updated parameters."""
+
+        import copy
+
+        new_instance = copy.deepcopy(self)
+        new_instance.history = []
+
+        for key, value in kwargs.items():
+            if hasattr(self, key):
+                setattr(new_instance, key, value)
+            if (key in self.kwargs) or (not hasattr(self, key)):
+                new_instance.kwargs[key] = value
+
+        return new_instance
+
     def inspect_history(self, n: int = 1):
         _inspect_history(self.history, n)
 

dspy/clients/lm.py

@@ -6,7 +6,7 @@
 import uuid
 from datetime import datetime
 from hashlib import sha256
-from typing import Any, Dict, List, Literal, Optional, cast, TYPE_CHECKING
+from typing import Any, Dict, List, Literal, Optional, cast
 
 import litellm
 import pydantic
@@ -21,8 +21,6 @@
 from dspy.clients.provider import Provider, TrainingJob
 from dspy.clients.utils_finetune import TrainDataFormat
 from dspy.utils.callback import BaseCallback, with_callbacks
-if TYPE_CHECKING:
-    from dspy.adapters.base import Adapter
 
 from .base_lm import BaseLM
 
@@ -142,17 +140,20 @@ def __call__(self, prompt=None, messages=None, **kwargs):
 
         # Logging, with removed api key & where `cost` is None on cache hit.
         kwargs = {k: v for k, v in kwargs.items() if not k.startswith("api_")}
-        entry = dict(prompt=prompt, messages=messages, kwargs=kwargs, response=response)
-        entry = dict(**entry, outputs=outputs, usage=dict(response["usage"]))
-        entry = dict(**entry, cost=response.get("_hidden_params", {}).get("response_cost"))
-        entry = dict(
-            **entry,
-            timestamp=datetime.now().isoformat(),
-            uuid=str(uuid.uuid4()),
-            model=self.model,
-            response_model=response["model"],
-            model_type=self.model_type,
-        )
+        entry = {
+            "prompt": prompt,
+            "messages": messages,
+            "kwargs": kwargs,
+            "response": response,
+            "outputs": outputs,
+            "usage": dict(response["usage"]),
+            "cost": response.get("_hidden_params", {}).get("response_cost"),
+            "timestamp": datetime.now().isoformat(),
+            "uuid": str(uuid.uuid4()),
+            "model": self.model,
+            "response_model": response["model"],
+            "model_type": self.model_type,
+        }
         self.history.append(entry)
         self.update_global_history(entry)
 
@@ -216,38 +217,8 @@ def _run_finetune_job(self, job: TrainingJob):
     def infer_provider(self) -> Provider:
         if OpenAIProvider.is_provider_model(self.model):
             return OpenAIProvider()
-        # TODO(PR): Keeping this function here will require us to import all
-        # providers in this file. Is this okay?
         return Provider()
 
-    def infer_adapter(self) -> "Adapter":
-        import dspy
-
-        if dspy.settings.adapter:
-            return dspy.settings.adapter
-
-        model_type_to_adapter = {
-            "chat": dspy.ChatAdapter(),
-        }
-        model_type = self.model_type
-        return model_type_to_adapter[model_type]
-
-    def copy(self, **kwargs):
-        """Returns a copy of the language model with possibly updated parameters."""
-
-        import copy
-
-        new_instance = copy.deepcopy(self)
-        new_instance.history = []
-
-        for key, value in kwargs.items():
-            if hasattr(self, key):
-                setattr(new_instance, key, value)
-            if (key in self.kwargs) or (not hasattr(self, key)):
-                new_instance.kwargs[key] = value
-
-        return new_instance
-    
     def dump_state(self):
         state_keys = ["model", "model_type", "cache", "cache_in_memory", "num_retries", "finetuning_model", "launch_kwargs", "train_kwargs"]
         return { key: getattr(self, key) for key in state_keys } | self.kwargs

dspy/teleprompt/bootstrap_finetune.py

@@ -4,8 +4,10 @@
 
 import dspy
 from dspy.adapters.base import Adapter
+from dspy.adapters.chat_adapter import ChatAdapter
 from dspy.clients.lm import LM
 from dspy.clients.utils_finetune import infer_data_format
+from dspy.dsp.utils.settings import settings
 from dspy.evaluate.evaluate import Evaluate
 from dspy.predict.predict import Predict
 from dspy.primitives.example import Example
@@ -160,7 +162,7 @@ def _prepare_finetune_data(self, trace_data: List[Dict[str, Any]], lm: LM, pred_
             logger.info(f"After filtering with the metric, {len(trace_data)} examples remain")
 
         data = []
-        adapter = self.adapter[lm] or lm.infer_adapter()
+        adapter = self.adapter[lm] or settings.adapter or ChatAdapter()
         data_format = infer_data_format(adapter)
         for item in trace_data:
             for pred_ind, _ in enumerate(item["trace"]):
@@ -181,18 +183,12 @@ def _prepare_finetune_data(self, trace_data: List[Dict[str, Any]], lm: LM, pred_
 def build_call_data_from_trace(
     trace: List[Dict],
     pred_ind: int,
-    adapter: Optional[Adapter] = None,
+    adapter: Adapter,
     exclude_demos: bool = False,
 ) -> Dict[str, List[Dict[str, Any]]]:
     # Find data that's relevant to the predictor
     pred, inputs, outputs = trace[pred_ind]  # assuming that the order is kept
 
-    if not adapter:
-        # TODO(feature): A trace is collected using a particular adapter. It
-        # would be nice to get this adapter information from the trace (e.g.
-        # pred.lm.adapter) as opposed to using the inference method below.
-        adapter = pred.lm.infer_adapter()
-
     demos = [] if exclude_demos else pred.demos
     call_data = adapter.format_finetune_data(
         signature=pred.signature,
@@ -209,8 +205,8 @@ def bootstrap_trace_data(
     metric: Optional[Callable] = None,
     num_threads=6,
 ) -> List[Dict[str, Any]]:
-    # Return a list of dicts with the following keys:
-    #     example_ind, example, prediction, trace, and score (if metric != None)
+    # Return a list of dicts with the following keys: example_ind, example, prediction, trace, and score
+    # (if metric != None)
     evaluator = Evaluate(
         devset=dataset,
         num_threads=num_threads,