बढ़ावा देने के लिए एक संक्षिप्त परिचय :: program_options

एल्गोरिदम के विकास में लगे हुए, मैं लगातार अपने आप को खींचता हूं, और अचानक एक छोटे से उदाहरण पर काम करने वाले परिवर्तन अन्य, बड़े डेटा पर भ्रम और परिणाम में उलझाएंगे। तब कमांड लाइन मेरी सहायता के लिए आती है। सबसे बुरी बात यह है कि हर बार हम तर्क पार्सर को लागू करने से थक गए हैं, जिसका अर्थ है कि बूस्ट लाइब्रेरी से program_options पैकेज C ++ प्रोग्रामर के लिए अंतिम उपाय नहीं है।

एक उदाहरण से शुरू करते हैं। मान लीजिए कि मैं प्रशिक्षण के साथ कुछ के लिए एक मान्यता एल्गोरिदम विकसित कर रहा हूं, और हमारे पास निम्नलिखित डेटा है। कुछ डेटा और एक्सटेंशन .dat (डेटा) के साथ फ़ाइलें; प्रशिक्षण जानकारी और एक्सटेंशन के साथ फ़ाइलें .trn (ट्रेन) और एक्सटेंशन .prs (पैरामीटर) के साथ पैरामीटर फाइलें। पैरामीटर फ़ाइलों को प्रशिक्षण के परिणामस्वरूप प्राप्त किया जाता है और मान्यता के लिए उपयोग किया जाता है। तो, हमारे पास 3 क्रियाएं हैं: ट्रेन (ट्रेन), पहचान (पहचान), स्कोर (मान्यता की गुणवत्ता का मूल्यांकन)। इस मामले में, उदाहरण के लिए, प्रशिक्षण, मान्यता, मूल्यांकन श्रृंखला कॉल स्क्रिप्ट दिखती है:

recognizer --type=train --input=train.dat --info=train.trn --output=best.prs recognizer --type=recognize --input=test1.dat --input=test2.dat --params=best.prs --output=./ recognizer --type=score --ethanol=test1_expected.trn --test=test1.trn --output=scores.txt recognizer --type=score --ethanol=test2_expected.trn --test=test2.trn --output=scores.txt 

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

  po::options_description desc("General options"); std::string task_type; desc.add_options() ("help,h", "Show help") ("type,t", po::value<std::string>(&task_type), "Select task: train, recognize, score") ; po::options_description train_desc("Train options"); train_desc.add_options() ("input,I", po::value<std::string>(), "Input .dat file") ("info,i", po::value<std::string>(), "Input .trn file") ("output,O", po::value<std::string>(), "Output parameters file .prs") ; po::options_description recognize_desc("Recognize options"); recognize_desc.add_options() ("input,I", po::value<std::vector<std::string> >(), "Input .dat file") ("params,p", po::value<std::string>(), "Input .prs file") ("output,O", po::value<std::string>(), "Output directory") ; po::options_description score_desc("Score options"); score_desc.add_options() ("ethanol,e", po::value<std::string>(), "Etalon .trn file") ("test,t", po::value<std::string>(), "Testing .trn file") ("output,O", po::value<std::string>(), "Output comparison file") ; 

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

  ("input,I", po::value<std::string>(), "Input .dat file") 

पहला तर्क इनपुट है, मैं वास्तव में तर्क के लिए दो विकल्प हैं: इनपुट तर्क का लंबा नाम है, मैं छोटा हूं (केस महत्वपूर्ण है)। बढ़ावा देने की ख़ासियत :: program_options यह है कि संक्षिप्त नाम हमेशा एकल-अक्षर होना चाहिए (आप, हालांकि, इसे सेट नहीं कर सकते हैं)। कमांड लाइन पर एक लंबे नाम के लिए एक कॉल इस तरह दिखेगा:

  --input=train.dat 

पहली नज़र में एक छोटा तर्क, कम पठनीय, लेकिन मैं इसका उपयोग करना पसंद करता हूं:

  -Itrain.dat 

दूसरा पैरामीटर पो :: मान <std :: string> () तर्क मान के प्रारूप को परिभाषित करता है (चिन्ह बराबर होने के बाद वाला भाग) और अनुपस्थित होने पर कोई मान आवश्यक नहीं है। उदाहरण के लिए, निम्नलिखित कॉल समतुल्य हैं:

  recognizer --help recognizer -h 

यदि आप अधिक बारीकी से देखते हैं, तो आप देखेंगे कि पहचान समूह में, इनपुट तर्क प्रकार का है:

  po::value<std::vector<std::string> >() 

std :: वेक्टर <std :: string> का अर्थ है कि इनपुट कमांड लाइन के तर्कों में एक से अधिक बार दिखाई दे सकता है, अर्थात, हमारे मामले में, हम एक समय में एक से अधिक फ़ाइल पहचान सकते हैं। उदाहरण के लिए:

  recognizer --type=recognize -itest1.dat -itest2.dat -pbest.prs -O./ 

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

 me@my: ./recognizer -h General options: -h [ --help ] Show help -t [ --type ] arg Select task: train, recognize, score Train options: -I [ --input ] arg Input .dat file -i [ --info ] arg Input .trn file -O [ --output ] arg Output parameters file .prs Recognize options: -I [ --input ] arg Input .dat file -p [ --params ] arg Input .prs file -O [ --output ] arg Output directory Score options: -e [ --ethanol ] arg Etalon .trn file -t [ --test ] arg Testing .trn file -O [ --output ] arg Output comparison file 

कमांड लाइन के तर्कों को पार्स करने के लिए आगे बढ़ते हैं। पहली बात यह है कि उस कार्य का पता लगाना है जिसे पहचानकर्ता को निष्पादित करना चाहिए:

  namespace po = boost::program_options; po::variables_map vm; po::parsed_options parsed = po::command_line_parser(ac, av).options(desc).allow_unregistered().run(); po::store(parsed, vm); po::notify(vm); 

हम केवल तर्क विकल्प के रूप में सामान्य विकल्प पास करते हैं। Allow_unregistered बढ़ावा देने के लिए एक कॉल के बिना :: program_options अतिरिक्त तर्कों के लिए शपथ लेंगे जो टेम्पलेट में वर्णित नहीं हैं, जिसमें केवल ऑपरेशन का प्रकार और मदद। इस कोड को निष्पादित करने के बाद, task_type वैरिएबल भर जाता है और आप "स्विच" लिख सकते हैं:

  if(task_type == "train") { desc.add(train_desc); po::store(po::parse_command_line(ac,av,desc), vm); train(vm); } else if(task_type == "recognize") { //... else { desc.add(train_desc).add(recognize_desc).add(score_desc); std::cout << desc << std::endl; } 

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

आइए समझने के लिए ट्रेन (vm) प्रक्रिया पर करीब से नज़र डालें कि परिणामी शब्दकोश से मूल्यों को कैसे प्राप्त करें।

  void train(const po::variables_map& vm) { std::string input_path, info_path, output_path; if (vm.count("input")) { input_path = vm["input"].as<std::string>(); } if(vm.count("info")) { info_path = vm["info"].as<std::string>(); } if(vm.count("output")) { output_path = vm["output"].as<std::string>(); } //... } 

जैसा कि आप देख सकते हैं, सब कुछ सरल है, हालांकि, ध्यान दें कि तर्कों को उनके पूर्ण नाम से एक्सेस किया जाना चाहिए, और विवरण में पारित लाइन द्वारा नहीं। तुलना "जानकारी, मैं" और सिर्फ "जानकारी"।

निष्कर्ष

उदाहरण का पूर्ण संस्करण पास्टबिन पर पाया जा सकता है। यह लाइब्रेरी की सभी विशेषताएं नहीं हैं, लेकिन जो लोग पहले से ही बीच में रुचि रखते हैं, वे आधिकारिक दस्तावेज पढ़ने के लिए चले गए हैं।

फायदे:

• अंतरंगता (कम से कम मेरे लिए)
• आत्मनिर्भरता (टिप्पणियाँ, प्रकार, नाम और समूह बॉक्स से बाहर)
• तर्क और कॉन्फ़िगरेशन फ़ाइलों के साथ काम करें (हालांकि यह कवर नहीं किया गया था)

नुकसान:

• मैला दस्तावेज
• बायनेरिज़ को जोड़ने की आवश्यकता है (कई अन्य बढ़ावा पैकेजों की तुलना में)
• एकल अक्षर लघु तर्क नाम