> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/deployment/ja/regash/legacy-serverless/instance-segmentation.md).

# インスタンスセグメンテーション

Roboflow でホストされているインスタンス分類モデルに対して推論を実行します。

{% tabs %}
{% tab title="cURL" %}
**Linux または MacOS**

という名前のローカルファイルのJSON予測を取得する `YOUR_IMAGE.jpg`:

```bash
base64 YOUR_IMAGE.jpg | curl -d @- \
-H "Authorization: Bearer YOUR_KEY" \
"https://serverless.roboflow.com/your-model/42"
```

ウェブ上の別の場所にホストされている画像をURL経由で推論する（忘れずに [URLエンコードしてください](https://www.urlencoder.org/)):

```bash
curl -X POST \
-H "Authorization: Bearer YOUR_KEY" \
"https://serverless.roboflow.com/your-model/42?\
image=https%3A%2F%2Fi.imgur.com%2FPEEvqPN.png"
```

**Windows**

インストールする必要があります [Windows版 curl](https://curl.se/windows/) と [GNUのWindows向けbase64ツール](http://gnuwin32.sourceforge.net/packages/coreutils.htm)。これを行う最も簡単な方法は、 [Windows向けGitインストーラー](https://git-scm.com/downloads) も含まれています `curl` と `base64` インストール時に「Use Git and optional Unix tools from the Command Prompt」を選択すると、コマンドラインツールも含まれます。

その後、上記と同じコマンドを使用できます。
{% endtab %}

{% tab title="Python" %}
**ローカル画像とホスト画像を推論する**

依存関係をインストールするには、 `pip install inference-sdk`.

```
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

CLIENT = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key="API_KEY"
).configure(InferenceConfiguration(api_key_transport="header"))

result = CLIENT.infer(your_image.jpg, model_id="football-pitch-segmentation/1")

```

{% endtab %}

{% tab title="JavaScript" %}
**Node.js**

これらの例では組み込みの `fetch` APIを使用します。これはNode.js 18以降と最新のブラウザで動作するため、インストールする依存関係はありません。

**ローカル画像を推論する**

```javascript
const fs = require("fs");

const image = fs.readFileSync("YOUR_IMAGE.jpg", {
    encoding: "base64"
});

fetch("https://serverless.roboflow.com/your-model/42", {
    method: "POST",
    headers: {
        "Authorization": "Bearer YOUR_KEY",
        "Content-Type": "application/x-www-form-urlencoded"
    },
    body: image
})
    .then((response) => {
        if (!response.ok) throw new Error("Request failed with status " + response.status);
        return response.json();
    })
    .then((data) => {
        console.log(data);
    })
    .catch((error) => {
        console.log(error.message);
    });
```

**URL経由で他の場所にホストされた画像を推論する**

```javascript
fetch(
    "https://serverless.roboflow.com/your-model/42?image=" +
        encodeURIComponent("https://i.imgur.com/PEEvqPN.png"),
    {
        method: "POST",
        headers: {
            "Authorization": "Bearer YOUR_KEY"
        }
    }
)
    .then((response) => {
        if (!response.ok) throw new Error("Request failed with status " + response.status);
        return response.json();
    })
    .then((data) => {
        console.log(data);
    })
    .catch((error) => {
        console.log(error.message);
    });
```

**Web**

roboflow\.js を使用したリアルタイムのオンデバイス推論が利用できます `roboflow.js`；詳細は [こちらのドキュメントをご覧ください](/deployment/ja/self-hosted/sdks/web-browser.md).
{% endtab %}

{% tab title="Swift/iOS" %}
**Swift**

**ローカル画像を推論する**

```swift
import UIKit

// 画像を読み込み、Base64に変換
let image = UIImage(named: "your-image-path") // アップロードする画像のパス 例: image.jpg
let imageData = image?.jpegData(compressionQuality: 1)
let fileContent = imageData?.base64EncodedString()
let postData = fileContent!.data(using: .utf8)

// API_KEY、モデル、モデルバージョンを使用して推論サーバーリクエストを初期化
var request = URLRequest(url: URL(string: "https://serverless.roboflow.com/your-model/your-model-version?name=YOUR_IMAGE.jpg")!,timeoutInterval: Double.infinity)
request.setValue("Bearer YOUR_APIKEY", forHTTPHeaderField: "Authorization")
request.addValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
request.httpMethod = "POST"
request.httpBody = postData

// POSTリクエストを実行
URLSession.shared.dataTask(with: request, completionHandler: { data, response, error in
    
    // レスポンスを文字列に変換
    guard let data = data else {
        print(String(describing: error))
        return
    }
    
    // レスポンス文字列を辞書に変換
    do {
        let dict = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
    } catch {
        print(error.localizedDescription)
    }
    
    // 文字列レスポンスを出力
    print(String(data: data, encoding: .utf8)!)
}).resume()
```

**Objective-C**

[Objective-Cのスニペットをリクエストするにはここをクリックしてください。](https://app.roboflow.com/request/snippet.inference-objc)
{% endtab %}

{% tab title="Android" %}
**Kotlin**

**ローカル画像を推論する**

```kotlin
import java.io.*
import java.net.HttpURLConnection
import java.net.URL
import java.nio.charset.StandardCharsets
import java.util.*

fun main() {
    // 画像パスを取得
    val filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg"
    val file = File(filePath)

    // Base64エンコード
    val encodedFile: String
    val fileInputStreamReader = FileInputStream(file)
    val bytes = ByteArray(file.length().toInt())
    fileInputStreamReader.read(bytes)
    encodedFile = String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII)
    val API_KEY = "" // APIキー
    val MODEL_ENDPOINT = "dataset/v" // モデルエンドポイントを設定（Dataset URL内にあります）

    // URLを構築
    val uploadURL ="https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?name=YOUR_IMAGE.jpg";

    // HTTPリクエスト
    var connection: HttpURLConnection? = null
    try {
        // URLへの接続を設定
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type",
                "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length",
                Integer.toString(encodedFile.toByteArray().size))
        connection.setRequestProperty("Authorization", "Bearer " + API_KEY)
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // リクエスト送信
        val wr = DataOutputStream(
                connection.outputStream)
        wr.writeBytes(encodedFile)
        wr.close()

        // レスポンス取得
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}
main()
```

**URL経由で他の場所にホストされた画像を推論する**

```kotlin
import java.io.BufferedReader
import java.io.DataOutputStream
import java.io.InputStreamReader
import java.net.HttpURLConnection
import java.net.URL
import java.net.URLEncoder

fun main() {
    String imageURL = "https://i.imgur.com/PEEvqPN.png"; // 画像URLを置き換えてください
    val API_KEY = "" // APIキー
    String MODEL_ENDPOINT = "dataset/v"; // モデルエンドポイントを設定

    // アップロードURL
    val uploadURL = "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?image=" + URLEncoder.encode(imageURL, "utf-8");

    // HTTPリクエスト
    var connection: HttpURLConnection? = null
    try {
        // URLへの接続を設定
        val url = URL(uploadURL)
        connection = url.openConnection() as HttpURLConnection
        connection.requestMethod = "POST"
        connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
        connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.toByteArray().size))
        connection.setRequestProperty("Authorization", "Bearer " + API_KEY)
        connection.setRequestProperty("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

        // リクエスト送信
        val wr = DataOutputStream(connection.outputStream)
        wr.writeBytes(uploadURL)
        wr.close()

        // レスポンス取得
        val stream = connection.inputStream
        val reader = BufferedReader(InputStreamReader(stream))
        var line: String?
        while (reader.readLine().also { line = it } != null) {
            println(line)
        }
        reader.close()
    } catch (e: Exception) {
        e.printStackTrace()
    } finally {
        connection?.disconnect()
    }
}

main()
```

**Java**

**ローカル画像を推論する**

```java
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class InferenceLocal {
    public static void main(String[] args) throws IOException {
        // 画像パスを取得
        String filePath = System.getProperty("user.dir") + System.getProperty("file.separator") + "YOUR_IMAGE.jpg";
        File file = new File(filePath);

        // Base64エンコード
        String encodedFile;
        FileInputStream fileInputStreamReader = new FileInputStream(file);
        byte[] bytes = new byte[(int) file.length()];
        fileInputStreamReader.read(bytes);
        encodedFile = new String(Base64.getEncoder().encode(bytes), StandardCharsets.US_ASCII);

        String API_KEY = ""; // APIキー
        String MODEL_ENDPOINT = "dataset/v"; // モデルエンドポイント

        // URLを構築
        String uploadURL = "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?name=YOUR_IMAGE.jpg";

        // HTTPリクエスト
        HttpURLConnection connection = null;
        try {
            // URLへの接続を設定
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            connection.setRequestProperty("Content-Length", Integer.toString(encodedFile.getBytes().length));
            connection.setRequestProperty("Authorization", "Bearer " + API_KEY);
            connection.setRequestProperty("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

            // リクエスト送信
            DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
            wr.writeBytes(encodedFile);
            wr.close();

            // レスポンス取得
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }

    }

}
```

**URL経由で他の場所にホストされた画像を推論する**

```java
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class InferenceHosted {
    public static void main(String[] args) {
        String imageURL = "https://i.imgur.com/PEEvqPN.png"; // 画像URLを置き換えてください
        String API_KEY = ""; // APIキー
        String MODEL_ENDPOINT = "dataset/v"; // モデルエンドポイント

        // アップロードURL
        String uploadURL = "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?image="
                + URLEncoder.encode(imageURL, StandardCharsets.UTF_8);

        // HTTPリクエスト
        HttpURLConnection connection = null;
        try {
            // URLへの接続を設定
            URL url = new URL(uploadURL);
            connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

            connection.setRequestProperty("Content-Length", Integer.toString(uploadURL.getBytes().length));
            connection.setRequestProperty("Authorization", "Bearer " + API_KEY);
            connection.setRequestProperty("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

            // リクエスト送信
            DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
            wr.writeBytes(uploadURL);
            wr.close();

            // レスポンス取得
            InputStream stream = connection.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.disconnect();
            }
        }
    }
}
```

{% endtab %}

{% tab title="Ruby" %}
**Gemfile**

{% code title="Gemfile" %}

```ruby
source "https://rubygems.org"

gem "httparty", "~> 0.18.1"
gem "base64", "~> 0.1.0"
gem "cgi", "~> 0.2.1"
```

{% endcode %}

**Gemfile.lock**

{% code title="Gemfile.lock" %}

```ruby
GEM
  リモート: https://rubygems.org/
  仕様:
    base64 (0.1.0)
    cgi (0.2.1)
    httparty (0.18.1)
      mime-types (~> 3.0)
      multi_xml (>= 0.5.2)
    mime-types (3.3.1)
      mime-types-data (~> 3.2015)
    mime-types-data (3.2021.0225)
    multi_xml (0.6.0)

プラットフォーム
  x64-mingw32
  x86_64-linux

依存関係
  base64 (~> 0.1.0)
  cgi (~> 0.2.1)
  httparty (~> 0.18.1)

同梱バージョン
   2.2.15
```

{% endcode %}

**ローカル画像を推論する**

```ruby
require 'base64'
require 'httparty'

encoded = Base64.encode64(File.open("YOUR_IMAGE.jpg", "rb").read)
model_endpoint = "dataset/v" # モデルエンドポイントを設定
api_key = "" # APIキーはこちら

params = "?name=YOUR_IMAGE.jpg"

response = HTTParty.post(
    "https://serverless.roboflow.com/" + model_endpoint + params,
    body: encoded, 
    headers: {
    'Authorization' => "Bearer " + api_key,
    'Content-Type' => 'application/x-www-form-urlencoded',
    'charset' => 'utf-8'
  })

  puts response

 
```

**URL経由で他の場所にホストされた画像を推論する**

```ruby
require 'httparty'
require 'cgi'

model_endpoint = "dataset/v" # モデルエンドポイントを設定
api_key = "" # APIキーはこちら
img_url = "https://i.imgur.com/PEEvqPN.png" # URLを構築

img_url = CGI::escape(img_url)

params =  "?image=" + img_url

response = HTTParty.post(
    "https://serverless.roboflow.com/" + model_endpoint + params,
    headers: {
    'Authorization' => "Bearer " + api_key,
    'Content-Type' => 'application/x-www-form-urlencoded',
    'charset' => 'utf-8'
  })

puts response
```

{% endtab %}

{% tab title="PHP" %}
**ローカル画像を推論する**

```php
<?php

// 画像をBase64エンコード
$data = base64_encode(file_get_contents("YOUR_IMAGE.jpg"));

$api_key = ""; // APIキーを設定
$model_endpoint = "dataset/v"; // モデルエンドポイントを設定（Dataset URL内にあります）

// HTTPリクエスト用URL
$url = "https://serverless.roboflow.com/" . $model_endpoint
. "?name=YOUR_IMAGE.jpg";

// HTTPリクエストを設定して送信
$options = array(
  'http' => array (
    'header' => "Content-type: application/x-www-form-urlencoded\r\n"
              . "Authorization: Bearer " . $api_key . "\r\n",
    'method'  => 'POST',
    'content' => $data
  ));

$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;
?>
```

**URL経由で他の場所にホストされた画像を推論する**

```php
<?php

$api_key = ""; // APIキーを設定
$model_endpoint = "dataset/v"; // モデルエンドポイントを設定（Dataset URL内にあります）
$img_url = "https://i.imgur.com/PEEvqPN.png";

// HTTPリクエスト用URL
$url =  "https://serverless.roboflow.com/" . $model_endpoint
. "?image=" . urlencode($img_url);

// HTTPリクエストを設定して送信
$options = array(
  'http' => array (
    'header' => "Content-type: application/x-www-form-urlencoded\r\n"
              . "Authorization: Bearer " . $api_key . "\r\n",
    'method'  => 'POST'
  ));

$context  = stream_context_create($options);
$result = file_get_contents($url, false, $context);
echo $result;
?>
```

{% endtab %}

{% tab title="Go" %}
**ローカル画像を推論する**

```go
package main

import (
    "bufio"
    "encoding/base64"
    "fmt"
    "io/ioutil"
    "os"
	"net/http"
	"strings"
)

func main() {
	api_key := ""  // APIキー
	model_endpoint := "dataset/v" // モデルエンドポイントを設定

    // ディスク上のファイルを開く。
    f, _ := os.Open("YOUR_IMAGE.jpg")

    // JPG全体をバイトスライスに読み込む。
    reader := bufio.NewReader(f)
    content, _ := ioutil.ReadAll(reader)

    // base64 としてエンコードします。
    data := base64.StdEncoding.EncodeToString(content)
	uploadURL := "https://serverless.roboflow.com/" + model_endpoint + "?name=YOUR_IMAGE.jpg"

	req, _ := http.NewRequest("POST", uploadURL, strings.NewReader(data))
    req.Header.Set("Authorization", "Bearer "+api_key)
    req.Header.Set("Accept", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

   	bytes, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(bytes))

}
```

**URL経由で他の場所にホストされた画像を推論する**

```go
package main

import (
    "fmt"
	"net/http"
	"net/url"
  "io/ioutil"
)

func main() {
	api_key := ""  // APIキー
	model_endpoint := "dataset/v" // モデルエンドポイントを設定
	img_url := "https://i.ibb.co/jzr27x0/YOUR-IMAGE.jpg"


	uploadURL := "https://serverless.roboflow.com/" + model_endpoint + "?image=" + url.QueryEscape(img_url)

	req, _ := http.NewRequest("POST", uploadURL, nil)
    req.Header.Set("Authorization", "Bearer "+api_key)
    req.Header.Set("Accept", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

   	bytes, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(bytes))


}
```

{% endtab %}

{% tab title=" .NET" %}
**ローカル画像を推論する**

```csharp
using System;
using System.IO;
using System.Net;
using System.Text;

namespace InferenceLocal
{
    class InferenceLocal
    {

        static void Main(string[] args)
        {
            byte[] imageArray = System.IO.File.ReadAllBytes(@"YOUR_IMAGE.jpg");
            string encoded = Convert.ToBase64String(imageArray);
            byte[] data = Encoding.ASCII.GetBytes(encoded);
            string API_KEY = ""; // API キー
            string MODEL_ENDPOINT = "dataset/v"; // モデルエンドポイントを設定

            // URLを構築
            string uploadURL =
                    "https://serverless.roboflow.com/" + MODEL_ENDPOINT + "?name=YOUR_IMAGE.jpg";

            // サービス要求の設定
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

            // リクエストの構成
            WebRequest request = WebRequest.Create(uploadURL);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.Headers.Add("Authorization", "Bearer " + API_KEY);
            request.ContentLength = data.Length;

            // データを書き込む
            using (Stream stream = request.GetRequestStream())
            {
                stream.Write(data, 0, data.Length);
            }

            // レスポンス取得
            string responseContent = null;
            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    using (StreamReader sr99 = new StreamReader(stream))
                    {
                        responseContent = sr99.ReadToEnd();
                    }
                }
            }

            Console.WriteLine(responseContent);

        }
    }
}
```

**URL経由で他の場所にホストされた画像を推論する**

```csharp
using System;
using System.IO;
using System.Net;
using System.Web;

namespace InferenceHosted
{
    class InferenceHosted
    {
        static void Main(string[] args)
        {
            string API_KEY = ""; // API キー
            string imageURL = "https://i.ibb.co/jzr27x0/YOUR-IMAGE.jpg";
            string MODEL_ENDPOINT = "dataset/v"; // モデルエンドポイントを設定

            // URLを構築
            string uploadURL =
                    "https://serverless.roboflow.com/" + MODEL_ENDPOINT
                    + "?image=" + HttpUtility.UrlEncode(imageURL);

            // サービスポイントの設定
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;

            // HTTP リクエストの構成
            WebRequest request = WebRequest.Create(uploadURL);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
            request.Headers.Add("Authorization", "Bearer " + API_KEY);
            request.ContentLength = 0;

            // レスポンス取得
            string responseContent = null;
            using (WebResponse response = request.GetResponse())
            {
                using (Stream stream = response.GetResponseStream())
                {
                    using (StreamReader sr99 = new StreamReader(stream))
                    {
                        responseContent = sr99.ReadToEnd();
                    }
                }
            }

            Console.WriteLine(responseContent);

        }
    }
}
```

{% endtab %}

{% tab title="Elixir" %}
ユーザーから要求があったコードスニペットを追加しています。推論 API を Elixir アプリに統合したい場合は、 [こちらをクリックして投票を記録してください](https://app.roboflow.com/request/snippet.upload-elixir).
{% endtab %}
{% endtabs %}

## レスポンスオブジェクトの形式

ホストされた API の推論ルートは、 `JSON` 予測の配列を含むオブジェクトを返します。各予測には次のプロパティがあります:

* `x` = 検出されたオブジェクトの水平方向の中心点
* `y` = 検出されたオブジェクトの垂直方向の中心点
* `width` = バウンディングボックスの幅
* `height` = バウンディングボックスの高さ
* `class` = 検出されたオブジェクトのクラスラベル
* `confidence` = 検出されたオブジェクトに正しいラベルと位置座標があるというモデルの信頼度
* `points` = オブジェクトのポリゴン輪郭を構成する点のリスト - リスト内の各項目は、キーを持つオブジェクトです `x` と `y` それぞれ点の水平方向および垂直方向の座標

```json
// JSON オブジェクトの例
{
  "predictions": [
    {
      "x": 179.2,
      "y": 247,
      "width": 231,
      "height": 147,
      "class": "A",
      "confidence": 0.98,
      "points": [
        {
          "x": 134,
          "y": 314
        },
        {
          "x": 116,
          "y": 313
        },
        {
          "x": 103,
          "y": 310.1
        },
        {
          "x": 72.7,
          "y": 282
        },
        {
          "x": 66.8,
          "y": 273
        },
      ]
    }
  ]
}
```

## API リファレンス

## Inference API の使用

<mark style="color:緑;">`POST`</mark> `https://serverless.roboflow.com/:datasetSlug/:versionNumber`

base64 でエンコードした画像を直接モデルエンドポイントに POST できます。あるいは、URL を `image` クエリ文字列のパラメータとして渡せます。画像がすでに別の場所でホストされている場合は、

#### パスパラメータ

| 名前          | 型      | 説明                                                                                                                          |
| ----------- | ------ | --------------------------------------------------------------------------------------------------------------------------- |
| datasetSlug | string | データセット名の URL セーフ版です。Web UI では、メインのプロジェクト画面の URL を見るか、モデルの学習後にデータセットのバージョンの学習結果セクションにある「Get curl command」ボタンをクリックすると見つけられます。 |
| version     | number | データセットのバージョンを識別するバージョン番号                                                                                                    |

#### クエリパラメータ

| 名前         | 型      | 説明                                                                                                                                             |
| ---------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| image      | string | <p>追加する画像の URL。画像が別の場所でホストされている場合に使用します。（リクエスト本文で base64 エンコードされた画像を POST しない場合は必須です。）<br><br><strong>注:</strong> URL エンコードするのを忘れないでください。</p>  |
| overlap    | number | <p>同じクラスのバウンディングボックス予測どうしが単一のボックスに結合される前に重なってよい最大割合（0〜100 のスケール）です。<br><br><strong>デフォルト:</strong> 30<br><br>このパラメータは RF-DETR モデルには影響しません。</p> |
| confidence | number | <p>0〜100 のスケールでの返される予測のしきい値です。数値が低いほど、返される予測は多くなります。数値が高いほど、高確度の予測は少なくなります。<br><br><strong>デフォルト:</strong> 40</p>                              |
| api\_key   | string | API キー（ワークスペースの API 設定ページで取得）                                                                                                                  |

#### リクエストボディ

| 名前 | 型      | 説明                                                 |
| -- | ------ | -------------------------------------------------- |
|    | string | base64 エンコードされた画像。（クエリパラメータで画像の URL を渡さない場合は必須です。） |

{% tabs %}
{% tab title="200 件の JSON 形式の予測。(x,y) はボックスの" %}

```
{
    "predictions": [{
        "x": 234.0,
        "y": 363.5,
        "width": 160,
        "height": 197,
        "class": "hand",
        "confidence": 0.943
    }, {
        "x": 504.5,
        "y": 363.0,
        "width": 215,
        "height": 172,
        "class": "hand",
        "confidence": 0.917
    }, {
        "x": 1112.5,
        "y": 691.0,
        "width": 139,
        "height": 52,
        "class": "hand",
        "confidence": 0.87
    }, {
        "x": 78.5,
        "y": 700.0,
        "width": 139,
        "height": 34,
        "class": "hand",
        "confidence": 0.404
    }]
}
```

{% endtab %}

{% tab title="403 api\_key がモデルにアクセスする権限を持っていない場合。" %}

```
{
    "Message": "このリソースにアクセスする権限がありません"
}
```

{% endtab %}
{% endtabs %}