인스턴스 분할(Instance Segmentation)

Roboflow에 호스팅된 인스턴스 분할 모델에서 추론을 실행하세요.

Linux 또는 MacOS

로컬 파일에서 JSON 예측을 가져오기 (파일 이름: YOUR_IMAGE.jpg:

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

웹에 호스팅된 이미지의 URL로 추론하기 (URL을 URL 인코딩하세요):

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

Windows

다음 항목들을 설치해야 합니다 Windows용 curl 이제 GPU TRT 컨테이너가 Docker에서 실행 중입니다. 다른 Ubuntu 터미널을 열어 Docker 컨테이너로 추론 데이터를 보낼 준비를 합니다. 다음을 사용하세요: Windows용 GNU의 base64 도구. 이를 가장 쉽게 설치하는 방법은 git for Windows 설치 프로그램을 사용하는 것입니다 이 설치 프로그램은 또한 curl 이제 GPU TRT 컨테이너가 Docker에서 실행 중입니다. 다른 Ubuntu 터미널을 열어 Docker 컨테이너로 추론 데이터를 보낼 준비를 합니다. 다음을 사용하세요: base64 설치 중에 "Use Git and optional Unix tools from the Command Prompt"를 선택하면 명령줄 도구들이 포함됩니다.

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

로컬 및 호스팅된 이미지에서 추론

의존성을 설치하려면, pip install inference-sdk.

from inference_sdk import InferenceHTTPClient

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

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

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://outline.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://outline.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);
});

웹

우리는 실시간 온-디바이스 추론을 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 = "" // Your API Key
    val MODEL_ENDPOINT = "dataset/v" // 모델 엔드포인트 설정 (Dataset URL에서 찾음)

    // URL 구성
    val uploadURL ="https://outline.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 = "" // Your API Key
    val MODEL_ENDPOINT = "dataset/v" // 모델 엔드포인트 설정

    // 업로드 URL
    val uploadURL = "https://outline.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 = ""; // Your API Key
        String MODEL_ENDPOINT = "dataset/v"; // 모델 엔드포인트

        // URL 구성
        String uploadURL = "https://outline.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 = ""; // Your API Key
        String MODEL_ENDPOINT = "dataset/v"; // 모델 엔드포인트

        // 업로드 URL
        String uploadURL = "https://outline.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 KEY 입력

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

response = HTTParty.post(
    "https://outline.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 KEY 입력
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://outline.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://outline.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://outline.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 := ""  // Your API Key
	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://outline.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 := ""  // Your API Key
	model_endpoint := "dataset/v" // 모델 엔드포인트 설정
	img_url := "https://i.ibb.co/jzr27x0/YOUR-IMAGE.jpg"


	uploadURL := "https://outline.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 = ""; // Your API Key
            string MODEL_ENDPOINT = "dataset/v"; // 모델 엔드포인트 설정

            // URL 구성
            string uploadURL =
                    "https://outline.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 = ""; // Your API Key
            string imageURL = "https://i.ibb.co/jzr27x0/YOUR-IMAGE.jpg";
            string MODEL_ENDPOINT = "dataset/v"; // 모델 엔드포인트 설정

            // URL 구성
            string uploadURL =
                    "https://outline.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 추론 경로는 다음을 반환합니다 JSON 예측 배열을 포함하는 객체입니다. 각 예측은 다음 속성을 가집니다:

x = 감지된 객체의 수평 중심점
y = 감지된 객체의 수직 중심점
width = 바운딩 박스의 너비
height = 바운딩 박스의 높이
class = 감지된 객체의 클래스 레이블
confidence = 감지된 객체가 올바른 레이블과 위치 좌표를 가질 확률(모델의 신뢰도)
points =list of points that make of the polygon outline of the object - each item in the list is an object with keys x 이제 GPU TRT 컨테이너가 Docker에서 실행 중입니다. 다른 Ubuntu 터미널을 열어 Docker 컨테이너로 추론 데이터를 보낼 준비를 합니다. 다음을 사용하세요: y for the horizontal and vertical coordinate of the point respectively

// 예시 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 사용

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

base64로 인코딩된 이미지를 모델 엔드포인트로 직접 POST할 수 있습니다. 또는 이미지가 이미 다른 곳에 호스팅되어 있다면 URL을 쿼리 문자열의 매개변수에 대해 입력 이미지를 선택하세요. 예측에는 모델 결과를 선택하세요. 선택적 구성 속성을 사용하여 경계 상자의 색상과 크기를 변경할 수 있습니다. 매개변수로 전달할 수 있습니다.

경로 매개변수

이름

유형

설명

datasetSlug

string

데이터셋 이름의 URL 안전 버전입니다. 웹 UI에서 메인 프로젝트 뷰의 URL을 보거나 모델을 학습한 후 데이터셋 버전의 학습 결과 섹션에서 "Get curl command" 버튼을 클릭하면 찾을 수 있습니다.

version

number

데이터셋 버전을 식별하는 버전 번호

쿼리 매개변수

이름

유형

설명

매개변수에 대해 입력 이미지를 선택하세요. 예측에는 모델 결과를 선택하세요. 선택적 구성 속성을 사용하여 경계 상자의 색상과 크기를 변경할 수 있습니다.

string

추가할 이미지의 URL. 이미지가 다른 곳에 호스팅된 경우 사용합니다. (요청 본문에 base64로 인코딩된 이미지를 POST하지 않을 때 필요합니다.) 참고: URL 인코딩하는 것을 잊지 마세요.

overlap

number

동일 클래스의 바운딩 박스 예측이 단일 박스로 결합되기 전에 허용되는 최대 중첩 비율(0-100 척도). 기본값: 30

confidence

number

0-100 척도의 반환된 예측에 대한 임계값입니다. 낮은 값은 더 많은 예측을 반환하고, 높은 값은 적은 수의 높은 확신 예측을 반환합니다. 기본값: 40

api_key

string

워크스페이스 API 설정 페이지에서 얻은 API 키

요청 본문

이름

유형

설명

string

base64로 인코딩된 이미지. (쿼리 매개변수로 이미지 URL을 전달하지 않을 때 필요합니다).

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

Previous분류(Classification)Next시맨틱 분할(Semantic Segmentation)

Last updated 10 months ago

Was this helpful?