REST APIリファレンス#

Ultralytics Platform は、データセット、画像、プロジェクト、モデル、トレーニング、エクスポート、デプロイメントにプログラムからアクセスするためのREST APIを提供します。

# List the datasets owned by a workspace
curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://platform.ultralytics.com/api/datasets/YOUR_USERNAME

API概要#

APIは、Platformの主要リソースを中心に構成されています。

graph LR
    A[API Key]:::start --> B[Datasets]:::proc
    A --> C[Projects]:::proc
    B -->|images| G[Images]:::proc
    C -->|contains| D[Models]:::proc
    B -->|train on| D
    D -->|deploy| E[Deployments]:::proc
    D -->|export| F[Exports]:::proc

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff

認証#

ほとんどのエンドポイントではAPIキーが必要です。公開データセット、プロジェクト、モデルの読み取り、公開データセット画像の一覧表示、公開モデルでの推論実行、Exploreでの検索など、公開コンテンツを提供するエンドポイントでは匿名リクエストも受け付け、キーが指定されると追加の結果を返します。

APIキーの取得#

1. Settings > API Keys に移動します
2. Create Keyをクリックします
3. 生成されたキーをコピーします

詳しい手順については、APIキーを参照してください。

Authorizationヘッダー#

APIキーをBearerトークンとして含めます。

Authorization: Bearer YOUR_API_KEY

例#

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://platform.ultralytics.com/api/account/summary

ベースURL#

すべてのAPIエンドポイントでは、次を使用します。

https://platform.ultralytics.com/api

リソースパス#

リソースには、データベースIDではなく、PlatformのURLに表示される人間が読みやすい名前を使用してアクセスします。

• {owner}は、個人のユーザー名またはチームのワークスペースハンドルです。4～32文字で、小文字の英数字を使用し、セグメント間には単一のハイフンを置きます。
• {dataset}、{project}、{model}、{deployment}は、同じ小文字とハイフンのパターンに従い、最大128文字です。
• {imageId}と{exportId}は、APIが返す24文字の16進数IDです。
• PATCHを通じてリソースの名前を変更すると、表示名のnameとURL名が同時に変更され、レスポンスには現在のURL名が返されるため、その名前を引き続き使用できます。

レート制限#

APIは、APIキーごとにスライディングウィンドウ方式の制限を適用します。各ルートは1つのカテゴリに分類され、カテゴリごとに独立したカウンターがあるため、predictリクエストを20回実行してもデフォルトの許容量は消費されません。

請求のチェックアウトやチーム管理など、ブラウザー専用のPlatformルートには独自の制限があり、APIキートラフィックには適用されません。

スロットリングが発生すると、APIはヘッダーとJSON本文の両方に429を含めて返します。

Retry-After: 12
X-RateLimit-Reset: 2026-02-21T12:34:56.000Z

{
    "error": "Rate limit exceeded",
    "retryAfter": 12,
    "resetAt": "2026-02-21T12:34:56.000Z"
}

専用エンドポイント（無制限）#

専用エンドポイントは、デプロイメント固有のserviceUrlを直接呼び出す場合（例：https://predict-abc123.run.app/predict）、Platform APIキーのレート制限の対象外です。その場合のスループットは、デプロイされたサービスの構成によって決まります。

レスポンス形式#

成功レスポンス#

レスポンスは、リソース固有のフィールドを持つJSONオブジェクトです。汎用的なエンベロープはありません。一覧エンドポイントは、件数とともに名前付きコレクションを返し、変更操作は変更された識別子を返します。

{
    "datasets": [{ "id": "65f1c0a2b3d4e5f601234567", "owner": "acme-vision", "dataset": "warehouse" }],
    "total": 1,
    "region": "us"
}

データを含むレスポンスには、region（us、eu、またはap）も含まれます。これは、そのワークスペースのストレージリージョンです。

エラーレスポンス#

すべてのエラーレスポンスは、errorメッセージを含むJSONオブジェクトです。

{
    "error": "Dataset not found"
}

ページネーション#

ページネーションの方式はコレクションによって異なります：

データセット API#

YOLO モデルのトレーニングに使用するラベル付き画像データセットを作成、参照、管理します。データセットのドキュメントをご覧ください。

データセットの一覧表示#

GET /api/datasets/{owner}

Python SDK: client.datasets.list(owner)

所有者のパブリックデータセットを返します。キーにそのワークスペースを表示する権限がある場合は、プライベートデータセットも返します。

クエリパラメーター：

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://platform.ultralytics.com/api/datasets/acme-vision?limit=10&includeSamples=false"

レスポンス：

{
    "datasets": [
        {
            "id": "65f1c0a2b3d4e5f601234567",
            "owner": "acme-vision",
            "dataset": "warehouse",
            "name": "Warehouse",
            "task": "detect",
            "visibility": "private",
            "imageCount": 1000,
            "classCount": 2,
            "classNames": ["person", "forklift"],
            "splits": { "train": 800, "val": 200, "test": 0, "labeled": 1000 },
            "annotationCount": 5400,
            "starCount": 3,
            "isStarred": false,
            "status": "ready",
            "createdAt": "2026-01-15T10:00:00Z",
            "updatedAt": "2026-01-16T08:30:00Z"
        }
    ],
    "total": 1,
    "region": "us"
}

データセットの取得#

GET /api/datasets/{owner}/{dataset}

Python SDK: client.datasets.retrieve(owner, dataset)

dataset キーの下に、classNames、splits、versions、source、およびユーザー定義の metadata オブジェクトを含む完全なデータセットオブジェクトを返します。

データセットの作成#

POST /api/datasets

Python SDK: client.datasets.create(dataset=..., name=...)

Body：

{
    "dataset": "warehouse",
    "name": "Warehouse",
    "task": "detect",
    "description": "Forklift and pedestrian safety dataset",
    "classNames": ["person", "forklift"],
    "visibility": "private",
    "metadata": { "location": "factory-1", "reviewed": true },
    "owner": "acme-vision"
}

レスポンスは実際に作成された dataset のスラッグを返すため、requireExactSlug を設定しない限り、アップロードする前に読み返してください。

レスポンス（201）：

{
    "id": "65f1c0a2b3d4e5f601234567",
    "owner": "acme-vision",
    "dataset": "warehouse",
    "region": "us"
}

データセットの更新#

PATCH /api/datasets/{owner}/{dataset}

Python SDK: client.datasets.update(owner, dataset)

Body（部分更新）：

{
    "name": "Warehouse Safety",
    "description": "New description",
    "visibility": "public",
    "metadata": { "location": "factory-2", "reviewed": true }
}

受け付けるフィールド：name、description、visibility、metadata、tags、classNames、classColors、format、task、license、iconColor、iconLetter、および starred。カスタムメタデータをクリアするには、空の metadata オブジェクト（{}）を送信します。メタデータキーは 128 文字、シリアライズされたオブジェクトは 500,000 文字に制限されます。

レスポンス：

{
    "success": true,
    "dataset": "warehouse-safety"
}

名前を変更すると URL 名も変更されるため、以降のリクエストでは返された dataset の値を使用してください。

データセットの削除#

DELETE /api/datasets/{owner}/{dataset}

Python SDK: client.datasets.delete(owner, dataset)

データセットをゴミ箱に移動します。30 日間は復元可能です。

データセットのクローン#

POST /api/datasets/{owner}/{dataset}/clone

Python SDK: client.datasets.clone(owner, dataset)

アクセス可能なデータセットを、その画像とラベルとともに、個人ワークスペースまたはチームワークスペースにコピーします。

Optional body（すべてのフィールドが任意）：

{
    "dataset": "warehouse-copy",
    "name": "Warehouse Copy",
    "description": "Cloned for experimentation",
    "visibility": "private",
    "license": "CC-BY-4.0",
    "owner": "acme-vision"
}

レスポンス（201）： id、owner、dataset、name、imageCount、classCount、および region。接続されたストレージソースを使用するデータセットは、ファイルがコピーされないため 409 を返します。

データセットエクスポートのダウンロード#

GET /api/datasets/{owner}/{dataset}/export

Python SDK: client.datasets.export(owner, dataset)

署名付き NDJSON ダウンロード URL を返します。v を省略すると、データセットの現在の状態をエクスポートします。生成以降に変更がない場合は、キャッシュされたエクスポートを再利用します。

クエリパラメーター：

レスポンス：

{
    "downloadUrl": "https://storage.googleapis.com/...&signature=...",
    "cached": true
}

特定のバージョンをリクエストすると、cached の代わりに downloadUrl と version を返します。

データセットバージョンの作成#

POST /api/datasets/{owner}/{dataset}/export

Python SDK: client.datasets.create_export(owner, dataset)

データセットの不変の番号付きスナップショットを作成し、その NDJSON エクスポートを保存します。エディターアクセスが必要です。

Body（任意）：

{
    "description": "Added 500 training images"
}

レスポンス：

{
    "version": 3,
    "downloadUrl": "https://storage.googleapis.com/...&signature=...",
    "reused": false
}

データセットが前のバージョンから変更されておらず、そのスナップショットが代わりに返された場合、reused は true です。

バージョン説明の更新#

PATCH /api/datasets/{owner}/{dataset}/export

Python SDK: client.datasets.update_export(owner, dataset, version=..., description=...)

Body：

{
    "version": 2,
    "description": "Fixed mislabeled classes"
}

レスポンス： {"ok": true}

データセットバージョンの復元#

POST /api/datasets/{owner}/{dataset}/restore

Python SDK: client.datasets.restore(owner, dataset, version=...)

画像バイトをコピーせずに、保存されたバージョンから画像、アノテーション、クラスを再構築します。

Body：

{
    "version": 2
}

レスポンス： {"version": 2, "imageCount": 1000}

データセット統計の取得#

GET /api/datasets/{owner}/{dataset}/class-stats

Python SDK: client.datasets.class_stats(owner, dataset)

クラスごとのアノテーション数、画像とアノテーションのヒストグラム、およびヒートマップを返します。大規模データセットはサンプリングされ、その場合は sampleSize に処理に使用された画像数が示されます。

レスポンス（抜粋）：

{
    "classes": [{ "classId": 0, "count": 1500, "imageCount": 450 }],
    "imageStats": {
        "widthHistogram": [{ "bin": 640, "count": 120, "size": 1 }],
        "heightHistogram": [{ "bin": 480, "count": 95, "size": 1 }],
        "pointsHistogram": [{ "bin": 4, "count": 200, "size": 1 }],
        "formatDistribution": { "jpg": 900, "png": 100 },
        "fileSizeHistogram": [{ "bin": 250000, "count": 300, "size": 50000 }],
        "objectsPerImageHistogram": [{ "bin": 5, "count": 210, "size": 1 }],
        "bboxWidthHistogram": [{ "bin": 120, "count": 340, "size": 20 }],
        "bboxHeightHistogram": [{ "bin": 90, "count": 300, "size": 20 }]
    },
    "locationHeatmap": {
        "bins": [
            [5, 10],
            [8, 3]
        ],
        "maxCount": 50
    },
    "dimensionHeatmap": {
        "bins": [
            [2, 5],
            [3, 1]
        ],
        "maxCount": 12,
        "minWidth": 10,
        "maxWidth": 1920,
        "minHeight": 10,
        "maxHeight": 1080
    },
    "classNames": ["person", "forklift"],
    "cached": true,
    "sampleSize": null
}

クラスの管理#

クラスのマージ（アノテーションを対象クラスに再割り当てしてから、元のクラスを削除します）：

POST /api/datasets/{owner}/{dataset}/classes/merge

Python SDK: client.datasets.merge_classes(owner, dataset, source_class_ids=..., target_class_id=...)

{
    "sourceClassIds": [2, 4],
    "targetClassId": 1
}

クラスの削除（クラスのアノテーションが削除され、残りのクラス ID は繰り上がります）：

POST /api/datasets/{owner}/{dataset}/classes/delete

Python SDK: client.datasets.delete_classes(owner, dataset, class_ids=...)

{
    "classIds": [2, 4]
}

両方の操作は、success、更新された classNames と classColors、および変更内容の概要（mergedClassIds と targetClassId、または deletedClassIds と deletedAnnotations）を返します。

分割の再配分#

POST /api/datasets/{owner}/{dataset}/splits/redistribute

Python SDK: client.datasets.redistribute_splits(owner, dataset, train=..., val=..., test=...)

画像を分割間でランダムに再割り当てします。3 つの割合の合計は 100 である必要があります。

{
    "train": 80,
    "val": 20,
    "test": 0
}

レスポンス： success、結果として得られる splits の件数、および modified（移動した画像数）。

データセット Embeddings#

GET /api/datasets/{owner}/{dataset}/embeddings
POST /api/datasets/{owner}/{dataset}/embeddings
DELETE /api/datasets/{owner}/{dataset}/embeddings

Python SDK： client.datasets.embeddings(owner, dataset)、client.datasets.create_embeddings(owner, dataset)、client.datasets.delete_embeddings(owner, dataset)

GET は分析概要（analyzedAt、embeddingsCount、latestImageAt、activeJob）を返します。POST は Embedding 分析をキューに追加し、jobId を含む 202 を返します。DELETE はアクティブなジョブをキャンセルし、キャンセルされたジョブ ID または null を返します。

画像クラスタリング#

GET /api/datasets/{owner}/{dataset}/images/clustering

Python SDK: client.datasets.clustering(owner, dataset)

完了した分析の UMAP 2D レイアウトを返します。offset と limit（デフォルトおよび最大 50,000）によるページネーションに対応しています。各エントリには id、umapX、umapY、split、classIds、width、height、bytes、labelCount、および missing が含まれます。

データセットでトレーニングされたモデルの一覧表示#

GET /api/datasets/{owner}/{dataset}/models

Python SDK: client.datasets.models(owner, dataset)

レスポンス：

{
    "models": [
        {
            "id": "65f1c0a2b3d4e5f601234599",
            "owner": "acme-vision",
            "project": "inspection",
            "model": "v3",
            "name": "v3",
            "status": "completed",
            "task": "detect",
            "epochs": 100,
            "bestEpoch": 87,
            "metrics": { "mAP50": 0.85, "mAP50-95": 0.72, "precision": 0.88, "recall": 0.81 },
            "startedAt": "2026-01-14T22:00:00Z",
            "completedAt": "2026-01-15T10:00:00Z",
            "createdAt": "2026-01-14T21:55:00Z"
        }
    ],
    "count": 1
}

データセット画像の一覧表示#

GET /api/datasets/{owner}/{dataset}/images

Python SDK: client.datasets.images(owner, dataset)

クエリパラメーター：

レスポンス：

{
    "images": [
        {
            "id": "65f1c0a2b3d4e5f601234567",
            "hash": "9f2c1d4b6a8e0f3c5d7b9a1e2f4c6d8b",
            "ext": "jpg",
            "name": "aisle-04.jpg",
            "thumbnailUrl": "https://storage.googleapis.com/...&signature=...",
            "width": 1920,
            "height": 1080,
            "split": "train",
            "labelCount": 6,
            "bytes": 284213,
            "error": null
        }
    ],
    "total": 1000,
    "hasMore": true,
    "classes": ["person", "forklift"],
    "errorCount": 0,
    "nextCursor": "65f1c0a2b3d4e5f601234567"
}

選択した画像を取得#

POST /api/datasets/{owner}/{dataset}/images

Python SDK: client.datasets.selected_images(owner, dataset, image_ids=...)

指定された画像IDが最大1,000件の場合に、同じ画像形式を返します。また、list操作と同じフィルターおよびURLクエリパラメーターを受け付けます

{
    "imageIds": ["65f1c0a2b3d4e5f601234567", "65f1c0a2b3d4e5f601234568"]
}

データセットデータを取り込む#

POST /api/datasets/{owner}/{dataset}/ingest

Python SDK: client.datasets.ingest(owner, dataset, body=...)

完了したアップロード、リモートアーカイブ、または接続済みストレージソースを既存のデータセットに取り込みます。ソースを1つだけ指定してください:

アップロードセッションは、POST /api/upload/signed-urlに渡されたassetIdによってデータセットに紐付けられます。取り込みでは、別のデータセットに属するセッションは拒否されます。

Body（アップロード済みアーカイブ）:

{
    "sessionId": "session_abc123",
    "targetSplit": "train"
}

Body（リモートアーカイブまたはNDJSON）:

{
    "sourceUrl": "https://example.com/my-dataset.zip"
}

Body（後続の取り込みでラベルをインポートする場合）:

{
    "sessionId": "session_abc123",
    "classMapping": { "person": 0, "automobile": "forklift", "background": null }
}

Body（画像ごとのメタデータを付加する場合）:

{
    "sessionId": "session_abc123",
    "imageMetadata": {
        "airbus-wing.jpg": { "aircraft": { "family": "A350" }, "inspectionStatus": "reviewed" },
        "images/tail.jpg": { "aircraft": { "family": "A320" }, "inspectionSeverity": 2 }
    }
}

メタデータキーは、フォルダーを含め、アーカイブ内の正規化されたパスと一致する必要があります。NDJSONインポートでは、各レコードに独自のmetadataオブジェクトを含めることができ、一致するimageMetadataエントリより優先されます。アーカイブパスは1,024文字、トップレベルのメタデータキーは128文字に制限されます。また、各メタデータオブジェクトとimageMetadataマップ全体は、シリアライズ後で500,000文字に制限されます。

レスポンス（201）：

{
    "jobId": "65f1c0a2b3d4e5f6012345aa",
    "status": "queued"
}

graph LR
    A[POST /api/datasets]:::start --> B[POST /api/upload/signed-url]:::proc
    B --> C[PUT archive to signed URL]:::proc
    C --> D[POST /api/upload/complete]:::proc
    D --> E["POST /api/datasets/{owner}/{dataset}/ingest"]:::proc
    E --> F[Process archive]:::proc
    F --> G[Dataset ready]:::out

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff

import io
import zipfile
from pathlib import Path

import requests

api = "https://platform.ultralytics.com/api"
headers = {"Authorization": "Bearer YOUR_API_KEY"}
owner, dataset = "acme-vision", "warehouse"
dataset_id = "65f1c0a2b3d4e5f601234567"  # id returned by POST /api/datasets
image_path = Path("airbus-wing.jpg")

archive = io.BytesIO()
with zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED) as zf:
    zf.write(image_path, image_path.name)
data = archive.getvalue()

signed = requests.post(
    f"{api}/upload/signed-url",
    headers=headers,
    json={
        "assetType": "datasets",
        "assetId": dataset_id,
        "filename": "images.zip",
        "contentType": "application/zip",
        "totalBytes": len(data),
    },
)
signed.raise_for_status()
upload = signed.json()

requests.put(upload["uploadUrl"], headers={"Content-Type": "application/zip"}, data=data).raise_for_status()
requests.post(
    f"{api}/upload/complete",
    headers=headers,
    json={"sessionId": upload["sessionId"]},
).raise_for_status()

ingest = requests.post(
    f"{api}/datasets/{owner}/{dataset}/ingest",
    headers=headers,
    json={
        "sessionId": upload["sessionId"],
        "imageMetadata": {
            "airbus-wing.jpg": {
                "aircraft": {"family": "A350", "section": "wing"},
                "inspectionStatus": "reviewed",
            }
        },
    },
)
ingest.raise_for_status()
print(ingest.json())

画像API#

24文字の画像IDを使用して、データセット画像の確認、アノテーション、移動、削除を行います。アノテーションのドキュメントを参照してください。

画像を取得#

GET /api/images/{imageId}

Python SDK: client.images.retrieve(image_id)

metadata（カスタム、ユーザー定義）、properties（ファイル名、ハッシュ、サイズ、split、件数、タイムスタンプ）、labels、およびデータセットのclassNamesを返します。

画像を更新#

PATCH /api/images/{imageId}

Python SDK: client.images.update(image_id, body=...)

アノテーションまたはカスタムメタデータのいずれか一方を置き換えます。2つの形式のうち一方だけを送信し、両方は送信しないでください。

Body（アノテーション）:

{
    "labels": [
        { "classId": 0, "bbox": [0.5, 0.5, 0.2, 0.3] },
        { "classId": 1, "segments": [0.1, 0.2, 0.3, 0.2, 0.2, 0.4] }
    ]
}

Body（メタデータ）:

{
    "metadata": { "location": "strasbourg", "reviewed": true }
}

画像を削除#

DELETE /api/images/{imageId}

Python SDK: client.images.delete(image_id)

1枚の画像とそのアノテーションを完全に削除します。

画像を自動アノテーション#

POST /api/images/{imageId}/predict

Python SDK: client.images.predict(image_id, model_id=...)

画像に対してYOLO推論を実行し、予測されたアノテーションを返します。アノテーションは保存されないため、内容に問題がなければPATCH /api/images/{imageId}を使用して結果を書き戻してください。

Response: success、predictions（アノテーションオブジェクト）、modelUsed、およびinferenceTime。クラスがデータセットと一致しないモデルの場合は、422を返します。

データセットを自動アノテーションする#

POST /api/datasets/{owner}/{dataset}/predict/batch

Python SDK: client.datasets.create_batch(owner, dataset, model_id=...)

データセットバージョンを保存し、モデルを使用してデータセットの未アノテーション画像をラベル付けする実行をキューに入れて 202 を返します。 リクエストボディには、単一画像のエンドポイントと同じ modelId、confidence、iou の各フィールドに加え、すでにラベルが付いている画像もアノテーションするための includeAnnotated（デフォルトは false）、およびモデルクラスごとのデータセットクラスインデックスを指定するオプショナルな classMapping 配列（またはそれをスキップする null）を指定します。既存のラベルが変更されることはなく、実行の課金対象は実際に処理された画像のみです。 402 は残高の見積もり超過、409 はデータセットの未準備、アノテーション対象画像の不在、または実行の重複、422 はデータセットにクラスがないことを示しており、このエンドポイントを呼び出す前に classes endpoint でクラスを作成してください。これはアプリのクラスのマッピングステップが実行開始前に行う処理と同じです。

同じパス（client.datasets.batch(owner, dataset)）に対する GET は、実行中の処理とその進捗、または破棄されるまでの直近の完了済み実行を返し、DELETE（client.datasets.delete_batch(owner, dataset)）は実行中の処理をキャンセルするか、課金を確定させて完了済みサマリーを破棄します。

画像を一括移動#

PATCH /api/images/bulk

Python SDK: client.images.update_bulk(image_ids=..., split=...)

最大1,000枚の画像を、あるデータセットから別のsplitに移動します。

{
    "imageIds": ["65f1c0a2b3d4e5f601234567"],
    "split": "val",
    "conflictPolicy": "skip"
}

ファイル名またはコンテンツの競合がある場合、skip、keep_both、またはreplaceのいずれかについて、バスケット全体に適用するconflictPolicyを選択するまで、409を返します。ResponseにはmodifiedCount、skippedCount、およびtargetSplitが含まれます。

画像を一括削除#

DELETE /api/images/bulk

Python SDK: client.images.delete_bulk(image_ids=...)

{
    "imageIds": ["65f1c0a2b3d4e5f601234567", "65f1c0a2b3d4e5f601234568"]
}

1つのデータセットから最大1,000枚の画像を削除し、deletedCountとdeletedImageIdsを返します。

署名付き画像URLを取得#

POST /api/images/urls

Python SDK: client.images.urls(image_ids=...)

1つのデータセットから最大100個の画像IDについて、一時的な署名付きURLを返します。

{
    "imageIds": ["65f1c0a2b3d4e5f601234567"]
}

Response: 画像IDをキーとするurlsとthumbnailsを返します。

プロジェクトAPI#

モデルをプロジェクトに整理します。各モデルは1つのプロジェクトに属します。プロジェクトのドキュメントを参照してください。

プロジェクト一覧#

GET /api/projects/{owner}

Python SDK: client.projects.list(owner)

クエリパラメーター：

プロジェクトを取得#

GET /api/projects/{owner}/{project}

Python SDK: client.projects.retrieve(owner, project)

projectオブジェクト、モデルごとの概要（ステータス、メトリクス、エポック数、重み、トレーニング引数）を含むmodels配列、およびisOwnerを返します。

プロジェクトを作成#

POST /api/projects

Python SDK: client.projects.create(project=..., name=...)

curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "project": "inspection",
    "name": "Inspection",
    "description": "Detection experiments",
    "metadata": {"department": "manufacturing", "cost_center": "cv-01"}
  }' \
  https://platform.ultralytics.com/api/projects

Response（201）: id、owner、project、region。

プロジェクトを更新#

PATCH /api/projects/{owner}/{project}

Python SDK: client.projects.update(owner, project)

受け付けるフィールド: name、description、visibility、metadata、tags、license、archived、iconColor、iconLetter、viewPreferences、およびstarred。

{
    "metadata": { "department": "research", "program": "inspection" }
}

空のmetadataオブジェクト（{}）を送信すると、消去できます。プロジェクトメタデータには、データセットメタデータと同じ128文字のキー制限および500,000文字のシリアライズ済みオブジェクト制限が適用されます。

プロジェクトの削除#

DELETE /api/projects/{owner}/{project}

Python SDK: client.projects.delete(owner, project)

プロジェクトとそのモデルをゴミ箱に移動し、cascadedModelsを返します。

プロジェクトをクローン#

POST /api/projects/{owner}/{project}/clone

Python SDK: client.projects.clone(owner, project)

アクセス可能なプロジェクトと、その完了済みモデルを複製します。オプションのBodyでは、project、name、description、visibility、license、および移行先のownerを指定できます。

モデルAPI#

トレーニング済みのYOLOモデルを管理します。メトリクスの表示、重みのダウンロード、推論の実行、トレーニングの監視を行えます。モデルのドキュメントを参照してください。

プロジェクト内のモデル一覧#

GET /api/models/{owner}/{project}

Python SDK: client.models.list(owner, project)

クエリパラメーター：

モデルを取得#

GET /api/models/{owner}/{project}/{model}

Python SDK: client.models.retrieve(owner, project, model)

クエリパラメーター：

デフォルトのResponseには、ステータス、タスク、メトリクス、trainArgs、trainResults、classNames、computeCost、metadataなどを含むmodelオブジェクトと、isOwnerが含まれます。

モデルを作成#

POST /api/models

Python SDK: client.models.create(body=...)

重みを関連付けたり、トレーニングしたりできる、未トレーニングのモデルレコードを作成します。

Response（201）: id、owner、project、model、region。

モデルを更新#

PATCH /api/models/{owner}/{project}/{model}

Python SDK: client.models.update(owner, project, model)

受け入れられるフィールドには、name、description、color、metadata、status、license、datasetSlug、trainArgs、trainResults、epochs、bestEpoch、bestFitness、version、trainingError、および starred が含まれます。projectId を単体で渡すと、モデルは同じ所有者の別のプロジェクトに移動します。レスポンスは、移動先のモデルの slug、そこですでにそのスラッグが使用されていた場合は renamed: true、モデルがまだトレーニング中の場合は 409 を返します。

{
    "metadata": { "release": "candidate-3", "reviewed": true }
}

カスタムmetadataは、trainArgs、environment、trainResultsなどのトレーニング管理フィールドとは別であり、データセットメタデータと同じサイズ制限が適用されます。

モデルの削除#

DELETE /api/models/{owner}/{project}/{model}

Python SDK: client.models.delete(owner, project, model)

モデルを30日間ゴミ箱に移動します。

モデルファイルをダウンロード#

GET /api/models/{owner}/{project}/{model}/files

Python SDK: client.models.files(owner, project, model)

モデルの重みに対する短期間有効な署名付きURLを返します。

{
    "files": [
        {
            "name": "best.pt",
            "size": 6534127,
            "downloadUrl": "https://storage.googleapis.com/...&signature=..."
        }
    ]
}

モデルのクローン#

POST /api/models/{owner}/{project}/{model}/clone

Python SDK: client.models.clone(owner, project, model, project_body=...)

アクセス可能なモデルを既存のプロジェクトにコピーします。

{
    "owner": "acme-vision",
    "project": "inspection",
    "model": "v3-copy",
    "name": "V3 Copy",
    "description": "Cloned from a public model"
}

推論を実行します#

POST /api/models/{owner}/{project}/{model}/predict

Python SDK: client.models.predict(owner, project, model, body=...)

パブリックモデルは認証なしで予測できます。プライベートモデルおよび共有モデルには、親プロジェクトへのアクセス権を持つAPIキーが必要です。

Multipart Form:

file または source のいずれかを指定してください。Depthモデルでは、bits（8、12、または 16）も指定して、Depth mapのPNG量子化を選択できます。 サービスの入力制限を超えるリクエストは 413 を返します。

curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@image.jpg" \
  -F "conf=0.5" \
  https://platform.ultralytics.com/api/models/acme-vision/inspection/v3/predict

レスポンス：

images の各エントリには、shape、speed、results と、dense predictionタスクの場合は semantic_mask または depth のPNGペイロードが含まれます（Depth値は pixel × max / divisor で、デフォルトの8-bit mapでは除数255、bits が12または16の場合は65535です）。metadata オブジェクトには、画像数、関数の実行時間、タスク、サービスのバージョンが示されます。内部モデルパスは返されません。

{
    "images": [
        {
            "shape": [1080, 1920],
            "speed": { "preprocess": 2.1, "inference": 12.4, "postprocess": 1.3 },
            "results": [
                {
                    "class": 0,
                    "name": "person",
                    "confidence": 0.92,
                    "box": { "x1": 100, "y1": 50, "x2": 300, "y2": 400 }
                }
            ]
        }
    ],
    "metadata": {
        "imageCount": 1,
        "functionTimeAlive": 184.2,
        "functionTimeCall": 0.31,
        "task": "detect",
        "version": { "ultralytics": "8.4.120" }
    }
}

トレーニングの進捗を確認#

GET /api/models/{owner}/{project}/{model}/training

Python SDK: client.models.training(owner, project, model)

ステータス、エポックの進捗、実行時間、コンピューティングの詳細、トレーニング引数、エポックメトリクス、安全なエラー詳細を含む job を返します。モデルが一度もトレーニングされていない場合は null を返します。パブリックプロジェクトのモデルは認証なしで読み取れます。

トレーニングをキャンセルする#

DELETE /api/models/{owner}/{project}/{model}/training

Python SDK: client.models.delete_training(owner, project, model)

実行中のコンピュートインスタンスを終了し、ジョブをキャンセル済みとしてマークします。トレーニングがすでにアクティブでない場合は 409 を返します。

トレーニング API#

クラウドGPUでYOLOのトレーニングを開始し、進捗をリアルタイムで監視します。 Cloud Trainingのドキュメントを参照してください。

graph LR
    A[POST /api/training/start]:::start --> B[Job Created]:::proc
    B --> C{Training}:::decide
    C -->|progress| D[GET .../training]:::proc
    C -->|cancel| E[DELETE .../training]:::error
    C -->|complete| F[Model Ready]:::out
    F --> G[Deploy or Export]:::proc

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef decide fill:#FF9800,color:#fff
    classDef out fill:#9C27B0,color:#fff
    classDef error fill:#F44336,color:#fff

GPUの利用可能状況を取得#

GET /api/training/gpu-availability

Python SDK: client.training.gpu_availability()

GPU IDごとに分類された現在の在庫状況を返します。パブリックで認証は不要です。managed=true を指定すると、APIキーが必要なマネージドトレーニング容量も含めることができます。

トレーニングを開始#

POST /api/training/start

Python SDK: client.training.start(model_id=..., train_args=...)

curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "modelId": "65f1c0a2b3d4e5f601234599",
    "gpuType": "rtx-4090",
    "trainArgs": {
      "model": "yolo26n.pt",
      "data": "ul://acme-vision/datasets/warehouse",
      "epochs": 100,
      "imgsz": 640,
      "batch": 16
    }
  }' \
  https://platform.ultralytics.com/api/training/start

レスポンス：

{
    "modelId": "65f1c0a2b3d4e5f601234599",
    "status": "starting",
    "gpuType": "rtx-4090",
    "estimatedCost": { "pricePerHour": 0.69, "gpuMemoryGb": 24 },
    "billing": {
        "estimatedCostCents": 138,
        "estimatedCostDisplay": "$1.38",
        "balanceCents": 2500
    }
}

クレジット残高が不足している場合、トレーニングは 402 を返し、要求されたGPUに利用可能な容量がない場合は 503 を返します。

Exports API#

モデルをONNX、TensorRT、CoreML、LiteRTなどの最適化フォーマットに変換して、エッジにデプロイします。 Deployのドキュメントを参照してください。

エクスポートを一覧表示#

GET /api/models/{owner}/{project}/{model}/exports

Python SDK: client.exports.list(owner, project, model)

クエリパラメーター：

エクスポートを作成#

POST /api/models/{owner}/{project}/{model}/exports

Python SDK: client.exports.create(owner, project, model, format=...)

curl -X POST \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"format": "onnx", "args": {"imgsz": 640, "quantize": 16}}' \
  https://platform.ultralytics.com/api/models/acme-vision/inspection/v3/exports

レスポンス（201）: id、format、status（queued または running）、gpuType、region。同等のエクスポートがすでに実行中の場合は 409 を返します。

サポートされているフォーマット:

下記の共通エクスポートテーブルにある format 引数を使用してください。PyTorchはソースフォーマットであり、APIエクスポートの対象ではありません。

nms=None は、外部 NMS の場合は生出力をデフォルトとします。nms=False を設定して利用可能な NMS なしのヘッドを選択します。サポートされていないフォーマットは、ネイティブ出力パスにフォールバックします。上記の nms エントリは、nms=True を使用して NMS を埋め込むことができるフォーマットを特定します。

エクスポートステータスを取得#

GET /api/models/{owner}/{project}/{model}/exports/{exportId}

Python SDK: client.exports.retrieve(owner, project, model, export_id)

status、format、args、gpuType、タイムスタンプを含む export オブジェクトを返します。完了すると、size、downloadUrl、downloadFilename を含む file オブジェクトも返します。

エクスポートをキャンセルまたは削除#

DELETE /api/models/{owner}/{project}/{model}/exports/{exportId}

Python SDK: client.exports.delete(owner, project, model, export_id)

アクティブなエクスポートをキャンセルするか、完了したエクスポートとそのファイルを削除します。レスポンスには実行された処理が示されます。

{
    "success": true,
    "action": "cancelled"
}

Deployments API#

ヘルスチェックとモニタリングを備えた専用推論エンドポイントにモデルをデプロイします。 Endpointsのドキュメントを参照してください。

graph LR
    A[Create]:::start --> B[Deploying]:::proc
    B --> C[Ready]:::out
    C -->|action stop| D[Stopped]:::extern
    C -->|action replace| B
    D -->|action start| C
    C -->|delete| E[Deleted]:::error
    D -->|delete| E
    C -->|predict| F[Inference Results]:::out

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff
    classDef error fill:#F44336,color:#fff
    classDef extern fill:#607D8B,color:#fff

デプロイメントを一覧表示#

GET /api/deployments/{owner}

Python SDK: client.deployments.list(owner)

クエリパラメーター：

匿名の呼び出し元は、1つのパブリックモデルでフィルタリングする必要があります。ワークスペース全体の一覧表示には認証が必要です。

デプロイメントを作成#

POST /api/deployments/{owner}

Python SDK: client.deployments.create(owner, project=..., model=..., deployment=..., name=..., region=...)

Body：

{
    "project": "inspection",
    "model": "v3",
    "deployment": "edge-1",
    "name": "Edge 1",
    "region": "us-central1"
}

レスポンス（201）: id、deployment、status（creating）、message、region。

デプロイメントを取得#

GET /api/deployments/{owner}/{deployment}

Python SDK: client.deployments.retrieve(owner, deployment)

status、statusMessage、region、serviceUrl、resources を含む deployment オブジェクトを返します。

デプロイメントを開始、停止、または置換#

PATCH /api/deployments/{owner}/{deployment}

Python SDK: client.deployments.update(owner, deployment, body=...)

単一の action フィールドで操作を選択します。

{ "action": "start" }

置換では、デプロイメントID、リージョン、エンドポイントURLを維持したまま新しいリビジョンをロールアウトします。ロールアウトに失敗した場合、既存のリビジョンは稼働し続けます。置換モデルは、完了済みで、キーからアクセスできる重みを持つモデルである必要があります。完了した操作は status および ready または stopped とともに 200 を返します。ロールアウト中の操作は deploying または stopping とともに 202 を返します。

デプロイメントを削除#

DELETE /api/deployments/{owner}/{deployment}

Python SDK: client.deployments.delete(owner, deployment)

推論エンドポイントを完全に削除します。

Health Check#

GET /api/deployments/{owner}/{deployment}/health

Python SDK: client.deployments.health(owner, deployment)

エンドポイントにPingを送信してウォームアップし、healthy、latencyMs、アップストリームの status コードを返します。

デプロイメントで推論を実行#

POST /api/deployments/{owner}/{deployment}/predict

Python SDK: client.deployments.predict(owner, deployment, body=...)

専用エンドポイントを介して画像または動画をルーティングします。リクエストとレスポンスのコントラクトは、model inferenceと一致します。

Multipart Form:

メトリクスを取得#

GET /api/deployments/{owner}/{deployment}/metrics

Python SDK: client.deployments.metrics(owner, deployment)

クエリパラメーター：

完全なレスポンスには、summary（リクエスト総数、エラー率、平均レイテンシ、p50/p95/p99レイテンシ）と timeSeries（リクエスト、エラー、レイテンシ、CPU、メモリ、インスタンス数）が含まれます。スパークラインレスポンスは requests24h、totalRequests、errorRate、avgLatencyMs を返します。

ログを取得#

GET /api/deployments/{owner}/{deployment}/logs

Python SDK: client.deployments.logs(owner, deployment)

クエリパラメーター：

Trash API#

論理削除されたプロジェクト、データセット、モデルを表示、復元、完全削除します。アイテムは30日後に自動的に消去されます。Trashのドキュメントを参照してください。

ゴミ箱の一覧表示#

GET /api/trash

Python SDK: client.lifecycle.trash()

クエリパラメーター：

レスポンスには、items（それぞれに daysRemaining を含む）、total、page、limit、totalPages、およびタイプ別の合計を含む summary が含まれます。

アイテムの復元#

POST /api/trash

Python SDK: client.lifecycle.restore(id=..., type=...)

{
    "id": "65f1c0a2b3d4e5f601234567",
    "type": "dataset"
}

プロジェクトを復元すると、そのプロジェクトとともにゴミ箱に移動されたモデルも復元され、restoredModels として報告されます。

完全削除#

DELETE /api/trash

Python SDK: client.lifecycle.delete_trash(body=...)

1つのアイテムを削除します。

{
    "id": "65f1c0a2b3d4e5f601234567",
    "type": "dataset"
}

または、ゴミ箱全体を空にします。

{
    "all": true
}

レスポンスには deletedCount と、該当する場合は cascadedModels および survivingDeployments が含まれます。

Upload API#

署名付きURLを使用して、ファイルをクラウドストレージに直接アップロードします。モデルのアップロードを完了するとその重みが関連付けられ、データセットアーカイブのアップロードを完了するとセッションが記録されます。その後、そのセッションをデータセット取り込みに渡します。Dataのドキュメントも参照してください。

署名付きアップロードURLを取得#

POST /api/upload/signed-url

Python SDK: client.upload.signed_url(body=...)

Body：

{
    "assetType": "datasets",
    "assetId": "65f1c0a2b3d4e5f601234567",
    "filename": "warehouse.zip",
    "contentType": "application/zip",
    "totalBytes": 52428800
}

レスポンス：

{
    "sessionId": "session_abc123",
    "uploadUrl": "https://storage.googleapis.com/...&signature=...",
    "expiresAt": "2026-02-22T12:00:00Z",
    "headers": { "x-goog-if-generation-match": "0" }
}

宣言した同じ Content-Type と headers で返されたすべてのヘッダーを使用して、PUT リクエストでファイルを uploadUrl にアップロードします。データセットのアップロードURLは12時間有効であり、作成専用です。同じURLへの2回目の PUT は 412 を返し、返されたヘッダーなしでの PUT は 400 を返します。

アップロードを完了#

POST /api/upload/complete

Python SDK: client.upload.complete(session_id=...)

{
    "sessionId": "session_abc123",
    "md5": "<optional md5 hex>"
}

レスポンス: success と、size および contentType を含む file オブジェクト。モデルの場合は重みが関連付けられ、データセットアーカイブの場合は、次に ingest を呼び出して処理を開始します。

md5 が提供された場合、保存されたオブジェクトと照合されます。不一致がある場合は 400 が返されます。まだ完了していないセッションでは、アップロードされたファイルも削除されてセッションが未完了のままになるため、新しい署名付きURLをリクエストして再度アップロードしてください。完了したデータセットセッションは、アーカイブが存在する間は再び完了させることができますが、ダイジェストが異なる競合する完了処理は 409 を返します。モデルセッションは完了時に削除されます。checksum はモデルファイルメタデータとして保存され、検証されません。

Storage Integrations API#

読み取り専用のGoogle Cloud Storage、Amazon S3、またはAzure Blob Storageアカウントを接続し、データセットソースとして参照します。 Integrationsのドキュメントを参照してください。

インテグレーション一覧#

GET /api/integrations/buckets

Python SDK: client.storage_integrations.list()

integrationsを返します。それぞれにid、provider、credentialIdentity、targets、createdAtが含まれます。認証情報は返されません。

ロケーションを検出#

POST /api/integrations/buckets/discover

Python SDK: client.storage_integrations.discover(body=...)

指定された認証情報で読み取り可能なバケットまたはコンテナを、保存せずに一覧表示します。

{
    "provider": "gcs",
    "credentials": {
        "client_email": "svc@project.iam.gserviceaccount.com",
        "private_key": "-----BEGIN PRIVATE KEY-----\n...",
        "project_id": "my-project"
    }
}

レスポンス： {"targets": ["my-bucket", "another-bucket"]}

ストレージを接続#

POST /api/integrations/buckets

Python SDK: client.storage_integrations.create(body=...)

検出と同じ認証情報の形式に加え、1～50個のバケット名またはコンテナ名を含む必須のtargets配列を指定します。保存されたインテグレーションを含む201を返します。一時的なS3認証情報（ASIAアクセスキー）は拒否されます。

オブジェクトを参照#

GET /api/integrations/buckets/{id}/objects

Python SDK: client.storage_integrations.objects(id, target=...)

クエリパラメーター：

entriesを返します（各kindはfolderまたはfileです）。次のページ用のオプションのcursorも返します。

ストレージを切断#

DELETE /api/integrations/buckets/{id}

Python SDK: client.storage_integrations.delete(id)

プロバイダーのデータを削除せずに、保存された認証情報を削除します。接続済みのデータセットは引き続き表示されますが、同じストレージアカウントを再接続するまで、ファイルは利用できません。ワークスペース管理者のアクセス権が必要です。

データセットインポート API#

サードパーティサービスからデータセットをインポートします。Roboflowインテグレーションを参照してください。

Roboflowインポートをプレビュー#

POST /api/integrations/roboflow/preview

Python SDK: client.datasets.preview_roboflow(api_key=...)

Roboflow APIキーをインポート計画に解決します。これには、ワークスペースの詳細、インポートされるnewDatasets、スキップ・非対応・解決不能なプロジェクトの件数、bytesTotal、およびstorageの残容量が含まれます。Roboflow APIキーはリクエストボディから読み取られ、永続化されません。

{
    "apiKey": "ROBOFLOW_API_KEY"
}

Roboflowからインポート#

POST /api/integrations/roboflow/import

Python SDK: client.datasets.import_roboflow(api_key=..., items=...)

プレビューで返された項目を使用して、選択した最大500件のRoboflowプロジェクトバージョンの取り込みジョブをキューに追加します。

{
    "apiKey": "ROBOFLOW_API_KEY",
    "items": [
        {
            "workspace": "my-workspace",
            "projectId": "warehouse-safety",
            "projectName": "Warehouse Safety",
            "projectType": "object-detection",
            "latestVersion": 4
        }
    ]
}

レスポンス（201）： imported、failed、skippedの配列です。インポートにはストレージの残容量が必要であり、各データセットはプランごとのインポートサイズ上限以内である必要があります。

アカウント API#

Platformアカウント、キー、ストレージ、公開プロフィールを確認します。設定ドキュメントを参照してください。

アカウント概要#

GET /api/account/summary

Python SDK: client.account.summary()

キーを発行したワークスペースのプラン、クレジット残高、リソース数を返します。

{
    "username": "acme-vision",
    "name": "Acme Vision",
    "accountType": "team",
    "plan": "pro",
    "creditsCents": 2500,
    "counts": { "projects": 4, "datasets": 7, "models": 21 },
    "teams": []
}

APIキー一覧#

GET /api/api-keys

Python SDK: client.account.api_keys()

キーのワークスペースに対するkeyId、name、keyPrefix、createdAtを含むkeysを返します。APIキーで認証されたリクエストにはメタデータのみが返されます。完全なキー値は、Platform UIのワークスペース所有者にSettings > API Keysで表示され、キーの作成と失効も同じ場所で行います。

ストレージ使用量を確認#

GET /api/storage

Python SDK: client.account.storage()

クエリパラメーター：

レスポンス：

{
    "tier": "pro",
    "usage": {
        "storage": { "current": 1073741824, "limit": 107374182400, "percent": 1.0 },
        "datasets": { "current": 536870912, "limit": 107374182400, "percent": 0.5 }
    },
    "breakdown": {
        "byCategory": {
            "datasets": { "bytes": 536870912, "count": 2 },
            "models": { "bytes": 268435456, "count": 4 },
            "exports": { "bytes": 268435456, "count": 3 }
        },
        "topItems": [
            {
                "_id": "65f1c0a2b3d4e5f601234567",
                "name": "Warehouse",
                "slug": "warehouse",
                "sizeBytes": 536870912,
                "type": "dataset"
            }
        ]
    },
    "region": "us",
    "username": "acme-vision",
    "updatedAt": "2026-01-15T10:00:00Z"
}

公開ユーザープロフィールを取得#

GET /api/users

Python SDK: client.account.profile(username=...)

クエリパラメーター：

公開userプロフィールを返します。followerCountも含まれ、認証済みの呼び出し元にはisFollowedも含まれます。

ユーザーをフォローまたはフォロー解除#

PATCH /api/users

Python SDK: client.account.follow(username=..., followed=...)

{
    "username": "target-user",
    "followed": true
}

レスポンス： followedと更新されたfollowerCountです。

Billing API#

プランの使用状況とクレジット台帳を確認します。Billingドキュメントを参照してください。

プランと使用状況を表示#

GET /api/billing/usage-summary

Python SDK: client.billing.usage_summary()

plan（ID、ステータス、請求サイクル、期間終了）、metrics（ストレージ上限と使用量）、trainingCredit、features、creditsCents、およびシート数を返します。

トランザクションを表示#

GET /api/billing/transactions

Python SDK: client.billing.transactions()

クエリパラメーター：

各トランザクションには、id、type（purchase、training、monthly_grant、refundなど）、amountCents、balanceAfter、createdAt、オプションのreceiptUrl、およびトレーニング料金のモデルコンテキストが含まれます。内部の請求詳細は返されません。

APIを探索#

コミュニティが共有している公開プロジェクトとデータセットを検索します。Exploreドキュメントを参照してください。

公開コンテンツを検索#

GET /api/explore/search

Python SDK: client.explore.search()

クエリパラメーター：

レスポンス： projects、datasets、hasMoreです。

curl "https://platform.ultralytics.com/api/explore/search?type=datasets&task=detect&sort=stars&limit=20"

Python SDK#

ultralytics-platformは、OpenAPIコントラクトから生成された型付きPythonクライアントです。エンドポイントごとに1つのメソッド（client.datasets.list、client.models.predict、client.exports.create、...）があります。各メソッドは、パスパラメーターを位置引数として、その他の入力をキーワード引数として受け取り、リクエストごとのオプションのtimeoutとextra_headersも受け取ります。

pip install "ultralytics-platform>=0.1.45" # Python 3.11+

from ultralytics_platform import Platform

with Platform() as client:  # reads ULTRALYTICS_API_KEY or the key saved by yolo login
    dataset = client.datasets.retrieve("acme-vision", "warehouse")
    images = client.datasets.images("acme-vision", "warehouse", limit=10)
    export = client.exports.create("acme-vision", "inspection", "v3", format="onnx")

AsyncPlatformはasync/awaitコード用に同じリソースツリーを公開します。失敗したレスポンスではstatus_code、body、解析済みのjsonを含むAPIErrorが送出され、接続失敗ではAPIConnectionErrorが送出されます。完全なREADMEについてはSDKリポジトリを参照してください。

Pythonインテグレーション#

トレーニングおよび推論のワークフローには、認証、アップロード、およびリアルタイムのメトリックストリーミングを自動的に処理する Ultralytics Python パッケージを使用します。Python 3.11+ では、pip install ultralytics は ultralytics-platform SDK もインストールします。model.train(project=...) が Platform を対象とする場合、トレーニングコールバックは SDK の client.training.metrics() を通じてイベントをストリーミングし、OpenAPI ドキュメント内の POST /api/webhooks/training/metrics および POST /api/webhooks/models/upload の操作である client.models.upload_checkpoint() を通じてチェックポイントのアップロード URL を要求するため、ご自身で呼び出す必要はありません。

インストールとセットアップ#

プラットフォーム統合には Python>=3.11 および ultralytics>=8.4.120 が必要です：

pip install "ultralytics>=8.4.120"

インストールを確認します。

yolo check

認証#

yolo login YOUR_API_KEY

Platform データセットの使用#

ul:// URIでデータセットを参照します。

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Train on your Platform dataset
model.train(
    data="ul://your-username/datasets/your-dataset",
    epochs=100,
    imgsz=640,
)

URI形式：

Platformへプッシュ#

結果をPlatformプロジェクトに送信します。

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Results automatically sync to Platform
model.train(
    data="coco8.yaml",
    epochs=100,
    project="your-username/my-project",
    name="experiment-1",
)

同期される内容：

• トレーニングメトリクス（リアルタイム）
• 最終モデルの重み
• 検証プロット
• コンソール出力
• システムメトリクス
• トレーニング引数とホスト環境（ホスト名、OS、Python、ハードウェア、git コミット、コマンドライン）

API例#

Platformからモデルをロード：

# Your own model
model = YOLO("ul://username/project/model-name")

# Official model
model = YOLO("ul://ultralytics/yolo26/yolo26n")

推論を実行：

results = model("image.jpg")

# Access results
for r in results:
    boxes = r.boxes  # Detection boxes
    masks = r.masks  # Segmentation masks
    keypoints = r.keypoints  # Pose keypoints
    probs = r.probs  # Classification probabilities

モデルをエクスポート：

# Export to ONNX
model.export(format="onnx", imgsz=640, quantize=16)

# Export to TensorRT
model.export(format="engine", imgsz=640, quantize=16)

# Export to CoreML
model.export(format="coreml", imgsz=640)  # use imgsz=224 for classification

検証：

metrics = model.val(data="ul://username/datasets/my-dataset")

print(f"mAP50: {metrics.box.map50}")
print(f"mAP50-95: {metrics.box.map}")

FAQ#