arize-phoenix 3.16.1__py3-none-any.whl → 7.7.0__py3-none-any.whl

phoenix/experimental/evals/models/anthropic.py

@@ -1,175 +0,0 @@
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
-
-from phoenix.exceptions import PhoenixContextLimitExceeded
-from phoenix.experimental.evals.models.base import BaseEvalModel
-from phoenix.experimental.evals.models.rate_limiters import RateLimiter
-
-if TYPE_CHECKING:
-    from tiktoken import Encoding
-
-MODEL_TOKEN_LIMIT_MAPPING = {
-    "claude-2.1": 200000,
-    "claude-2.0": 100000,
-    "claude-instant-1.2": 100000,
-}
-
-
-@dataclass
-class AnthropicModel(BaseEvalModel):
-    model: str = "claude-2.1"
-    """The model name to use."""
-    temperature: float = 0.0
-    """What sampling temperature to use."""
-    max_tokens: int = 256
-    """The maximum number of tokens to generate in the completion."""
-    top_p: float = 1
-    """Total probability mass of tokens to consider at each step."""
-    top_k: int = 256
-    """The cutoff where the model no longer selects the words"""
-    stop_sequences: List[str] = field(default_factory=list)
-    """If the model encounters a stop sequence, it stops generating further tokens. """
-    max_retries: int = 6
-    """Maximum number of retries to make when generating."""
-    retry_min_seconds: int = 10
-    """Minimum number of seconds to wait when retrying."""
-    retry_max_seconds: int = 60
-    """Maximum number of seconds to wait when retrying."""
-    extra_parameters: Dict[str, Any] = field(default_factory=dict)
-    """Any extra parameters to add to the request body (e.g., countPenalty for a21 models)"""
-    max_content_size: Optional[int] = None
-    """If you're using a fine-tuned model, set this to the maximum content size"""
-
-    def __post_init__(self) -> None:
-        self._init_environment()
-        self._init_client()
-        self._init_tiktoken()
-        self._init_rate_limiter()
-
-    def _init_environment(self) -> None:
-        try:
-            import tiktoken
-
-            self._tiktoken = tiktoken
-        except ImportError:
-            self._raise_import_error(
-                package_name="tiktoken",
-            )
-
-    def _init_client(self) -> None:
-        try:
-            import anthropic  # type:ignore
-
-            self._anthropic = anthropic
-            self.client = self._anthropic.Anthropic()
-            self.async_client = self._anthropic.AsyncAnthropic()
-        except ImportError:
-            self._raise_import_error(
-                package_name="anthropic",
-            )
-
-    def _init_tiktoken(self) -> None:
-        try:
-            encoding = self._tiktoken.encoding_for_model(self.model)
-        except KeyError:
-            encoding = self._tiktoken.get_encoding("cl100k_base")
-        self._tiktoken_encoding = encoding
-
-    def _init_rate_limiter(self) -> None:
-        self._rate_limiter = RateLimiter(
-            rate_limit_error=self._anthropic.RateLimitError,
-            max_rate_limit_retries=10,
-            initial_per_second_request_rate=1,
-            maximum_per_second_request_rate=20,
-            enforcement_window_minutes=1,
-        )
-
-    def invocation_parameters(self) -> Dict[str, Any]:
-        return {
-            "max_tokens_to_sample": self.max_tokens,
-            "stop_sequences": self.stop_sequences,
-            "temperature": self.temperature,
-            "top_p": self.top_p,
-            "top_k": self.top_k,
-        }
-
-    @property
-    def encoder(self) -> "Encoding":
-        return self._tiktoken_encoding
-
-    def get_tokens_from_text(self, text: str) -> List[int]:
-        return self.encoder.encode(text)
-
-    def get_text_from_tokens(self, tokens: List[int]) -> str:
-        return self.encoder.decode(tokens)
-
-    @property
-    def max_context_size(self) -> int:
-        context_size = self.max_content_size or MODEL_TOKEN_LIMIT_MAPPING.get(self.model, None)
-
-        if context_size is None:
-            raise ValueError(
-                "Can't determine maximum context size. An unknown model name was "
-                + f"used: {self.model}. Please set the `max_content_size` argument"
-                + "when using fine-tuned models. "
-            )
-
-        return context_size
-
-    def _generate(self, prompt: str, **kwargs: Dict[str, Any]) -> str:
-        # instruction is an invalid input to Anthropic models, it is passed in by
-        # BaseEvalModel.__call__ and needs to be removed
-        kwargs.pop("instruction", None)
-        invocation_parameters = self.invocation_parameters()
-        invocation_parameters.update(kwargs)
-        response = self._rate_limited_completion(
-            model=self.model,
-            prompt=self._format_prompt_for_claude(prompt),
-            **invocation_parameters,
-        )
-
-        return str(response)
-
-    def _rate_limited_completion(self, **kwargs: Any) -> Any:
-        @self._rate_limiter.limit
-        def _completion(**kwargs: Any) -> Any:
-            try:
-                response = self.client.completions.create(**kwargs)
-                return response.completion
-            except self._anthropic.BadRequestError as e:
-                exception_message = e.args[0]
-                if exception_message and "prompt is too long" in exception_message:
-                    raise PhoenixContextLimitExceeded(exception_message) from e
-                raise e
-
-        return _completion(**kwargs)
-
-    async def _async_generate(self, prompt: str, **kwargs: Dict[str, Any]) -> str:
-        # instruction is an invalid input to Anthropic models, it is passed in by
-        # BaseEvalModel.__call__ and needs to be removed
-        kwargs.pop("instruction", None)
-        invocation_parameters = self.invocation_parameters()
-        invocation_parameters.update(kwargs)
-        response = await self._async_rate_limited_completion(
-            model=self.model, prompt=self._format_prompt_for_claude(prompt), **invocation_parameters
-        )
-
-        return str(response)
-
-    async def _async_rate_limited_completion(self, **kwargs: Any) -> Any:
-        @self._rate_limiter.alimit
-        async def _async_completion(**kwargs: Any) -> Any:
-            try:
-                response = await self.async_client.completions.create(**kwargs)
-                return response.completion
-            except self._anthropic.BadRequestError as e:
-                exception_message = e.args[0]
-                if exception_message and "prompt is too long" in exception_message:
-                    raise PhoenixContextLimitExceeded(exception_message) from e
-                raise e
-
-        return await _async_completion(**kwargs)
-
-    def _format_prompt_for_claude(self, prompt: str) -> str:
-        # Claude requires prompt in the format of Human: ... Assistant:
-        return f"{self._anthropic.HUMAN_PROMPT} {prompt} {self._anthropic.AI_PROMPT}"

phoenix/experimental/evals/models/base.py

@@ -1,170 +0,0 @@
-import logging
-from abc import ABC, abstractmethod, abstractproperty
-from contextlib import contextmanager
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Generator, List, Optional, Sequence
-
-from phoenix.experimental.evals.models.rate_limiters import RateLimiter
-
-if TYPE_CHECKING:
-    from tiktoken import Encoding
-
-from tqdm.asyncio import tqdm_asyncio
-from tqdm.auto import tqdm
-from typing_extensions import TypeVar
-
-from phoenix.experimental.evals.utils.threads import to_thread
-from phoenix.utilities.logging import printif
-
-T = TypeVar("T", bound=type)
-
-
-def is_list_of(lst: Sequence[object], tp: T) -> bool:
-    return isinstance(lst, list) and all(isinstance(x, tp) for x in lst)
-
-
-logger = logging.getLogger(__name__)
-
-TQDM_BAR_FORMAT = (
-    "Eta:{eta} |{bar}| {percentage:3.1f}% "
-    "({n_fmt}/{total_fmt}) "
-    "[{elapsed}<{remaining}, {rate_fmt}{postfix}]"
-)
-
-
-@contextmanager
-def set_verbosity(
-    model: "BaseEvalModel", verbose: bool = False
-) -> Generator["BaseEvalModel", None, None]:
-    try:
-        _model_verbose_setting = model._verbose
-        _rate_limiter_verbose_setting = model._rate_limiter._verbose
-        model._verbose = verbose
-        model._rate_limiter._verbose = verbose
-        yield model
-    finally:
-        model._verbose = _model_verbose_setting
-        model._rate_limiter._verbose = _rate_limiter_verbose_setting
-
-
-@dataclass
-class BaseEvalModel(ABC):
-    default_concurrency: int = 20
-    _verbose: bool = False
-    _rate_limiter: RateLimiter = field(default_factory=RateLimiter)
-
-    def reload_client(self) -> None:
-        pass
-
-    def __call__(self, prompt: str, instruction: Optional[str] = None, **kwargs: Any) -> str:
-        """Run the LLM on the given prompt."""
-        if not isinstance(prompt, str):
-            raise TypeError(
-                "Invalid type for argument `prompt`. Expected a string but found "
-                f"{type(prompt)}. If you want to run the LLM on multiple prompts, use "
-                "`generate` instead."
-            )
-        if instruction is not None and not isinstance(instruction, str):
-            raise TypeError(
-                "Invalid type for argument `instruction`. Expected a string but found "
-                f"{type(instruction)}."
-            )
-        return self._generate(prompt=prompt, instruction=instruction, **kwargs)
-
-    async def async_call(self, prompt: str, instruction: Optional[str] = None) -> str:
-        """Run the LLM on the given prompt."""
-        if not isinstance(prompt, str):
-            raise TypeError(
-                "Invalid type for argument `prompt`. Expected a string but found "
-                f"{type(prompt)}. If you want to run the LLM on multiple prompts, use "
-                "`generate` instead."
-            )
-        if instruction is not None and not isinstance(instruction, str):
-            raise TypeError(
-                "Invalid type for argument `instruction`. Expected a string but found "
-                f"{type(instruction)}."
-            )
-        response = await self.agenerate(prompts=[prompt], instruction=instruction)
-        return response[0]
-
-    def generate(
-        self, prompts: List[str], instruction: Optional[str] = None, **kwargs: Any
-    ) -> List[str]:
-        printif(self._verbose, f"Generating responses for {len(prompts)} prompts...")
-        if extra_info := self.verbose_generation_info():
-            printif(self._verbose, extra_info)
-        if not is_list_of(prompts, str):
-            raise TypeError(
-                "Invalid type for argument `prompts`. Expected a list of strings "
-                f"but found {type(prompts)}."
-            )
-        try:
-            outputs = []
-            for prompt in tqdm(prompts, bar_format=TQDM_BAR_FORMAT):
-                output = self._generate(prompt=prompt, instruction=instruction, **kwargs)
-                logger.info(f"Prompt: {prompt}\nInstruction: {instruction}\nOutput: {output}")
-                outputs.append(output)
-
-        except (KeyboardInterrupt, Exception) as e:
-            raise e
-        return outputs
-
-    async def agenerate(self, prompts: List[str], instruction: Optional[str] = None) -> List[str]:
-        if not is_list_of(prompts, str):
-            raise TypeError(
-                "Invalid type for argument `prompts`. Expected a list of strings "
-                f"but found {type(prompts)}."
-            )
-        try:
-            result: List[str] = await tqdm_asyncio.gather(
-                *[self._agenerate(prompt=prompt, instruction=instruction) for prompt in prompts],
-                bar_format=TQDM_BAR_FORMAT,
-                ncols=100,
-            )
-        except (KeyboardInterrupt, Exception) as e:
-            raise e
-        return result
-
-    def verbose_generation_info(self) -> str:
-        # if defined, returns additional model-specific information to display if `generate` is
-        # run with `verbose=True`
-        return ""
-
-    @abstractmethod
-    async def _async_generate(self, prompt: str, **kwargs: Any) -> str:
-        raise NotImplementedError
-
-    @abstractmethod
-    def _generate(self, prompt: str, **kwargs: Any) -> str:
-        raise NotImplementedError
-
-    async def _agenerate(self, prompt: str, instruction: Optional[str]) -> str:
-        return str(await to_thread(self._generate, prompt=prompt, instruction=instruction))
-
-    @staticmethod
-    def _raise_import_error(
-        package_name: str, package_display_name: str = "", package_min_version: str = ""
-    ) -> None:
-        if not package_display_name:
-            package_display_name = package_name
-        msg = (
-            f"Could not import necessary dependencies to use {package_display_name}. "
-            "Please install them with "
-        )
-        if package_min_version:
-            msg += f"`pip install {package_name}>={package_min_version}`."
-        else:
-            msg += f"`pip install {package_name}`."
-        raise ImportError(msg)
-
-    @abstractmethod
-    def get_tokens_from_text(self, text: str) -> List[int]: ...
-
-    @abstractmethod
-    def get_text_from_tokens(self, tokens: List[int]) -> str: ...
-
-    @abstractproperty
-    def max_context_size(self) -> int: ...
-
-    @abstractproperty
-    def encoder(self) -> "Encoding": ...

phoenix/experimental/evals/models/bedrock.py

@@ -1,221 +0,0 @@
-import json
-import logging
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
-
-from phoenix.exceptions import PhoenixContextLimitExceeded
-from phoenix.experimental.evals.models.base import BaseEvalModel
-from phoenix.experimental.evals.models.rate_limiters import RateLimiter
-
-if TYPE_CHECKING:
-    from tiktoken import Encoding
-
-logger = logging.getLogger(__name__)
-
-MINIMUM_BOTO_VERSION = "1.28.58"
-MODEL_TOKEN_LIMIT_MAPPING = {
-    "anthropic.claude-instant-v1": 100 * 1024,
-    "anthropic.claude-v1": 100 * 1024,
-    "anthropic.claude-v2": 100 * 1024,
-    "amazon.titan-text-express-v1": 8 * 1024,
-    "ai21.j2-mid-v1": 8 * 1024,
-    "ai21.j2-ultra-v1": 8 * 1024,
-}
-
-
-@dataclass
-class BedrockModel(BaseEvalModel):
-    model_id: str = "anthropic.claude-v2"
-    """The model name to use."""
-    temperature: float = 0.0
-    """What sampling temperature to use."""
-    max_tokens: int = 256
-    """The maximum number of tokens to generate in the completion."""
-    top_p: float = 1
-    """Total probability mass of tokens to consider at each step."""
-    top_k: int = 256
-    """The cutoff where the model no longer selects the words"""
-    stop_sequences: List[str] = field(default_factory=list)
-    """If the model encounters a stop sequence, it stops generating further tokens. """
-    max_retries: int = 6
-    """Maximum number of retries to make when generating."""
-    retry_min_seconds: int = 10
-    """Minimum number of seconds to wait when retrying."""
-    retry_max_seconds: int = 60
-    """Maximum number of seconds to wait when retrying."""
-    client: Any = None
-    """The bedrock session client. If unset, a new one is created with boto3."""
-    max_content_size: Optional[int] = None
-    """If you're using a fine-tuned model, set this to the maximum content size"""
-    extra_parameters: Dict[str, Any] = field(default_factory=dict)
-    """Any extra parameters to add to the request body (e.g., countPenalty for a21 models)"""
-
-    def __post_init__(self) -> None:
-        self._init_environment()
-        self._init_client()
-        self._init_tiktoken()
-        self._init_rate_limiter()
-
-    def _init_environment(self) -> None:
-        try:
-            import tiktoken
-
-            self._tiktoken = tiktoken
-        except ImportError:
-            self._raise_import_error(
-                package_name="tiktoken",
-            )
-
-    def _init_client(self) -> None:
-        if not self.client:
-            try:
-                import boto3  # type:ignore
-
-                self.client = boto3.client("bedrock-runtime")
-            except ImportError:
-                self._raise_import_error(
-                    package_name="boto3",
-                    package_min_version=MINIMUM_BOTO_VERSION,
-                )
-
-    def _init_tiktoken(self) -> None:
-        try:
-            encoding = self._tiktoken.encoding_for_model(self.model_id)
-        except KeyError:
-            encoding = self._tiktoken.get_encoding("cl100k_base")
-        self._tiktoken_encoding = encoding
-
-    def _init_rate_limiter(self) -> None:
-        self._rate_limiter = RateLimiter(
-            rate_limit_error=self.client.exceptions.ThrottlingException,
-            max_rate_limit_retries=10,
-            initial_per_second_request_rate=2,
-            maximum_per_second_request_rate=20,
-            enforcement_window_minutes=1,
-        )
-
-    @property
-    def max_context_size(self) -> int:
-        context_size = self.max_content_size or MODEL_TOKEN_LIMIT_MAPPING.get(self.model_id, None)
-
-        if context_size is None:
-            raise ValueError(
-                "Can't determine maximum context size. An unknown model name was "
-                + f"used: {self.model_id}. Please set the `max_content_size` argument"
-                + "when using fine-tuned models. "
-            )
-
-        return context_size
-
-    @property
-    def encoder(self) -> "Encoding":
-        return self._tiktoken_encoding
-
-    def get_tokens_from_text(self, text: str) -> List[int]:
-        return self.encoder.encode(text)
-
-    def get_text_from_tokens(self, tokens: List[int]) -> str:
-        return self.encoder.decode(tokens)
-
-    async def _async_generate(self, prompt: str, **kwargs: Dict[str, Any]) -> str:
-        return self._generate(prompt, **kwargs)
-
-    def _generate(self, prompt: str, **kwargs: Dict[str, Any]) -> str:
-        body = json.dumps(self._create_request_body(prompt))
-        accept = "application/json"
-        contentType = "application/json"
-
-        response = self._rate_limited_completion(
-            body=body, modelId=self.model_id, accept=accept, contentType=contentType
-        )
-
-        return self._parse_output(response) or ""
-
-    def _rate_limited_completion(self, **kwargs: Any) -> Any:
-        """Use tenacity to retry the completion call."""
-
-        @self._rate_limiter.limit
-        def _completion(**kwargs: Any) -> Any:
-            try:
-                return self.client.invoke_model(**kwargs)
-            except Exception as e:
-                exception_message = e.args[0]
-                if not exception_message:
-                    raise e
-
-                if "Input is too long" in exception_message:
-                    # Error from Anthropic models
-                    raise PhoenixContextLimitExceeded(exception_message) from e
-                elif "expected maxLength" in exception_message:
-                    # Error from Titan models
-                    raise PhoenixContextLimitExceeded(exception_message) from e
-                elif "Prompt has too many tokens" in exception_message:
-                    # Error from AI21 models
-                    raise PhoenixContextLimitExceeded(exception_message) from e
-                raise e
-
-        return _completion(**kwargs)
-
-    def _format_prompt_for_claude(self, prompt: str) -> str:
-        # Claude requires prompt in the format of Human: ... Assisatnt:
-        if not prompt.strip().lower().startswith("human:"):
-            prompt = f"\n\nHuman:{prompt}"
-        if not prompt.strip().lower().startswith("assistant:"):
-            prompt = f"{prompt}\n\nAssistant:"
-        return prompt
-
-    def _create_request_body(self, prompt: str) -> Dict[str, Any]:
-        # The request formats for bedrock models differ
-        # see https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters.html
-        if self.model_id.startswith("ai21"):
-            return {
-                **{
-                    "prompt": prompt,
-                    "temperature": self.temperature,
-                    "topP": self.top_p,
-                    "maxTokens": self.max_tokens,
-                    "stopSequences": self.stop_sequences,
-                },
-                **self.extra_parameters,
-            }
-        elif self.model_id.startswith("anthropic"):
-            return {
-                **{
-                    "prompt": self._format_prompt_for_claude(prompt),
-                    "temperature": self.temperature,
-                    "top_p": self.top_p,
-                    "top_k": self.top_k,
-                    "max_tokens_to_sample": self.max_tokens,
-                    "stop_sequences": self.stop_sequences,
-                },
-                **self.extra_parameters,
-            }
-        else:
-            if not self.model_id.startswith("amazon"):
-                logger.warn(f"Unknown format for model {self.model_id}, returning titan format...")
-            return {
-                **{
-                    "inputText": prompt,
-                    "textGenerationConfig": {
-                        "temperature": self.temperature,
-                        "topP": self.top_p,
-                        "maxTokenCount": self.max_tokens,
-                        "stopSequences": self.stop_sequences,
-                    },
-                },
-                **self.extra_parameters,
-            }
-
-    def _parse_output(self, response: Any) -> Any:
-        if self.model_id.startswith("ai21"):
-            body = json.loads(response.get("body").read())
-            return body.get("completions")[0].get("data").get("text")
-        elif self.model_id.startswith("anthropic"):
-            body = json.loads(response.get("body").read().decode())
-            return body.get("completion")
-        elif self.model_id.startswith("amazon"):
-            body = json.loads(response.get("body").read())
-            return body.get("results")[0].get("outputText")
-        else:
-            body = json.loads(response.get("body").read())
-            return body.get("results")[0].get("data").get("outputText")