crfm-helm 0.4.0__py3-none-any.whl → 0.5.10__py3-none-any.whl

helm/{proxy/clients → clients}/anthropic_client.py

@@ -1,18 +1,23 @@
-from typing import Any, Dict, List, Optional
+import dataclasses
+from typing import Any, Dict, List, Optional, TypedDict, Union, cast
 import json
+import os
 import requests
+import tempfile
 import time
 import urllib.parse
 
 from helm.common.cache import CacheConfig
-from helm.common.hierarchical_logger import htrack_block, hlog
+from helm.common.hierarchical_logger import hexception, htrack_block, hlog, hwarn
+from helm.common.media_object import IMAGE_TYPE, TEXT_TYPE
 from helm.common.optional_dependencies import handle_module_not_found_error
 from helm.common.request import (
+    Thinking,
     wrap_request_time,
     EMBEDDING_UNAVAILABLE_REQUEST_RESULT,
     Request,
     RequestResult,
-    Sequence,
+    GeneratedOutput,
     Token,
     ErrorFlags,
 )
@@ -20,16 +25,34 @@ from helm.common.tokenization_request import (
     TokenizationRequest,
     TokenizationRequestResult,
 )
-from helm.proxy.tokenizers.tokenizer import Tokenizer
-from .client import CachingClient, truncate_sequence
+from helm.proxy.retry import NonRetriableException
+from helm.tokenizers.tokenizer import Tokenizer
+from helm.clients.client import CachingClient, truncate_sequence, truncate_and_tokenize_response_text
 
 try:
-    import anthropic
+    from anthropic import Anthropic, BadRequestError
+    from anthropic.types import MessageParam
+    from anthropic.types.message import Message
+    from anthropic.types.text_block import TextBlock
+    from anthropic.types.thinking_block import ThinkingBlock
+    from anthropic.types.image_block_param import ImageBlockParam
+    from anthropic.types.text_block_param import TextBlockParam
+    from anthropic.types.thinking_config_enabled_param import ThinkingConfigEnabledParam
     import websocket
 except ModuleNotFoundError as e:
     handle_module_not_found_error(e, ["anthropic"])
 
 
+class AnthropicCompletionRequest(TypedDict):
+    prompt: str
+    stop_sequences: List[str]
+    model: str
+    max_tokens_to_sample: int
+    temperature: float
+    top_p: float
+    top_k: int
+
+
 class AnthropicClient(CachingClient):
     """
     Client for the Anthropic models (https://arxiv.org/abs/2204.05862).
@@ -53,6 +76,9 @@ class AnthropicClient(CachingClient):
     MAX_COMPLETION_LENGTH: int = (
         8192  # See https://docs.google.com/document/d/1vX6xgoA-KEKxqtMlBVAqYvE8KUfZ7ABCjTxAjf1T5kI/edit#
     )
+    # An Anthropic error message: "At least one of the image dimensions exceed max allowed size: 8000 pixels"
+    MAX_IMAGE_DIMENSION: int = 8000
+
     ADDITIONAL_TOKENS: int = 5
     PROMPT_ANSWER_START: str = "The answer is "
 
@@ -63,12 +89,12 @@ class AnthropicClient(CachingClient):
         self.tokenizer = tokenizer
         self.tokenizer_name = tokenizer_name
         self.api_key: Optional[str] = api_key
-        self._client = anthropic.Client(api_key) if api_key else None
+        self.client = Anthropic(api_key=api_key)
 
-    def _send_request(self, raw_request: Dict[str, Any]) -> Dict[str, Any]:
+    def _send_request(self, raw_request: AnthropicCompletionRequest) -> Dict[str, Any]:
         if self.api_key is None:
             raise Exception("API key is not set. Please set it in the HELM config file.")
-        result = self._client.completion(**raw_request)
+        result = self.client.completions.create(**raw_request).model_dump()
         assert "error" not in result, f"Request failed with error: {result['error']}"
         return result
 
@@ -103,7 +129,7 @@ class AnthropicClient(CachingClient):
         if request.max_tokens == 0 and not request.echo_prompt:
             raise ValueError("echo_prompt must be True when max_tokens=0.")
 
-        raw_request = {
+        raw_request: AnthropicCompletionRequest = {
             "prompt": request.prompt,
             "stop_sequences": request.stop_sequences,
             "model": request.model_engine,
@@ -113,7 +139,7 @@ class AnthropicClient(CachingClient):
             "top_k": request.top_k_per_token,
         }
 
-        completions: List[Sequence] = []
+        completions: List[GeneratedOutput] = []
 
         # `num_completions` is not supported, so instead make `num_completions` separate requests.
         for completion_index in range(request.num_completions):
@@ -158,6 +184,7 @@ class AnthropicClient(CachingClient):
                         embedding=[],
                         error_flags=ErrorFlags(is_retriable=False, is_fatal=False),
                     )
+                hexception(error)
                 return RequestResult(success=False, cached=False, error=str(error), completions=[], embedding=[])
 
             # Post process the completion.
@@ -172,11 +199,9 @@ class AnthropicClient(CachingClient):
             )
 
             # Log probs are not currently not supported by the Anthropic, so set to 0 for now.
-            tokens: List[Token] = [
-                Token(text=str(text), logprob=0, top_logprobs={}) for text in tokenization_result.raw_tokens
-            ]
+            tokens: List[Token] = [Token(text=str(text), logprob=0) for text in tokenization_result.raw_tokens]
 
-            completion = Sequence(text=response["completion"], logprob=0, tokens=tokens)
+            completion = GeneratedOutput(text=response["completion"], logprob=0, tokens=tokens)
             # See NOTE() in _filter_completion() to understand why warnings are printed for truncation.
             # TODO(#1512): Fix this with post-processing.
             sequence = truncate_sequence(completion, request, print_warning=True)
@@ -192,6 +217,264 @@ class AnthropicClient(CachingClient):
         )
 
 
+def _is_content_moderation_failure(response: Dict) -> bool:
+    """Return whether a response failed because of the content moderation filter."""
+    if (
+        "error" in response
+        and "message" in response["error"]
+        and response["error"]["message"] == "Output blocked by content filtering policy"
+    ):
+        hlog(f"Anthropic - output blocked by content filtering policy: {response}")
+        return True
+    return False
+
+
+class AnthropicMessagesRequest(TypedDict, total=False):
+    messages: List[MessageParam]
+    model: str
+    stop_sequences: List[str]
+    system: str
+    max_tokens: int
+    temperature: float
+    top_k: int
+    top_p: float
+    thinking: ThinkingConfigEnabledParam
+
+
+class AnthropicMessagesRequestError(NonRetriableException):
+    pass
+
+
+class AnthropicMessagesEmptyContentError(Exception):
+    pass
+
+
+class AnthropicMessagesClient(CachingClient):
+    # Source: https://docs.anthropic.com/claude/docs/models-overview
+    MAX_OUTPUT_TOKENS: int = 64000
+
+    MAX_IMAGE_SIZE_BYTES: int = 5242880  # 5MB
+
+    def __init__(
+        self,
+        tokenizer: Tokenizer,
+        tokenizer_name: str,
+        cache_config: CacheConfig,
+        thinking_budget_tokens: Optional[int] = None,
+        anthropic_model_name: Optional[str] = None,
+        api_key: Optional[str] = None,
+        stream: Optional[bool] = None,
+    ):
+        super().__init__(cache_config=cache_config)
+        self.tokenizer = tokenizer
+        self.tokenizer_name = tokenizer_name
+        self.client = Anthropic(api_key=api_key)
+        self.api_key: Optional[str] = api_key
+        self.anthropic_model_name: Optional[str] = anthropic_model_name
+        self.thinking_budget_tokens: Optional[int] = thinking_budget_tokens
+        self.stream: Optional[bool] = stream
+
+    def make_request(self, request: Request) -> RequestResult:
+        if request.max_tokens > AnthropicMessagesClient.MAX_OUTPUT_TOKENS:
+            raise AnthropicMessagesRequestError(
+                f"Request.max_tokens must be <= {AnthropicMessagesClient.MAX_OUTPUT_TOKENS}"
+            )
+
+        messages: List[MessageParam] = []
+        system_message: Optional[MessageParam] = None
+
+        if request.messages is not None:
+            request.validate()
+            messages = cast(List[MessageParam], request.messages)
+            if messages[0]["role"] == "system":
+                system_message = messages[0]
+                messages = messages[1:]
+
+        elif request.multimodal_prompt is not None:
+            request.validate()
+            blocks: List[Union[TextBlockParam, ImageBlockParam]] = []
+            for media_object in request.multimodal_prompt.media_objects:
+                if media_object.is_type(IMAGE_TYPE):
+                    from helm.common.images_utils import (
+                        encode_base64,
+                        get_dimensions,
+                        copy_image,
+                        resize_image_to_max_file_size,
+                    )
+
+                    assert media_object.location
+                    image_location: str = media_object.location
+                    base64_image: str
+
+                    image_width, image_height = get_dimensions(media_object.location)
+                    if (
+                        image_width > AnthropicClient.MAX_IMAGE_DIMENSION
+                        or image_height > AnthropicClient.MAX_IMAGE_DIMENSION
+                    ):
+                        hwarn(
+                            f"Image {image_location} exceeds max allowed size: "
+                            f"{AnthropicClient.MAX_IMAGE_DIMENSION} pixels"
+                        )
+                        # Save the resized image to a temporary file
+                        with tempfile.NamedTemporaryFile(suffix=".jpg") as temp_file:
+                            hlog(f"Resizing image to temporary path: {temp_file.name}")
+                            copy_image(
+                                src=image_location,
+                                dest=temp_file.name,
+                                width=min(image_width, AnthropicClient.MAX_IMAGE_DIMENSION),
+                                height=min(image_height, AnthropicClient.MAX_IMAGE_DIMENSION),
+                            )
+                            base64_image = encode_base64(temp_file.name, format="JPEG")
+
+                    elif os.path.getsize(image_location) > AnthropicMessagesClient.MAX_IMAGE_SIZE_BYTES:
+                        hwarn(
+                            f"Image {image_location} exceeds max allowed size: "
+                            f"{AnthropicMessagesClient.MAX_IMAGE_SIZE_BYTES} bytes"
+                        )
+                        # Resize the image so it is smaller than the max allowed size
+                        with tempfile.NamedTemporaryFile(suffix=".jpg") as temp_file:
+                            hlog(f"Resizing image to temporary path: {temp_file.name}")
+                            resize_image_to_max_file_size(
+                                src=image_location,
+                                dest=temp_file.name,
+                                max_size_in_bytes=AnthropicMessagesClient.MAX_IMAGE_SIZE_BYTES,
+                            )
+                            base64_image = encode_base64(temp_file.name, format="JPEG")
+                    else:
+                        base64_image = encode_base64(image_location, format="JPEG")
+
+                    image_block: ImageBlockParam = {
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": "image/jpeg",
+                            "data": base64_image,
+                        },
+                    }
+                    blocks.append(image_block)
+                if media_object.is_type(TEXT_TYPE):
+                    assert media_object.text
+                    text_block: TextBlockParam = {
+                        "type": "text",
+                        "text": media_object.text,
+                    }
+                    # Anthropic does not support empty text blocks
+                    if media_object.text:
+                        if media_object.text.strip():
+                            blocks.append(text_block)
+            messages = [{"role": "user", "content": blocks}]
+
+        else:
+            messages = [{"role": "user", "content": request.prompt}]
+
+        raw_request: AnthropicMessagesRequest = {
+            "messages": messages,
+            "model": self.anthropic_model_name or request.model_engine,
+            "stop_sequences": request.stop_sequences,
+            "max_tokens": request.max_tokens,
+            "temperature": request.temperature,
+            "top_p": request.top_p,
+            "top_k": request.top_k_per_token,
+        }
+        if system_message is not None:
+            raw_request["system"] = cast(str, system_message["content"])
+        if self.thinking_budget_tokens:
+            raw_request["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": self.thinking_budget_tokens,
+            }
+            # Avoid error:
+            # `top_k` must be unset when thinking is enabled. Please consult our documentation at https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking#important-considerations-when-using-extended-thinking  # noqa: E501
+            del raw_request["top_k"]
+        if raw_request["model"].startswith("claude-sonnet-4-5"):
+            # Avoid error:
+            # `temperature` and `top_p` cannot both be specified for this model. Please use only one.
+            del raw_request["top_p"]
+
+        completions: List[GeneratedOutput] = []
+
+        # `num_completions` is not supported, so instead make `num_completions` separate requests.
+        for completion_index in range(request.num_completions):
+
+            def do_it() -> Dict[str, Any]:
+                try:
+                    if self.stream:
+                        with self.client.messages.stream(**raw_request) as message_stream:
+                            result = message_stream.get_final_message().model_dump()
+                    else:
+                        result = self.client.messages.create(**raw_request).model_dump()
+                    if "content" not in result or not result["content"]:
+                        raise AnthropicMessagesEmptyContentError(f"Anthropic response has empty content: {result}")
+                    elif "text" not in result["content"][-1]:
+                        raise AnthropicMessagesEmptyContentError(f"Anthropic response has non-text content: {result}")
+                    return result
+                except BadRequestError as e:
+                    response = e.response.json()
+                    if _is_content_moderation_failure(response):
+                        return response
+                    raise
+
+            try:
+                cache_key = CachingClient.make_cache_key(
+                    {
+                        "completion_index": completion_index,
+                        **raw_request,
+                    },
+                    request,
+                )
+                raw_response, cached = self.cache.get(cache_key, wrap_request_time(do_it))
+
+            except AnthropicMessagesEmptyContentError:
+                hwarn("Anthropic response has empty content")
+                return RequestResult(
+                    success=False,
+                    cached=False,
+                    error="Anthropic response has empty content",
+                    completions=[],
+                    embedding=[],
+                    error_flags=ErrorFlags(is_retriable=False, is_fatal=False),
+                )
+
+            if _is_content_moderation_failure(raw_response):
+                hwarn(f"Returning empty request for {request.model_deployment} " "due to content moderation filter")
+                return RequestResult(
+                    success=False,
+                    cached=cached,
+                    error=raw_response["error"]["message"],
+                    completions=[],
+                    embedding=[],
+                    error_flags=ErrorFlags(is_retriable=False, is_fatal=False),
+                    request_time=raw_response["request_time"],
+                    request_datetime=raw_response["request_datetime"],
+                )
+
+            response_message: Message = Message.model_validate(raw_response)
+            response_text: Optional[str] = None
+            response_thinking: Optional[str] = None
+            for content in response_message.content:
+                if isinstance(content, TextBlock):
+                    response_text = content.text
+                elif isinstance(content, ThinkingBlock):
+                    response_thinking = content.thinking
+            if response_text is None:
+                raise Exception("Anthropic response did not contain text block")
+            completion = truncate_and_tokenize_response_text(
+                response_text, request, self.tokenizer, self.tokenizer_name, original_finish_reason=""
+            )
+            if response_thinking is not None:
+                completion = dataclasses.replace(completion, thinking=Thinking(text=response_thinking))
+            completions.append(completion)
+
+        return RequestResult(
+            success=True,
+            cached=cached,
+            request_time=raw_response["request_time"],
+            request_datetime=raw_response["request_datetime"],
+            completions=completions,
+            embedding=[],
+        )
+
+
 class AnthropicRequestError(Exception):
     pass
 
@@ -379,8 +662,8 @@ class AnthropicLegacyClient(CachingClient):
                     if logprobs["tokens"] != tokens:
                         # This is a known limitation with the Anthropic API. For now keep track of the
                         # entries with the mismatch.
-                        hlog(
-                            f"WARNING: naive truncation for logprobs did not work."
+                        hwarn(
+                            f"naive truncation for logprobs did not work."
                             f"\nRequest:{raw_request}\nExpected: {tokens}\nActual: {logprobs['tokens']}"
                         )
                         check_logprobs = True
@@ -394,7 +677,7 @@ class AnthropicLegacyClient(CachingClient):
 
         # Since Anthropic doesn't support multiple completions, we have to manually call it multiple times,
         # and aggregate the results into `completions` and `request_time`.
-        completions: List[Sequence] = []
+        completions: List[GeneratedOutput] = []
         all_cached = True
         request_time = 0
         request_datetime: Optional[int] = None
@@ -418,6 +701,7 @@ class AnthropicLegacyClient(CachingClient):
                 )
                 response, cached = self.cache.get(cache_key, wrap_request_time(do_it))
             except AnthropicRequestError as error:
+                hexception(error)
                 return RequestResult(success=False, cached=False, error=str(error), completions=[], embedding=[])
 
             sequence_logprob: float = 0
@@ -427,8 +711,7 @@ class AnthropicLegacyClient(CachingClient):
             for text, token_logprob, all_logprobs, all_tokens in zip(
                 log_probs["tokens"], log_probs["logprobs"], log_probs["topk_logprobs"], log_probs["topk_tokens"]
             ):
-                top_logprobs: Dict[str, float] = {text: logprob for text, logprob in zip(all_tokens, all_logprobs)}
-                tokens.append(Token(text=text, logprob=token_logprob, top_logprobs=top_logprobs))
+                tokens.append(Token(text=text, logprob=token_logprob))
                 sequence_logprob += token_logprob
 
             finish_reason: str = response["stop_reason"]
@@ -436,7 +719,7 @@ class AnthropicLegacyClient(CachingClient):
             if finish_reason == AnthropicLegacyClient.STOP_SEQUENCE_STOP_REASON:
                 finish_reason = "stop"
 
-            completion = Sequence(
+            completion = GeneratedOutput(
                 text=response["text"],
                 logprob=sequence_logprob,
                 tokens=tokens,

helm/clients/audio_language/diva_llama_client.py

@@ -0,0 +1,122 @@
+import threading
+from typing import Any, Dict, List, Optional, Tuple, TypedDict
+
+import numpy as np
+from transformers import AutoModel, PreTrainedModel
+
+from helm.clients.client import CachingClient
+from helm.common.cache import CacheConfig
+from helm.common.hierarchical_logger import hexception
+from helm.common.media_object import TEXT_TYPE
+from helm.common.request import (
+    GeneratedOutput,
+    Request,
+    RequestResult,
+    wrap_request_time,
+)
+from helm.common.audio_utils import get_array_from_audio_file
+from helm.proxy.retry import NonRetriableException
+
+
+_LOCK = threading.Lock()
+_PRE_TRAINED_MODEL: Optional[PreTrainedModel] = None
+
+
+def _get_pre_trained_model(model_name: str, **kwargs) -> PreTrainedModel:
+    global _LOCK
+    global _PRE_TRAINED_MODEL
+    with _LOCK:
+        if _PRE_TRAINED_MODEL is None:
+            _PRE_TRAINED_MODEL = AutoModel.from_pretrained(model_name, **kwargs)
+    return _PRE_TRAINED_MODEL
+
+
+class DivaLlamaRequest(TypedDict):
+    """Cache key for DivaLlamaClient"""
+
+    model: str
+    media_objects: List[Dict[str, Any]]
+
+
+class DivaLlamaClient(CachingClient):
+    SAMPLE_RATE = 16000
+
+    def __init__(
+        self,
+        cache_config: CacheConfig,
+        **kwargs,
+    ):
+        super().__init__(cache_config)
+        self.pre_trained_model = _get_pre_trained_model("WillHeld/DiVA-llama-3-v0-8b", trust_remote_code=True, **kwargs)
+
+    @staticmethod
+    def _get_generate_input(request: Request) -> Tuple[np.ndarray, Optional[str]]:
+        if request.prompt:
+            raise NonRetriableException("request.prompt must be empty for DivaLlamaClient")
+        if request.embedding:
+            raise NonRetriableException("request.embedding must be empty for DivaLlamaClient")
+        if request.messages:
+            raise NonRetriableException("request.messages must be empty for DivaLlamaClient")
+        if request.multimodal_prompt is None:
+            raise NonRetriableException("request.multimodal_prompt must not be None for DivaLlamaClient")
+        text_input: Optional[str] = None
+        audio_input: Optional[np.ndarray] = None
+        for media_object in request.multimodal_prompt.media_objects:
+            if media_object.is_type("audio"):
+                if audio_input is not None:
+                    raise NonRetriableException(
+                        "Only one audio object allowed in request.multimodal_prompt.media_objects"
+                    )
+                assert media_object.location
+                audio_input = get_array_from_audio_file(media_object.location, DivaLlamaClient.SAMPLE_RATE)
+            elif media_object.is_type(TEXT_TYPE):
+                if text_input is not None:
+                    raise NonRetriableException(
+                        "Only one text object allowed in request.multimodal_prompt.media_objects"
+                    )
+                assert media_object.text is not None
+                text_input = media_object.text
+            else:
+                raise NonRetriableException(f"Unsupported media content type type: {media_object.content_type}")
+        if audio_input is None:
+            raise NonRetriableException(
+                "Expected a single audio object allowed in request.multimodal_prompt.media_objects"
+            )
+        return audio_input, text_input
+
+    def make_request(self, request: Request) -> RequestResult:
+        assert request.multimodal_prompt is not None
+        raw_request: DivaLlamaRequest = {
+            "model": request.model,
+            "media_objects": [media_object.to_dict() for media_object in request.multimodal_prompt.media_objects],
+        }
+
+        try:
+
+            def do_it() -> Dict[str, Any]:
+                with _LOCK:
+                    audio_input, text_input = DivaLlamaClient._get_generate_input(request)
+                    if text_input is None:
+                        return {"completions": self.pre_trained_model.generate([audio_input])}  # type: ignore
+                    else:
+                        return {
+                            "completions": self.pre_trained_model.generate([audio_input], [text_input])  # type: ignore
+                        }
+
+            cache_key = CachingClient.make_cache_key(raw_request, request)
+            response, cached = self.cache.get(cache_key, wrap_request_time(do_it))
+        except Exception as e:  # Do something if error is encountered.
+            hexception(e)
+            error: str = f"HuggingFace error: {e}"
+            return RequestResult(success=False, cached=False, error=error, completions=[], embedding=[])
+
+        generated_output = GeneratedOutput(text=response["completions"][0], logprob=0, tokens=[])
+
+        return RequestResult(
+            success=True,
+            cached=cached,
+            request_time=response["request_time"],
+            request_datetime=response.get("request_datetime"),
+            completions=[generated_output],
+            embedding=[],
+        )

helm/clients/audio_language/llama_omni/arguments.py

@@ -0,0 +1,61 @@
+import transformers
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ModelArguments:
+    model_name_or_path: Optional[str] = field(default="facebook/opt-125m")
+    version: Optional[str] = field(default="v0")
+    freeze_backbone: bool = field(default=False)
+    tune_speech_projector: bool = field(default=False)
+    tune_speech_encoder: bool = field(default=False)
+    tune_speech_generator_only: bool = field(default=False)
+    speech_encoder_type: Optional[str] = field(default=None)
+    speech_encoder: Optional[str] = field(default=None)
+    pretrain_speech_projector: Optional[str] = field(default=None)
+    speech_projector_type: Optional[str] = field(default="linear")
+    speech_generator_type: Optional[str] = field(default="ctc")
+    ctc_decoder_config: str = "(2,4096,32,11008)"
+    ctc_upsample_factor: int = 1
+    ctc_loss_weight: float = 1.0
+    unit_vocab_size: int = 1000
+    speech_encoder_ds_rate: int = 5
+    speech_encoder_hidden_size: int = 1280
+
+
+@dataclass
+class DataArguments:
+    data_path: str = field(default="", metadata={"help": "Path to the training data."})
+    is_multimodal: bool = False
+    input_type: str = field(default="mel")
+    speech_normalize: bool = False
+    mel_size: int = 128
+    has_tgt_units: bool = False
+
+
+@dataclass
+class TrainingArguments(transformers.TrainingArguments):
+    cache_dir: Optional[str] = field(default=None)
+    optim: str = field(default="adamw_torch")
+    freeze_speech_projector: bool = field(default=False)
+    model_max_length: int = field(
+        default=512,
+        metadata={"help": "Maximum sequence length. Sequences will be right padded (and possibly truncated)."},
+    )
+    double_quant: bool = field(
+        default=True, metadata={"help": "Compress the quantization statistics through double quantization."}
+    )
+    quant_type: str = field(
+        default="nf4", metadata={"help": "Quantization data type to use. Should be one of `fp4` or `nf4`."}
+    )
+    bits: int = field(default=16, metadata={"help": "How many bits to use."})
+    lora_enable: bool = False
+    lora_r: int = 64
+    lora_alpha: int = 16
+    lora_dropout: float = 0.05
+    lora_weight_path: str = ""
+    lora_bias: str = "none"
+    speech_projector_lr: Optional[float] = None
+    group_by_modality_length: bool = field(default=False)

helm/clients/audio_language/llama_omni/constants.py

@@ -0,0 +1,9 @@
+CONTROLLER_HEART_BEAT_EXPIRATION = 30
+WORKER_HEART_BEAT_INTERVAL = 15
+
+LOGDIR = "."
+
+# Model Constants
+IGNORE_INDEX = -100
+SPEECH_TOKEN_INDEX = -200
+DEFAULT_SPEECH_TOKEN = "<speech>"