अणुओं, स्पेक्ट्रा, सिग्नलों और रोबोट एपिसोड पर मॉडल प्रशिक्षित करें

v2.14.0 में नया

यह ट्यूटोरियल Potato अध्ययन में वैज्ञानिक एनोटेशन पर चार मॉडल प्रशिक्षित करता है। rdkit-property किसी अणु के बारे में एक प्रश्न का उत्तर देता है, peak-cnn NMR, IR, Raman, UV-Vis और मास स्पेक्ट्रा पर पीक चुनता है, signal-cnn स्लीप एपॉक का चरण तय करता है या EEG, ECG और सेंसर रिकॉर्डिंग पर लेबल किए अंतराल चिह्नित करता है, और episode-model रोबोट एपिसोड के फ़ेज़, परिणाम और रिवॉर्ड वक्र चिह्नित करता है। यह पेज उन टीमों के लिए है जो पहले से Potato में अणु, स्पेक्ट्रा, सिग्नल या रोबोट एपिसोड एनोटेट करती हैं और चाहती हैं कि बाकी आइटम को प्री-लेबल एक मॉडल लगाए। हर ट्रेनर के लिए पेज potato validate config.yaml --strict पास करने वाला config, रन क्या सीखता है, कौन-सा होल्ड-आउट स्कोर पढ़ना है, और भविष्यवाणियाँ एनोटेटरों तक कैसे पहुँचती हैं, यह देता है। अपना पहला मॉडल प्रशिक्षित करें टेक्स्ट क्लासिफ़ायर के साथ Training पेज के चरण दिखाता है, और यह ट्यूटोरियल उसी वॉकथ्रू को पहले से पढ़ा मानता है।

चार ट्रेनर

हर ट्रेनर एक एनोटेशन स्कीम के उत्तरों से सीखता है, और मॉडल का इनपुट उस डिस्प्ले या फ़ाइल से पढ़ता है जिसकी ओर स्कीम इशारा करती है:

rdkit-property एक scikit-learn मॉडल फ़िट करता है, और बाकी तीन ट्रेनर model_training.device जिस डिवाइस को चुनता है उस पर छोटे PyTorch नेटवर्क फ़िट करते हैं। हर रन एक स्कीम पर प्रशिक्षित होता है, मॉडल को रन के होल्ड-आउट val और test आइटम पर स्कोर करता है, और राइट-बैक केवल writeback.schemas में सूचीबद्ध स्कीम के लिए करता है। रन के train स्प्लिट के आइटम को कभी प्री-लेबल नहीं मिलता। peak-cnn, signal-cnn और episode-model वह चेकपॉइंट रखते हैं जिस एपॉक ने val पर सबसे अच्छा स्कोर किया, इसलिए Potato इन तीन नेटवर्कों का होल्ड-आउट स्कोर test से लेता है। छोटे अध्ययन में test आइटम कम होते हैं, और रन की test_n मीट्रिक स्कोर के पीछे की गिनती देती है।

तीनों नेटवर्क किसी आइटम की भविष्यवाणी को उस भविष्यवाणी के सबसे अनिश्चित हिस्से का विश्वास देते हैं, यानी सबसे कमज़ोर पीक, अंतराल, फ़ेज़ या परिणाम का। इसलिए writeback.min_confidence सीमा किसी एक हिस्से के सीमा से नीचे होने पर पूरा आइटम रोक देती है। rdkit-property की स्लाइडर भविष्यवाणी में विश्वास मान नहीं होता और वह सीमा हमेशा पार कर लेती है।

rdkit-property से अणु के गुण

rdkit-property उस अणु के बारे में प्रश्न के उत्तर सीखता है जिसे आइटम दिखाता है, और मॉडल का इनपुट आइटम का टेक्स्ट नहीं बल्कि अणु की संरचना है। हर संरचना त्रिज्या 2 और 2,048 बिट का Morgan फ़िंगरप्रिंट बनती है, जिसके बाद RDKit के 2D डिस्क्रिप्टर आते हैं, जैसे आणविक भार और logP। त्रिज्या 2 पर Morgan फ़िंगरप्रिंट ECFP4 के बराबर है, यानी 4 बंध के व्यास वाला एक्सटेंडेड-कनेक्टिविटी फ़िंगरप्रिंट। डिफ़ॉल्ट रूप से लॉजिस्टिक रिग्रेशन radio, select या likert उत्तर फ़िट करता है, और रिज रिग्रेशन slider को। दोनों के लिए विकल्प रैंडम फ़ॉरेस्ट है। प्रशिक्षण करने वाले सर्वर पर RDKit इंस्टॉल करें:

pip install "potato-annotation[chemistry]"

नीचे का config हर यौगिक को संरचना के चित्र के रूप में दिखाता है और दो प्रश्न पूछता है, यौगिक बनाना कितना कठिन होगा इसके लिए 1 से 10 का स्लाइडर, और यौगिक को आगे बनाने के बारे में हाँ-या-नहीं का विकल्प:

annotation_task_name: "Compound triage"
task_dir: .
output_annotation_dir: annotation_output
data_files: [data/molecules.jsonl]
item_properties: {id_key: id, text_key: note}
user_config:
  allow_all_users: true
 
instance_display:
  fields:
    - key: smiles                 # SMILES, a molfile, or a .mol, .sdf or .smi file
      type: molecule
      label: "Compound"
 
annotation_schemes:
  - annotation_type: slider
    name: synthesis
    description: "How hard would this compound be to make? 1 is one step from a catalog reagent, 10 is a research project."
    min_value: 1
    max_value: 10
    starting_value: 5
    step: 1
  - annotation_type: radio
    name: advance
    description: "Would you make this compound next?"
    labels: ["yes", "no"]
 
model_training:
  enabled: true
  writeback:
    schemas: [synthesis, advance]
    include_unlabeled: true
    min_confidence: 0.6

डेटा फ़ाइल की हर पंक्ति में एक यौगिक है:

{"id": "cpd_023", "smiles": "CC(=O)Nc1ccc(O)cc1", "note": "Compound 23"}

ट्रेनर संरचना instance_display के पहले molecule फ़ील्ड से लेता है। जिस अध्ययन में molecule फ़ील्ड नहीं है, वह chemical_structure स्कीम के बगल में प्रश्न पूछ सकता है, और तब ट्रेनर उस संरचना से सीखता है जो एनोटेटरों ने बनाई। जब एनोटेटरों ने अलग-अलग संरचनाएँ बनाई हों, ट्रेनर सबसे आम चित्र लेता है, और जब किसी ने नहीं बनाई, ट्रेनर वह संरचना लेता है जिससे एडिटर शुरू हुआ था (prefill_field)। Training पेज molecule फ़ील्ड के लिए rdkit-property तब देता है जब कम से कम 80% आइटम फ़ील्ड भरते हों। जिस संरचना को RDKit पार्स न कर सके वह प्रशिक्षण से बाहर रहती है, उसे भविष्यवाणी नहीं मिलती, और वह रन की n_unparseable मीट्रिक में गिनी जाती है। विकल्प या Likert प्रश्न के लिए Training पेज टेक्स्ट ट्रेनर भी देता है, क्योंकि आइटम में अब भी टेक्स्ट है।

स्लाइडर की भविष्यवाणी स्लाइडर के step तक गोल की जाती है और min_value तथा max_value के बीच रखी जाती है, इसलिए मॉडल हमेशा ऐसी स्थिति सुझाता है जो स्लाइडर में है। स्लाइडर का मुख्य स्कोर सटीक-स्थिति सटीकता है, जो उत्तर 7 के सामने भविष्यवाणी 6 को गलत गिनती है। भविष्यवाणियाँ दिखाने लायक करीब हैं या नहीं यह तय करने से पहले सटीकता के साथ औसत निरपेक्ष त्रुटि val_mae या test_mae पढ़ें। रन को train स्प्लिट में कम से कम 10 लेबल किए गए अणु चाहिए। model, class_weight, radius और bits जैसे पैरामीटर Training पेज के Parameters फ़ील्ड में या API अनुरोध में जाते हैं:

curl -X POST -H "X-API-Key: $KEY" -H "Content-Type: application/json" \
  http://localhost:8000/admin/training/api/runs \
  -d '{"trainer": "rdkit-property", "schemas": ["advance"],
       "params": {"model": "random_forest", "class_weight": "balanced"}}'

रन का लॉग अणुओं की संख्या, फ़ीचर की संख्या और मॉडल का नाम देता है। संतुलित क्लास भार दुर्लभ उत्तरों को अधिक महत्व देता है। जब अधिकतर यौगिकों को एक ही उत्तर मिले तब class_weight: balanced का उपयोग करें। रन पूरा होने पर बिना लेबल वाला यौगिक खोलने वाले एनोटेटर को स्लाइडर मॉडल के मान पर और मॉडल का चुना विकल्प चयनित मिलता है, दोनों संपादन योग्य।

peak-cnn से स्पेक्ट्रा पर पीक

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

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

नीचे का config एनोटेटरों से 1H NMR स्पेक्ट्रा पर सुझाए गए पीक की समीक्षा करवाता है:

annotation_task_name: "1H NMR peak picking"
task_dir: .
media_directory: media
output_annotation_dir: annotation_output
data_files: [data/spectra.jsonl]
item_properties: {id_key: id, text_key: note}
user_config:
  allow_all_users: true
 
instance_display:
  fields:
    - key: spectrum
      type: spectrum
      label: "1H NMR"
      display_options:
        prepick:
          method: auto            # item peaks, then model, then file peak table, then detector
          prominence: 0.05
          max_peaks: 30
 
annotation_schemes:
  - annotation_type: peak_picking
    name: peaks
    description: "Accept or reject each suggested peak, and add any the suggestions missed"
    viewer_field: spectrum
    peak_fields:
      - name: assignment
        placeholder: "e.g. OCH2"
    require_review: true
    label_requirement: {required: true}
 
model_training:
  enabled: true
  trainer_params:
    peak-cnn:
      tolerance: 0.02             # ppm
  writeback:
    schemas: [peaks]
    include_unlabeled: true

मॉडल के पीक एनोटेटरों तक केवल डिस्प्ले की prepick सेटिंग से पहुँचते हैं, और prepick के बिना डिस्प्ले कोई सुझाव नहीं दिखाता। method: auto के अंतर्गत डिस्प्ले पहले आइटम के अपने peaks देता है, फिर मॉडल के पीक, फिर फ़ाइल की पीक तालिका, और फिर वे पीक जो डिटेक्टर पाता है। पहले रन से पहले एनोटेटर डिटेक्टर के सुझावों की समीक्षा करते हैं, और रन के बाद वही आइटम बिना रीस्टार्ट के मॉडल के पीक दिखाते हैं। method: model के साथ डिस्प्ले केवल मॉडल के पीक दिखाता है। डिटेक्टर के सुझाव मिलाए बिना यह नापने के लिए कि एनोटेटर मॉडल के पीक कितनी बार स्वीकार करते हैं, method: model का उपयोग करें। हर मॉडल पीक "· model" के साथ सूचीबद्ध होता है, डिस्प्ले सबसे अधिक विश्वास वाले max_peaks रखता है, और स्वीकार किया गया मॉडल पीक source: model के साथ सहेजा जाता है।

tolerance पैरामीटर तय करता है कि भविष्यवाणी किया गया पीक किसी एनोटेट किए गए पीक से x इकाइयों में कितना दूर हो सकता है और फिर भी मिला हुआ गिना जाए। tolerance के बिना रन स्पेक्ट्रम की x सीमा का 0.5% उपयोग करता है, और 12 ppm की 1H विंडो का 0.5% 0.06 ppm है। 400 MHz पर 7 Hz का कपलिंग मल्टिप्लेट की रेखाओं को 0.0175 ppm से अलग करता है। डिफ़ॉल्ट सहनशीलता उस अंतर से चौड़ी है, और config उसकी जगह 0.02 ppm सेट करता है। रन उन पीक पर परिशुद्धता, रिकॉल और F1 स्कोर करता है जो एक-से-एक, निकटतम पहले, मिलाए गए हों, और मिले पीक का औसत ऑफ़सेट रिपोर्ट करता है। जिस स्पेक्ट्रम को एनोटेटर ने बिना पीक का कहा, उस पर भविष्यवाणी किया गया पीक झूठा अलार्म गिना जाता है। रन को train स्प्लिट में कम से कम 5 एनोटेट किए गए स्पेक्ट्रा चाहिए।

नेटवर्क के देखने से पहले हर स्पेक्ट्रम को length बिंदुओं में पुनर्नमूना किया जाता है, डिफ़ॉल्ट 4,096। जब पीक x सीमा के 1/length से संकरे हों, जैसे उच्च-विभेदन मास स्पेक्ट्रम में, तब length बढ़ाएँ। mzML फ़ाइलें पढ़ने के लिए भी spectra एक्स्ट्रा चाहिए, जैसा स्पेक्ट्रम डिस्प्ले पेज बताता है।

signal-cnn से स्लीप चरण और सिग्नल अंतराल

signal-cnn EEG, ECG, EMG और एक्सेलेरोमीटर डेटा जैसी शारीरिक और सेंसर रिकॉर्डिंग पर interval_label उत्तरों से सीखता है। नेटवर्क एक छोटा InceptionTime मॉडल है, जो तीन चौड़ाइयों के समानांतर कन्वोल्यूशन का ढेर है। ट्रेनर हर रिकॉर्डिंग को टाइम-सीरीज़ डिस्प्ले के रीडरों से पढ़ता है, डिस्प्ले जिन चैनलों का नाम देता है उन्हें लेता है, हर चैनल को rate (डिफ़ॉल्ट 100 Hz) पर पुनर्नमूना करता है, और हर चैनल को मानकीकृत करता है। PyTorch इंस्टॉल करें, और WFDB तथा Parquet रिकॉर्डिंग के लिए signals एक्स्ट्रा:

pip install "potato-annotation[train-vision,signals]"

नीचे का config रात भर की पॉलीसोम्नोग्राफ़ी पर नींद को 30-सेकंड के एपॉक में स्कोर करता है, वैसे जैसे मानव स्कोरर हर एपॉक को wake, N1, N2, N3 या REM लेबल करता है:

annotation_task_name: "Sleep staging"
task_dir: .
media_directory: media
output_annotation_dir: annotation_output
data_files: [data/psg.jsonl]
item_properties: {id_key: id, text_key: note}
user_config:
  allow_all_users: true
 
instance_display:
  fields:
    - key: signal
      type: time_series
      label: "PSG"
      display_options:
        window: 30
        channels: ["EEG Fpz-Cz", "EOG", "EMG chin"]   # also the channels signal-cnn reads
 
annotation_schemes:
  - annotation_type: interval_label
    name: stage
    description: "Sleep stage of each 30-second epoch"
    signal_field: signal
    mode: epoch
    epoch_length: 30
    require_all_epochs: true
    label_requirement: {required: true}
    labels:
      - {name: W, key_value: "1"}
      - {name: N1, key_value: "2"}
      - {name: N2, key_value: "3"}
      - {name: N3, key_value: "4"}
      - {name: REM, key_value: "5"}
 
model_training:
  enabled: true
  writeback:
    schemas: [stage]
    include_unlabeled: true

स्कीम का mode कार्य तय करता है। epoch मोड में हर एनोटेट किया गया एपॉक एक प्रशिक्षण उदाहरण है, और मॉडल नई रिकॉर्डिंग के हर एपॉक को लेबल करता है। जिस अंतिम एपॉक की रिकॉर्डिंग एपॉक की लंबाई के आधे से कम है, उसे लेबल नहीं मिलता। होल्ड-आउट मुख्य स्कोर एनोटेट किए गए एपॉक पर macro-F1 है। macro-F1 N1 जैसे दुर्लभ चरण को N2 जितना ही भार देता है। डिफ़ॉल्ट रूप से प्रशिक्षण हानि हर चरण को उल्टी लेबल आवृत्ति से भारित करती है (balanced: true), और तब N1 एपॉक N2 एपॉक से अधिक गिना जाता है। हर रिकॉर्डिंग पहली प्रशिक्षण रिकॉर्डिंग के चैनलों के साथ, उसी क्रम में पढ़ी जाती है, और जिस रिकॉर्डिंग में कोई प्रशिक्षण चैनल न हो, उसे गायब चैनल की जगह सपाट रेखा मिलती है। जो डिस्प्ले कोई चैनल नाम नहीं देता, वह ट्रेनर को max_channels (16) तक हर चैनल देता है।

free मोड इसके बजाय चिह्नित खंडों पर प्रशिक्षित होता है। आर्टिफ़ैक्ट या अराउज़ल चिह्नित करने के लिए उसी signal_field पर mode: free वाली दूसरी interval_label स्कीम जोड़ें:

  - annotation_type: interval_label
    name: artifacts
    description: "Mark artifacts"
    signal_field: signal
    mode: free
    labels:
      - {name: artifact, key_value: "a"}
      - {name: spike, key_value: "s", kind: event}

free मोड में नेटवर्क यादृच्छिक 30-सेकंड क्रॉप (window_s) पर प्रशिक्षित होता है, हर 1-सेकंड फ़्रेम (frame_s) को लेबल करता है, एक ही लेबल वाले लगातार फ़्रेमों को एक अंतराल में मिलाता है, और min_duration से छोटे अंतराल छोड़ देता है। मुख्य स्कोर अंतराल F1 है, जो भविष्यवाणी किए गए अंतराल को उसी लेबल वाले एनोटेट किए अंतराल से IoU 0.5 पर मिलाता है। ऊपर के spike लेबल जैसी बिंदु घटनाएँ न प्रशिक्षित होती हैं न भविष्यवाणी की जाती हैं। रन को train स्प्लिट में कम से कम 3 एनोटेट की गई रिकॉर्डिंग चाहिए, और epoch मोड को डेटा में कम से कम दो अलग लेबल भी चाहिए।

मॉडल के अंतराल रिकॉर्डिंग पर धराशायी रेखाओं वाले प्री-एनोटेशन के रूप में दिखते हैं, "· from the model" के साथ सूचीबद्ध होते हैं, और एनोटेटर के पहले बदलाव करने या "Keep these" पर क्लिक करने पर सहेजे जाते हैं। रिकॉर्डिंग के अपने एनोटेशन को प्राथमिकता मिलती है। जिस EDF+ फ़ाइल में हिप्नोग्राम है वह हिप्नोग्राम दिखाती है, मॉडल के अंतराल नहीं, और यही preannotation_field अंतराल वाले आइटम पर लागू होता है। स्कीम पर pre_annotations: false सेट करने से दोनों तरह के बंद हो जाते हैं।

episode-model से रोबोट एपिसोड

episode-model episode_annotation उत्तर की तीन परतें सीखता है, यानी फ़ेज़, परिणाम और प्रगति रिवॉर्ड वक्र। मॉडल का इनपुट एपिसोड की दर्ज की हर संख्यात्मक श्रृंखला है, जैसे जोड़ों की स्थितियाँ और ग्रिपर की स्थिति, प्रति फ़्रेम एक पंक्ति के साथ। इनपुट में वे श्रृंखलाएँ शामिल हैं जिन्हें series_shown स्क्रीन से बाहर रखता है, और वीडियो शामिल नहीं है। मॉडल ऐसा फ़ेज़ नहीं पा सकता जो केवल कैमरे पर दिखे और रोबोट के मापों को अपरिवर्तित छोड़े। PyTorch इंस्टॉल करें, साथ में LeRobot डेटासेट के लिए pyarrow या HDF5 डेमो के लिए h5py:

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

नीचे का config पिक-एंड-प्लेस डेमोंस्ट्रेशन पर तीनों परतें इकट्ठा करता है, जैसा रोबोट एपिसोड पेज बताता है:

annotation_task_name: "Robot episode review"
task_dir: .
media_directory: media
output_annotation_dir: annotation_output
data_files: [data/episodes.jsonl]
item_properties: {id_key: id, text_key: note}
user_config:
  allow_all_users: true
 
annotation_schemes:
  - annotation_type: episode_annotation
    name: episode_review
    description: "Mark the phases, judge the outcome, and draw the progress."
    source_field: episode
    layers: [phases, outcome, reward]
    phases:
      - {name: reach, key_value: "1"}
      - {name: grasp, key_value: "2"}
      - {name: transport, key_value: "3"}
      - {name: place, key_value: "4"}
      - {name: retract, key_value: "5"}
    outcomes: [success, partial, failure]
    failure_causes: [missed grasp, object slipped, collision]
    reward_range: [0.0, 1.0]
    series_shown: [gripper, wrist_force, shoulder_lift, elbow]
 
model_training:
  enabled: true
  writeback:
    schemas: [episode_review]
    include_unlabeled: true

नेटवर्क श्रृंखला पर कन्वोल्यूशन चलाकर उसे तीन हेड वाले द्विदिश GRU में भेजता है, एक हर फ़्रेम के फ़ेज़ के लिए, एक एपिसोड के परिणाम के लिए, और एक हर फ़्रेम के रिवॉर्ड के लिए। जो परत किसी उत्तर में खाली है वह उस एपिसोड की हानि से बाहर रहती है, इसलिए केवल परिणाम से चिह्नित एपिसोड भी परिणाम हेड को प्रशिक्षित करता है। परिणाम हेड तब प्रशिक्षित होता है जब प्रशिक्षण एपिसोड में कम से कम दो अलग परिणाम हों। रिवॉर्ड हेड केवल उस खंड पर प्रशिक्षित होता है जहाँ एनोटेटर ने वक्र खींचा, क्योंकि उस खंड के बाहर एनोटेटर ने कोई उत्तर नहीं दिया। max_frames (2,000) से लंबे एपिसोड यादृच्छिक क्रॉप पर प्रशिक्षित होते हैं।

भविष्यवाणी सहेजे गए उत्तर के आकार की होती है, जिसमें स्कीम की सूची के फ़ेज़, स्कीम का एक परिणाम, और reward_range के भीतर 50 बिंदुओं का रिवॉर्ड वक्र होता है, उन परतों के लिए जो स्कीम दिखाती है। भविष्यवाणी टाइमलाइन को पहले से भरती है और एनोटेटर के टाइमलाइन संपादित करने पर सहेजी जाती है। विफलता का कारण और निर्देश एनोटेटर पर छोड़े जाते हैं। होल्ड-आउट मुख्य स्कोर 0.1-सेकंड ग्रिड पर फ़ेज़ macro-F1 है। रन IoU 0.5 पर फ़ेज़ सेगमेंट F1, परिणाम की सटीकता, और जहाँ वक्र खींचा गया वहाँ रिवॉर्ड वक्र का Pearson r भी रिपोर्ट करता है। जिस स्कीम में फ़ेज़ नहीं हैं, वह परिणाम की सटीकता को मुख्य स्कोर लेती है, और फिर रिवॉर्ड सहसंबंध को। रन को train स्प्लिट में कम से कम 5 एनोटेट किए गए एपिसोड चाहिए। rollout_evaluation के लिए Potato में कोई ट्रेनर नहीं है, क्योंकि रोलआउट वरीयता वीडियो की तुलना करती है और episode-model कोई वीडियो नहीं पढ़ता।

रन शुरू करें और परिणाम जाँचें

model_training जोड़ने के बाद सर्वर रीस्टार्ट करें:

potato start config.yaml -p 8000

/admin/training खोलें, स्कीम और ट्रेनर चुनें, और Train now पर क्लिक करें। पेज केवल वे ट्रेनर देता है जो हर स्कीम के अनुकूल हैं, और जो ट्रेनर इंस्टॉल नहीं है उसे "not installed" के रूप में, इंस्टॉल कमांड के साथ सूचीबद्ध करता है। रन पूरा होने पर Potato होल्ड-आउट स्कोर Runs तालिका में सूचीबद्ध करता है, और स्प्लिट तथा मीट्रिक टूलटिप में होते हैं। रन पेज हर मीट्रिक और हर आइटम का स्प्लिट सूचीबद्ध करता है। GET /admin/training/api/status में राइट-बैक रिपोर्ट प्रकाशित भविष्यवाणियाँ और हर जाँच से रोकी गई भविष्यवाणियाँ गिनती है, जैसे n_skipped_low_confidence।

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

आगे पढ़ें

• मॉडल प्रशिक्षण का अवलोकन
• सभी ट्रेनर
• रासायनिक संरचनाएँ, स्पेक्ट्रा और टाइम सीरीज़
• रोबोट एपिसोड एनोटेशन और रोबोट एपिसोड गाइड
• रसायन विज्ञान के लिए Potato, शरीर क्रिया विज्ञान और रोबोटिक्स
• मॉडल-सहायता प्राप्त लेबलिंग
• rdkit-property, peak-cnn, signal-cnn और episode-model के लिए अपस्ट्रीम संदर्भ

संदर्भ

• Ismail Fawaz, H., Lucas, B., Forestier, G., Pelletier, C., Schmidt, D. F., Weber, J., Webb, G. I., Idoumghar, L., Muller, P.-A., and Petitjean, F. (2020). InceptionTime: Finding AlexNet for Time Series Classification. Data Mining and Knowledge Discovery, 34(6), 1936-1962. https://doi.org/10.1007/s10618-020-00710-y
• Rogers, D., and Hahn, M. (2010). Extended-Connectivity Fingerprints. Journal of Chemical Information and Modeling, 50(5), 742-754. https://doi.org/10.1021/ci100050t