आप जो मॉडल पहले से चलाते हैं उससे प्री-लेबल और होल्ड-आउट स्कोर

v2.14.0 में नया

यह ट्यूटोरियल उन टीमों के लिए है जो Potato के बाहर पहले से कोई मॉडल चलाती हैं और किसी को भी मॉडल के उत्तर दिखाने से पहले जानना चाहती हैं कि मॉडल टीम के अपने एनोटेटरों से कितना सहमत है। Potato के मॉडल प्रशिक्षण में पाँच ट्रेनर हैं, जिन्हें ब्रिज कहते हैं, जो कुछ प्रशिक्षित नहीं करते। ब्रिज अध्ययन के होल्ड-आउट आइटम को कहीं और परोसे जा रहे मॉडल को भेजता है, उत्तरों को अध्ययन के लेबल के विरुद्ध स्कोर करता है, और उत्तरों को समीक्षा के लिए प्री-लेबल के रूप में राइट-बैक करता है, जैसा प्रशिक्षित मॉडल का रन करता है। नीचे के चरण OpenAI-संगत API के पीछे के विज़न-लैंग्वेज मॉडल, Roboflow मॉडल, CVAT सर्वरलेस फ़ंक्शन, Hugging Face मॉडल और Label Studio ML बैकएंड को हर एक के सत्यापित config के साथ समझाते हैं।

ब्रिज रन क्या भेजता और स्कोर करता है

ब्रिज ऐसा ट्रेनर है जिसका फ़िट चरण केवल जाँचता है कि सेवा उत्तर देती है। फिर रन अपने val और test स्प्लिट के आइटम सेवा को भेजता है, और writeback.include_unlabeled: true होने पर वे आइटम भी जिन पर किसी ने लेबल नहीं लगाया। Potato उत्तरों को स्कीम के अपने रूपों, स्पैन या विकल्पों में बदलता है और उत्तरों को होल्ड-आउट आइटम पर समाधानित मानव लेबल के विरुद्ध उन्हीं होल्ड-आउट मीट्रिक से स्कोर करता है जो प्रशिक्षित मॉडल को मिलती हैं (बॉक्स के लिए mAP50, स्पैन के लिए span F1, एकल विकल्प के लिए macro-F1)। राइट-बैक, मॉडल समीक्षा कतार और हर प्री-लेबल की रन आईडी वैसे ही काम करते हैं जैसे किसी अन्य रन के बाद।

आइटम का स्प्लिट केवल आइटम की आईडी और model_training.split_seed पर निर्भर करता है, इसलिए जब तक सीड स्थिर रहता है, ब्रिज रन और प्रशिक्षित मॉडल का रन एक ही val और test आइटम पर स्कोर करते हैं। तब /admin/training की Runs तालिका आपके पहले से मौजूद मॉडल को अध्ययन के लेबल पर प्रशिक्षित मॉडल के बगल में रखती है। train स्प्लिट के आइटम को ब्रिज से कोई भविष्यवाणी नहीं मिलती, और राइट-बैक कभी train-स्प्लिट आइटम को प्री-लेबल नहीं करता। इसलिए 70/15/15 के डिफ़ॉल्ट स्प्लिट पर ब्रिज लेबल किए आइटम के लगभग 30% पर स्कोर करता है।

शुरू करने से पहले

label-studio-ml के अलावा चार ब्रिज को Potato सर्वर पर requests और Pillow चाहिए, और जब तक दोनों पैकेज इम्पोर्ट नहीं होते, Training पेज ब्रिज को "not installed" सूचीबद्ध करता है। label-studio-ml को Potato के अलावा कुछ नहीं चाहिए। पाँचों ब्रिज में से कोई मॉडल, GPU लाइब्रेरी या torch इंस्टॉल नहीं करता, क्योंकि मॉडल सेवा में चलता है।

हर इमेज ट्रेनर की तरह इमेज प्रोजेक्ट के भीतर लोकल फ़ाइलें होनी चाहिए। ब्रिज उस आइटम को छोड़ देता है जिसकी इमेज रिमोट http(s) URL है, और लेबल वाला पर भविष्यवाणी के बिना आइटम होल्ड-आउट स्कोर में गलत गिना जाता है। रन उन होल्ड-आउट आइटम का अनुपात जिन्हें भविष्यवाणी मिली val_coverage और test_coverage के रूप में रिपोर्ट करता है, इसलिए कम कवरेज उन इमेज की ओर इशारा करता है जिन्हें ब्रिज भेज नहीं सका।

कुंजियाँ एनवायरनमेंट वेरिएबल में रहती हैं

कुंजी कभी config में नहीं जाती। हर ब्रिज जो कुंजी भेजता है एक पैरामीटर लेता है जो कुंजी रखने वाले एनवायरनमेंट वेरिएबल का नाम देता है (api_key_env, Hugging Face के लिए token_env, या Label Studio के लिए दो basic_auth_*_env नाम), और वेरिएबल को सर्वर शुरू होने से पहले Potato सर्वर के एनवायरनमेंट में सेट होना चाहिए। cvat-nuclio कोई कुंजी नहीं भेजता और ऐसा कोई पैरामीटर नहीं लेता। कुंजी लेने वाले चारों ब्रिज ऐसा मान अस्वीकार करते हैं जो वेरिएबल का नाम नहीं है, और त्रुटि मान को दोहराती नहीं, क्योंकि उस जगह का मान संभवतः स्वयं कुंजी है। जब सेवा का त्रुटि बॉडी या कनेक्शन त्रुटि अनुरोध को दोहराती है, ब्रिज त्रुटि दिखाने से पहले कुंजी के मान को [redacted] से बदल देते हैं। Label Studio ML बैकएंड के /predict के त्रुटि बॉडी भी इसी तरह साफ़ किए जाते हैं। क्वेरी स्ट्रिंग या Authorization हेडर में कुंजी जैसा दिखने वाला कुछ भी इसी तरह बदल दिया जाता है।

hf-inference और roboflow रन केवल लोकल होते हैं। दोनों ब्रिज कुंजी Potato सर्वर पर पढ़ते हैं, और ssh, SLURM या एजेंट बैकएंड पर रन को कुंजी उस होस्ट तक भेजनी पड़ती, इसलिए Potato वहाँ ऐसा रन शुरू करने से इनकार करता है। openai-vlm-boxes, cvat-nuclio और label-studio-ml किसी भी बैकएंड पर चलते हैं जो सेवा तक पहुँच सके, कुंजी का वेरिएबल उस बैकएंड के होस्ट पर सेट होने के साथ।

चरण 1: तीन ब्रिज के साथ इमेज अध्ययन

नीचे का config साइट की तस्वीरों का अध्ययन सेट करता है जिसमें एनोटेटर हर हार्ड हैट और हर खाली सिर पर बॉक्स बनाते हैं। model_training.trainer_params एक साथ कई ट्रेनरों के डिफ़ॉल्ट रखता है, इसलिए एक config तीनों इमेज ब्रिज की सेटिंग रखता है, और हर रन अपने ट्रेनर का ब्लॉक उपयोग करता है। ट्रेनर चुनने पर Training पेज का Parameters फ़ील्ड इन्हीं डिफ़ॉल्ट से भर जाता है।

annotation_task_name: "Hard hats on site photos"
task_dir: .
media_directory: media
output_annotation_dir: annotation_output
admin_api_key: "replace-with-a-long-random-string"
 
data_files:
  - data/photos.jsonl
 
item_properties:
  id_key: id
  text_key: image_url
 
annotation_schemes:
  - annotation_type: image_annotation
    name: ppe
    description: "Box every hard hat and every bare head."
    source_field: image_url
    tools: [bbox, polygon]
    labels:
      - name: helmet
      - name: head
 
model_training:
  enabled: true
  writeback:
    schemas: [ppe]
    include_unlabeled: true
  trainer_params:
    openai-vlm-boxes:
      url: http://localhost:8000/v1
      model: Qwen/Qwen2.5-VL-7B-Instruct
      coordinate_format: pixels
    roboflow:
      model_id: site-safety/3        # your Roboflow project and version
      url: https://detect.roboflow.com
      api_key_env: ROBOFLOW_API_KEY
      confidence: 0.4
      label_map: {hardhat: helmet, no-hardhat: head}   # the model's class names on the left
    cvat-nuclio:
      url: http://localhost:32768
      threshold: 0.5
      label_map: {person: null}

data/photos.jsonl की हर पंक्ति media/ के अंतर्गत एक इमेज का नाम देती है:

{"id": "site_001", "image_url": "media/site_001.jpg"}

writeback.schemas वह है जो मॉडल के बॉक्स एनोटेटरों को दिखाता है, और include_unlabeled उन तस्वीरों को भी सेवा को भेजता है जिन पर किसी ने लेबल नहीं लगाया। यदि किसी को प्री-लेबल दिखने से पहले होल्ड-आउट स्कोर चाहिए तो पहले रन के लिए दोनों कुंजियाँ छोड़ दें। label_map सेवा के क्लास नामों को स्कीम के लेबल से जोड़ता है, और null से जुड़ा क्लास छोड़ दिया जाता है। जिस क्लास की कोई प्रविष्टि नहीं है वह उसी नाम के लेबल पर जाता है, और मिलान अक्षर-स्थिति की अनदेखी करता है। किसी अन्य क्लास के बॉक्स बाहर रखे जाते हैं, और रन लॉग बाहर रखे बॉक्स गिनता है।

चरण 2: openai-vlm-boxes से विज़न-लैंग्वेज मॉडल

openai-vlm-boxes हर इमेज को लंबी भुजा पर अधिकतम 1,280 पिक्सेल तक छोटा करता है (max_image_side) और इमेज को चैट कम्प्लीशन रूट पर ऐसे प्रॉम्प्ट के साथ भेजता है जो स्कीम के लेबल का नाम देता है। Potato उत्तर को JSON बॉक्स के रूप में पढ़ता है। OpenAI-संगत API वाला कोई भी सर्वर चलता है। नीचे की कमांड vLLM से Qwen2.5-VL परोसती है, जिसके दस्तावेज़ क्लाइंट को http://localhost:8000/v1 से जोड़ते हैं:

vllm serve Qwen/Qwen2.5-VL-7B-Instruct

vLLM के पोर्ट 8000 पर होने पर Potato को दूसरे पोर्ट पर शुरू करें:

potato start config.yaml -p 9000

विज़न-लैंग्वेज मॉडल प्रॉम्प्ट जो भी माँगे, अपने निर्देशांक नियम में उत्तर देते हैं, और दो पैरामीटर Potato को बताते हैं कि संख्याएँ कैसे पढ़नी हैं। coordinate_format है fraction (इमेज का 0 से 1), per_mille (0 से 1,000), या भेजी गई इमेज के pixels। box_order है [x0, y0, x1, y1] के लिए xyxy या [y0, x0, y1, x1] के लिए yxyx। Qwen2.5-VL पिक्सेल में उत्तर देता है, इसलिए ऊपर का config coordinate_format: pixels सेट करता है। auto के अंतर्गत Potato हर उत्तर में संख्याओं के आकार से प्रारूप का एक बार अनुमान लगाता है। 1.05 तक के मान भिन्न पढ़े जाते हैं, भेजी गई इमेज के आकार से अधिक के मान प्रति-हज़ार पढ़े जाते हैं, और बाकी सब पिक्सेल। इसलिए बड़ी इमेज के भीतर समाने वाला प्रति-हज़ार बॉक्स पिक्सेल पढ़ा जाता है, अतः जब भी मॉडल का नियम पता हो, प्रारूप का नाम दें।

Gemma और Gemini प्रॉम्प्ट भिन्न माँगने पर भी प्रति-हज़ार बॉक्स y पहले के साथ, [ymin, xmin, ymax, xmax], उत्तर देते हैं। दोनों पैरामीटर auto पर होने पर Potato उस मॉडल के बॉक्स जिसके नाम में gemma या gemini है, y पहले वाले प्रति-हज़ार के रूप में पढ़ता है। लाल और नीले वर्गों के Gemma 4 12B परीक्षण प्रोजेक्ट पर Potato टीम ने बॉक्स x पहले पढ़ने पर mAP50 0.0 और बॉक्स y पहले पढ़ने पर 1.0 नापा। Ollama Gemma 3 को gemma वाले नाम से परोसता है, इसलिए auto लागू होता है:

ollama run gemma3:12b

config में openai-vlm-boxes ब्लॉक को नीचे के ब्लॉक से बदलें:

model_training:
  trainer_params:
    openai-vlm-boxes:
      url: http://localhost:11434/v1
      model: gemma3:12b
      json_mode: object

जिस Gemma या Gemini फ़ाइन-ट्यून को इन दोनों शब्दों में से किसी के बिना नाम से परोसा जाए, उसे auto के अंतर्गत x पहले वाली पढ़त मिलती है। ऐसे मॉडल के लिए coordinate_format: per_mille और box_order: yxyx सेट करें। json_mode: object Ollama से response_format: json_object के साथ JSON माँगता है। डिफ़ॉल्ट schema लेबल को enum बनाकर JSON स्कीमा भेजता है। vLLM और OpenAI स्कीमा का पालन करते हैं। जिस रन में कोई उत्तर JSON के रूप में पार्स न हो वह विफल होता है, और त्रुटि json_mode: object या सरल प्रॉम्प्ट सुझाती है (prompt, जहाँ {labels} स्कीम के लेबल बन जाता है)।

विज़न-लैंग्वेज मॉडल अपने बॉक्स के साथ कोई स्कोर नहीं देता, इसलिए बॉक्स में विश्वास नहीं होता। writeback.min_confidence हर openai-vlm-boxes भविष्यवाणी को पार होने देता है, और मॉडल समीक्षा भविष्यवाणियों को सबसे कम से सबसे अधिक विश्वास के क्रम में नहीं लगा सकती। openai-vlm-boxes संदर्भ होस्टेड API के लिए api_key_env और टोकन तथा टाइमआउट सेटिंग सूचीबद्ध करता है।

चरण 3: रन शुरू करें और स्कोर पढ़ें

http://localhost:9000/admin/training खोलें, openai-vlm-boxes और ppe स्कीम चुनें, और Train now पर क्लिक करें। वही रन API से शुरू होता है:

curl -X POST -H "X-API-Key: $KEY" -H "Content-Type: application/json" \
  http://localhost:9000/admin/training/api/runs \
  -d '{"trainer": "openai-vlm-boxes", "schemas": ["ppe"]}'

फ़िट चरण /models से सर्वर के मॉडल सूचीबद्ध करता है और लॉग करता है कि रन किस मॉडल से पूछता है और रन मॉडल के बॉक्स कैसे पढ़ता है। फिर भविष्यवाणी का चरण प्रति अनुरोध एक इमेज भेजता है। रन पूरा होने पर होल्ड-आउट mAP50 Runs तालिका में दिखता है, और रन पेज val_map_50, test_map_50, कवरेज के आँकड़े, और "Not used" चेतावनी सूचीबद्ध करता है जो उन उत्तरों को गिनती है जो JSON नहीं थे, स्कीम में अनुपस्थित लेबल के बॉक्स, और इमेज से बाहर के बॉक्स। जब स्कोर 0 के पास हो, कवरेज ऊँचा हो और चेतावनी खाली हो, तब पहले coordinate_format और box_order जाँचें।

Roboflow मॉडल

roboflow हर इमेज को <url>/<model_id> पर पोस्ट करता है, जहाँ model_id प्रोजेक्ट और संस्करण है, project/version के रूप में। कुंजी डिफ़ॉल्ट रूप से ROBOFLOW_API_KEY में जाती है (api_key_env), और कुंजी के बिना रन शुरू होने से इनकार करता है:

export ROBOFLOW_API_KEY=...   # in the shell that starts Potato
potato start config.yaml -p 9000

Potato का डिफ़ॉल्ट url https://detect.roboflow.com है, और ऊपर का config डिफ़ॉल्ट का नाम देता है। इंस्टेंस सेगमेंटेशन के लिए रन url: https://outline.roboflow.com सेट करता है। url एक पैरामीटर है, इसलिए रन https://serverless.roboflow.com भी दे सकता है, वह होस्ट जो Roboflow का ऑब्जेक्ट डिटेक्शन संदर्भ उसी project/version रूट के लिए देता है। Potato टीम ने उस होस्ट को इस ब्रिज के साथ परखा नहीं है। स्वयं-होस्ट किया Roboflow Inference सर्वर डिफ़ॉल्ट रूप से पोर्ट 9001 पर सुनता है (url: http://localhost:9001)।

Roboflow का API कुंजी क्वेरी स्ट्रिंग में लेता है। Potato अनुरोध URL को न रन लॉग में लिखता है न त्रुटि संदेश में। Potato confidence और overlap (डिफ़ॉल्ट 0.4 और 0.3) API को प्रतिशत के रूप में भेजता है, और Roboflow का संदर्भ दोनों को 0 से 100 के पैमाने पर प्रलेखित करता है। shapes: auto वहाँ रूपरेखा लिखता है जहाँ मॉडल रूपरेखा लौटाता है और स्कीम में पॉलिगॉन टूल है, और अन्यथा बॉक्स। स्वास्थ्य जाँच 8 × 8 की सफ़ेद इमेज पोस्ट करती है, और Roboflow अनुरोध को खाते के उपयोग में गिनता है।

CVAT सर्वरलेस फ़ंक्शन

cvat-nuclio CVAT के लिए पहले से तैनात डिटेक्टर को Nuclio फ़ंक्शन के रूप में उपयोग करता है, जैसे cvat/serverless में YOLOv7 या Faster R-CNN फ़ंक्शन। Potato हर इमेज को CVAT से गुज़रे बिना फ़ंक्शन के अपने URL पर {"image": <base64>, "threshold": t} के रूप में पोस्ट करता है। nuctl get functions तैनात फ़ंक्शन उनके पोर्ट के साथ सूचीबद्ध करता है, और नीचे की कमांड वह रूप है जो CVAT के दस्तावेज़ देते हैं:

nuctl get functions --platform local

फ़ंक्शन पिक्सेल में आकृतियों के साथ उत्तर देता है। rectangle बॉक्स बनता है, और polygon पॉलिगॉन बनता है, या जब स्कीम में पॉलिगॉन टूल न हो तब पॉलिगॉन का बाउंडिंग बॉक्स। mask आकृतियाँ छोड़ दी जाती हैं और गिनी जाती हैं। फ़ंक्शन threshold (डिफ़ॉल्ट 0.5) से कम स्कोर वाली आकृतियाँ छोड़ता है। स्कीम में person लेबल नहीं है, इसलिए config का label_map: {person: null} COCO डिटेक्टर के लोगों को छोड़ देता है।

hf-inference से Hugging Face मॉडल

hf-inference Hugging Face पर तैनात मॉडल को बुलाता है, या तो समर्पित Inference Endpoint को उसके https:// URL से (endpoint_url) या सर्वरलेस HF Inference API पर मॉडल आईडी से (model)। endpoint_url या model सेट करें, दोनों नहीं। कार्य स्कीम के प्रकार का अनुसरण करता है:

• radio, select और multiselect के लिए टेक्स्ट वर्गीकरण। एकल-विकल्प स्कीम मॉडल का शीर्ष लेबल लेती है। जब वह लेबल label_map के बाद स्कीम के लेबल में नहीं होता, आइटम को उपविजेता की जगह कोई भविष्यवाणी नहीं मिलती। multiselect स्कीम हर वह लेबल लेती है जिसका स्कोर कम से कम threshold (डिफ़ॉल्ट 0.5) हो।
• span के लिए टोकन वर्गीकरण, जिसमें वर्ड पीस aggregation_strategy (simple, first, average या max) से इकाइयों में समूहित होते हैं और वर्ण ऑफ़सेट मॉडल से लिए जाते हैं।
• image_annotation के लिए ऑब्जेक्ट डिटेक्शन। threshold से कम स्कोर वाले बॉक्स छोड़ दिए जाते हैं।

नीचे का config स्पैन के लिए dslim/bert-base-NER से पूछता है। मॉडल कार्ड एक BERT मॉडल बताता है जो अंग्रेज़ी CoNLL-2003 पर नामित इकाइयों के लिए फ़ाइन-ट्यून किया गया है। HF Inference Hub के मॉडलों का एक उपसमूह परोसता है, इसलिए सर्वरलेस API पर निर्भर होने से पहले जाँचें कि मॉडल के पेज पर HF Inference सूचीबद्ध है।

annotation_task_name: "Named entities in news sentences"
task_dir: .
output_annotation_dir: annotation_output
admin_api_key: "replace-with-a-long-random-string"
 
data_files:
  - data/sentences.jsonl
 
item_properties:
  id_key: id
  text_key: text
 
annotation_schemes:
  - annotation_type: span
    name: entities
    description: "Highlight every person, organization, and place."
    labels: [person, organization, location]
 
model_training:
  enabled: true
  writeback:
    schemas: [entities]
    include_unlabeled: true
  trainer_params:
    hf-inference:
      model: dslim/bert-base-NER
      token_env: HF_TOKEN
      aggregation_strategy: simple
      label_map: {PER: person, ORG: organization, LOC: location, MISC: null}

मॉडल की PER, ORG और LOC इकाइयाँ स्कीम के लेबल से जुड़ती हैं, और MISC छोड़ दिया जाता है क्योंकि स्कीम में ऐसा लेबल नहीं है। जब किसी इकाई का पूरा नाम किसी से मेल न खाए, Potato B- या I- उपसर्ग हटाकर फिर कोशिश करता है। LABEL_0 और LABEL_1 से उत्तर देने वाले सेंटिमेंट क्लासिफ़ायर को इसी तरह label_map: {LABEL_0: negative, LABEL_1: positive} चाहिए। स्वास्थ्य जाँच एक वास्तविक अनुरोध है, एक छोटा वाक्य या 8 × 8 की इमेज, और wait_for_model: true (डिफ़ॉल्ट) सर्वरलेस मॉडल के लोड होने तक 503 से विफल होने की जगह प्रतीक्षा करता है।

Label Studio ML बैकएंड

label-studio-ml चलते हुए Label Studio ML बैकएंड का उपयोग करता है। रिपॉज़िटरी के उदाहरणों से docker-compose up से शुरू किया बैकएंड http://localhost:9090 पर HTTP से मॉडल परोसता है। रन बैकएंड का GET /health जाँचता है, आइटम को 16 के बैच में POST /predict पर भेजता है (batch_size), और लौटे क्षेत्रों को उसी कन्वर्टर से पढ़ता है जिसे potato import -f label_studio उपयोग करता है। Label Studio के UTF-16 स्पैन ऑफ़सेट कोड पॉइंट बन जाते हैं, और प्रतिशत निर्देशांक इमेज विजेट के बन जाते हैं।

annotation_task_name: "Review sentiment"
task_dir: .
output_annotation_dir: annotation_output
admin_api_key: "replace-with-a-long-random-string"
 
data_files:
  - data/reviews.jsonl
 
item_properties:
  id_key: id
  text_key: text
 
annotation_schemes:
  - annotation_type: radio
    name: sentiment
    description: "Is this review positive or negative?"
    labels: [positive, negative]
 
model_training:
  enabled: true
  writeback:
    schemas: [sentiment]
    include_unlabeled: true
    min_confidence: 0.6
  trainer_params:
    label-studio-ml:
      url: http://localhost:9090
      basic_auth_user_env: LS_ML_USER
      basic_auth_pass_env: LS_ML_PASS

स्टॉक बैकएंड का एकमात्र प्रमाणीकरण HTTP Basic है, जो बैकएंड पर BASIC_AUTH_USER और BASIC_AUTH_PASS से सेट होता है। basic_auth_user_env और basic_auth_pass_env Potato सर्वर के उन वेरिएबल का नाम देते हैं जिनमें वही दो मान हैं, और दोनों पैरामीटर साथ जाते हैं। api_key_env इसके बजाय Authorization: Token <value> भेजता है, ऐसे बैकएंड के लिए जो प्रॉक्सी के पीछे है और टोकन की अपेक्षा करती है। स्टॉक बैकएंड उस हेडर का उत्तर 500 से देता है। Potato हर अनुरोध के साथ भेजा जाने वाला लेबलिंग config स्कीम से बनाता है (Choices, Labels, RectangleLabels या PolygonLabels), और label_config बनाए गए XML को आपके अपने से बदल देता है।

इमेज बैकएंड को एक और सेटिंग चाहिए। media_url_prefix के बिना Potato हर इमेज Potato मशीन पर निरपेक्ष पाथ के रूप में भेजता है, और Label Studio SDK पर बना बैकएंड data.image को URL के रूप में पढ़ता है और सादे पाथ पर विफल होता है। उसी मशीन के बैकएंड के लिए नीचे का प्रीफ़िक्स जोड़ें और बैकएंड को LOCAL_FILES_DOCUMENT_ROOT को टास्क डायरेक्टरी पर सेट करके शुरू करें:

model_training:
  trainer_params:
    label-studio-ml:
      url: http://localhost:9090
      media_url_prefix: /data/local-files/?d=

दूसरी मशीन के बैकएंड के लिए टास्क डायरेक्टरी को HTTP पर परोसें और उस सर्वर का URL प्रीफ़िक्स के रूप में दें। टास्क डायरेक्टरी के बाहर की इमेज का डायरेक्टरी के सापेक्ष कोई पाथ नहीं होता, इसलिए Potato इमेज नहीं भेजता, और रन लॉग नाम देता है कि कितनी बाहर रखी गईं।

Potato बैकएंड को भविष्यवाणी अनुरोध भेजता है, एनोटेशन घटनाएँ नहीं, इसलिए बैकएंड का अपने /webhook हैंडलर में अपना प्रशिक्षण Potato से शुरू नहीं होता। potato import -f label_studio पूरे Label Studio प्रोजेक्ट को उसके लेबलिंग config, एनोटेटरों के उत्तरों और सहेजी गई भविष्यवाणियों के साथ Potato में ले आता है (प्रोजेक्ट इम्पोर्ट करना)। Label Studio से Potato में माइग्रेट करना वे टैग बताता है जिन्हें इम्पोर्टर छोड़ देता है।

प्री-लेबल की समीक्षा करें

ब्रिज की भविष्यवाणियाँ प्रशिक्षित मॉडल की भविष्यवाणियों जैसी ही राइट-बैक जाँचों से गुज़रती हैं। राइट-बैक train-स्प्लिट आइटम और writeback.schemas में अनुपस्थित स्कीम छोड़ता है, उन आइटम और स्कीम के जोड़े छोड़ता है जिन्हें समीक्षक ने अस्वीकार किया, और writeback.min_confidence से नीचे की भविष्यवाणियाँ रोक लेता है। बॉक्स और स्पैन के लिए भविष्यवाणी का विश्वास सबसे कम विश्वास वाली आकृति या स्पैन का विश्वास है, इसलिए जब आइटम पर कोई एक बॉक्स या स्पैन कम स्कोर करे तब सीमा आइटम की पूरी भविष्यवाणी रोक देती है। Roboflow का confidence और CVAT का threshold इसके बजाय सेवा पर प्रति बॉक्स काम करते हैं, और hf-inference का threshold प्रति बॉक्स या प्रति multiselect लेबल काम करता है। मॉडल-इन-द-लूप ट्यूटोरियल समीक्षा कतार, स्वीकार और अस्वीकार निर्णय और दोबारा प्रशिक्षण समझाता है। कतार और निर्णय ब्रिज के लिए उसी तरह काम करते हैं।

हर आइटम और स्कीम के लिए एक भविष्यवाणी रखी जाती है, इसलिए किसी अन्य ब्रिज या प्रशिक्षित मॉडल का बाद का रन पहले रन के प्री-लेबल बदल देता है। किसी रन के प्री-लेबल वापस लेने के लिए DELETE /admin/training/api/runs/<run_id>/predictions भेजें। इन्फ़रेंस ब्रिज संदर्भ चार ब्रिज के हर पैरामीटर को सूचीबद्ध करता है, और label-studio-ml संदर्भ Label Studio के पैरामीटर सूचीबद्ध करता है।

आगे पढ़ें

• मॉडल प्रशिक्षण लूप और Training पेज समझाता है।
• ट्रेनर सभी 38 ट्रेनर कार्य के अनुसार सूचीबद्ध करता है, ताकि अध्ययन के लेबल पर प्रशिक्षित मॉडल की तुलना ब्रिज के स्कोर से की जा सके।
• कॉन्फ़िगरेशन स्प्लिट, राइट-बैक और रूट का दस्तावेज़ देता है।
• इमेज एनोटेशन और स्पैन एनोटेशन उन स्कीम का दस्तावेज़ देते हैं जिन्हें ब्रिज भरते हैं।
• विज़ुअल AI सपोर्ट विज़न मॉडल के सुझाव अनुरोध पर एनोटेटर को दिखाता है, होल्ड-आउट स्कोर के बिना।