物体検出（Object Detection）

Roboflow でホストされている物体検出モデルで推論を実行します。

Roboflow Hosted API を使用して物体検出推論を実行する方法はいくつかあります。さまざまな SDK のいずれかを使用するか、ホストされたエンドポイントに REST リクエストを送信できます。

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

# inference-sdk をインポートする
from inference_sdk import InferenceHTTPClient

CLIENT = InferenceHTTPClient(
    api_url="https://detect.roboflow.com",
    api_key="API_KEY"
)

result = CLIENT.infer(your_image.jpg, model_id="football-players-detection-3zvbc/12")

Linux または MacOS

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

base64 YOUR_IMAGE.jpg | curl -d @- \
"https://detect.roboflow.com/your-model/42?api_key=YOUR_KEY"

URL を介してウェブ上にホストされている画像で推論する（以下を忘れずに URL エンコードする):

curl -X POST "https://detect.roboflow.com/your-model/42?\
api_key=YOUR_KEY&\
image=https%3A%2F%2Fi.imgur.com%2FPEEvqPN.png"

Windows

次をインストールする必要があります Windows 用 curl および Windows 用 GNU の base64 ツール。これを行う最も簡単な方法は git for Windows インストーラーを使用することです（これには curl および base64 が含まれます）。インストール時に「Use Git and optional Unix tools from the Command Prompt」を選択すると、コマンドラインツールも含まれます。

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

Node.js

この例では axios を POST リクエストの実行に使用しているので、まず npm install axios で依存関係をインストールしてください。

ローカル画像での推論

const axios = require("axios");
const fs = require("fs");

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

axios({
    method: "POST",
    url: "https://detect.roboflow.com/your-model/42",
    params: {
        api_key: "YOUR_KEY"
    },
    data: image,
    headers: {
        "Content-Type": "application/x-www-form-urlencoded"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});

URL 経由で別の場所にホストされている画像での推論

const axios = require("axios");

axios({
    method: "POST",
    url: "https://detect.roboflow.com/your-model/42",
    params: {
        api_key: "YOUR_KEY",
        image: "https://i.imgur.com/PEEvqPN.png"
    }
})
.then(function(response) {
    console.log(response.data);
})
.catch(function(error) {
    console.log(error.message);
});

Web

リアルタイムのオンデバイス推論は roboflow.jsで利用できます；詳細はこちらのドキュメントを参照してください.

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://detect.roboflow.com/your-model/your-model-version?api_key=YOUR_APIKEY&name=YOUR_IMAGE.jpg")!,timeoutInterval: Double.infinity)
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 のスニペットをリクエストするにはここをクリックしてください。

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://detect.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&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("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 経由で別の場所にホストされている画像での推論

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() {
    val imageURL = "https://i.imgur.com/PEEvqPN.png" // 画像 URL を置き換えてください
    val API_KEY = "" // あなたの API キー
    val MODEL_ENDPOINT = "dataset/v" // モデルエンドポイントを設定

    // アップロード用 URL
    val uploadURL = "https://detect.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&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("Content-Language", "en-US")
        connection.useCaches = false
        connection.doOutput = true

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

        // レスポンスを取得
        val stream = URL(uploadURL).openStream()
        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

ローカル画像での推論

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://detect.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY
                + "&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("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 経由で別の場所にホストされている画像での推論

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://detect.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY + "&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("Content-Language", "en-US");
            connection.setUseCaches(false);
            connection.setDoOutput(true);

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

            // レスポンスを取得
            InputStream stream = new URL(uploadURL).openStream();
            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();
            }
        }
    }
}

Gemfile

Gemfile

source "https://rubygems.org"

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

Gemfile.lock

Gemfile.lock

GEM
  remote: https://rubygems.org/
  specs:
    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)

PLATFORMS
  x64-mingw32
  x86_64-linux

DEPENDENCIES
  base64 (~> 0.1.0)
  cgi (~> 0.2.1)
  httparty (~> 0.18.1)

BUNDLED WITH
   2.2.15

ローカル画像での推論

require 'base64'
require 'httparty'

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

params = "?api_key=" + api_key
+ "&name=YOUR_IMAGE.jpg"

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

  puts response

URL 経由で別の場所にホストされている画像での推論

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 =  "?api_key=" + api_key + "&image=" + img_url

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

puts response

ローカル画像での推論

<?php

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

$api_key = ""; // API キーを設定
$model_endpoint = "dataset/v"; // モデルエンドポイントを設定（Dataset URL で確認）

// HTTP リクエストの URL
$url = "https://detect.roboflow.com/" . $model_endpoint
. "?api_key=" . $api_key
. "&name=YOUR_IMAGE.jpg";

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

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

URL 経由で別の場所にホストされている画像での推論

<?php

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

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

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

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

ローカル画像での推論

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://detect.roboflow.com/" + model_endpoint + "?api_key=" + api_key + "&name=YOUR_IMAGE.jpg"

	req, _ := http.NewRequest("POST", uploadURL, strings.NewReader(data))
    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 経由で別の場所にホストされている画像での推論

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://detect.roboflow.com/" + model_endpoint + "?api_key=" + api_key + "&image=" + url.QueryEscape(img_url)

	req, _ := http.NewRequest("POST", uploadURL, nil)
    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))


}

ローカル画像での推論

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://detect.roboflow.com/" + MODEL_ENDPOINT + "?api_key=" + API_KEY
                + "&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.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 経由で別の場所にホストされている画像での推論

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://detect.roboflow.com/" + MODEL_ENDPOINT
                    + "?api_key=" + API_KEY
                    + "&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.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);

        }
    }
}

APIリファレンス

URL

POST https://detect.roboflow.com/:projectId/:versionNumber

名前

タイプ

説明

projectId

string

データセット名の URL セーフなバージョン。これは、Web UI のメインプロジェクトビューの URL を見るか、モデルをトレーニングした後のデータセットバージョンのトレイン結果セクションにある「Get curl command」ボタンをクリックして確認できます。

version

number

データセットのバージョンを識別するバージョン番号

プロジェクト ID とバージョン番号の取得方法を見るここ.

Hosted Inference API に画像を REST リクエストで送信する方法は 2 つあります：

添付する base64 エンコードされた画像を POST リクエストボディに
画像ファイルの URL を image URL クエリで送信する
- 例： https://detect.roboflow.com/:datasetSlug/:versionNumber?image=https://imageurl.com

Query Parameters

名前

タイプ

説明

image

string

追加する画像の URL。画像が別の場所にホストされている場合に使用します。（リクエストボディで base64 エンコードされた画像を POST しない場合は必須。） 注意： URL エンコードするのを忘れないでください。

classes

string

予測を特定のクラスのものに制限します。カンマ区切りの文字列で指定してください。例： dog,cat デフォルト： 指定なし（すべてのクラスを表示）

overlap

number

同一クラスのバウンディングボックス予測が結合されて単一のボックスになる前に許容される最大重なり率（0〜100 の尺度）。

デフォルト： 30

confidence

number

返される予測の閾値（0〜100 の尺度）。低い数値ほど多くの予測を返します。高い数値ほど確信度の高い予測のみを返します。

デフォルト： 40

stroke

number

予測周りに表示されるバウンディングボックスの幅（ピクセル単位）（効果があるのは format が image).

デフォルト： 1

labels

boolean

予測にテキストラベルを表示するかどうか（効果があるのは format が image).

デフォルト： false

format

string

オプション：

json: JSON の予測配列を返します。（レスポンス形式タブを参照）
image: 注釈付き予測を含む画像をバイナリブロブとして返します。その Content-Type は image/jpeg.

デフォルト: json

api_key

string

あなたの API キー（ワークスペースの API 設定ページから取得）

Request Body

タイプ

説明

string

Base64 エンコードされた画像。（クエリパラメータで画像 URL を渡さない場合は必須。）

コンテンツタイプは次の形式である必要があります application/x-www-form-urlencoded 文字列のボディで。

レスポンス形式

ホストされた API 推論エンドポイントとほとんどの SDK は、次のような JSON 配列 predictions を含むオブジェクトを返します。各 prediction は以下のプロパティを持ちます：

x = 検出されたオブジェクトの水平中心点
y = 検出されたオブジェクトの垂直中心点
width = バウンディングボックスの幅
height = バウンディングボックスの高さ
class = 検出されたオブジェクトのクラスラベル
confidence = 検出されたオブジェクトが正しいラベルと位置座標であるというモデルの確信度

以下は REST API からのサンプルレスポンスオブジェクトです：

{
    "predictions": [
        {
            "x": 189.5,
            "y": 100,
            "width": 163,
            "height": 186,
            "class": "helmet",
            "confidence": 0.544
        }
    ],
    "image": {
        "width": 2048,
        "height": 1371
    }
}

The image attribute は推論に送信した画像の高さと幅を含みます。バウンディングボックスの計算でこれらの値を使用する必要がある場合があります。

Inference API の JSON 出力からボックスを描画する

バウンディングボックスを描画するためのフレームワークやパッケージは位置表現が異なる場合があります。レスポンス JSON オブジェクトのプロパティを考慮すると、次のルールの組み合わせを使って常にバウンディングボックスを描画できます：

中心点は常に (x,y)
コーナーポイント (x1, y1) および (x2, y2) は次のように求められます：
- x1 = x - (width/2)
- y1 = y - (height/2)
- x2 = x + (width/2)
- y2 = y + (height/2)

コーナーポイント方式は一般的なパターンで、例えば以下のようなライブラリで見られます： Pillow を使って box オブジェクトを構築し、Image 内にバウンディングボックスをレンダリングします Image.

検出結果を扱う際は、見つかったすべての検出を反復処理することを忘れないでください predictions!

# Pillow ライブラリのボックスオブジェクトの例
for bounding_box in detections:
    x1 = bounding_box['x'] - bounding_box['width'] / 2
    x2 = bounding_box['x'] + bounding_box['width'] / 2
    y1 = bounding_box['y'] - bounding_box['height'] / 2
    y2 = bounding_box['y'] + bounding_box['height'] / 2
    box = (x1, x2, y1, y2)

Last updated 1 year ago

Was this helpful?

hashtagAPIリファレンス

hashtagURL

hashtagQuery Parameters

hashtagRequest Body

hashtagレスポンス形式

hashtagInference API の JSON 出力からボックスを描画する

APIリファレンス

URL

Query Parameters

Request Body

レスポンス形式

Inference API の JSON 出力からボックスを描画する