together 1.5.20__py3-none-any.whl → 1.5.23__py3-none-any.whl

together/resources/finetune.py

@@ -89,18 +89,10 @@ def create_finetune_request(
 
     model_or_checkpoint = model or from_checkpoint
 
-    if batch_size == "max":
-        log_warn_once(
-            "Starting from together>=1.3.0, "
-            "the default batch size is set to the maximum allowed value for each model."
-        )
     if warmup_ratio is None:
         warmup_ratio = 0.0
 
     training_type: TrainingType = FullTrainingType()
-    max_batch_size: int = 0
-    max_batch_size_dpo: int = 0
-    min_batch_size: int = 0
     if lora:
         if model_limits.lora_training is None:
             raise ValueError(
@@ -133,28 +125,23 @@ def create_finetune_request(
         min_batch_size = model_limits.full_training.min_batch_size
         max_batch_size_dpo = model_limits.full_training.max_batch_size_dpo
 
-    if batch_size == "max":
-        if training_method == "dpo":
-            batch_size = max_batch_size_dpo
-        else:
-            batch_size = max_batch_size
+    if batch_size != "max":
+        if training_method == "sft":
+            if batch_size > max_batch_size:
+                raise ValueError(
+                    f"Requested batch size of {batch_size} is higher that the maximum allowed value of {max_batch_size}."
+                )
+        elif training_method == "dpo":
+            if batch_size > max_batch_size_dpo:
+                raise ValueError(
+                    f"Requested batch size of {batch_size} is higher that the maximum allowed value of {max_batch_size_dpo}."
+                )
 
-    if training_method == "sft":
-        if batch_size > max_batch_size:
-            raise ValueError(
-                f"Requested batch size of {batch_size} is higher that the maximum allowed value of {max_batch_size}."
-            )
-    elif training_method == "dpo":
-        if batch_size > max_batch_size_dpo:
+        if batch_size < min_batch_size:
             raise ValueError(
-                f"Requested batch size of {batch_size} is higher that the maximum allowed value of {max_batch_size_dpo}."
+                f"Requested batch size of {batch_size} is lower that the minimum allowed value of {min_batch_size}."
             )
 
-    if batch_size < min_batch_size:
-        raise ValueError(
-            f"Requested batch size of {batch_size} is lower that the minimum allowed value of {min_batch_size}."
-        )
-
     if warmup_ratio > 1 or warmup_ratio < 0:
         raise ValueError(f"Warmup ratio should be between 0 and 1 (got {warmup_ratio})")
 

together/types/__init__.py

@@ -7,6 +7,14 @@ from together.types.audio_speech import (
     AudioSpeechStreamChunk,
     AudioSpeechStreamEvent,
     AudioSpeechStreamResponse,
+    AudioTranscriptionRequest,
+    AudioTranslationRequest,
+    AudioTranscriptionResponse,
+    AudioTranscriptionVerboseResponse,
+    AudioTranslationResponse,
+    AudioTranslationVerboseResponse,
+    AudioTranscriptionResponseFormat,
+    AudioTimestampGranularities,
 )
 from together.types.chat_completions import (
     ChatCompletionChunk,
@@ -53,6 +61,19 @@ from together.types.images import ImageRequest, ImageResponse
 from together.types.models import ModelObject
 from together.types.rerank import RerankRequest, RerankResponse
 from together.types.batch import BatchJob, BatchJobStatus, BatchEndpoint
+from together.types.evaluation import (
+    EvaluationType,
+    EvaluationStatus,
+    JudgeModelConfig,
+    ModelRequest,
+    ClassifyParameters,
+    ScoreParameters,
+    CompareParameters,
+    EvaluationRequest,
+    EvaluationCreateResponse,
+    EvaluationJob,
+    EvaluationStatusResponse,
+)
 
 
 __all__ = [
@@ -102,10 +123,29 @@ __all__ = [
     "AudioSpeechStreamChunk",
     "AudioSpeechStreamEvent",
     "AudioSpeechStreamResponse",
+    "AudioTranscriptionRequest",
+    "AudioTranslationRequest",
+    "AudioTranscriptionResponse",
+    "AudioTranscriptionVerboseResponse",
+    "AudioTranslationResponse",
+    "AudioTranslationVerboseResponse",
+    "AudioTranscriptionResponseFormat",
+    "AudioTimestampGranularities",
     "DedicatedEndpoint",
     "ListEndpoint",
     "Autoscaling",
     "BatchJob",
     "BatchJobStatus",
     "BatchEndpoint",
+    "EvaluationType",
+    "EvaluationStatus",
+    "JudgeModelConfig",
+    "ModelRequest",
+    "ClassifyParameters",
+    "ScoreParameters",
+    "CompareParameters",
+    "EvaluationRequest",
+    "EvaluationCreateResponse",
+    "EvaluationJob",
+    "EvaluationStatusResponse",
 ]

together/types/audio_speech.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
+import base64
 from enum import Enum
-from typing import Iterator
-import threading
+from typing import BinaryIO, Iterator, List, Optional, Union
 
 from pydantic import BaseModel, ConfigDict
 
 from together.together_response import TogetherResponse
-import base64
 
 
 class AudioResponseFormat(str, Enum):
@@ -79,23 +78,19 @@ class AudioSpeechStreamEventResponse(BaseModel):
 
 
 class AudioSpeechStreamResponse(BaseModel):
-
     response: TogetherResponse | Iterator[TogetherResponse]
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
     def stream_to_file(self, file_path: str) -> None:
-
         if isinstance(self.response, TogetherResponse):
             # save response to file
             with open(file_path, "wb") as f:
                 f.write(self.response.data)
 
         elif isinstance(self.response, Iterator):
-
             with open(file_path, "wb") as f:
                 for chunk in self.response:
-
                     # Try to parse as stream chunk
                     stream_event_response = AudioSpeechStreamEventResponse(
                         response={"data": chunk.data}
@@ -108,3 +103,83 @@ class AudioSpeechStreamResponse(BaseModel):
                     audio = base64.b64decode(stream_event_response.response.data.b64)
 
                     f.write(audio)
+
+
+class AudioTranscriptionResponseFormat(str, Enum):
+    JSON = "json"
+    VERBOSE_JSON = "verbose_json"
+
+
+class AudioTimestampGranularities(str, Enum):
+    SEGMENT = "segment"
+    WORD = "word"
+
+
+class AudioTranscriptionRequest(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    file: Union[str, BinaryIO]
+    model: str = "openai/whisper-large-v3"
+    language: Optional[str] = None
+    prompt: Optional[str] = None
+    response_format: AudioTranscriptionResponseFormat = (
+        AudioTranscriptionResponseFormat.JSON
+    )
+    temperature: float = 0.0
+    timestamp_granularities: Optional[AudioTimestampGranularities] = (
+        AudioTimestampGranularities.SEGMENT
+    )
+
+
+class AudioTranslationRequest(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    file: Union[str, BinaryIO]
+    model: str = "openai/whisper-large-v3"
+    language: Optional[str] = None
+    prompt: Optional[str] = None
+    response_format: AudioTranscriptionResponseFormat = (
+        AudioTranscriptionResponseFormat.JSON
+    )
+    temperature: float = 0.0
+    timestamp_granularities: Optional[AudioTimestampGranularities] = (
+        AudioTimestampGranularities.SEGMENT
+    )
+
+
+class AudioTranscriptionSegment(BaseModel):
+    id: int
+    start: float
+    end: float
+    text: str
+
+
+class AudioTranscriptionWord(BaseModel):
+    word: str
+    start: float
+    end: float
+
+
+class AudioTranscriptionResponse(BaseModel):
+    text: str
+
+
+class AudioTranscriptionVerboseResponse(BaseModel):
+    language: Optional[str] = None
+    duration: Optional[float] = None
+    text: str
+    segments: Optional[List[AudioTranscriptionSegment]] = None
+    words: Optional[List[AudioTranscriptionWord]] = None
+
+
+class AudioTranslationResponse(BaseModel):
+    text: str
+
+
+class AudioTranslationVerboseResponse(BaseModel):
+    task: Optional[str] = None
+    language: Optional[str] = None
+    duration: Optional[float] = None
+    text: str
+    segments: Optional[List[AudioTranscriptionSegment]] = None
+    words: Optional[List[AudioTranscriptionWord]] = None

together/types/evaluation.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class EvaluationType(str, Enum):
+    CLASSIFY = "classify"
+    SCORE = "score"
+    COMPARE = "compare"
+
+
+class EvaluationStatus(str, Enum):
+    PENDING = "pending"
+    QUEUED = "queued"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    ERROR = "error"
+    USER_ERROR = "user_error"
+
+
+class JudgeModelConfig(BaseModel):
+    model_name: str
+    system_template: str
+
+
+class ModelRequest(BaseModel):
+    model_name: str
+    max_tokens: int
+    temperature: float
+    system_template: str
+    input_template: str
+
+
+class ClassifyParameters(BaseModel):
+    judge: JudgeModelConfig
+    labels: List[str]
+    pass_labels: List[str]
+    model_to_evaluate: Optional[Union[str, ModelRequest]] = None
+    input_data_file_path: str
+
+
+class ScoreParameters(BaseModel):
+    judge: JudgeModelConfig
+    min_score: float
+    max_score: float
+    pass_threshold: float
+    model_to_evaluate: Optional[Union[str, ModelRequest]] = None
+    input_data_file_path: str
+
+
+class CompareParameters(BaseModel):
+    judge: JudgeModelConfig
+    model_a: Optional[Union[str, ModelRequest]] = None
+    model_b: Optional[Union[str, ModelRequest]] = None
+    input_data_file_path: str
+
+
+class EvaluationRequest(BaseModel):
+    type: EvaluationType
+    parameters: Union[ClassifyParameters, ScoreParameters, CompareParameters]
+
+
+class EvaluationCreateResponse(BaseModel):
+    workflow_id: str
+    status: EvaluationStatus
+
+
+class EvaluationJob(BaseModel):
+    workflow_id: str = Field(alias="workflow_id")
+    type: Optional[EvaluationType] = None
+    status: EvaluationStatus
+    results: Optional[Dict[str, Any]] = None
+    parameters: Optional[Dict[str, Any]] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+    class Config:
+        populate_by_name = True
+
+
+class EvaluationStatusResponse(BaseModel):
+    status: EvaluationStatus
+    results: Optional[Dict[str, Any]] = None

together/types/files.py

@@ -14,11 +14,13 @@ from together.types.common import (
 class FilePurpose(str, Enum):
     FineTune = "fine-tune"
     BatchAPI = "batch-api"
+    Eval = "eval"
 
 
 class FileType(str, Enum):
     jsonl = "jsonl"
     parquet = "parquet"
+    csv = "csv"
 
 
 class FileRequest(BaseModel):

together/types/finetune.py

@@ -195,7 +195,7 @@ class FinetuneRequest(BaseModel):
     # number of evaluation loops to run
     n_evals: int | None = None
     # training batch size
-    batch_size: int | None = None
+    batch_size: int | Literal["max"] | None = None
     # up to 40 character suffix for output model name
     suffix: str | None = None
     # weights & biases api key