together 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

together/error.py

@@ -11,6 +11,7 @@ class TogetherException(Exception):
         http_status: Optional[int] = None,
         json_body: Optional[Any] = None,
         headers: Optional[Union[str, Dict[Any, Any]]] = None,
+        request_id: Optional[str] = "",
     ) -> None:
         super(TogetherException, self).__init__(message)
 
@@ -28,12 +29,14 @@ class TogetherException(Exception):
         self.http_status = http_status
         self.json_body = json_body
         self.headers = headers or {}
+        self.request_id = request_id
 
     def __repr__(self) -> str:
-        return "%s(message=%r, http_status=%r)" % (
+        return "%s(message=%r, http_status=%r, request_id=%r)" % (
             self.__class__.__name__,
             self._message,
             self.http_status,
+            self.request_id,
         )
 
 
@@ -59,7 +62,14 @@ class InstanceError(TogetherException):
         headers: Optional[str] = None,
         model: Optional[str] = "model",
     ) -> None:
-        message = f"No running instances for {model}. You can start an instance by navigating to the Together Playground at api.together.ai"
+        message = f"""No running instances for {model}.
+                You can start an instance with one of the following methods:
+                  1. navigating to the Together Playground at api.together.ai
+                  2. starting one in python using together.Models.start(model_name)
+                  3. `$ together models start <MODEL_NAME>` at the command line.
+                See `together.Models.list()` in python or `$ together models list` in command line
+                to get an updated list of valid model names.
+                """
         super(InstanceError, self).__init__(
             message, http_body, http_status, json_body, headers
         )

together/files.py

@@ -2,58 +2,41 @@ import json
 import os
 import posixpath
 import urllib.parse
-from typing import Any, Dict, List, Mapping, Optional, Union, cast
+from typing import Any, Dict, List, Mapping, Optional, Union
 
 import requests
 from tqdm import tqdm
 from tqdm.utils import CallbackIOWrapper
 
 import together
-from together.utils.utils import get_logger, verify_api_key
+from together.utils import (
+    create_get_request,
+    get_logger,
+    response_to_dict,
+)
 
 
-logger = get_logger(str(__name__), log_level=together.log_level)
-
 # the number of bytes in a gigabyte, used to convert bytes to GB for readable comparison
 NUM_BYTES_IN_GB = 2**30
 
 # maximum number of GB sized files we support finetuning for
 MAX_FT_GB = 4.9
 
+logger = get_logger(str(__name__))
 
-class Files:
-    def __init__(
-        self,
-    ) -> None:
-        verify_api_key(logger)
 
+class Files:
     @classmethod
     def list(self) -> Dict[str, List[Dict[str, Union[str, int]]]]:
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "User-Agent": together.user_agent,
-        }
-
         # send request
-        try:
-            response = requests.get(together.api_base_files, headers=headers)
-            response.raise_for_status()
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-
-        return response_json
+        response = create_get_request(together.api_base_files)
+        if not response:
+            return {}
+        return response_to_dict(response)
 
     @classmethod
-    def check(self, file: str, model: Optional[str] = None) -> Dict[str, object]:
-        return check_json(file, model)
+    def check(self, file: str) -> Dict[str, object]:
+        return check_json(file)
 
     @classmethod
     def upload(
@@ -70,10 +53,11 @@ class Files:
         }
 
         if check:
-            report_dict = check_json(file, model)
+            report_dict = check_json(file)
             if not report_dict["is_check_passed"]:
-                print(report_dict)
-                raise together.FileTypeError("Invalid file supplied. Failed to upload.")
+                raise together.FileTypeError(
+                    f"Invalid file supplied. Failed to upload.\nReport:\n {report_dict}"
+                )
         else:
             report_dict = {}
 
@@ -116,7 +100,7 @@ class Files:
             file_id = response.headers["X-Together-File-Id"]
 
             logger.info(f"R2 Signed URL: {r2_signed_url}")
-            logger.info("File-ID")
+            logger.info(f"File-ID: {file_id}")
 
             logger.info("Uploading file...")
 
@@ -177,44 +161,16 @@ class Files:
             logger.critical(f"Response error raised: {e}")
             raise together.ResponseError(e)
 
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-
-        return response_json
+        return response_to_dict(response)
 
     @classmethod
     def retrieve(self, file_id: str) -> Dict[str, Union[str, int]]:
         retrieve_url = urllib.parse.urljoin(together.api_base_files, file_id)
-
         logger.info(f"Retrieve URL: {retrieve_url}")
-
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "User-Agent": together.user_agent,
-        }
-
-        # send request
-        try:
-            response = requests.get(retrieve_url, headers=headers)
-            response.raise_for_status()
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-
-        return response_json
+        response = create_get_request(retrieve_url)
+        if not response:
+            return {}
+        return response_to_dict(response)
 
     @classmethod
     def retrieve_content(self, file_id: str, output: Union[str, None] = None) -> str:
@@ -288,23 +244,11 @@ class Files:
 
 def check_json(
     file: str,
-    model: Optional[str] = None,
 ) -> Dict[str, object]:
     report_dict = {
         "is_check_passed": True,
         "model_special_tokens": "we are not yet checking end of sentence tokens for this model",
     }
-    num_samples_w_eos_token = 0
-
-    model_info_dict = cast(Dict[str, Any], together.model_info_dict)
-
-    eos_token = None
-    if model is not None and model in model_info_dict:
-        if "eos_token" in model_info_dict[model]:
-            eos_token = model_info_dict[model]["eos_token"]
-            report_dict[
-                "model_special_tokens"
-            ] = f"the end of sentence token for this model is {eos_token}"
 
     if not os.path.isfile(file):
         report_dict["file_present"] = f"File not found at given file path {file}"
@@ -358,10 +302,6 @@ def check_json(
 
                         report_dict["is_check_passed"] = False
 
-                    elif eos_token:
-                        if eos_token in json_line["text"]:
-                            num_samples_w_eos_token += 1
-
             # make sure this is outside the for idx, line in enumerate(f): for loop
             if idx + 1 < together.min_samples:
                 report_dict["min_samples"] = (
@@ -383,6 +323,4 @@ def check_json(
             )
             report_dict["is_check_passed"] = False
 
-    report_dict["num_samples_w_eos_token"] = num_samples_w_eos_token
-
     return report_dict

together/finetune.py

@@ -1,4 +1,5 @@
 import posixpath
+import pprint
 import urllib.parse
 from typing import Any, Dict, List, Optional, Union
 
@@ -7,49 +8,22 @@ from tqdm import tqdm
 
 import together
 from together import Files
-from together.utils.utils import get_logger, verify_api_key
-
-
-logger = get_logger(str(__name__), log_level=together.log_level)
-
-
-# this will change soon to be data driven and give a clearer estimate
-def model_param_count(name: str) -> int:
-    pcount = {
-        "togethercomputer/RedPajama-INCITE-7B-Chat": 6857302016,
-        "togethercomputer/RedPajama-INCITE-7B-Base": 6857302016,
-        "togethercomputer/RedPajama-INCITE-7B-Instruct": 6857302016,
-        "togethercomputer/RedPajama-INCITE-Chat-3B-v1": 2775864320,
-        "togethercomputer/RedPajama-INCITE-Base-3B-v1": 2775864320,
-        "togethercomputer/RedPajama-INCITE-Instruct-3B-v1": 2775864320,
-        "togethercomputer/Pythia-Chat-Base-7B": 6857302016,
-        "togethercomputer/llama-2-7b": 6738415616,
-        "togethercomputer/llama-2-7b-chat": 6738415616,
-        "togethercomputer/llama-2-13b": 13015864320,
-        "togethercomputer/llama-2-13b-chat": 13015864320,
-        "togethercomputer/LLaMA-2-7B-32K": 6738415616,
-        "togethercomputer/Llama-2-7B-32K-Instruct": 6738415616,
-        "togethercomputer/CodeLlama-7b": 6738546688,
-        "togethercomputer/CodeLlama-7b-Python": 6738546688,
-        "togethercomputer/CodeLlama-7b-Instruct": 6738546688,
-        "togethercomputer/CodeLlama-13b": 13016028160,
-        "togethercomputer/CodeLlama-13b-Python": 13016028160,
-        "togethercomputer/CodeLlama-13b-Instruct": 13016028160,
-        "togethercomputer/llama-2-70b": 68976648192,
-        "togethercomputer/llama-2-70b-chat": 68976648192,
-    }
-    try:
-        return pcount[name]
-    except Exception:
-        return 0
+from together.utils import (
+    create_get_request,
+    create_post_request,
+    get_logger,
+    response_to_dict,
+    round_to_closest_multiple_of_32,
+)
 
 
-class Finetune:
-    def __init__(
-        self,
-    ) -> None:
-        verify_api_key(logger)
+pp = pprint.PrettyPrinter(indent=4)
+
+logger = get_logger(str(__name__))
 
+
+class Finetune:
+    # TODO @orangetin: cleanup create validation etc
     @classmethod
     def create(
         self,
@@ -71,47 +45,52 @@ class Finetune:
         ] = None,  # resulting finetuned model name will include the suffix
         estimate_price: bool = False,
         wandb_api_key: Optional[str] = None,
+        confirm_inputs: bool = True,
     ) -> Dict[Any, Any]:
+        adjusted_inputs = False
+
         if n_epochs is None or n_epochs < 1:
-            logger.fatal("The number of epochs must be specified")
-            raise ValueError("n_epochs is required")
+            n_epochs = 1
+            adjusted_inputs = True
 
         # Validate parameters
         if n_checkpoints is None:
             n_checkpoints = 1
         elif n_checkpoints < 1:
             n_checkpoints = 1
-            logger.warning(
-                f"The number of checkpoints must be >= 1, setting to {n_checkpoints}"
-            )
+            adjusted_inputs = True
         elif n_checkpoints > n_epochs:
             n_checkpoints = n_epochs
-            logger.warning(
-                f"The number of checkpoints must be < the number of epochs, setting to {n_checkpoints}"
-            )
-
-        if (
-            model
-            in ["togethercomputer/llama-2-70b", "togethercomputer/llama-2-70b-chat"]
-            and batch_size != 144
-        ):
-            raise ValueError(
-                f"Batch size must be 144 for {model} model. Please set batch size to 144"
-            )
+            adjusted_inputs = True
 
+        # TODO: Replace with mongodb retrieval for max, min, and default batch size
         if batch_size is None:
             batch_size = 32
         elif batch_size < 4:
-            raise ValueError("Batch size must be >= 4.")
+            batch_size = 4
+            adjusted_inputs = True
+
+        max_batch_size = 128
+        if model.startswith("togethercomputer/llama-2-70b"):
+            max_batch_size = 64
+            batch_size = round_to_closest_multiple_of_32(batch_size)
+            adjusted_inputs = True
+        elif model.startswith("togethercomputer/CodeLlama-7b"):
+            max_batch_size = 16
+        elif model.startswith("togethercomputer/CodeLlama-13b"):
+            max_batch_size = 8
+
+        if batch_size > max_batch_size:
+            batch_size = max_batch_size
+            adjusted_inputs = True
 
         # TODO: REMOVE THIS CHECK WHEN WE HAVE CHECKPOINTING WORKING FOR 70B models
         if n_checkpoints > 1 and model in [
             "togethercomputer/llama-2-70b",
             "togethercomputer/llama-2-70b-chat",
         ]:
-            raise ValueError(
-                "Saving checkpoints during training currently not supported for {model}.  Please set the number of checkpoints to 1"
-            )
+            n_checkpoints = 1
+            adjusted_inputs = True
 
         parameter_payload = {
             "training_file": training_file,
@@ -131,8 +110,8 @@ class Finetune:
         }
 
         # check if model name is one of the models available for finetuning
-        if parameter_payload["model"] not in together.finetune_model_names:
-            logger.warning(
+        if not together.Models._is_finetune_model(model):
+            raise ValueError(
                 "The finetune model name must be one of the subset of models available for finetuning. "
                 "Here is a list of those models https://docs.together.ai/docs/models-fine-tuning"
             )
@@ -151,7 +130,7 @@ class Finetune:
             raise together.FileTypeError(training_file_feedback)
 
         if estimate_price:
-            param_size = model_param_count(model)
+            param_size = together.Models._param_count(model)
             if param_size == 0:
                 error = f"Unknown model {model}.  Cannot estimate price.  Please check the name of the model"
                 raise together.FileTypeError(error)
@@ -169,7 +148,7 @@ class Finetune:
                             {
                                 "tokens": token_estimate,
                                 "epochs": n_epochs,
-                                "parameters": model_param_count(model),
+                                "parameters": together.Models._param_count(model),
                             },
                         ],
                         "id": 1,
@@ -181,141 +160,59 @@ class Finetune:
                     print(training_file_feedback)
                     exit()
 
-        # Send POST request to SUBMIT FINETUNE JOB
-        # HTTP headers for authorization
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "Content-Type": "application/json",
-            "User-Agent": together.user_agent,
-        }
-        try:
-            response = requests.post(
-                together.api_base_finetune, headers=headers, json=parameter_payload
-            )
-            response.raise_for_status()
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
+        if confirm_inputs:
+            if adjusted_inputs:
+                print(
+                    "Note: Some hyperparameters have been adjusted with their minimum/maximum values for a given model."
+                )
+            print("Job creation details:")
+            pp.pprint(parameter_payload)
+            confirm_response = input("\nDo you want to submit the job? [y/N]")
+            if "y" not in confirm_response.lower():
+                return {"status": "job not submitted"}
 
-        return response_json
+        # Send POST request to SUBMIT FINETUNE JOB
+        response = create_post_request(
+            together.api_base_finetune, json=parameter_payload
+        )
+        if not response:
+            return {}
+        return response_to_dict(response)
 
     @classmethod
     def list(self) -> Dict[Any, Any]:
-        verify_api_key(logger)
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "User-Agent": together.user_agent,
-        }
-
         # send request
-        try:
-            response = requests.get(together.api_base_finetune, headers=headers)
-            response.raise_for_status()
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-
-        return response_json
+        response = create_get_request(together.api_base_finetune)
+        if not response:
+            return {}
+        return response_to_dict(response)
 
     @classmethod
     def retrieve(self, fine_tune_id: str) -> Dict[Any, Any]:
         retrieve_url = urllib.parse.urljoin(together.api_base_finetune, fine_tune_id)
-
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "User-Agent": together.user_agent,
-        }
-
-        # send request
-        try:
-            response = requests.get(retrieve_url, headers=headers)
-            response.raise_for_status()
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-
-        return response_json
+        response = create_get_request(retrieve_url)
+        if not response:
+            return {}
+        return response_to_dict(response)
 
     @classmethod
     def cancel(self, fine_tune_id: str) -> Dict[Any, Any]:
         relative_path = posixpath.join(fine_tune_id, "cancel")
         retrieve_url = urllib.parse.urljoin(together.api_base_finetune, relative_path)
-
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "User-Agent": together.user_agent,
-        }
-
-        # send request
-        try:
-            response = requests.post(retrieve_url, headers=headers)
-            response.raise_for_status()
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-
-        return response_json
+        response = create_post_request(retrieve_url)
+        if not response:
+            return {}
+        return response_to_dict(response)
 
     @classmethod
     def list_events(self, fine_tune_id: str) -> Dict[Any, Any]:
         # TODO enable stream
         relative_path = posixpath.join(fine_tune_id, "events")
         retrieve_url = urllib.parse.urljoin(together.api_base_finetune, relative_path)
-
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "User-Agent": together.user_agent,
-        }
-
-        # send request
-        try:
-            response = requests.get(retrieve_url, headers=headers)
-            response.raise_for_status()
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-
-        return response_json
+        response = create_get_request(retrieve_url)
+        if not response:
+            return {}
+        return response_to_dict(response)
 
     @classmethod
     def get_checkpoints(self, fine_tune_id: str) -> List[Dict[str, Any]]:
@@ -370,7 +267,7 @@ class Finetune:
         if step != -1:
             model_file_path += f"&checkpoint_step={step}"
 
-        logger.info(f"Downloading weights from {model_file_path}...")
+        print(f"Downloading weights from {model_file_path}...")
 
         headers = {
             "Authorization": f"Bearer {together.api_key}",

together/image.py

@@ -1,20 +1,13 @@
 from typing import Any, Dict, Optional
 
-import requests
-
 import together
-from together.utils.utils import get_logger, verify_api_key
+from together.utils import create_post_request, get_logger, response_to_dict
 
 
-logger = get_logger(str(__name__), log_level=together.log_level)
+logger = get_logger(str(__name__))
 
 
 class Image:
-    def __init__(
-        self,
-    ) -> None:
-        verify_api_key(logger)
-
     @classmethod
     def create(
         self,
@@ -42,37 +35,10 @@ class Image:
             "negative_prompt": negative_prompt,
         }
 
-        # HTTP headers for authorization
-        headers = {
-            "Authorization": f"Bearer {together.api_key}",
-            "Content-Type": "application/json",
-            "User-Agent": together.user_agent,
-        }
-
         # send request
-        try:
-            response = requests.post(
-                together.api_base_complete,
-                headers=headers,
-                json=parameter_payload,
-            )
-        except requests.exceptions.RequestException as e:
-            logger.critical(f"Response error raised: {e}")
-            raise together.ResponseError(e)
-
-        if response.status_code == 429:
-            logger.critical(
-                f"No running instances for {model}. You can start an instance by navigating to the Together Playground at api.together.ai"
-            )
-            raise together.InstanceError(model=model)
-
-        response.raise_for_status()
-
-        try:
-            response_json = dict(response.json())
-        except Exception as e:
-            logger.critical(
-                f"JSON Error raised: {e}\nResponse status code = {response.status_code}"
-            )
-            raise together.JSONError(e, http_status=response.status_code)
-        return response_json
+        response = create_post_request(
+            together.api_base_complete, json=parameter_payload
+        )
+        if not response:
+            return {}
+        return response_to_dict(response)