키포인트 감지

Roboflow에 호스팅된 객체 감지 모델에서 추론을 실행하세요.

Python

Python을 사용하여 호스팅된 API를 통해 추론을 실행하려면, 다음을 사용하세요. roboflow Python 패키지:

from roboflow import Roboflow
rf = Roboflow(api_key="API_KEY")
project = rf.workspace().project("MODEL_ENDPOINT")
model = project.version(VERSION).model

# 로컬 이미지에서 추론
print(model.predict("your_image.jpg", confidence=40, overlap=30).json())

# 예측 시각화
# model.predict("your_image.jpg", confidence=40, overlap=30).save("prediction.jpg")

# 외부에 호스팅된 이미지에서 추론
# print(model.predict("URL_OF_YOUR_IMAGE", hosted=True, confidence=40, overlap=30).json())

cURL

Linux 또는 MacOS

로컬 파일 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 도구입니다. 가장 쉬운 방법은 Windows용 git 설치 프로그램을 사용하는 것입니다 여기에는 curl 와 base64 설치 중 "Use Git and optional Unix tools from the Command Prompt"를 선택하면 명령줄 도구도 포함됩니다.

그런 다음 위와 동일한 명령어를 사용할 수 있습니다.

Javascript

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/iOS

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, 모델, 모델 버전으로 Inference 서버 요청 초기화
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 코드 스니펫을 요청하려면 여기를 클릭하세요.

Android

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)

    // Base 64 인코딩
    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);

        // Base 64 인코딩
        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();
            }
        }
    }
}

Ruby

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

로컬 이미지로 추론하기

<?php

// 이미지 Base 64 인코딩
$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;
?>

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://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))


}

.NET

로컬 이미지로 추론하기

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);

        }
    }
}

Elixir

사용자 요청에 따라 코드 스니펫을 추가하고 있습니다. inference API를 Elixir 앱에 통합하고 싶으시면, 여기를 클릭하여 투표를 기록하세요.

응답 객체 형식

호스팅된 API 추론 경로는 JSON 예측 배열이 포함된 객체를 반환합니다. 각 예측에는 다음 속성이 있습니다:

• x = 감지된 객체의 수평 중심점

• y = 감지된 객체의 수직 중심점

• width = 바운딩 박스의 너비

• height = 바운딩 박스의 높이

• class = 감지된 객체의 클래스 라벨

• confidence = 감지된 객체가 올바른 라벨과 위치 좌표를 가질 확률에 대한 모델의 신뢰도

• keypoints = 키포인트 예측 배열

  • x = 키포인트의 수평 중심 (이미지 좌상단 기준)

  • y = 키포인트의 수직 중심 (이미지 좌상단 기준)

  • class_name = 키포인트 이름

  • class_id = 키포인트의 id, skeleton에 매핑됨 vertices 버전 레코드에서, 버텍스 색상과 skeleton 엣지를 매핑하려면, Project Version 보기

  • confidence = 키포인트가 올바른 위치에 있고, 보이는지(가려지거나 삭제되지 않음)에 대한 신뢰도

REST API의 예시 응답 객체는 다음과 같습니다:

{
    "predictions": [
        {
            "x": 189.5,
            "y": 100,
            "width": 163,
            "height": 186,
            "class": "helmet",
            "confidence": 0.544,
            "keypoints": [
                {
                    "x": 189, 
                    "y": 20,
                    "class_name": "top",
                    "class_id": 0,
                    "confidence": 0.91
                },
                {
                    "x": 188, 
                    "y": 180,
                    "class_name": "bottom",
                    "class_id": 1,
                    "confidence": 0.93
                }
            ]
        }
    ],
    "image": {
        "width": 2048,
        "height": 1371
    }
}

해당 이미지 속성에는 추론에 보낸 이미지의 높이와 너비가 포함됩니다. 바운딩 박스 계산에 이 값을 사용할 수 있습니다.

Inference API 매개변수

Inference API 사용하기

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

base64로 인코딩된 이미지를 직접 모델 엔드포인트에 POST할 수 있습니다. 또는 이미 다른 곳에 호스팅된 이미지라면, 이미지 쿼리 문자열의 파라미터로 URL을 전달할 수 있습니다.

경로 파라미터

이름	유형	설명
datasetSlug	string	데이터셋 이름의 url-safe 버전입니다. 웹 UI의 메인 프로젝트 뷰에서 URL을 확인하거나, 모델 학습 후 데이터셋 버전의 학습 결과 섹션에서 "Get curl command" 버튼을 클릭하여 찾을 수 있습니다.
version	number	데이터셋 버전을 식별하는 버전 번호입니다.

쿼리 파라미터

이름	유형	설명
이미지	string	추가할 이미지의 URL입니다. 이미지가 외부에 호스팅된 경우 사용하세요. (요청 본문에 base64 인코딩 이미지를 POST하지 않을 때 필수) 참고: URL 인코딩을 잊지 마세요.
classes	string	특정 클래스의 예측만 제한합니다. 콤마로 구분된 문자열로 제공합니다. 예시: dog,cat 기본값: 없음 (모든 클래스 표시)
overlap	number	동일 클래스의 바운딩 박스 예측이 하나의 박스로 합쳐지기 전에 허용되는 최대 중첩 비율(0-100 기준)입니다. 기본값: 30
confidence	number	반환된 예측의 임계값(0-100 기준)입니다. 낮은 숫자는 더 많은 예측을 반환하고, 높은 숫자는 더 적지만 높은 확신의 예측만 반환합니다. 기본값: 40
stroke	number	예측 주위에 표시되는 바운딩 박스의 너비(픽셀 단위)입니다 ( format 일 때만 적용) 이미지). 기본값: 1
labels	boolean	예측에 텍스트 라벨을 표시할지 여부 ( format 일 때만 적용) 이미지). 기본값: false
format	string	json - JSON 예측 배열을 반환합니다. (응답 형식 탭 참조). 이미지 - 주석이 달린 예측이 포함된 이미지를 바이너리 blob으로 반환합니다. Content-Type 는 image/jpeg. image_and_json - base64로 시각화 필드를 포함한 JSON 예측 배열을 반환합니다. 기본값: json
api_key	string	API 키 (워크스페이스 API 설정 페이지에서 획득)

요청 본문

이름	유형	설명
	string	base64로 인코딩된 이미지입니다. (쿼리 파라미터에 이미지 URL을 전달하지 않을 때 필수)

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
    }]
}

403 api_key가 모델에 접근할 권한이 없는 경우.

{
    "Message": "User is not authorized to access this resource"
}