प्री-लेबल और दोबारा प्रशिक्षण के साथ चक्र में मॉडल वाली लेबलिंग

v2.14.0 में नया

यह ट्यूटोरियल एक भावना अध्ययन को चक्र में मॉडल वाले चक्र से गुज़ारता है। मॉडल पहले लेबलों पर प्रशिक्षित होता है, मॉडल की भविष्यवाणियाँ एनोटेटरों को प्री-लेबल के रूप में दिखती हैं, समीक्षक सबसे कम विश्वास वाले प्री-लेबल सुधारते हैं, और सुधार अगले रन को खिलाते हैं। ट्यूटोरियल उन अध्ययन स्वामियों के लिए है जिन्होंने अपना पहला मॉडल प्रशिक्षित कर लिया है और अब चाहते हैं कि एनोटेटर मॉडल के साथ मिलकर काम करें। एक चरण को छोड़कर हर चरण sklearn-text के साथ लैपटॉप पर चलता है। अधिग्रहण का चरण एक छोटा ट्रांसफ़ॉर्मर प्रशिक्षित करता है और CPU पर कुछ मिनट लेता है।

भावना प्रोजेक्ट

प्रोजेक्ट Potato का मॉडल-प्रशिक्षण उदाहरण है, जिसमें 160 कृत्रिम उत्पाद समीक्षाएँ और sentiment नाम की एक radio स्कीम है। प्री-लेबल वह एक लेबल है जो किसी मॉडल ने किसी आइटम के लिए तब प्रस्तावित किया जब किसी व्यक्ति ने उस आइटम पर लेबल नहीं लगाया था। राइट-बैक वह चरण है जो प्रशिक्षण रन की भविष्यवाणियों को एनोटेशन पेज पर प्री-लेबल में बदलता है। ट्यूटोरियल के अंत तक प्रोजेक्ट पहले 120 लेबलों पर वर्गीकारक प्रशिक्षित करता है, बाकी समीक्षाओं पर प्री-लेबल प्रकाशित करता है, सबसे कम विश्वास वाली समीक्षाएँ पहले परोसता है, नए लेबल आने के साथ दोबारा प्रशिक्षित होता है, और एक होल्ड-आउट स्प्लिट को डेटासेट संस्करण के रूप में रखता है।

प्री-लेबल एनोटेशन को तेज़ बनाते हैं और एनोटेटरों को मॉडल के उत्तर की ओर भी खींचते हैं। यह सौदा कब सार्थक है, यह अपने लेबलों पर प्रशिक्षित मॉडल से मॉडल-सहायित लेबलिंग में है, और प्री-लेबल को बिना पढ़े स्वीकार करने वाले एनोटेटरों की चर्चा पूर्व-लेबल किए डेटा में समीक्षा और बिना सोचे स्वीकार करने में अंतर कैसे पहचानें में है। नीचे की config शुरू से ही एनोटेटरों के एक हिस्से को हर प्री-लेबल से होल्ड-आउट रखती है। होल्ड-आउट उत्तर अध्ययन को वह खिंचाव मापने देते हैं।

प्रोजेक्ट सेट करें

Potato इंस्टॉल करें। sklearn-text को बेस पैकेज के अलावा कुछ नहीं चाहिए:

pip install --upgrade potato-annotation

Potato रिपॉज़िटरी से examples/ai-assisted/model-training/ को नए फ़ोल्डर में कॉपी करें। फ़ोल्डर में 160 समीक्षाओं वाली data/reviews.json है, और data/gold.json है, जिन लेबलों से सिमुलेटर उत्तर देता है। उदाहरण की config.yaml को इस config से बदल दें:

annotation_task_name: "Review Sentiment (model in the loop)"
 
data_files:
  - "data/reviews.json"
 
item_properties:
  id_key: "id"
  text_key: "text"
 
task_dir: "."
output_annotation_dir: "annotation_output"
 
require_password: false
admin_api_key: "demo-admin-key"
 
num_annotators_per_item: 1
assignment_strategy: llm_confidence
 
annotation_schemes:
  - annotation_type: "radio"
    name: "sentiment"
    description: "Is this review positive or negative?"
    labels:
      - "positive"
      - "negative"
    sequential_key_binding: true
 
ai_support:
  holdout:
    fraction: 0.2
    salt: "review-sentiment"
 
datasets:
  enabled: true
 
model_training:
  enabled: true
  writeback:
    schemas: ["sentiment"]
    include_unlabeled: true
    min_confidence: 0.6

उदाहरण की config में जोड़ा गया हर ब्लॉक एक काम करता है:

• assignment_strategy: llm_confidence हर आइटम परोसता है, सबसे कम विश्वास वाला प्री-लेबल पहले। जिन आइटमों की कोई भविष्यवाणी नहीं है वे आखिर में आते हैं, कतार के क्रम में।
• ai_support.holdout एनोटेटर-आइटम जोड़ियों के 20% से हर तरह की AI सहायता रोक लेता है, प्री-लेबल समेत। होल्ड-आउट एनोटेशन शुरू होने से पहले सेट करें, क्योंकि अध्ययन के बीच fraction या salt बदलने से समूह दोबारा बँट जाते हैं।
• datasets.enabled अंतिम चरण में रन के स्प्लिट को डेटासेट संस्करण के रूप में सहेजने देता है।
• writeback.schemas उन स्कीमों के नाम देता है जिनकी भविष्यवाणियाँ एनोटेटर देखते हैं। सूची डिफ़ॉल्ट रूप से खाली होती है, और प्रशिक्षण चालू करने से एनोटेशन पेज पर तब तक कुछ नहीं बदलता जब तक सूची किसी स्कीम को नामित न करे।
• include_unlabeled: true हर रन को उन समीक्षाओं पर भी भविष्यवाणी करवाता है जिन पर अभी किसी ने लेबल नहीं लगाया। इस सेटिंग के बिना रन केवल अपने होल्ड-आउट val और test आइटमों पर भविष्यवाणी करता है। उन आइटमों पर पहले से मानव लेबल हैं।
• min_confidence: 0.6 0.6 से कम विश्वास वाली भविष्यवाणी को एनोटेटरों की नज़र से बाहर रखता है। Potato फिर भी भविष्यवाणी को रन के साथ सहेजता है।

writeback.field डिफ़ॉल्ट predictions रखता है, वह आइटम फ़ील्ड जिसमें प्री-लेबल लिखे जाते हैं। डिफ़ॉल्ट के साथ pre_annotation ब्लॉक की ज़रूरत नहीं। सर्वर शुरू करने से पहले config जाँचें:

potato validate config.yaml
potato start config.yaml -p 8000

आरंभिक सेट पर लेबल लगाएँ

आपके लेबलों पर प्रशिक्षित मॉडल को पहले लेबल चाहिए। प्रशिक्षण स्प्लिट में 10 से कम आइटम हों तो sklearn-text फ़िट करने से मना कर देता है। http://localhost:8000 पर कुछ समीक्षाओं पर लेबल लगाएँ, या तीन सिमुलेटेड एनोटेटरों से गोल्ड फ़ाइल के आधार पर 40-40 समीक्षाओं पर लेबल लगवाएँ:

python -m potato.simulator --server http://localhost:8000 --users 3 \
  --strategy gold_standard --competence good=1.0 --max-annotations 40 \
  --gold-file data/gold.json --sequential --fast-mode --no-export

--competence good=1.0 हर सिमुलेटेड एनोटेटर को good प्रोफ़ाइल देता है, जो 80–90% समीक्षाओं का उत्तर सही देती है। num_annotators_per_item: 1 के साथ तीनों एनोटेटर 120 अलग समीक्षाएँ कवर करते हैं और 40 को मॉडल के लिए बिना लेबल छोड़ देते हैं।

प्रशिक्षित करें और राइट-बैक रिपोर्ट पढ़ें

एडमिन कुंजी के साथ http://localhost:8000/admin/training खोलें, sklearn-text और sentiment स्कीम चुनें, और Train now पर क्लिक करें। वही रन कमांड लाइन से भी शुरू होता है:

curl -X POST -H "X-API-Key: demo-admin-key" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs \
  -d '{"trainer": "sklearn-text", "schemas": ["sentiment"]}'

रन कुछ सेकंड लेता है। Potato लेबल की गई समीक्षाओं को train, val और test में बाँटता है (डिफ़ॉल्ट रूप से 70%, 15% और 15%), वर्गीकारक को train पर फ़िट करता है, और उसे val और test पर स्कोर करता है। फिर स्टेटस रूट स्कोर और राइट-बैक रिपोर्ट बताता है:

curl -H "X-API-Key: demo-admin-key" http://localhost:8000/admin/training/api/status

इस ट्यूटोरियल के एक रन ने नीचे का परिणाम लौटाया, उन फ़ील्ड तक छाँटा हुआ जो यहाँ मायने रखते हैं:

{
  "metrics": {
    "heldout_metric": "val macro_f1",
    "heldout_score": 0.7333,
    "n_train": 76.0,
    "val_n": 20.0,
    "test_n": 24.0,
    "test_macro_f1": 0.8222
  },
  "writeback": {
    "n_read": 84,
    "n_written": 78,
    "n_skipped_low_confidence": 6,
    "n_skipped_train_split": 0,
    "n_skipped_rejected": 0,
    "n_skipped_schema_not_enabled": 0,
    "summary": "Published 78 prediction(s) as prelabels."
  }
}

रन ने 84 समीक्षाओं पर भविष्यवाणी की, यानी 44 val और test समीक्षाएँ और 40 जिन पर किसी ने लेबल नहीं लगाया था। छह भविष्यवाणियाँ 0.6 की सीमा से नीचे रहीं, और बाकी 78 प्री-लेबल बनीं। आपके स्कोर और गिनतियाँ रन-दर-रन अलग होंगी, क्योंकि सिमुलेटेड एनोटेटर यादृच्छिक गलतियाँ करते हैं और अलग समीक्षाओं पर लेबल लगाते हैं। हर स्किप काउंटर राइट-बैक की चार जाँचों में से एक को नामित करता है, जिन्हें Config क्रम से सूचीबद्ध करता है।

राइट-बैक कभी किसी मानव लेबल को नहीं बदलता। भविष्यवाणियाँ आइटम के डेटा में जाती हैं, और एनोटेशन हर एनोटेटर की अपनी अवस्था में रहते हैं। परिणाम देखने के लिए नए उपयोगकर्ता नाम से लॉगिन करें। अगली समीक्षा मॉडल का उत्तर चुने हुए के साथ आती है:

नया एनोटेटर मॉडल का उत्तर चुना हुआ देखता है और उसे पुष्ट करता है या बदल देता है

जब तक एनोटेटर केवल प्री-लेबल को देख रहा है, प्री-लेबल सहेजा नहीं जाता। एनोटेटर के प्री-लेबल को संपादित करने या अगली समीक्षा पर जाने पर प्री-लेबल एनोटेटर का उत्तर बन जाता है। इसलिए बिना उत्तर वाली समीक्षा पूरी नहीं गिनी जाती, और मॉडल का उत्तर मानव लेबल के रूप में प्रशिक्षण में नहीं लौटता।

एनोटेटरों को प्री-लेबल दिखाने से पहले होल्ड-आउट स्कोर पढ़ें। 20 समीक्षाओं पर 0.73 macro-F1 का रन का val स्कोर गलत प्री-लेबल के लिए काफ़ी जगह छोड़ता है। अपस्ट्रीम राइट-बैक संदर्भ बाकी स्किप काउंटर और हर एनोटेशन प्रकार प्री-लेबल कैसे दिखाता है, यह सूचीबद्ध करता है।

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

llm_confidence के तहत अगले एनोटेटर को 40 बिना लेबल वाली समीक्षाएँ मिलती हैं, प्रकाशित प्री-लेबल के विश्वास के क्रम में, सबसे कम पहले। दूसरी रणनीति प्री-लेबल को लेबलिंग के लिए नहीं, गुणवत्ता नियंत्रण के लिए परोसती है। assignment_strategy: model_review केवल वे आइटम परोसती है जिनमें प्री-लेबल है, सबसे कम विश्वास वाले पहले, और बिना भविष्यवाणी वाले आइटम छोड़ देती है। मॉडल के आउटपुट की समीक्षा के दौर के लिए model_review पर जाएँ, और जब तक हर आइटम को लेबल चाहिए तब तक llm_confidence पर रहें। अपस्ट्रीम मॉडल समीक्षा संदर्भ दोनों कतारें समझाता है।

मॉडल समीक्षा रिपोर्ट कतार दिखाती है और यह भी कि मॉडल ने क्या छोड़ा:

curl -H "X-API-Key: demo-admin-key" http://localhost:8000/admin/model-review

ऊपर के रन की रिपोर्ट, सूचियाँ छोटी की हुई:

{
  "n_items": 160,
  "n_prelabelled": 78,
  "queue": ["review_062", "review_024", "review_044", "review_122", "..."],
  "worst_first": ["review_062", "review_024", "review_044", "..."],
  "n_empty": 82,
  "empty_prediction_ids": ["review_006", "review_007", "review_008", "..."],
  "provenance": {
    "review_062": {
      "sentiment": {
        "run_id": "20261104T043431-de5686",
        "trainer": "sklearn-text",
        "heldout_metric": "val macro_f1",
        "heldout_score": 0.7333
      }
    }
  }
}

queue में किसी आइटम की रैंक स्कीमों में उस आइटम का सबसे कम भविष्यवाणी विश्वास है। worst_first कतार का सबसे कम विश्वास वाला 20% है, कभी एक आइटम से कम नहीं। empty_prediction_ids उन आइटमों को सूचीबद्ध करता है जिनमें प्री-लेबल नहीं है। इस प्रोजेक्ट में 82 खाली आइटम 76 प्रशिक्षण समीक्षाएँ और सीमा से नीचे की 6 भविष्यवाणियाँ हैं। प्रशिक्षण समीक्षाओं को कभी प्री-लेबल नहीं मिलता।

provenance दर्ज करता है कि हर प्री-लेबल कहाँ से आया। कतार के हर उस आइटम के लिए जिसका प्री-लेबल किसी प्रशिक्षण रन ने लिखा, प्रविष्टि रन, ट्रेनर और रन का होल्ड-आउट स्कोर नामित करती है। जो प्री-लेबल डेटा फ़ाइल के साथ आया, उसकी कोई प्रविष्टि नहीं होती। जब प्री-लेबल गलत लगे, तो रन ID रन के पेज /admin/training/runs/<run_id> तक ले जाती है, जो पैरामीटर और हर आइटम का स्प्लिट दिखाता है।

निर्णय दर्ज करना

निर्णय एक प्री-लेबल पर समीक्षक का फ़ैसला दर्ज करता है, समीक्षक के एनोटेशन से अलग। "मॉडल सही था" और "किसी व्यक्ति ने स्वतंत्र रूप से यह लेबल चुना" अलग तथ्य हैं, और दोनों को अलग रखने से मॉडल की सटीकता मापने योग्य बनी रहती है। Potato निर्णय एक ही रूट से लेता है, उस एनोटेटर से जिसे आइटम सौंपा गया है या API कुंजी वाले एडमिन से:

curl -X POST -H "Content-Type: application/json" -H "X-API-Key: demo-admin-key" \
  -d '{"instance_id": "review_062", "verdict": "correct", "schema_name": "sentiment"}' \
  http://localhost:8000/api/model-review/verdict

accept का अर्थ है कि मॉडल सही था, correct का अर्थ है कि किसी व्यक्ति ने उत्तर बदला, और reject का अर्थ है कि मॉडल गलत था। reject प्री-लेबल को तुरंत आइटम से हटा देता है, और बाद के रन उस आइटम और स्कीम के लिए दोबारा भविष्यवाणी प्रकाशित नहीं करते। reject फिर भी मॉडल की प्रिसीज़न के विरुद्ध गिना जाता है, छूटे हुए लेबल के रूप में नहीं बल्कि अस्वीकृत प्री-लेबल के रूप में, और वही निर्णय दोबारा भेजने से कोई गिनती नहीं बदलती। correct निर्णय आइटम को हर बाद के रन के train स्प्लिट में ले जाता है, जैसा नीचे का सुधारे और पिन किए आइटम प्रशिक्षण में अनुभाग बताता है। उसी आइटम पर दूसरा निर्णय दर्ज करने से पहला बदल जाता है, और अज्ञात निर्णय HTTP 400 के साथ अस्वीकार होता है।

कतार को अधिग्रहण स्कोर से क्रमित करें

विश्वास का क्रम पहले वे आइटम परोसता है जहाँ मॉडल का शीर्ष उत्तर सबसे कमज़ोर है। सक्रिय अधिगम में अधिग्रहण फ़ंक्शन बिना लेबल के आइटमों को इस आधार पर क्रमित करता है कि हर आइटम पर लेबल अगले मॉडल की कितनी मदद करेगा। hf-text-classification और hf-image-classification एक acquisition पैरामीटर लेते हैं जो हर भविष्यवाणी पर ऐसा स्कोर लिखता है, और llm_confidence तब सबसे ऊँचा स्कोर पहले परोसता है। ट्रेनर को टेक्स्ट-प्रशिक्षण एक्स्ट्रा चाहिए:

pip install "potato-annotation[train-text]"

पैरामीटर के साथ रन शुरू करें, Training पेज के Parameters फ़ील्ड से या API से:

curl -X POST -H "X-API-Key: demo-admin-key" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs \
  -d '{"trainer": "hf-text-classification", "schemas": ["sentiment"],
       "params": {"acquisition": "margin"}}'

पैरामीटर पाँच मान लेता है:

margin रन की भविष्यवाणी विश्वास के बगल में स्कोर रखती है:

{"label": "positive", "confidence": 0.5207,
 "probabilities": {"negative": 0.4793, "positive": 0.5207},
 "acquisition": 0.9586}

llm_confidence के तहत अधिग्रहण स्कोर वाले आइटम पहले आते हैं, फिर केवल विश्वास वाले आइटम, फिर वे आइटम जिनकी भविष्यवाणी में विश्वास नहीं है, फिर बिना भविष्यवाणी वाले आइटम। acquisition एकल-लेबल स्कीमों (radio, select, likert) पर काम करता है। क्रम प्रकाशित प्री-लेबल पढ़ता है, इसलिए स्कीम writeback.schemas में होनी चाहिए, और बिना लेबल वाले आइटमों को कोई स्कोर मिलने के लिए include_unlabeled: true सेट होना चाहिए। model_review स्कोर को अनदेखा करता है और विश्वास का क्रम रखता है, क्योंकि समीक्षा का दौर मॉडल के गलत उत्तर खोजता है। अपस्ट्रीम का आगे क्या पूछें, यह चुनने वाला अनुभाग ब्योरा देता है।

नए रन के प्री-लेबल रखने से पहले उसके होल्ड-आउट स्कोर की तुलना sklearn-text रन से करें। Potato हर आइटम और स्कीम के लिए एक भविष्यवाणी रखता है, और नए रन की भविष्यवाणी पुरानी को बदल देती है। जहाँ नए रन की भविष्यवाणी सहेजी जाती है पर दिखाई नहीं जाती, जैसे min_confidence के तहत, वहाँ पुराने रन का प्री-लेबल भी आइटम से हट जाता है, जैसा Config बताता है। इस ट्यूटोरियल के एक CPU रन में, डिफ़ॉल्ट मॉडल के तीन epoch (params में epochs: 3) ने 84 प्रशिक्षण समीक्षाओं पर 0.52 test macro-F1 स्कोर किया, जो उन्हीं लेबलों पर sklearn-text रन से नीचे था, और रन ने 37 प्री-लेबल प्रकाशित किए। किसी रन के प्री-लेबल वापस लेने के लिए रन की भविष्यवाणियाँ हटा दें:

curl -X DELETE -H "X-API-Key: demo-admin-key" \
  http://localhost:8000/admin/training/api/runs/<run_id>/predictions

वापस लेना रन की सहेजी भविष्यवाणियाँ हटाता है और रन के प्री-लेबल आइटमों से उतार देता है। पहले के किसी रन के प्री-लेबल वापस नहीं आते, इसलिए दोबारा प्रकाशित करने के लिए फिर प्रशिक्षित करें।

अपने आप दोबारा प्रशिक्षित करें

auto_retrain एनोटेशन आने के साथ अपने आप रन शुरू करता है। जब किसी रन का होल्ड-आउट स्कोर प्री-लेबल दिखाने का समर्थन करे, तब model_training में ब्लॉक जोड़ें:

model_training:
  enabled: true
  writeback:
    schemas: ["sentiment"]
    include_unlabeled: true
    min_confidence: 0.6
  auto_retrain:
    enabled: true
    trainer: sklearn-text
    schemas: ["sentiment"]
    update_frequency: 25
    min_interval_s: 600

Potato हर एनोटेशन सहेजे जाने के बाद जाँचता है। पिछले स्वचालित रन के बाद 25 एनोटेशन आ जाने और पिछले रन के खत्म होने के बाद 600 सेकंड बीत जाने पर रन शुरू होता है। दोनों मान डिफ़ॉल्ट हैं, और trainer तथा schemas आवश्यक हैं। params ट्रेनर के पैरामीटर देता है, जैसे Training पेज का Parameters फ़ील्ड देता है।

auto_retrain को पहले एनोटेशन से नहीं, पहले मैन्युअल रन के बाद चालू करें। जिस प्रोजेक्ट का अभी कोई रन नहीं हुआ, वह update_frequency एनोटेशन होते ही प्रशिक्षित हो जाता है। शुरू से update_frequency: 20 सेट होने पर इस प्रोजेक्ट का पहला स्वचालित रन 12 समीक्षाओं पर प्रशिक्षित हुआ, 3 समीक्षाओं पर 1.0 का val macro-F1 स्कोर किया, और 72 प्री-लेबल प्रकाशित किए। 3 समीक्षाओं पर होल्ड-आउट स्कोर अगली 72 के बारे में लगभग कुछ नहीं कहता।

जब कोई जाँच रन शुरू न करने का निर्णय लेती है, तब /admin/training/api/status का skip_reason कारण देता है, जैसे "waiting for 3 more annotation(s)" या "waiting 299 more second(s) since the last run"। स्वचालित रन रन कतार में शामिल नहीं होते। कतार खाली होने के बाद सहेजा गया अगला एनोटेशन नई जाँच शुरू करता है। काउंटर मेमोरी में रहते हैं, और पुनः आरंभ के बाद जिस प्रोजेक्ट का रन पहले हो चुका है वह नए एनोटेशन पुनः आरंभ से गिनता है। जिस ट्रेनर का लाइसेंस पुष्ट करना पड़ता है (ultralytics-detect, ultralytics-segment, layoutlmv3) उसे ब्लॉक में accept_licence: true भी चाहिए, वरना हर स्वचालित रन छोड़ दिया जाता है। दोनों ब्लॉक वाली पूरी config potato validate config.yaml --strict पास करती है।

प्रशिक्षण में सुधारे और पिन किए आइटम

दो तरह के आइटम हर बाद के रन के train स्प्लिट में जाते हैं, स्थिर स्प्लिट में उनकी जगह चाहे जो हो। पहली तरह correct निर्णय वाला आइटम है। सुधार उन आइटमों से आते हैं जिन पर मॉडल सबसे बुरा रहा, और val या test में रहने पर सुधार मॉडल को उसी की अपनी गलतियों के नमूने पर स्कोर करते। accept और reject निर्णय आइटम को नहीं हिलाते। दूसरी तरह पिन किया आइटम है, जिसे एडमिन हाथ से प्रशिक्षण में भेजता है:

curl -X POST -H "X-API-Key: demo-admin-key" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/pinned \
  -d '{"instance_ids": ["review_007", "review_008"]}'

पिन किया आइटम तब प्रशिक्षित होता है जब कोई उस पर लेबल लगा दे, और तब तक हर रन आइटम को प्रतीक्षारत गिनता है। curation: {enabled: true} के साथ Catalog पेज पर किसी स्लाइस के बगल का Train on these बटन स्लाइस से मेल खाने वाली हर चीज़ पिन कर देता है, जैसे बिल्ट-इन model-found-nothing स्लाइस। DELETE /admin/training/api/pinned पिन हटाता है।

जो रन होल्ड-आउट आइटम train में ले गया, वह गिनती के साथ चेतावनी लॉग करता है। एक correct निर्णय के बाद इस ट्यूटोरियल के अगले रन ने यह लॉग किया:

1 held-out item(s) moved to train (corrected: 1). Held-out scores are computed without them, so they are not directly comparable with a run that had them.

गिनतियाँ रन बंडल की manifest.json में stats.forced_train के नीचे हैं। रनों के बीच होल्ड-आउट स्कोर की तुलना चेतावनी को ध्यान में रखकर करें, क्योंकि दोनों रनों ने अलग आइटम स्कोर किए।

रन का test स्प्लिट डेटासेट के रूप में सहेजें

स्प्लिट बदलने पर होल्ड-आउट स्कोर बदलता है, और आइटमों का एक स्थिर सेट ही दो मॉडलों को तुलनीय बनाता है। रन के पेज का Keep this split as a dataset अनुभाग रन के val, test या train आइटम, उनके सहमत मानव लेबल के साथ, किसी डेटासेट के नए संस्करण के रूप में सहेजता है। स्प्लिट चुनें, डेटासेट का नाम लिखें, और Save as dataset version पर क्लिक करें। बटन के पीछे का रूट कमांड लाइन से वही अनुरोध लेता है:

curl -X POST -H "X-API-Key: demo-admin-key" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs/<run_id>/pin-split \
  -d '{"dataset": "sentiment-test", "split": "test"}'

प्रतिक्रिया नए संस्करण और आइटमों की संख्या नामित करती है, यहाँ संस्करण v0001 के रूप में सहेजी गई 23 test समीक्षाएँ। सहेजने के बाद संस्करण बदलता नहीं, इसलिए बाद के मॉडल और डेटासेट के प्रयोग रनर के LLM प्रॉम्प्ट ठीक उन्हीं आइटमों पर स्कोर हो सकते हैं। जिस डेटासेट में संस्करण पहले से हैं, उसमें सहेजने पर केवल उसी स्प्लिट वाला नया संस्करण बनता है, ताकि बाद के रन के val आइटम उन आइटमों से न मिल जाएँ जिन पर बाद के रन ने प्रशिक्षण लिया। हर उदाहरण के इनपुट प्री-लेबल फ़ील्ड छोड़ देते हैं, ताकि मूल्यांकन मॉडल का उत्तर न पढ़ सके। datasets.enabled सेट न होने पर रूट HTTP 400 लौटाता है।

एनोटेटरों को प्री-लेबल से होल्ड-आउट रखना

config का ai_support.holdout ब्लॉक पहले एनोटेशन से एनोटेटर-आइटम जोड़ियों के 20% को सहायता से मुक्त रखता है। होल्ड-आउट जोड़ी के लिए एनोटेशन पेज कोई प्री-लेबल नहीं दिखाता, और ब्राउज़र को भेजा आइटम डेटा writeback.field (यहाँ predictions) और pre_annotation.field दोनों छोड़ देता है। चयन हर एनोटेटर और आइटम पर साल्ट वाला हैश है, इसलिए जोड़ी हर बार और पुनः आरंभ के बाद भी उसी समूह में रहती है। हर समीक्षा पर कई एनोटेटर होने पर ज़्यादातर समीक्षाओं को कुछ सहायता वाले और कुछ होल्ड-आउट एनोटेटर मिलते हैं। एडमिन डैशबोर्ड का AI influence टैब दोनों समूहों की तुलना इन बातों पर करता है कि उत्तर कितनी बार मॉडल से मेल खाते हैं, कितनी बार गोल्ड से मेल खाते हैं, और हर समूह के भीतर सहमति। num_annotators_per_item: 1 के साथ हर समीक्षा केवल एक समूह में आती है, इसलिए प्रभाव मापने वाले अध्ययन के लिए मान 1 से ऊपर रखें। तुलना कैसे पढ़ें, यह अपने लेबलों पर प्रशिक्षित मॉडल से मॉडल-सहायित लेबलिंग समझाता है।

आगे पढ़ें

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

संदर्भ

• Houlsby, N., Huszár, F., Ghahramani, Z., and Lengyel, M. (2011). Bayesian Active Learning for Classification and Preference Learning. arXiv:1112.5745. https://arxiv.org/abs/1112.5745
• Sener, O., and Savarese, S. (2018). Active Learning for Convolutional Neural Networks: A Core-Set Approach. ICLR 2018. https://arxiv.org/abs/1708.00489