त्वरित शुरुआत

यह गाइड आपको नए इंस्टॉलेशन से डेटा एनोटेट करने तक 5 मिनट से कम समय में ले जाती है। यह दिखाती है कि टास्क खुद कैसे लिखें। शुरू करने का दूसरा तरीका है कि आप अध्ययन का विवरण किसी कोडिंग एजेंट को दें और potato-skill को उसे डिज़ाइन और तैयार करने दें। यह तरीका कोडिंग एजेंट के साथ त्वरित शुरुआत में बताया गया है।

पांच चरणों में Potato

पूर्वापेक्षाएँ

• Python 3.9 या उससे अधिक
• pip पैकेज मैनेजर
• एक टर्मिनल

इंस्टॉलेशन

हम Potato को वर्चुअल एनवायरनमेंट में इंस्टॉल करने की सलाह देते हैं, ताकि वह आपके सिस्टम के Python से न टकराए:

python -m venv potato-env
source potato-env/bin/activate   # Windows: potato-env\Scripts\activate
pip install potato-annotation

इंस्टॉलेशन की पुष्टि करें:

python -c "import potato; print(potato.__version__)"

आपको 2.12.1 प्रिंट होता दिखना चाहिए। वर्शन 2.9 से potato --version भी यही नंबर बताता है, और अगर आप किसी चेकआउट से चला रहे हैं तो कमिट भी जोड़ता है।

अपना पहला प्रोजेक्ट बनाएं

1. एक प्रोजेक्ट डायरेक्टरी बनाएं

mkdir my-annotation-task
cd my-annotation-task

2. अपनी डेटा फ़ाइल बनाएं

एक data फ़ोल्डर बनाएं और उसके अंदर data.json नाम की फ़ाइल बनाएं:

mkdir data

[
  {"id": "1", "text": "I love this product! It's amazing."},
  {"id": "2", "text": "This is the worst experience ever."},
  {"id": "3", "text": "It's okay, nothing special."}
]

Potato data_files के लिए .jsonl (हर पंक्ति में एक JSON ऑब्जेक्ट), .csv और .tsv भी स्वीकार करता है। मेल खाते एक्सटेंशन वाली फ़ाइल का पाथ दें, और Potato उसी से रीडर चुन लेता है।

3. अपनी कॉन्फ़िगरेशन बनाएं

अपनी प्रोजेक्ट डायरेक्टरी में config.yaml नाम की फ़ाइल बनाएं:

पाथ सैंडबॉक्स: आपकी कॉन्फ़िगरेशन के अंदर के सभी रिलेटिव पाथ (जैसे data_files या output_annotation_dir) task_dir के सापेक्ष हल किए जाते हैं और उन्हें उसी के अंदर रहना चाहिए। जो पाथ task_dir से बाहर हल होते हैं, उन्हें पाथ ट्रैवर्सल रोकने के लिए अस्वीकार कर दिया जाता है।

annotation_task_name: "Sentiment Analysis"
 
# All relative paths below are resolved against task_dir.
task_dir: "."
 
# Data configuration
data_files:
  - "data/data.json"
 
# Tell Potato which fields in each record to use.
# id_key = unique identifier; text_key = the text shown to annotators.
item_properties:
  id_key: id
  text_key: text
 
# Where per-user annotation state is stored (relative to task_dir).
output_annotation_dir: "annotation_output/"
 
# Also write a periodic flat export, because the per-user state files are
# awkward to analyze. No exporter is named "json", so use "jsonl".
export_annotation_format: "jsonl"
 
# Annotation scheme
annotation_schemes:
  - annotation_type: radio
    name: sentiment
    description: "What is the sentiment of this text?"   # required for radio schemes
    labels:
      - Positive
      - Negative
      - Neutral
 
# Skip password authentication so anyone can log in with just a username.
require_password: false

4. सर्वर शुरू करें

potato start config.yaml -p 8000

समतुल्य लंबा रूप:

python -m potato start config.yaml -p 8000

अगर पोर्ट 8000 पहले से उपयोग में है, तो -p 8001 से कोई दूसरा पोर्ट चुनें। सर्वर रोकने के लिए टर्मिनल में Ctrl+C दबाएं।

तेज़ पहला रन: प्रयोग करते समय लॉगिन और सहमति पेज छोड़ने के लिए --debug --debug-phase=annotation जोड़ें: potato start config.yaml --debug --debug-phase=annotation। तब हर विज़िटर एक ही साझा debug_user के रूप में साइन इन होता है, इसलिए इसे केवल अपनी मशीन पर उपयोग करें।

5. अपना ब्राउज़र खोलें

http://localhost:8000 पर जाएं। आपको एक लॉगिन स्क्रीन दिखेगी जिसमें केवल एक username फ़ील्ड होगा। कुछ भी टाइप करें (जैसे alice) और Continue पर क्लिक करें, और आप एनोटेट करना शुरू कर देंगे।

हर बार जब आप कोई लेबल चुनकर Next पर क्लिक करते हैं, आपका एनोटेशन अपने-आप सेव हो जाता है। कोई अलग "सेव" बटन नहीं है।

आपके एनोटेशन कहां जाते हैं

एनोटेट करते समय Potato हर उपयोगकर्ता की स्थिति लिखता है:

my-annotation-task/
├── config.yaml
├── data/
│   └── data.json
└── annotation_output/              # created automatically
    └── alice/
        └── user_state.json         # one folder per username

user_state.json में उस उपयोगकर्ता की पूरी एनोटेशन स्थिति होती है। सभी एनोटेटरों की एक समेकित, फ़्लैट फ़ाइल बनाने के लिए Potato का एक्सपोर्ट CLI चलाएं, जिसका वर्णन एक्सपोर्ट दस्तावेज़ में है। इसके द्वारा रजिस्टर किए गए सभी फ़ॉर्मैट देखने के लिए python -m potato.export --list-formats चलाएं।

पहली बार चलाने पर आम समस्याएं

• Address already in use। पोर्ट 8000 पहले से लिया हुआ है। -p 8001 (या कोई भी खाली पोर्ट) इस्तेमाल करें।
• KeyError: 'description'। किसी radio (या उसके जैसी) स्कीम में उसका ज़रूरी description फ़ील्ड नहीं है। हर स्कीम को इसकी ज़रूरत होती है।
• Path ... is outside the task directory। कोई data_files या output_annotation_dir पाथ task_dir से बाहर जाता है। सब कुछ प्रोजेक्ट फ़ोल्डर के अंदर रखें, या task_dir को ऐसे एब्सोल्यूट पाथ पर सेट करें जिसमें ये सब शामिल हों।
• लॉगिन पेज पर पासवर्ड फ़ील्ड दिखता है। आप require_password: false भूल गए हैं, या आप किसी कैश्ड ब्राउज़र टैब पर हैं। सर्वर रीस्टार्ट करें और हार्ड-रिफ़्रेश करें।

अक्सर पूछे जाने वाले प्रश्न

नीचे के प्रश्न Potato को इंस्टॉल करने, उसे Docker में चलाने और एनोटेटरों के देखने से पहले कॉन्फ़िगरेशन जांचने के बारे में हैं।

Potato कैसे इंस्टॉल करें?

इसे PyPI से pip install potato-annotation के ज़रिए, Python 3.9 या उससे अधिक पर इंस्टॉल करें। वर्चुअल एनवायरनमेंट में इंस्टॉल करने से Potato की डिपेंडेंसी आपके सिस्टम के Python से अलग रहती हैं, और potato --version वर्शन नंबर प्रिंट करके इंस्टॉलेशन की पुष्टि करता है।

क्या Potato को Docker में चलाया जा सकता है?

हां। Potato एक पहले से बनी इमेज, ghcr.io/davidjurgens/potato, GitHub Container Registry पर प्रकाशित करता है। आपका प्रोजेक्ट फ़ोल्डर कंटेनर में /app पर माउंट होता है और सर्वर उसके अंदर पोर्ट 7860 पर सुनता है, इसलिए एक ही इमेज हर टास्क के लिए काम आती है। POTATO_SECRET_KEY सेट करें ताकि रीस्टार्ट के बाद भी एनोटेटरों के सेशन बने रहें। Potato को सर्वर पर तैनात करना में पूरा docker run कमांड दिया गया है।

एनोटेटरों के देखने से पहले Potato कॉन्फ़िगरेशन कैसे जांचें?

potato validate config.yaml --strict चलाएं। यह कॉन्फ़िगरेशन को उसी तरह जांचता है जैसे सर्वर शुरू होते समय जांचता है, और चेतावनियों को, जैसे किसी अपरिचित की को, विफलता में बदल देता है। इसके बाद potato preview config.yaml दिखाता है कि कॉन्फ़िगरेशन क्या घोषित करता है और इंटरफ़ेस को ब्राउज़र में रेंडर करता है, ताकि किसी के लॉग इन करने से पहले आप टास्क को वैसे ही देख सकें जैसे कोई एनोटेटर देखेगा।

आगे क्या?

• अधिक विकल्पों के लिए कॉन्फ़िगरेशन मूल बातें जानें
• potato-skill की मदद से कोडिंग एजेंट से अपना अगला टास्क डिज़ाइन और तैयार करवाएं
• विभिन्न एनोटेशन प्रकारों का अन्वेषण करें
• अपनी टीम के लिए उपयोगकर्ता प्रबंधन सेट करें
• AI सपोर्ट और एक्टिव लर्निंग सहित v2 में नया क्या है देखें

टूल्स और उपयोगिताएं

मूल बातों में सहज होने के बाद, ये उपयोगी टूल देखें:

• Preview CLI - सर्वर चलाए बिना कॉन्फ़िगरेशन को मान्य करें
• Debugging Guide - डीबग फ्लैग और समस्या निवारण के सुझाव
• User Simulator - सिमुलेटेड एनोटेटरों के साथ परीक्षण करें