ultralytics 8.0.237__py3-none-any.whl → 8.0.239__py3-none-any.whl

ultralytics/engine/tuner.py

@@ -73,40 +73,43 @@ class Tuner:
         Args:
             args (dict, optional): Configuration for hyperparameter evolution.
         """
-        self.space = args.pop('space', None) or {  # key: (min, max, gain(optional))
+        self.space = args.pop("space", None) or {  # key: (min, max, gain(optional))
             # 'optimizer': tune.choice(['SGD', 'Adam', 'AdamW', 'NAdam', 'RAdam', 'RMSProp']),
-            'lr0': (1e-5, 1e-1),  # initial learning rate (i.e. SGD=1E-2, Adam=1E-3)
-            'lrf': (0.0001, 0.1),  # final OneCycleLR learning rate (lr0 * lrf)
-            'momentum': (0.7, 0.98, 0.3),  # SGD momentum/Adam beta1
-            'weight_decay': (0.0, 0.001),  # optimizer weight decay 5e-4
-            'warmup_epochs': (0.0, 5.0),  # warmup epochs (fractions ok)
-            'warmup_momentum': (0.0, 0.95),  # warmup initial momentum
-            'box': (1.0, 20.0),  # box loss gain
-            'cls': (0.2, 4.0),  # cls loss gain (scale with pixels)
-            'dfl': (0.4, 6.0),  # dfl loss gain
-            'hsv_h': (0.0, 0.1),  # image HSV-Hue augmentation (fraction)
-            'hsv_s': (0.0, 0.9),  # image HSV-Saturation augmentation (fraction)
-            'hsv_v': (0.0, 0.9),  # image HSV-Value augmentation (fraction)
-            'degrees': (0.0, 45.0),  # image rotation (+/- deg)
-            'translate': (0.0, 0.9),  # image translation (+/- fraction)
-            'scale': (0.0, 0.95),  # image scale (+/- gain)
-            'shear': (0.0, 10.0),  # image shear (+/- deg)
-            'perspective': (0.0, 0.001),  # image perspective (+/- fraction), range 0-0.001
-            'flipud': (0.0, 1.0),  # image flip up-down (probability)
-            'fliplr': (0.0, 1.0),  # image flip left-right (probability)
-            'mosaic': (0.0, 1.0),  # image mixup (probability)
-            'mixup': (0.0, 1.0),  # image mixup (probability)
-            'copy_paste': (0.0, 1.0)}  # segment copy-paste (probability)
+            "lr0": (1e-5, 1e-1),  # initial learning rate (i.e. SGD=1E-2, Adam=1E-3)
+            "lrf": (0.0001, 0.1),  # final OneCycleLR learning rate (lr0 * lrf)
+            "momentum": (0.7, 0.98, 0.3),  # SGD momentum/Adam beta1
+            "weight_decay": (0.0, 0.001),  # optimizer weight decay 5e-4
+            "warmup_epochs": (0.0, 5.0),  # warmup epochs (fractions ok)
+            "warmup_momentum": (0.0, 0.95),  # warmup initial momentum
+            "box": (1.0, 20.0),  # box loss gain
+            "cls": (0.2, 4.0),  # cls loss gain (scale with pixels)
+            "dfl": (0.4, 6.0),  # dfl loss gain
+            "hsv_h": (0.0, 0.1),  # image HSV-Hue augmentation (fraction)
+            "hsv_s": (0.0, 0.9),  # image HSV-Saturation augmentation (fraction)
+            "hsv_v": (0.0, 0.9),  # image HSV-Value augmentation (fraction)
+            "degrees": (0.0, 45.0),  # image rotation (+/- deg)
+            "translate": (0.0, 0.9),  # image translation (+/- fraction)
+            "scale": (0.0, 0.95),  # image scale (+/- gain)
+            "shear": (0.0, 10.0),  # image shear (+/- deg)
+            "perspective": (0.0, 0.001),  # image perspective (+/- fraction), range 0-0.001
+            "flipud": (0.0, 1.0),  # image flip up-down (probability)
+            "fliplr": (0.0, 1.0),  # image flip left-right (probability)
+            "mosaic": (0.0, 1.0),  # image mixup (probability)
+            "mixup": (0.0, 1.0),  # image mixup (probability)
+            "copy_paste": (0.0, 1.0),  # segment copy-paste (probability)
+        }
         self.args = get_cfg(overrides=args)
-        self.tune_dir = get_save_dir(self.args, name='tune')
-        self.tune_csv = self.tune_dir / 'tune_results.csv'
+        self.tune_dir = get_save_dir(self.args, name="tune")
+        self.tune_csv = self.tune_dir / "tune_results.csv"
         self.callbacks = _callbacks or callbacks.get_default_callbacks()
-        self.prefix = colorstr('Tuner: ')
+        self.prefix = colorstr("Tuner: ")
         callbacks.add_integration_callbacks(self)
-        LOGGER.info(f"{self.prefix}Initialized Tuner instance with 'tune_dir={self.tune_dir}'\n"
-                    f'{self.prefix}💡 Learn about tuning at https://docs.ultralytics.com/guides/hyperparameter-tuning')
+        LOGGER.info(
+            f"{self.prefix}Initialized Tuner instance with 'tune_dir={self.tune_dir}'\n"
+            f"{self.prefix}💡 Learn about tuning at https://docs.ultralytics.com/guides/hyperparameter-tuning"
+        )
 
-    def _mutate(self, parent='single', n=5, mutation=0.8, sigma=0.2):
+    def _mutate(self, parent="single", n=5, mutation=0.8, sigma=0.2):
         """
         Mutates the hyperparameters based on bounds and scaling factors specified in `self.space`.
 
@@ -121,15 +124,15 @@ class Tuner:
         """
         if self.tune_csv.exists():  # if CSV file exists: select best hyps and mutate
             # Select parent(s)
-            x = np.loadtxt(self.tune_csv, ndmin=2, delimiter=',', skiprows=1)
+            x = np.loadtxt(self.tune_csv, ndmin=2, delimiter=",", skiprows=1)
             fitness = x[:, 0]  # first column
             n = min(n, len(x))  # number of previous results to consider
             x = x[np.argsort(-fitness)][:n]  # top n mutations
-            w = x[:, 0] - x[:, 0].min() + 1E-6  # weights (sum > 0)
-            if parent == 'single' or len(x) == 1:
+            w = x[:, 0] - x[:, 0].min() + 1e-6  # weights (sum > 0)
+            if parent == "single" or len(x) == 1:
                 # x = x[random.randint(0, n - 1)]  # random selection
                 x = x[random.choices(range(n), weights=w)[0]]  # weighted selection
-            elif parent == 'weighted':
+            elif parent == "weighted":
                 x = (x * w.reshape(n, 1)).sum(0) / w.sum()  # weighted combination
 
             # Mutate
@@ -174,44 +177,44 @@ class Tuner:
 
         t0 = time.time()
         best_save_dir, best_metrics = None, None
-        (self.tune_dir / 'weights').mkdir(parents=True, exist_ok=True)
+        (self.tune_dir / "weights").mkdir(parents=True, exist_ok=True)
         for i in range(iterations):
             # Mutate hyperparameters
             mutated_hyp = self._mutate()
-            LOGGER.info(f'{self.prefix}Starting iteration {i + 1}/{iterations} with hyperparameters: {mutated_hyp}')
+            LOGGER.info(f"{self.prefix}Starting iteration {i + 1}/{iterations} with hyperparameters: {mutated_hyp}")
 
             metrics = {}
             train_args = {**vars(self.args), **mutated_hyp}
             save_dir = get_save_dir(get_cfg(train_args))
-            weights_dir = save_dir / 'weights'
-            ckpt_file = weights_dir / ('best.pt' if (weights_dir / 'best.pt').exists() else 'last.pt')
+            weights_dir = save_dir / "weights"
+            ckpt_file = weights_dir / ("best.pt" if (weights_dir / "best.pt").exists() else "last.pt")
             try:
                 # Train YOLO model with mutated hyperparameters (run in subprocess to avoid dataloader hang)
-                cmd = ['yolo', 'train', *(f'{k}={v}' for k, v in train_args.items())]
+                cmd = ["yolo", "train", *(f"{k}={v}" for k, v in train_args.items())]
                 return_code = subprocess.run(cmd, check=True).returncode
-                metrics = torch.load(ckpt_file)['train_metrics']
-                assert return_code == 0, 'training failed'
+                metrics = torch.load(ckpt_file)["train_metrics"]
+                assert return_code == 0, "training failed"
 
             except Exception as e:
-                LOGGER.warning(f'WARNING ❌️ training failure for hyperparameter tuning iteration {i + 1}\n{e}')
+                LOGGER.warning(f"WARNING ❌️ training failure for hyperparameter tuning iteration {i + 1}\n{e}")
 
             # Save results and mutated_hyp to CSV
-            fitness = metrics.get('fitness', 0.0)
+            fitness = metrics.get("fitness", 0.0)
             log_row = [round(fitness, 5)] + [mutated_hyp[k] for k in self.space.keys()]
-            headers = '' if self.tune_csv.exists() else (','.join(['fitness'] + list(self.space.keys())) + '\n')
-            with open(self.tune_csv, 'a') as f:
-                f.write(headers + ','.join(map(str, log_row)) + '\n')
+            headers = "" if self.tune_csv.exists() else (",".join(["fitness"] + list(self.space.keys())) + "\n")
+            with open(self.tune_csv, "a") as f:
+                f.write(headers + ",".join(map(str, log_row)) + "\n")
 
             # Get best results
-            x = np.loadtxt(self.tune_csv, ndmin=2, delimiter=',', skiprows=1)
+            x = np.loadtxt(self.tune_csv, ndmin=2, delimiter=",", skiprows=1)
             fitness = x[:, 0]  # first column
             best_idx = fitness.argmax()
             best_is_current = best_idx == i
             if best_is_current:
                 best_save_dir = save_dir
                 best_metrics = {k: round(v, 5) for k, v in metrics.items()}
-                for ckpt in weights_dir.glob('*.pt'):
-                    shutil.copy2(ckpt, self.tune_dir / 'weights')
+                for ckpt in weights_dir.glob("*.pt"):
+                    shutil.copy2(ckpt, self.tune_dir / "weights")
             elif cleanup:
                 shutil.rmtree(ckpt_file.parent)  # remove iteration weights/ dir to reduce storage space
 
@@ -219,15 +222,19 @@ class Tuner:
             plot_tune_results(self.tune_csv)
 
             # Save and print tune results
-            header = (f'{self.prefix}{i + 1}/{iterations} iterations complete ✅ ({time.time() - t0:.2f}s)\n'
-                      f'{self.prefix}Results saved to {colorstr("bold", self.tune_dir)}\n'
-                      f'{self.prefix}Best fitness={fitness[best_idx]} observed at iteration {best_idx + 1}\n'
-                      f'{self.prefix}Best fitness metrics are {best_metrics}\n'
-                      f'{self.prefix}Best fitness model is {best_save_dir}\n'
-                      f'{self.prefix}Best fitness hyperparameters are printed below.\n')
-            LOGGER.info('\n' + header)
+            header = (
+                f'{self.prefix}{i + 1}/{iterations} iterations complete ✅ ({time.time() - t0:.2f}s)\n'
+                f'{self.prefix}Results saved to {colorstr("bold", self.tune_dir)}\n'
+                f'{self.prefix}Best fitness={fitness[best_idx]} observed at iteration {best_idx + 1}\n'
+                f'{self.prefix}Best fitness metrics are {best_metrics}\n'
+                f'{self.prefix}Best fitness model is {best_save_dir}\n'
+                f'{self.prefix}Best fitness hyperparameters are printed below.\n'
+            )
+            LOGGER.info("\n" + header)
             data = {k: float(x[best_idx, i + 1]) for i, k in enumerate(self.space.keys())}
-            yaml_save(self.tune_dir / 'best_hyperparameters.yaml',
-                      data=data,
-                      header=remove_colorstr(header.replace(self.prefix, '# ')) + '\n')
-            yaml_print(self.tune_dir / 'best_hyperparameters.yaml')
+            yaml_save(
+                self.tune_dir / "best_hyperparameters.yaml",
+                data=data,
+                header=remove_colorstr(header.replace(self.prefix, "# ")) + "\n",
+            )
+            yaml_print(self.tune_dir / "best_hyperparameters.yaml")

ultralytics/engine/validator.py

@@ -89,10 +89,10 @@ class BaseValidator:
         self.nc = None
         self.iouv = None
         self.jdict = None
-        self.speed = {'preprocess': 0.0, 'inference': 0.0, 'loss': 0.0, 'postprocess': 0.0}
+        self.speed = {"preprocess": 0.0, "inference": 0.0, "loss": 0.0, "postprocess": 0.0}
 
         self.save_dir = save_dir or get_save_dir(self.args)
-        (self.save_dir / 'labels' if self.args.save_txt else self.save_dir).mkdir(parents=True, exist_ok=True)
+        (self.save_dir / "labels" if self.args.save_txt else self.save_dir).mkdir(parents=True, exist_ok=True)
         if self.args.conf is None:
             self.args.conf = 0.001  # default conf=0.001
         self.args.imgsz = check_imgsz(self.args.imgsz, max_dim=1)
@@ -110,7 +110,7 @@ class BaseValidator:
         if self.training:
             self.device = trainer.device
             self.data = trainer.data
-            self.args.half = self.device.type != 'cpu'  # force FP16 val during training
+            self.args.half = self.device.type != "cpu"  # force FP16 val during training
             model = trainer.ema.ema or trainer.model
             model = model.half() if self.args.half else model.float()
             # self.model = model
@@ -119,11 +119,13 @@ class BaseValidator:
             model.eval()
         else:
             callbacks.add_integration_callbacks(self)
-            model = AutoBackend(model or self.args.model,
-                                device=select_device(self.args.device, self.args.batch),
-                                dnn=self.args.dnn,
-                                data=self.args.data,
-                                fp16=self.args.half)
+            model = AutoBackend(
+                model or self.args.model,
+                device=select_device(self.args.device, self.args.batch),
+                dnn=self.args.dnn,
+                data=self.args.data,
+                fp16=self.args.half,
+            )
             # self.model = model
             self.device = model.device  # update device
             self.args.half = model.fp16  # update half
@@ -133,16 +135,16 @@ class BaseValidator:
                 self.args.batch = model.batch_size
             elif not pt and not jit:
                 self.args.batch = 1  # export.py models default to batch-size 1
-                LOGGER.info(f'Forcing batch=1 square inference (1,3,{imgsz},{imgsz}) for non-PyTorch models')
+                LOGGER.info(f"Forcing batch=1 square inference (1,3,{imgsz},{imgsz}) for non-PyTorch models")
 
-            if str(self.args.data).split('.')[-1] in ('yaml', 'yml'):
+            if str(self.args.data).split(".")[-1] in ("yaml", "yml"):
                 self.data = check_det_dataset(self.args.data)
-            elif self.args.task == 'classify':
+            elif self.args.task == "classify":
                 self.data = check_cls_dataset(self.args.data, split=self.args.split)
             else:
                 raise FileNotFoundError(emojis(f"Dataset '{self.args.data}' for task={self.args.task} not found ❌"))
 
-            if self.device.type in ('cpu', 'mps'):
+            if self.device.type in ("cpu", "mps"):
                 self.args.workers = 0  # faster CPU val as time dominated by inference, not dataloading
             if not pt:
                 self.args.rect = False
@@ -152,13 +154,13 @@ class BaseValidator:
             model.eval()
             model.warmup(imgsz=(1 if pt else self.args.batch, 3, imgsz, imgsz))  # warmup
 
-        self.run_callbacks('on_val_start')
+        self.run_callbacks("on_val_start")
         dt = Profile(), Profile(), Profile(), Profile()
         bar = TQDM(self.dataloader, desc=self.get_desc(), total=len(self.dataloader))
         self.init_metrics(de_parallel(model))
         self.jdict = []  # empty before each val
         for batch_i, batch in enumerate(bar):
-            self.run_callbacks('on_val_batch_start')
+            self.run_callbacks("on_val_batch_start")
             self.batch_i = batch_i
             # Preprocess
             with dt[0]:
@@ -166,7 +168,7 @@ class BaseValidator:
 
             # Inference
             with dt[1]:
-                preds = model(batch['img'], augment=augment)
+                preds = model(batch["img"], augment=augment)
 
             # Loss
             with dt[2]:
@@ -182,23 +184,25 @@ class BaseValidator:
                 self.plot_val_samples(batch, batch_i)
                 self.plot_predictions(batch, preds, batch_i)
 
-            self.run_callbacks('on_val_batch_end')
+            self.run_callbacks("on_val_batch_end")
         stats = self.get_stats()
         self.check_stats(stats)
-        self.speed = dict(zip(self.speed.keys(), (x.t / len(self.dataloader.dataset) * 1E3 for x in dt)))
+        self.speed = dict(zip(self.speed.keys(), (x.t / len(self.dataloader.dataset) * 1e3 for x in dt)))
         self.finalize_metrics()
         self.print_results()
-        self.run_callbacks('on_val_end')
+        self.run_callbacks("on_val_end")
         if self.training:
             model.float()
-            results = {**stats, **trainer.label_loss_items(self.loss.cpu() / len(self.dataloader), prefix='val')}
+            results = {**stats, **trainer.label_loss_items(self.loss.cpu() / len(self.dataloader), prefix="val")}
             return {k: round(float(v), 5) for k, v in results.items()}  # return results as 5 decimal place floats
         else:
-            LOGGER.info('Speed: %.1fms preprocess, %.1fms inference, %.1fms loss, %.1fms postprocess per image' %
-                        tuple(self.speed.values()))
+            LOGGER.info(
+                "Speed: %.1fms preprocess, %.1fms inference, %.1fms loss, %.1fms postprocess per image"
+                % tuple(self.speed.values())
+            )
             if self.args.save_json and self.jdict:
-                with open(str(self.save_dir / 'predictions.json'), 'w') as f:
-                    LOGGER.info(f'Saving {f.name}...')
+                with open(str(self.save_dir / "predictions.json"), "w") as f:
+                    LOGGER.info(f"Saving {f.name}...")
                     json.dump(self.jdict, f)  # flatten and save
                 stats = self.eval_json(stats)  # update stats
             if self.args.plots or self.args.save_json:
@@ -228,6 +232,7 @@ class BaseValidator:
             if use_scipy:
                 # WARNING: known issue that reduces mAP in https://github.com/ultralytics/ultralytics/pull/4708
                 import scipy  # scope import to avoid importing for all commands
+
                 cost_matrix = iou * (iou >= threshold)
                 if cost_matrix.any():
                     labels_idx, detections_idx = scipy.optimize.linear_sum_assignment(cost_matrix, maximize=True)
@@ -257,11 +262,11 @@ class BaseValidator:
 
     def get_dataloader(self, dataset_path, batch_size):
         """Get data loader from dataset path and batch size."""
-        raise NotImplementedError('get_dataloader function not implemented for this validator')
+        raise NotImplementedError("get_dataloader function not implemented for this validator")
 
     def build_dataset(self, img_path):
         """Build dataset."""
-        raise NotImplementedError('build_dataset function not implemented in validator')
+        raise NotImplementedError("build_dataset function not implemented in validator")
 
     def preprocess(self, batch):
         """Preprocesses an input batch."""
@@ -306,7 +311,7 @@ class BaseValidator:
 
     def on_plot(self, name, data=None):
         """Registers plots (e.g. to be consumed in callbacks)"""
-        self.plots[Path(name)] = {'data': data, 'timestamp': time.time()}
+        self.plots[Path(name)] = {"data": data, "timestamp": time.time()}
 
     # TODO: may need to put these following functions into callback
     def plot_val_samples(self, batch, ni):

ultralytics/hub/__init__.py

@@ -1,28 +1,50 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 import requests
+from hub_sdk import HUB_API_ROOT, HUB_WEB_ROOT, HUBClient
 
 from ultralytics.data.utils import HUBDatasetStats
 from ultralytics.hub.auth import Auth
-from ultralytics.hub.utils import HUB_API_ROOT, HUB_WEB_ROOT, PREFIX
+from ultralytics.hub.utils import PREFIX
 from ultralytics.utils import LOGGER, SETTINGS
 
 
-def login(api_key=''):
+def login(api_key: str = None, save=True) -> bool:
     """
     Log in to the Ultralytics HUB API using the provided API key.
 
+    The session is not stored; a new session is created when needed using the saved SETTINGS or the HUB_API_KEY environment variable if successfully authenticated.
+
     Args:
-        api_key (str, optional): May be an API key or a combination API key and model ID, i.e. key_id
+        api_key (str, optional): The API key to use for authentication. If not provided, it will be retrieved from SETTINGS or HUB_API_KEY environment variable.
+        save (bool, optional): Whether to save the API key to SETTINGS if authentication is successful.
+    Returns:
+        bool: True if authentication is successful, False otherwise.
+    """
+    api_key_url = f"{HUB_WEB_ROOT}/settings?tab=api+keys"  # set the redirect URL
+    saved_key = SETTINGS.get("api_key")
+    active_key = api_key or saved_key
+    credentials = {"api_key": active_key} if active_key and active_key != "" else None  # set credentials
 
-    Example:
-        ```python
-        from ultralytics import hub
+    client = HUBClient(credentials)  # initialize HUBClient
 
-        hub.login('API_KEY')
-        ```
-    """
-    Auth(api_key, verbose=True)
+    if client.authenticated:
+        # Successfully authenticated with HUB
+
+        if save and client.api_key != saved_key:
+            SETTINGS.update({"api_key": client.api_key})  # update settings with valid API key
+
+        # Set message based on whether key was provided or retrieved from settings
+        log_message = (
+            "New authentication successful ✅" if client.api_key == api_key or not credentials else "Authenticated ✅"
+        )
+        LOGGER.info(f"{PREFIX}{log_message}")
+
+        return True
+    else:
+        # Failed to authenticate with HUB
+        LOGGER.info(f"{PREFIX}Retrieve API key from {api_key_url}")
+        return False
 
 
 def logout():
@@ -36,49 +58,50 @@ def logout():
         hub.logout()
         ```
     """
-    SETTINGS['api_key'] = ''
+    SETTINGS["api_key"] = ""
     SETTINGS.save()
     LOGGER.info(f"{PREFIX}logged out ✅. To log in again, use 'yolo hub login'.")
 
 
-def reset_model(model_id=''):
+def reset_model(model_id=""):
     """Reset a trained model to an untrained state."""
-    r = requests.post(f'{HUB_API_ROOT}/model-reset', json={'apiKey': Auth().api_key, 'modelId': model_id})
+    r = requests.post(f"{HUB_API_ROOT}/model-reset", json={"modelId": model_id}, headers={"x-api-key": Auth().api_key})
     if r.status_code == 200:
-        LOGGER.info(f'{PREFIX}Model reset successfully')
+        LOGGER.info(f"{PREFIX}Model reset successfully")
         return
-    LOGGER.warning(f'{PREFIX}Model reset failure {r.status_code} {r.reason}')
+    LOGGER.warning(f"{PREFIX}Model reset failure {r.status_code} {r.reason}")
 
 
 def export_fmts_hub():
     """Returns a list of HUB-supported export formats."""
     from ultralytics.engine.exporter import export_formats
-    return list(export_formats()['Argument'][1:]) + ['ultralytics_tflite', 'ultralytics_coreml']
+
+    return list(export_formats()["Argument"][1:]) + ["ultralytics_tflite", "ultralytics_coreml"]
 
 
-def export_model(model_id='', format='torchscript'):
+def export_model(model_id="", format="torchscript"):
     """Export a model to all formats."""
     assert format in export_fmts_hub(), f"Unsupported export format '{format}', valid formats are {export_fmts_hub()}"
-    r = requests.post(f'{HUB_API_ROOT}/v1/models/{model_id}/export',
-                      json={'format': format},
-                      headers={'x-api-key': Auth().api_key})
-    assert r.status_code == 200, f'{PREFIX}{format} export failure {r.status_code} {r.reason}'
-    LOGGER.info(f'{PREFIX}{format} export started ✅')
+    r = requests.post(
+        f"{HUB_API_ROOT}/v1/models/{model_id}/export", json={"format": format}, headers={"x-api-key": Auth().api_key}
+    )
+    assert r.status_code == 200, f"{PREFIX}{format} export failure {r.status_code} {r.reason}"
+    LOGGER.info(f"{PREFIX}{format} export started ✅")
 
 
-def get_export(model_id='', format='torchscript'):
+def get_export(model_id="", format="torchscript"):
     """Get an exported model dictionary with download URL."""
     assert format in export_fmts_hub(), f"Unsupported export format '{format}', valid formats are {export_fmts_hub()}"
-    r = requests.post(f'{HUB_API_ROOT}/get-export',
-                      json={
-                          'apiKey': Auth().api_key,
-                          'modelId': model_id,
-                          'format': format})
-    assert r.status_code == 200, f'{PREFIX}{format} get_export failure {r.status_code} {r.reason}'
+    r = requests.post(
+        f"{HUB_API_ROOT}/get-export",
+        json={"apiKey": Auth().api_key, "modelId": model_id, "format": format},
+        headers={"x-api-key": Auth().api_key},
+    )
+    assert r.status_code == 200, f"{PREFIX}{format} get_export failure {r.status_code} {r.reason}"
     return r.json()
 
 
-def check_dataset(path='', task='detect'):
+def check_dataset(path="", task="detect"):
     """
     Function for error-checking HUB dataset Zip file before upload. It checks a dataset for errors before it is uploaded
     to the HUB. Usage examples are given below.
@@ -97,4 +120,4 @@ def check_dataset(path='', task='detect'):
         ```
     """
     HUBDatasetStats(path=path, task=task).get_json()
-    LOGGER.info(f'Checks completed correctly ✅. Upload this dataset to {HUB_WEB_ROOT}/datasets/.')
+    LOGGER.info(f"Checks completed correctly ✅. Upload this dataset to {HUB_WEB_ROOT}/datasets/.")

ultralytics/hub/auth.py

@@ -1,11 +1,12 @@
 # Ultralytics YOLO 🚀, AGPL-3.0 license
 
 import requests
+from hub_sdk import HUB_API_ROOT, HUB_WEB_ROOT
 
-from ultralytics.hub.utils import HUB_API_ROOT, HUB_WEB_ROOT, PREFIX, request_with_credentials
+from ultralytics.hub.utils import PREFIX, request_with_credentials
 from ultralytics.utils import LOGGER, SETTINGS, emojis, is_colab
 
-API_KEY_URL = f'{HUB_WEB_ROOT}/settings?tab=api+keys'
+API_KEY_URL = f"{HUB_WEB_ROOT}/settings?tab=api+keys"
 
 
 class Auth:
@@ -22,9 +23,10 @@ class Auth:
         api_key (str or bool): API key for authentication, initialized as False.
         model_key (bool): Placeholder for model key, initialized as False.
     """
+
     id_token = api_key = model_key = False
 
-    def __init__(self, api_key='', verbose=False):
+    def __init__(self, api_key="", verbose=False):
         """
         Initialize the Auth class with an optional API key.
 
@@ -32,18 +34,18 @@ class Auth:
             api_key (str, optional): May be an API key or a combination API key and model ID, i.e. key_id
         """
         # Split the input API key in case it contains a combined key_model and keep only the API key part
-        api_key = api_key.split('_')[0]
+        api_key = api_key.split("_")[0]
 
         # Set API key attribute as value passed or SETTINGS API key if none passed
-        self.api_key = api_key or SETTINGS.get('api_key', '')
+        self.api_key = api_key or SETTINGS.get("api_key", "")
 
         # If an API key is provided
         if self.api_key:
             # If the provided API key matches the API key in the SETTINGS
-            if self.api_key == SETTINGS.get('api_key'):
+            if self.api_key == SETTINGS.get("api_key"):
                 # Log that the user is already logged in
                 if verbose:
-                    LOGGER.info(f'{PREFIX}Authenticated ✅')
+                    LOGGER.info(f"{PREFIX}Authenticated ✅")
                 return
             else:
                 # Attempt to authenticate with the provided API key
@@ -58,12 +60,12 @@ class Auth:
 
         # Update SETTINGS with the new API key after successful authentication
         if success:
-            SETTINGS.update({'api_key': self.api_key})
+            SETTINGS.update({"api_key": self.api_key})
             # Log that the new login was successful
             if verbose:
-                LOGGER.info(f'{PREFIX}New authentication successful ✅')
+                LOGGER.info(f"{PREFIX}New authentication successful ✅")
         elif verbose:
-            LOGGER.info(f'{PREFIX}Retrieve API key from {API_KEY_URL}')
+            LOGGER.info(f"{PREFIX}Retrieve API key from {API_KEY_URL}")
 
     def request_api_key(self, max_attempts=3):
         """
@@ -72,13 +74,14 @@ class Auth:
         Returns the model ID.
         """
         import getpass
+
         for attempts in range(max_attempts):
-            LOGGER.info(f'{PREFIX}Login. Attempt {attempts + 1} of {max_attempts}')
-            input_key = getpass.getpass(f'Enter API key from {API_KEY_URL} ')
-            self.api_key = input_key.split('_')[0]  # remove model id if present
+            LOGGER.info(f"{PREFIX}Login. Attempt {attempts + 1} of {max_attempts}")
+            input_key = getpass.getpass(f"Enter API key from {API_KEY_URL} ")
+            self.api_key = input_key.split("_")[0]  # remove model id if present
             if self.authenticate():
                 return True
-        raise ConnectionError(emojis(f'{PREFIX}Failed to authenticate ❌'))
+        raise ConnectionError(emojis(f"{PREFIX}Failed to authenticate ❌"))
 
     def authenticate(self) -> bool:
         """
@@ -89,14 +92,14 @@ class Auth:
         """
         try:
             if header := self.get_auth_header():
-                r = requests.post(f'{HUB_API_ROOT}/v1/auth', headers=header)
-                if not r.json().get('success', False):
-                    raise ConnectionError('Unable to authenticate.')
+                r = requests.post(f"{HUB_API_ROOT}/v1/auth", headers=header)
+                if not r.json().get("success", False):
+                    raise ConnectionError("Unable to authenticate.")
                 return True
-            raise ConnectionError('User has not authenticated locally.')
+            raise ConnectionError("User has not authenticated locally.")
         except ConnectionError:
             self.id_token = self.api_key = False  # reset invalid
-            LOGGER.warning(f'{PREFIX}Invalid API key ⚠️')
+            LOGGER.warning(f"{PREFIX}Invalid API key ⚠️")
             return False
 
     def auth_with_cookies(self) -> bool:
@@ -110,12 +113,12 @@ class Auth:
         if not is_colab():
             return False  # Currently only works with Colab
         try:
-            authn = request_with_credentials(f'{HUB_API_ROOT}/v1/auth/auto')
-            if authn.get('success', False):
-                self.id_token = authn.get('data', {}).get('idToken', None)
+            authn = request_with_credentials(f"{HUB_API_ROOT}/v1/auth/auto")
+            if authn.get("success", False):
+                self.id_token = authn.get("data", {}).get("idToken", None)
                 self.authenticate()
                 return True
-            raise ConnectionError('Unable to fetch browser authentication details.')
+            raise ConnectionError("Unable to fetch browser authentication details.")
         except ConnectionError:
             self.id_token = False  # reset invalid
             return False
@@ -128,7 +131,7 @@ class Auth:
             (dict): The authentication header if id_token or API key is set, None otherwise.
         """
         if self.id_token:
-            return {'authorization': f'Bearer {self.id_token}'}
+            return {"authorization": f"Bearer {self.id_token}"}
         elif self.api_key:
-            return {'x-api-key': self.api_key}
+            return {"x-api-key": self.api_key}
         # else returns None