Skip to content

armgit / dspy

Public Imported from GitHub
0

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

Python

feat(dspy): initial cleanup of Snowflake (LM)support

alejandrodfae177731d3
diff --git a/dsp/modules/snowflake.py b/dsp/modules/snowflake.py
new file mode 100644
index 000000000..3cc7c4aa5
--- /dev/null
+++ b/dsp/modules/snowflake.py
@@ -0,0 +1,142 @@
+"""Module for interacting with Snowflake Cortex."""
+import json
+from typing import Any
+
+import backoff
+from pydantic_core import PydanticCustomError
+
+from dsp.modules.lm import LM
+
+try:
+ from snowflake.snowpark import Session
+ from snowflake.snowpark import functions as snow_func
+
+except ImportError:
+ pass
+
+
+def backoff_hdlr(details) -> None:
+ """Handler from https://pypi.org/project/backoff ."""
+ print(
+ f"Backing off {details['wait']:0.1f} seconds after {details['tries']} tries ",
+ f"calling function {details['target']} with kwargs",
+ f"{details['kwargs']}",
+ )
+
+
+def giveup_hdlr(details) -> bool:
+ """Wrapper function that decides when to give up on retry."""
+ if "rate limits" in str(details):
+ return False
+ return True
+
+
+class Snowflake(LM):
+ """Wrapper around Snowflake's CortexAPI.
+
+ Currently supported models include 'mistral-large','reka-flash','mixtral-8x7b',
+ 'llama2-70b-chat','mistral-7b','gemma-7b'.
+ """
+
+ def __init__(self, model: str = "mistral-large", credentials=None, **kwargs):
+ """Parameters
+
+ ----------
+ model : str
+ Which pre-trained model from Snowflake to use?
+ Choices are 'mistral-large','reka-flash','mixtral-8x7b','llama2-70b-chat','mistral-7b','gemma-7b'
+ Full list of supported models is available here: https://docs.snowflake.com/en/user-guide/snowflake-cortex/llm-functions#complete
+ **kwargs: dict
+ Additional arguments to pass to the API provider.
+ """
+ super().__init__(model)
+
+ self.model = model
+ cortex_models = ["mistral-large", "reka-flash", "mixtral-8x7b", "llama2-70b-chat", "mistral-7b", "gemma-7b"]
+
+ if model in cortex_models:
+ self.available_args = {
+ "max_tokens",
+ "temperature",
+ "top_p",
+ }
+ else:
+ raise PydanticCustomError(
+ "model",
+ 'model name is not valid, got "{model_name}"',
+ )
+
+ self.client = self._init_cortex(credentials=credentials)
+ self.provider = "Snowflake"
+ self.kwargs = {
+ **self.kwargs,
+ "temperature": 0.7,
+ "max_output_tokens": 1024,
+ "top_p": 1.0,
+ "top_k": 1,
+ **kwargs,
+ }
+
+ @classmethod
+ def _init_cortex(cls, credentials: dict) -> None:
+ return Session.builder.configs(credentials).create()
+
+ def _prepare_params(
+ self,
+ parameters: Any,
+ ) -> dict:
+ params_mapping = {"n": "candidate_count", "max_tokens": "max_output_tokens"}
+ params = {params_mapping.get(k, k): v for k, v in parameters.items()}
+ params = {**self.kwargs, **params}
+ return {k: params[k] for k in set(params.keys()) & self.available_args}
+
+ def _cortex_complete_request(self, prompt: str, **kwargs) -> dict:
+ complete = snow_func.builtin("snowflake.cortex.complete")
+ cortex_complete_args = complete(
+ snow_func.lit(self.model),
+ snow_func.lit([{"role": "user", "content": prompt}]),
+ snow_func.lit(kwargs),
+ )
+ raw_response = self.client.range(1).withColumn("complete_cal", cortex_complete_args).collect()[0].COMPLETE_CAL
+
+ return json.loads(raw_response)
+
+ def basic_request(self, prompt: str, **kwargs) -> list:
+ raw_kwargs = kwargs
+ kwargs = self._prepare_params(raw_kwargs)
+
+ response = self._cortex_complete_request(prompt, **kwargs)
+
+ history = {
+ "prompt": prompt,
+ "response": {
+ "prompt": prompt,
+ "choices": [{"text": c} for c in response["choices"]],
+ },
+ "kwargs": kwargs,
+ "raw_kwargs": raw_kwargs,
+ }
+
+ self.history.append(history)
+
+ return [i["text"]["messages"] for i in history["response"]["choices"]]
+
+ @backoff.on_exception(
+ backoff.expo,
+ (Exception),
+ max_time=1000,
+ on_backoff=backoff_hdlr,
+ giveup=giveup_hdlr,
+ )
+ def _request(self, prompt: str, **kwargs):
+ """Handles retrieval of completions from Snowflake Cortex whilst handling API errors."""
+ return self.basic_request(prompt, **kwargs)
+
+ def __call__(
+ self,
+ prompt: str,
+ only_completed: bool = True,
+ return_sorted: bool = False,
+ **kwargs,
+ ):
+ return self._request(prompt, **kwargs)
diff --git a/dspy/__init__.py b/dspy/__init__.py
index 2d5ba4f00..be397521d 100644
--- a/dspy/__init__.py
+++ b/dspy/__init__.py
@@ -5,10 +5,10 @@ from .predict import *
from .primitives import *
from .retrieve import *
from .signatures import *
+from .utils.logging import logger, set_log_level, set_log_output
# Functional must be imported after primitives, predict and signatures
from .functional import * # isort: skip
-from .utils.logging import logger, set_log_level, set_log_output
settings = dsp.settings
@@ -25,6 +25,7 @@ Clarifai = dsp.ClarifaiLLM
Google = dsp.Google
GoogleVertexAI = dsp.GoogleVertexAI
GROQ = dsp.GroqLM
+Snowflake = dsp.Snowflake
HFClientTGI = dsp.HFClientTGI
HFClientVLLM = HFClientVLLM