Bỏ để qua phần nội dung

Tài liệu tham khảo cho hub_sdk/modules/models.py

Ghi

Tệp này có sẵn tại https://github.com/ultralytics/hub-sdk/blob/main/hub_sdk/modules/models.py. Nếu bạn phát hiện ra một vấn đề, vui lòng giúp khắc phục nó bằng cách đóng góp Yêu cầu 🛠️ kéo. Cảm ơn bạn 🙏 !



hub_sdk.modules.models.Models

Căn cứ: CRUDClient

Một lớp đại diện cho một khách hàng để tương tác với các Mô hình thông qua các hoạt động CRUD. Lớp này mở rộng CRUDClient lớp và cung cấp các phương pháp cụ thể để làm việc với các Mô hình.

Thuộc tính:

Tên Kiểu Sự miêu tả
base_endpoint str

URL điểm cuối cơ sở cho API, được đặt thành "mô hình".

hub_client ModelUpload

Một phiên bản của ModelUpload được sử dụng để tương tác với tải lên mô hình.

id (str, None)

Mã định danh duy nhất của mô hình, nếu có.

data dict

Một từ điển để lưu trữ dữ liệu mô hình.

metrics

Trình giữ chỗ để lưu trữ số liệu mô hình, nếu có sau khi truy xuất.

Ghi

Thuộc tính 'id' được đặt trong quá trình khởi tạo và có thể được sử dụng để xác định duy nhất một mô hình. Thuộc tính "data" được sử dụng để lưu trữ dữ liệu mô hình được tìm nạp từ API.

Mã nguồn trong hub_sdk/modules/models.py
class Models(CRUDClient):
    """
    A class representing a client for interacting with Models through CRUD operations. This class extends the CRUDClient
    class and provides specific methods for working with Models.

    Attributes:
        base_endpoint (str): The base endpoint URL for the API, set to "models".
        hub_client (ModelUpload): An instance of ModelUpload used for interacting with model uploads.
        id (str, None): The unique identifier of the model, if available.
        data (dict): A dictionary to store model data.
        metrics: Placeholder for storing model metrics, if available after retrieval.

    Note:
        The 'id' attribute is set during initialization and can be used to uniquely identify a model.
        The 'data' attribute is used to store model data fetched from the API.
    """

    def __init__(self, model_id: Optional[str] = None, headers: Optional[Dict[str, Any]] = None):
        """
        Initialize a Models instance.

        Args:
            model_id (str, optional): The unique identifier of the model.
            headers (dict, optional): Headers to be included in API requests.
        """
        self.base_endpoint = "models"
        super().__init__(self.base_endpoint, "model", headers)
        self.hub_client = ModelUpload(headers)
        self.id = model_id
        self.data = {}
        self.metrics = None
        if model_id:
            self.get_data()

    @staticmethod
    def _reconstruct_data(data: dict) -> dict:
        """
        Reconstruct format of model data supported by ultralytics.

        Args:
            data: dict
        Returns:
            (dict): Reconstructed data format
        """
        if not data:
            return data

        data["config"] = {
            "batchSize": data.pop("batch_size", None),
            "epochs": data.pop("epochs", None),
            "imageSize": data.pop("imgsz", None),
            "patience": data.pop("patience", None),
            "device": data.pop("device", None),
            "cache": data.pop("cache", None),
        }

        return data

    def get_data(self) -> None:
        """
        Retrieves data for the current model instance.

        If a valid model ID has been set, it sends a request to fetch the model data and stores it in the instance.
        If no model ID has been set, it logs an error message.

        Returns:
            (None): The method does not return a value.
        """
        if not self.id:
            self.logger.error("No model id has been set. Update the model id or create a model.")
            return

        try:
            response = super().read(self.id)

            if response is None:
                self.logger.error(f"Received no response from the server for model ID: {self.id}")
                return

            # Check if the response has a .json() method (it should if it's a response object)
            if not hasattr(response, "json"):
                self.logger.error(f"Invalid response object received for model ID: {self.id}")
                return

            resp_data = response.json()
            if resp_data is None:
                self.logger.error(f"No data received in the response for model ID: {self.id}")
                return

            data = resp_data.get("data", {})
            self.data = self._reconstruct_data(data)
            self.logger.debug(f"Model data retrieved for ID: {self.id}")

        except Exception as e:
            self.logger.error(f"An error occurred while retrieving data for model ID: {self.id}, {str(e)}")

    def create_model(self, model_data: dict) -> None:
        """
        Creates a new model with the provided data and sets the model ID for the current instance.

        Args:
            model_data (dict): A dictionary containing the data for creating the model.

        Returns:
            (None): The method does not return a value.
        """
        try:
            response = super().create(model_data)

            if response is None:
                self.logger.error("Received no response from the server while creating the model.")
                return

            # Ensuring the response object has the .json() method
            if not hasattr(response, "json"):
                self.logger.error("Invalid response object received while creating the model.")
                return

            resp_data = response.json()
            if resp_data is None:
                self.logger.error("No data received in the response while creating the model.")
                return

            self.id = resp_data.get("data", {}).get("id")

            # Check if the ID was successfully retrieved
            if not self.id:
                self.logger.error("Model ID not found in the response data.")
                return

            self.get_data()

        except Exception as e:
            self.logger.error(f"An error occurred while creating the model: {str(e)}")

    def is_resumable(self) -> bool:
        """
        Check if the model training can be resumed.

        Returns:
            (bool): True if resumable, False otherwise.
        """
        return self.data.get("has_last_weights", False)

    def has_best_weights(self) -> bool:
        """
        Check if the model has best weights saved.

        Returns:
            (bool): True if best weights available, False otherwise.
        """
        return self.data.get("has_best_weights", False)

    def is_pretrained(self) -> bool:
        """
        Check if the model is pretrained.

        Returns:
            (bool): True if pretrained, False otherwise.
        """
        return self.data.get("is_pretrained", False)

    def is_trained(self) -> bool:
        """
        Check if the model is trained.

        Returns:
            (bool): True if trained, False otherwise.
        """
        return self.data.get("status") == "trained"

    def is_custom(self) -> bool:
        """
        Check if the model is custom.

        Returns:
            (bool): True if custom, False otherwise.
        """
        return self.data.get("is_custom", False)

    def get_architecture(self) -> Optional[str]:
        """
        Get the architecture name of the model.

        Returns:
            (Optional[str]): The architecture name followed by '.yaml' or None if not available.
        """
        return self.data.get("cfg")

    def get_dataset_url(self) -> Optional[str]:
        """
        Get the dataset URL associated with the model.

        Returns:
            (Optional[str]): The URL of the dataset or None if not available.
        """
        return self.data.get("data")

    def get_weights_url(self, weight: str = "best") -> Optional[str]:
        """
        Get the URL of the model weights.

        Args:
            weight (str, optional): Type of weights to retrieve.

        Returns:
            (Optional[str]): The URL of the specified weights or None if not available.
        """
        if weight == "last":
            return self.data.get("resume")

        return self.data.get("weights")

    def delete(self, hard: bool = False) -> Optional[Response]:
        """
        Delete the model resource represented by this instance.

        Args:
            hard (bool, optional): If True, perform a hard (permanent) delete.

        Note:
            The 'hard' parameter determines whether to perform a soft delete (default) or a hard delete.
            In a soft delete, the model might be marked as deleted but retained in the system.
            In a hard delete, the model is permanently removed from the system.

        Returns:
            (Optional[Response]): Response object from the delete request, or None if delete fails.
        """
        return super().delete(self.id, hard)

    def update(self, data: dict) -> Optional[Response]:
        """
        Update the model resource represented by this instance.

        Args:
            data (dict): The updated data for the model resource.

        Returns:
            (Optional[Response]): Response object from the update request, or None if update fails.
        """
        return super().update(self.id, data)

    def get_metrics(self) -> Optional[List[Dict[str, Any]]]:
        """
        Get metrics to of model.

        Returns:
            (list(dict), optional): The list of metrics objects, or None if it fails.
        """
        if self.metrics:
            return self.metrics

        endpoint = f"{HUB_API_ROOT}/v1/{self.base_endpoint}/{self.id}/metrics"
        try:
            results = self.get(endpoint)
            self.metrics = results.json().get("data")
            return self.metrics
        except Exception as e:
            self.logger.error(f"Model Metrics not found: {e}")

    def upload_model(
        self,
        epoch: int,
        weights: str,
        is_best: bool = False,
        map: float = 0.0,
        final: bool = False,
    ) -> Optional[Response]:
        """
        Upload a model checkpoint to Ultralytics HUB.

        Args:
            epoch (int): The current training epoch.
            weights (str): Path to the model weights file.
            is_best (bool): Indicates if the current model is the best one so far.
            map (float): Mean average precision of the model.
            final (bool): Indicates if the model is the final model after training.

        Returns:
            (Optional[Response]): Response object from the upload request, or None if upload fails.
        """
        return self.hub_client.upload_model(self.id, epoch, weights, is_best=is_best, map=map, final=final)

    def upload_metrics(self, metrics: dict) -> Optional[Response]:
        """
        Upload model metrics to Ultralytics HUB.

        Args:
            metrics (dict):

        Returns:
            (Optional[Response]): Response object from the upload metrics request, or None if it fails.
        """
        return self.hub_client.upload_metrics(self.id, metrics)  # response

    def start_heartbeat(self, interval: int = 60):
        """
        Starts sending heartbeat signals to a remote hub server.

        This method initiates the sending of heartbeat signals to a hub server
        in order to indicate the continued availability and health of the client.

        Args:
            interval (int): The time interval, in seconds, between consecutive heartbeats.

        Returns:
            (None): The method does not return a value.

        Note:
            Heartbeats are essential for maintaining a connection with the hub server
            and ensuring that the client remains active and responsive.
        """
        self.hub_client._register_signal_handlers()
        self.hub_client._start_heartbeats(self.id, interval)

    def stop_heartbeat(self) -> None:
        """
        Stops sending heartbeat signals to a remote hub server.

        This method terminates the sending of heartbeat signals to the hub server,
        effectively signaling that the client is no longer available or active.

        Returns:
            (None): The method does not return a value.

        Note:
            Stopping heartbeats should be done carefully, as it may result in the hub server
            considering the client as disconnected or unavailable.
        """
        self.hub_client._stop_heartbeats()

    def export(self, format: str) -> Optional[Response]:
        """
        Export to Ultralytics HUB.

        Args: format (str): Export format here. Here are supported export [formats](
        https://docs.ultralytics.com/modes/export/#export-formats)

        Returns:
            (Optional[Response]): Response object from the export request, or None if export fails.
        """
        return self.hub_client.export(self.id, format)  # response

    def predict(self, image: str, config: Dict[str, Any]) -> Optional[Response]:
        """
        Predict to Ultralytics HUB.

        Args:
            image (str): The path to the image file.
            config (dict): A configuration for the prediction (JSON).

        Returns:
            (Optional[Response]): Response object from the predict request, or None if upload fails.
        """
        return self.hub_client.predict(self.id, image, config)  # response

__init__(model_id=None, headers=None)

Khởi tạo phiên bản Mô hình.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
model_id str

Mã định danh duy nhất của mô hình.

None
headers dict

Tiêu đề được bao gồm trong yêu cầu API.

None
Mã nguồn trong hub_sdk/modules/models.py
def __init__(self, model_id: Optional[str] = None, headers: Optional[Dict[str, Any]] = None):
    """
    Initialize a Models instance.

    Args:
        model_id (str, optional): The unique identifier of the model.
        headers (dict, optional): Headers to be included in API requests.
    """
    self.base_endpoint = "models"
    super().__init__(self.base_endpoint, "model", headers)
    self.hub_client = ModelUpload(headers)
    self.id = model_id
    self.data = {}
    self.metrics = None
    if model_id:
        self.get_data()

create_model(model_data)

Tạo một mô hình mới với dữ liệu được cung cấp và đặt ID mô hình cho phiên bản hiện tại.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
model_data dict

Một từ điển chứa dữ liệu để tạo mô hình.

bắt buộc

Trở lại:

Kiểu Sự miêu tả
None

Phương thức không trả về một giá trị.

Mã nguồn trong hub_sdk/modules/models.py
def create_model(self, model_data: dict) -> None:
    """
    Creates a new model with the provided data and sets the model ID for the current instance.

    Args:
        model_data (dict): A dictionary containing the data for creating the model.

    Returns:
        (None): The method does not return a value.
    """
    try:
        response = super().create(model_data)

        if response is None:
            self.logger.error("Received no response from the server while creating the model.")
            return

        # Ensuring the response object has the .json() method
        if not hasattr(response, "json"):
            self.logger.error("Invalid response object received while creating the model.")
            return

        resp_data = response.json()
        if resp_data is None:
            self.logger.error("No data received in the response while creating the model.")
            return

        self.id = resp_data.get("data", {}).get("id")

        # Check if the ID was successfully retrieved
        if not self.id:
            self.logger.error("Model ID not found in the response data.")
            return

        self.get_data()

    except Exception as e:
        self.logger.error(f"An error occurred while creating the model: {str(e)}")

delete(hard=False)

Xóa tài nguyên mô hình được đại diện bởi phiên bản này.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
hard bool

Nếu True, hãy thực hiện xóa cứng (vĩnh viễn).

False
Ghi

Tham số 'cứng' xác định xem nên thực hiện xóa mềm (mặc định) hay xóa cứng. Trong xóa mềm, mô hình có thể được đánh dấu là đã xóa nhưng được giữ lại trong hệ thống. Trong một bản xóa cứng, mô hình sẽ bị xóa vĩnh viễn khỏi hệ thống.

Trở lại:

Kiểu Sự miêu tả
Optional[Response]

Phản hồi đối tượng từ yêu cầu xóa, hoặc Không có nếu xóa không thành công.

Mã nguồn trong hub_sdk/modules/models.py
def delete(self, hard: bool = False) -> Optional[Response]:
    """
    Delete the model resource represented by this instance.

    Args:
        hard (bool, optional): If True, perform a hard (permanent) delete.

    Note:
        The 'hard' parameter determines whether to perform a soft delete (default) or a hard delete.
        In a soft delete, the model might be marked as deleted but retained in the system.
        In a hard delete, the model is permanently removed from the system.

    Returns:
        (Optional[Response]): Response object from the delete request, or None if delete fails.
    """
    return super().delete(self.id, hard)

export(format)

Xuất sang Ultralytics Trung tâm.

Args: format (str): Định dạng xuất tại đây. Dưới đây là các định dạng xuất được hỗ trợ

Trở lại:

Kiểu Sự miêu tả
Optional[Response]

Đối tượng phản hồi từ yêu cầu xuất hoặc Không có nếu xuất không thành công.

Mã nguồn trong hub_sdk/modules/models.py
def export(self, format: str) -> Optional[Response]:
    """
    Export to Ultralytics HUB.

    Args: format (str): Export format here. Here are supported export [formats](
    https://docs.ultralytics.com/modes/export/#export-formats)

    Returns:
        (Optional[Response]): Response object from the export request, or None if export fails.
    """
    return self.hub_client.export(self.id, format)  # response

get_architecture()

Lấy tên kiến trúc của mô hình.

Trở lại:

Kiểu Sự miêu tả
Optional[str]

Tên kiến trúc theo sau là '.yaml' hoặc Không có nếu không có sẵn.

Mã nguồn trong hub_sdk/modules/models.py
def get_architecture(self) -> Optional[str]:
    """
    Get the architecture name of the model.

    Returns:
        (Optional[str]): The architecture name followed by '.yaml' or None if not available.
    """
    return self.data.get("cfg")

get_data()

Truy xuất dữ liệu cho phiên bản mô hình hiện tại.

Nếu ID mô hình hợp lệ đã được đặt, nó sẽ gửi yêu cầu tìm nạp dữ liệu mô hình và lưu trữ nó trong phiên bản. Nếu không có ID mô hình nào được đặt, nó sẽ ghi lại thông báo lỗi.

Trở lại:

Kiểu Sự miêu tả
None

Phương thức không trả về một giá trị.

Mã nguồn trong hub_sdk/modules/models.py
def get_data(self) -> None:
    """
    Retrieves data for the current model instance.

    If a valid model ID has been set, it sends a request to fetch the model data and stores it in the instance.
    If no model ID has been set, it logs an error message.

    Returns:
        (None): The method does not return a value.
    """
    if not self.id:
        self.logger.error("No model id has been set. Update the model id or create a model.")
        return

    try:
        response = super().read(self.id)

        if response is None:
            self.logger.error(f"Received no response from the server for model ID: {self.id}")
            return

        # Check if the response has a .json() method (it should if it's a response object)
        if not hasattr(response, "json"):
            self.logger.error(f"Invalid response object received for model ID: {self.id}")
            return

        resp_data = response.json()
        if resp_data is None:
            self.logger.error(f"No data received in the response for model ID: {self.id}")
            return

        data = resp_data.get("data", {})
        self.data = self._reconstruct_data(data)
        self.logger.debug(f"Model data retrieved for ID: {self.id}")

    except Exception as e:
        self.logger.error(f"An error occurred while retrieving data for model ID: {self.id}, {str(e)}")

get_dataset_url()

Lấy URL tập dữ liệu được liên kết với mô hình.

Trở lại:

Kiểu Sự miêu tả
Optional[str]

URL của tập dữ liệu hoặc Không có nếu không có sẵn.

Mã nguồn trong hub_sdk/modules/models.py
def get_dataset_url(self) -> Optional[str]:
    """
    Get the dataset URL associated with the model.

    Returns:
        (Optional[str]): The URL of the dataset or None if not available.
    """
    return self.data.get("data")

get_metrics()

Đưa số liệu vào mô hình.

Trở lại:

Kiểu Sự miêu tả
(list(dict), optional)

Danh sách các đối tượng số liệu hoặc Không có nếu không thành công.

Mã nguồn trong hub_sdk/modules/models.py
def get_metrics(self) -> Optional[List[Dict[str, Any]]]:
    """
    Get metrics to of model.

    Returns:
        (list(dict), optional): The list of metrics objects, or None if it fails.
    """
    if self.metrics:
        return self.metrics

    endpoint = f"{HUB_API_ROOT}/v1/{self.base_endpoint}/{self.id}/metrics"
    try:
        results = self.get(endpoint)
        self.metrics = results.json().get("data")
        return self.metrics
    except Exception as e:
        self.logger.error(f"Model Metrics not found: {e}")

get_weights_url(weight='best')

Lấy URL của trọng lượng mô hình.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
weight str

Loại trọng lượng cần lấy.

'best'

Trở lại:

Kiểu Sự miêu tả
Optional[str]

URL của trọng số được chỉ định hoặc Không có nếu không có sẵn.

Mã nguồn trong hub_sdk/modules/models.py
def get_weights_url(self, weight: str = "best") -> Optional[str]:
    """
    Get the URL of the model weights.

    Args:
        weight (str, optional): Type of weights to retrieve.

    Returns:
        (Optional[str]): The URL of the specified weights or None if not available.
    """
    if weight == "last":
        return self.data.get("resume")

    return self.data.get("weights")

has_best_weights()

Kiểm tra xem mô hình có trọng lượng tốt nhất được tiết kiệm không.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu trọng lượng tốt nhất có sẵn, False nếu không.

Mã nguồn trong hub_sdk/modules/models.py
def has_best_weights(self) -> bool:
    """
    Check if the model has best weights saved.

    Returns:
        (bool): True if best weights available, False otherwise.
    """
    return self.data.get("has_best_weights", False)

is_custom()

Kiểm tra xem mô hình có tùy chỉnh không.

Trở lại:

Kiểu Sự miêu tả
bool

Đúng nếu tùy chỉnh, Sai khác.

Mã nguồn trong hub_sdk/modules/models.py
def is_custom(self) -> bool:
    """
    Check if the model is custom.

    Returns:
        (bool): True if custom, False otherwise.
    """
    return self.data.get("is_custom", False)

is_pretrained()

Kiểm tra xem mô hình có được đào tạo trước không.

Trở lại:

Kiểu Sự miêu tả
bool

Đúng nếu được đào tạo trước, Sai nếu không.

Mã nguồn trong hub_sdk/modules/models.py
def is_pretrained(self) -> bool:
    """
    Check if the model is pretrained.

    Returns:
        (bool): True if pretrained, False otherwise.
    """
    return self.data.get("is_pretrained", False)

is_resumable()

Kiểm tra xem việc đào tạo mô hình có thể được tiếp tục hay không.

Trở lại:

Kiểu Sự miêu tả
bool

True nếu có thể nối lại, False nếu không.

Mã nguồn trong hub_sdk/modules/models.py
def is_resumable(self) -> bool:
    """
    Check if the model training can be resumed.

    Returns:
        (bool): True if resumable, False otherwise.
    """
    return self.data.get("has_last_weights", False)

is_trained()

Kiểm tra xem mô hình đã được đào tạo chưa.

Trở lại:

Kiểu Sự miêu tả
bool

Đúng nếu được đào tạo, Sai nếu không.

Mã nguồn trong hub_sdk/modules/models.py
def is_trained(self) -> bool:
    """
    Check if the model is trained.

    Returns:
        (bool): True if trained, False otherwise.
    """
    return self.data.get("status") == "trained"

predict(image, config)

Dự đoán để Ultralytics Trung tâm.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
image str

Đường dẫn đến tệp hình ảnh.

bắt buộc
config dict

Cấu hình cho dự đoán (JSON).

bắt buộc

Trở lại:

Kiểu Sự miêu tả
Optional[Response]

Đối tượng phản hồi từ yêu cầu dự đoán hoặc Không có nếu tải lên không thành công.

Mã nguồn trong hub_sdk/modules/models.py
def predict(self, image: str, config: Dict[str, Any]) -> Optional[Response]:
    """
    Predict to Ultralytics HUB.

    Args:
        image (str): The path to the image file.
        config (dict): A configuration for the prediction (JSON).

    Returns:
        (Optional[Response]): Response object from the predict request, or None if upload fails.
    """
    return self.hub_client.predict(self.id, image, config)  # response

start_heartbeat(interval=60)

Bắt đầu gửi tín hiệu nhịp tim đến máy chủ trung tâm từ xa.

Phương pháp này bắt đầu gửi tín hiệu nhịp tim đến máy chủ trung tâm để cho biết sự sẵn có và sức khỏe liên tục của khách hàng.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
interval int

Khoảng thời gian, tính bằng giây, giữa các nhịp tim liên tiếp.

60

Trở lại:

Kiểu Sự miêu tả
None

Phương thức không trả về một giá trị.

Ghi

Nhịp tim rất cần thiết để duy trì kết nối với máy chủ trung tâm và đảm bảo rằng khách hàng vẫn hoạt động và đáp ứng.

Mã nguồn trong hub_sdk/modules/models.py
def start_heartbeat(self, interval: int = 60):
    """
    Starts sending heartbeat signals to a remote hub server.

    This method initiates the sending of heartbeat signals to a hub server
    in order to indicate the continued availability and health of the client.

    Args:
        interval (int): The time interval, in seconds, between consecutive heartbeats.

    Returns:
        (None): The method does not return a value.

    Note:
        Heartbeats are essential for maintaining a connection with the hub server
        and ensuring that the client remains active and responsive.
    """
    self.hub_client._register_signal_handlers()
    self.hub_client._start_heartbeats(self.id, interval)

stop_heartbeat()

Ngừng gửi tín hiệu nhịp tim đến máy chủ trung tâm từ xa.

Phương pháp này chấm dứt việc gửi tín hiệu nhịp tim đến máy chủ trung tâm, báo hiệu hiệu quả rằng khách hàng không còn khả dụng hoặc hoạt động.

Trở lại:

Kiểu Sự miêu tả
None

Phương thức không trả về một giá trị.

Ghi

Ngừng nhịp tim nên được thực hiện cẩn thận, vì nó có thể dẫn đến máy chủ trung tâm coi khách hàng là bị ngắt kết nối hoặc không khả dụng.

Mã nguồn trong hub_sdk/modules/models.py
def stop_heartbeat(self) -> None:
    """
    Stops sending heartbeat signals to a remote hub server.

    This method terminates the sending of heartbeat signals to the hub server,
    effectively signaling that the client is no longer available or active.

    Returns:
        (None): The method does not return a value.

    Note:
        Stopping heartbeats should be done carefully, as it may result in the hub server
        considering the client as disconnected or unavailable.
    """
    self.hub_client._stop_heartbeats()

update(data)

Cập nhật tài nguyên mô hình được đại diện bởi phiên bản này.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
data dict

Dữ liệu cập nhật cho tài nguyên mô hình.

bắt buộc

Trở lại:

Kiểu Sự miêu tả
Optional[Response]

Phản hồi đối tượng từ yêu cầu cập nhật hoặc Không có nếu cập nhật không thành công.

Mã nguồn trong hub_sdk/modules/models.py
def update(self, data: dict) -> Optional[Response]:
    """
    Update the model resource represented by this instance.

    Args:
        data (dict): The updated data for the model resource.

    Returns:
        (Optional[Response]): Response object from the update request, or None if update fails.
    """
    return super().update(self.id, data)

upload_metrics(metrics)

Tải số liệu mô hình lên Ultralytics Trung tâm.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
metrics dict
bắt buộc

Trở lại:

Kiểu Sự miêu tả
Optional[Response]

Đối tượng phản hồi từ yêu cầu chỉ số tải lên hoặc Không có nếu không thành công.

Mã nguồn trong hub_sdk/modules/models.py
def upload_metrics(self, metrics: dict) -> Optional[Response]:
    """
    Upload model metrics to Ultralytics HUB.

    Args:
        metrics (dict):

    Returns:
        (Optional[Response]): Response object from the upload metrics request, or None if it fails.
    """
    return self.hub_client.upload_metrics(self.id, metrics)  # response

upload_model(epoch, weights, is_best=False, map=0.0, final=False)

Tải điểm kiểm tra mẫu lên Ultralytics Trung tâm.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
epoch int

Thời đại đào tạo hiện nay.

bắt buộc
weights str

Đường dẫn đến tệp trọng số mô hình.

bắt buộc
is_best bool

Cho biết nếu mô hình hiện tại là mô hình tốt nhất cho đến nay.

False
map float

Độ chính xác trung bình trung bình của mô hình.

0.0
final bool

Cho biết nếu mô hình là mô hình cuối cùng sau khi đào tạo.

False

Trở lại:

Kiểu Sự miêu tả
Optional[Response]

Đối tượng phản hồi từ yêu cầu tải lên hoặc Không có nếu tải lên không thành công.

Mã nguồn trong hub_sdk/modules/models.py
def upload_model(
    self,
    epoch: int,
    weights: str,
    is_best: bool = False,
    map: float = 0.0,
    final: bool = False,
) -> Optional[Response]:
    """
    Upload a model checkpoint to Ultralytics HUB.

    Args:
        epoch (int): The current training epoch.
        weights (str): Path to the model weights file.
        is_best (bool): Indicates if the current model is the best one so far.
        map (float): Mean average precision of the model.
        final (bool): Indicates if the model is the final model after training.

    Returns:
        (Optional[Response]): Response object from the upload request, or None if upload fails.
    """
    return self.hub_client.upload_model(self.id, epoch, weights, is_best=is_best, map=map, final=final)



hub_sdk.modules.models.ModelList

Căn cứ: PaginatedList

Mã nguồn trong hub_sdk/modules/models.py
class ModelList(PaginatedList):
    def __init__(self, page_size=None, public=None, headers=None):
        """
        Initialize a ModelList instance.

        Args:
            page_size (int, optional): The number of items to request per page.
            public (bool, optional): Whether the items should be publicly accessible.
            headers (dict, optional): Headers to be included in API requests.
        """
        base_endpoint = "models"
        super().__init__(base_endpoint, "model", page_size, public, headers)

__init__(page_size=None, public=None, headers=None)

Khởi tạo phiên bản ModelList.

Thông số:

Tên Kiểu Sự miêu tả Mặc định
page_size int

Số lượng mục cần yêu cầu trên mỗi trang.

None
public bool

Liệu các mục có thể truy cập công khai hay không.

None
headers dict

Tiêu đề được bao gồm trong yêu cầu API.

None
Mã nguồn trong hub_sdk/modules/models.py
def __init__(self, page_size=None, public=None, headers=None):
    """
    Initialize a ModelList instance.

    Args:
        page_size (int, optional): The number of items to request per page.
        public (bool, optional): Whether the items should be publicly accessible.
        headers (dict, optional): Headers to be included in API requests.
    """
    base_endpoint = "models"
    super().__init__(base_endpoint, "model", page_size, public, headers)