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

टॉप -10 रूसी कॉमेडीज़ को संकलित करने के हाल के खाली समय में हम एक ऐसे बॉट को बनाने के लिए समर्पित हैं जो एक सेलिब्रिटी को ढूंढता है जिसे उपयोगकर्ता सबसे अधिक पसंद करता है। वर्किंग चैट में, सभी ने इस विचार की सराहना की कि हमने बॉट को सार्वजनिक रूप से उपलब्ध कराने का फैसला किया। इस लेख में, हम सिद्धांत को संक्षेप में याद करते हैं, हमारे बॉट के निर्माण के बारे में बात करते हैं और इसे स्वयं कैसे करते हैं।

सिद्धांत का एक सा (ज्यादातर चित्रों में)

चेहरा पहचान प्रणाली कैसे व्यवस्थित की जाती है, इसके बारे में विस्तार से मैंने अपने पिछले लेखों में से एक में बात की थी। एक इच्छुक पाठक लिंक का अनुसरण कर सकता है, और मैं केवल मुख्य बिंदुओं के नीचे रूपरेखा तैयार करूंगा।

तो, आपके पास एक तस्वीर है जिसमें, शायद, यहां तक ​​कि एक चेहरा भी दिखाया गया है और आप समझना चाहते हैं कि यह किसका है। ऐसा करने के लिए, आपको 4 सरल चरणों का पालन करने की आवश्यकता है:

1. चेहरे की सीमा आयत का चयन करें।
2. चेहरे के मुख्य बिंदुओं को हाइलाइट करें।
3. संरेखित करें और अपना चेहरा क्रॉप करें।
4. कुछ मशीन-व्याख्या किए गए प्रतिनिधित्व में एक चेहरे की छवि बदलें।
5. आपके द्वारा उपलब्ध अन्य लोगों के साथ इस दृश्य की तुलना करें।

चेहरे का चयन

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

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

प्रत्येक पिक्सेल के लिए ढाल की गणना करना आवश्यक नहीं है, यह प्रत्येक छोटे वर्ग के लिए औसत ढाल n द्वारा गणना करने के लिए पर्याप्त है। प्राप्त वेक्टर फ़ील्ड का उपयोग करते हुए, आप फिर एक खिड़की के साथ कुछ डिटेक्टर के माध्यम से जा सकते हैं और प्रत्येक खिड़की के लिए निर्धारित कर सकते हैं कि इसमें चेहरा कितनी संभावना है। डिटेक्टर SVM, एक यादृच्छिक जंगल, या कुछ और हो सकता है।

मुख्य बिंदुओं को हाइलाइट करें

मुख्य बिंदु ऐसे बिंदु हैं जो अंतरिक्ष में किसी व्यक्ति की पहचान करने में मदद करते हैं। कमजोर और असुरक्षित वैज्ञानिकों को आमतौर पर 68 प्रमुख बिंदुओं की आवश्यकता होती है, और विशेष रूप से उपेक्षित मामलों में और भी अधिक। सामान्य और आत्मविश्वासी लड़के, जो प्रति सेकंड 300k कमाते थे, उनके पास हमेशा पर्याप्त पांच थे: आंखों और नाक के आंतरिक और बाहरी कोने।

ऐसे बिंदुओं को निकाला जा सकता है, उदाहरण के लिए, रजिस्टरों के कैस्केड द्वारा।

चेहरा संरेखण

बचपन में सरेआम आवेदन? यहाँ सब कुछ ठीक वैसा ही है: आप एक शालीन परिवर्तन करते हैं जो तीन मनमाने बिंदुओं को उनके मानक पदों में बदल देता है। नाक को वैसे ही छोड़ा जा सकता है, लेकिन आंखों के लिए अपने केंद्रों को गिनने के लिए - ये तीन बिंदु तैयार हैं।

चेहरा छवियों को वेक्टर में बदलें

फेसनेट के बारे में लेख के प्रकाशन को तीन साल बीत चुके हैं, इस समय के दौरान कई दिलचस्प प्रशिक्षण योजनाएं और नुकसान के कार्य दिखाई दिए, लेकिन यह वह है जो उपलब्ध ओपनसोर्स समाधानों के बीच हावी है। जाहिर है, पूरी बात समझने में आसानी, कार्यान्वयन और सभ्य परिणामों का संयोजन है। कम से कम इस तथ्य के लिए धन्यवाद कि पिछले तीन वर्षों में आर्किटेक्चर को ResNet में बदल दिया गया है।

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

नेटवर्क की अंतिम परत के आउटपुट को एम्बेडिंग कहा जाता है - छोटे आयाम (आमतौर पर 128-आयामी) के एक निश्चित स्थान में किसी व्यक्ति का प्रतिनिधि प्रतिनिधित्व।

चेहरे की तुलना

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

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

किस पुस्तकालय का उपयोग करें?

पाइप लाइन के विभिन्न हिस्सों को लागू करने वाले ओपन लाइब्रेरीज़ का चुनाव बढ़िया है। dlib और dlib चेहरे और मुख्य बिंदुओं को पा सकते हैं, और नेटवर्क के पूर्व-प्रशिक्षित संस्करण किसी भी बड़े तंत्रिका नेटवर्क ढांचे के लिए मिल सकते हैं। एक ओपनफैस परियोजना है जहां आप गति और गुणवत्ता की अपनी आवश्यकताओं के लिए वास्तुकला का चयन कर सकते हैं। लेकिन केवल एक पुस्तकालय आपको तीन उच्च-स्तरीय कार्यों के लिए कॉल में चेहरे की पहचान के सभी 5 बिंदुओं को लागू करने की अनुमति देता है: dlib । उसी समय, यह आधुनिक C ++ में लिखा गया है, BLAS का उपयोग करता है, पायथन के लिए एक आवरण है, इसमें GPU की आवश्यकता नहीं होती है, और CPU पर बहुत जल्दी काम करता है। हमारी पसंद उसके ऊपर गिर गई।

अपना बॉट बनाना

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

टोकन कुछ इस तरह दिखता है: 643075690:AAFC8ola8WRdhGbJtzjmkOhne1FGfu1BFg । यह टेलीग्राम बॉट एपीआई के प्रत्येक अनुरोध पर प्राधिकरण के लिए आवश्यक है।

मुझे उम्मीद है कि इस स्तर पर किसी को भी प्रोग्रामिंग भाषा चुनने पर कोई संदेह नहीं होगा। बेशक, आपको हास्केल में लिखना होगा। मुख्य मॉड्यूल के साथ शुरू करते हैं।

 import System.Process main :: IO () main = do (_, _, _, handle) <- createProcess (shell "python bot.py") _ <- waitForProcess handle putStrLn "Done!" 

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

 python -m venv .env source .env/bin/activate pip install python-telegram-bot 

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

python-telegram-bot बॉट के साथ एक बॉट शुरू करना आसान है। निम्नलिखित कोड को bot.py जोड़ें।

 from telegram.ext import Updater from telegram.ext import MessageHandler, Filters #      TOKEN = '<TOKEN>' def echo(bot, update): bot.send_message(chat_id=update.message.chat_id, text=update.message.text) updater = Updater(token=TOKEN) dispatcher = updater.dispatcher echo_handler = MessageHandler(Filters.text, echo) dispatcher.add_handler(echo_handler) 

बॉट चलाते हैं। डिबगिंग उद्देश्यों के लिए, यह बिना हास्केल कोड को python bot.py साथ किया जा सकता है।

इस तरह के एक साधारण बॉट एक न्यूनतम वार्तालाप को बनाए रखने में सक्षम है, और इसलिए, फ्रंट-एंड डेवलपर के रूप में काम करने के लिए इसे आसानी से व्यवस्थित किया जा सकता है।

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

 from telegram.ext import Updater from telegram.ext import MessageHandler, Filters #      TOKEN = '<TOKEN>' def handle_photo(bot, update): bot.send_message(chat_id=update.message.chat_id, text='nice') updater = Updater(token=TOKEN) dispatcher = updater.dispatcher photo_handler = MessageHandler(Filters.photo, handle_photo) dispatcher.add_handler(photo_handler) updater.start_polling() updater.idle() 

जब चित्र टेलीग्राम सर्वर में प्रवेश करता है, तो यह स्वचालित रूप से कई पूर्व निर्धारित आकारों में समायोजित हो जाता है। बॉट, बदले में, message.photo में निहित उन लोगों से किसी भी आकार की एक छवि डाउनलोड कर सकता है। आरोही क्रम में छांट ली गई सूची। सबसे आसान विकल्प: सबसे बड़ी छवि लें। बेशक, किराने के माहौल में, आपको नेटवर्क लोड और लोड समय के बारे में सोचने और न्यूनतम उपयुक्त आकार की एक छवि चुनने की आवश्यकता है। handle_photo फ़ंक्शन के शीर्ष पर छवि डाउनलोड कोड जोड़ें।

 import io 

 message = update.message photo = message.photo[~0] with io.BytesIO() as fd: file_id = bot.get_file(photo.file_id) file_id.download(out=fd) fd.seek(0) 

छवि डाउनलोड हो चुकी है और मेमोरी में है। इसकी व्याख्या करने और इसे पिक्सेल तीव्रता के एक मैट्रिक्स के रूप में प्रस्तुत करने के लिए, हम Pillow और numpy पुस्तकालयों का उपयोग करते हैं।

 from PIL import Image import numpy as np 

निम्न कोड with ब्लॉक के with जोड़ना होगा।

 image = Image.open(fd) image.load() image = np.asarray(image) 

समय आ गया है dlib। फ़ंक्शन के बाहर, एक फेस डिटेक्टर बनाएं।

 import dlib 

 face_detector = dlib.get_frontal_face_detector() 

और फ़ंक्शन के अंदर हम इसका उपयोग करते हैं।

 face_detects = face_detector(image, 1) 

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

 if not face_detects: bot.send_message(chat_id=update.message.chat_id, text='no faces') face = face_detects[0] 

हम अगले चरण पर जाते हैं - प्रमुख बिंदुओं की खोज। प्रशिक्षित मॉडल डाउनलोड करें और फ़ंक्शन के बाहर इसका लोड बढ़ाएं।

 shape_predictor = dlib.shape_predictor('path/to/shape_predictor_5_face_landmarks.dat') 

प्रमुख बिंदुओं का पता लगाएं।

 landmarks = shape_predictor(image, face) 

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

 face_recognition_model = dlib.face_recognition_model_v1('path/to/dlib_face_recognition_resnet_model_v1.dat') 

 embedding = face_recognition_model.compute_face_descriptor(image, landmarks) embedding = np.asarray(embedding) 

जरा देखिए कि हम कितने शानदार समय में रहते हैं। दीक्षांत तंत्रिका नेटवर्क की संपूर्ण जटिलता, समर्थन वेक्टर विधि, और मान्यता का सामना करने के लिए लागू किए गए रूपांतरणों को तीन पुस्तकालय कॉल में समझाया गया है।

चूँकि हम नहीं जानते कि अभी तक कुछ भी सार्थक कैसे किया जा सकता है, चलो उपयोगकर्ता को अपने एम्बेडिंग के औसत मूल्य को एक हजार से गुणा करके वापस करते हैं।

 bot.send_message( chat_id=update.message.chat_id, text=f'yours embedding mean: {embedding.mean() * 1e3:.2f}' ) 

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

यदि आप डेटाबेस में एक लाख सेलेब्रिटी होना चाहते हैं, तो सब कुछ ठीक वैसा ही दिखाई देगा, केवल अधिक फाइलें हैं और यह संभावना नहीं है कि आप उन्हें अपने हाथों से देख सकते हैं। अब dlib कॉल का उपयोग करके build_embeddings.py उपयोगिता बनाते हैं जिसे हम पहले से जानते हैं और बाइनरी प्रारूप में उनके नाम के साथ सेलिब्रिटी एम्बेडिंग को सहेजते हैं।

 import os import dlib import numpy as np import pickle from PIL import Image face_detector = dlib.get_frontal_face_detector() shape_predictor = dlib.shape_predictor('assets/shape_predictor_5_face_landmarks.dat') face_recognition_model = dlib.face_recognition_model_v1('assets/dlib_face_recognition_resnet_model_v1.dat') fs = os.listdir('photos') es = [] for f in fs: print(f) image = np.asarray(Image.open(os.path.join('photos', f))) face_detects = face_detector(image, 1) face = face_detects[0] landmarks = shape_predictor(image, face) embedding = face_recognition_model.compute_face_descriptor(image, landmarks, num_jitters=10) embedding = np.asarray(embedding) name, _ = os.path.splitext(f) es.append((name, embedding)) with open('assets/embeddings.pickle', 'wb') as f: pickle.dump(es, f) 

हमारे बॉट कोड में एम्बेड लोडिंग जोड़ें।

 import pickle 

 with open('assets/embeddings.pickle', 'rb') as f: star_embeddings = pickle.load(f) 

और संपूर्ण खोज से हमें पता चलेगा कि हमारा उपयोगकर्ता किसके समान है।

 ds = [] for name, emb in star_embeddings: distance = np.linalg.norm(embedding - emb) ds.append((name, distance)) best_match, best_distance = min(ds, key=itemgetter(1)) bot.send_message( chat_id=update.message.chat_id, text=f'your look exactly like *{best_match}*', parse_mode='Markdown' ) 

कृपया ध्यान दें कि हम यूक्लिडियन दूरी का उपयोग दूरी के रूप में करते हैं, क्योंकि dlib में नेटवर्क को इसकी मदद से सटीक रूप से प्रशिक्षित किया गया था।

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

पूरा प्रशिक्षण बॉट कोड GitHub पर उपलब्ध है ।

हम अपने बॉट के बारे में बात करते हैं

आपके डेटाबेस में कितनी हस्तियां हैं? आपने उन्हें कहां पाया?

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

 [ { "name": " ", "alias": "tilda-swinton", "role": "actor", "n_movies": 14 }, { "name": " ", "alias": "michael-shannon", "role": "actor", "n_movies": 22 }, ... ] 

कैटलॉग में 22,000 ऐसी प्रविष्टियां थीं। वैसे, एक कैटलॉग नहीं, बल्कि एक कैटलॉग।

इन सभी लोगों के लिए फ़ोटो कहाँ ढूंढें?

खैर, आप जानते हैं, यहाँ और वहाँ । उदाहरण के लिए, एक अद्भुत पुस्तकालय जो आपको Google से चित्र-क्वेरी परिणाम अपलोड करने की अनुमति देता है। 22 हजार लोग - इतने सारे नहीं, 56 धाराओं का उपयोग करके हम एक घंटे से भी कम समय में उनके लिए तस्वीरें डाउनलोड करने में कामयाब रहे।

डाउनलोड की गई तस्वीरों में, आपको गलत प्रारूप में टूटी हुई, शोरगुल वाली तस्वीरों को त्यागने की आवश्यकता है। फिर केवल उन लोगों को छोड़ दें जहां चेहरे हैं और जहां ये चेहरे कुछ शर्तों को पूरा करते हैं: आंखों के बीच न्यूनतम दूरी, सिर का झुकाव। यह सब हमें 12,000 तस्वीरों के साथ छोड़ देता है।

12 हजार हस्तियों में से, उपयोगकर्ताओं को इस समय केवल 2 मिले हैं। अर्थात, लगभग 8 हजार हस्तियां हैं जो अभी भी किसी और के साथ नहीं हैं। इसे ऐसे ही मत छोड़ो! टेलीग्राम खोलें और उन सभी को ढूंढें।

यूक्लिडियन दूरी के लिए समानता का प्रतिशत कैसे निर्धारित करें?

बड़ा अच्छा सवाल! वास्तव में, यूक्लिडियन दूरी, कोसाइन के विपरीत, ऊपर से बंधी नहीं है। इसलिए, एक उचित प्रश्न यह उठता है कि उपयोगकर्ता को "बधाई के बजाय कुछ और अधिक सार्थक कैसे दिखाया जाए, एंजेलिना जोली की एम्बेडिंग और एम्बेडिंग के बीच की दूरी 0.27635462738" है? हमारी टीम के सदस्यों में से एक ने निम्नलिखित सरल और सरल समाधान का प्रस्ताव दिया। यदि आप एम्बेडों के बीच की दूरी का वितरण करते हैं, तो यह सामान्य होगा। तो, उसके लिए, आप औसत और मानक विचलन की गणना कर सकते हैं, और फिर प्रत्येक उपयोगकर्ता के लिए, इन मापदंडों के अनुसार, विचार करें कि कितने प्रतिशत लोग उनकी हस्तियों की तुलना में कम हैं । यह d से प्लस इन्फिनिटी तक प्रायिकता घनत्व फ़ंक्शन को एकीकृत करने के बराबर है, जहां d उपयोगकर्ता और सेलिब्रिटी रैलियों के बीच की दूरी है।

यहाँ सटीक फ़ंक्शन है जिसका हम उपयोग करते हैं:

 def _transform_dist_to_sim(self, dist): p = 0.5 * (1 + erf((dist - self._dist_mean) / (self._dist_std * 1.4142135623730951))) return max(min(1 - p, 1.0), self._min_similarity) 

क्या वास्तव में मैच खोजने के लिए सभी यूनियनों की सूची पर पुनरावृति करना आवश्यक है?

बेशक, यह इष्टतम नहीं है और इसमें बहुत समय लगता है। गणना को अनुकूलित करने का सबसे आसान तरीका मैट्रिक्स ऑपरेशन का उपयोग करना है। एक दूसरे से वैक्टर को हटाने के बजाय, आप उनसे एक मैट्रिक्स की रचना कर सकते हैं और एक वेक्टर को मैट्रिक्स से घटा सकते हैं, और फिर पंक्तियों में L2 मान की गणना कर सकते हैं।

 scores = np.linalg.norm(emb - embeddings, axis=1) best_idx = scores.argmax() 

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

 import nmslib index = nmslib.init(method='hnsw', space='l2', data_type=nmslib.DataType.DENSE_VECTOR) for idx, emb in enumerate(embeddings): index.addDataPoint(idx, emb) index_time_params = { 'indexThreadQty': 4, 'skip_optimized_index': 0, 'post': 2, 'delaunay_type': 1, 'M': 100, 'efConstruction': 2000 } index.createIndex(index_time_params, print_progress=True) index.saveIndex('./assets/embeddings.bin') 

M और efConstruction मापदंडों को विस्तार से प्रलेखन में वर्णित किया गया है और प्रयोगात्मक रूप से आवश्यक सटीकता, सूचकांक निर्माण समय और खोज गति के आधार पर चुना जाता है। सूचकांक का उपयोग करने से पहले, आपको डाउनलोड करना होगा:

 index = nmslib.init(method='hnsw', space='l2', data_type=nmslib.DataType.DENSE_VECTOR) index.loadIndex('./assets/embeddings.bin') query_time_params = {'efSearch': 400} index.setQueryTimeParams(query_time_params) 

efSearch पैरामीटर प्रश्नों की सटीकता और गति को प्रभावित करता है और efConstruction मेल नहीं खा सकता है। अब आप अनुरोध कर सकते हैं।

 ids, dists = index.knnQuery(embedding, k=1) best_dx = ids[0] best_dist = dists[0] 

हमारे मामले में, nmslib रैखिक संस्करण की तुलना में 20 गुना तेज है, और एक अनुरोध औसतन 0.005 सेकंड पर संसाधित होता है।

उत्पादन के लिए मेरे बॉट को कैसे तैयार किया जाए?

1. अतुल्यकालिक

सबसे पहले, आपको handle_photo फ़ंक्शन को अतुल्यकालिक बनाने की आवश्यकता है। जैसा कि मैंने पहले ही कहा था, python-telegram-bot लिए मल्टीथ्रेडिंग प्रदान करता है और एक सुविधाजनक डेकोरेटर को लागू करता है।

 from telegram.ext.dispatcher import run_async @run_async def handle_photo(bot, update): ... 

अब फ्रेमवर्क अपने हैंडलर को अपने पूल में एक अलग थ्रेड में लॉन्च करेगा। Updater बनाते समय पूल का आकार सेट किया जाता है। "लेकिन अजगर में कोई मल्टीथ्रेडिंग नहीं है!" आप के सबसे अधीर पहले से ही माफ कर दिया है। और यह पूरी तरह सच नहीं है। GIL के कारण, नियमित पायथन कोड वास्तव में समानांतर में निष्पादित नहीं किया जा सकता है, लेकिन GIL को सभी IO परिचालनों के लिए प्रतीक्षा करने के लिए जारी किया गया है, और यह C एक्सटेंशन का उपयोग करने वाले पुस्तकालयों द्वारा भी जारी किया जा सकता है।

अब हमारे handle_photo फ़ंक्शन का विश्लेषण करें: इसमें बस IO ऑपरेशंस का इंतज़ार करना (फोटो अपलोड करना, रिस्पांस भेजना, डिस्क से फोटो पढ़ना आदि) शामिल हैं और numpy , nmslib और Pillow लाइब्रेरीज़ से कॉलिंग फंक्शन्स हैं।

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

2. मल्टीप्रोसेसिंग

dlib से निपटने का सबसे आसान तरीका मॉडल को एक अलग इकाई में dlib है और इसे एक अलग प्रक्रिया में चलाना है। और प्रक्रिया पूल में बेहतर है।

 def _worker_initialize(config): global model model = Model(config) model.load_state() def _worker_do(image): return model.process_image(image) pool = multiprocessing.Pool(8, initializer=_worker_initialize, initargs=(config,)) 

 result = pool.apply(_worker_do, (image,)) 

3. लोहा

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

4. बाढ़ नियंत्रण

टेलीग्राम बॉट्स को प्रति सेकंड 30 से अधिक संदेश भेजने की अनुमति नहीं देते हैं। यदि आपका बॉट लोकप्रिय है और बहुत सारे लोग एक ही समय में इसका उपयोग करते हैं, तो कुछ सेकंड के लिए प्रतिबंध को पकड़ना बहुत आसान है, जो कई उपयोगकर्ताओं के लिए उम्मीद से निराश हो जाएगा। इस समस्या को हल करने के लिए, python-telegram-bot हमें एक कतार प्रदान करता है जो प्रति सेकंड निर्दिष्ट संदेश सीमा से अधिक नहीं भेज सकता है, भेजने के बीच बराबर अंतराल बनाए रखता है।

 from telegram.ext.messagequeue import MessageQueue 

इसका उपयोग करने के लिए, आपको अपने बॉट को परिभाषित करने और Updater बनाने के दौरान इसे बदलने की आवश्यकता है।

 from telegram.utils.promise import Promise class MQBot(Bot): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._message_queue = MessageQueue( all_burst_limit=30, all_time_limit_ms=1000 ) def __del__(self): try: self._message_queue.stop() finally: super().__del__() def send_message(self, *args, **kwargs): is_group = kwargs.get('chat_id', 0) >= 0 return self._message_queue(Promise(super().send_message, args, kwargs), is_group) 

 bot = MQBot(token=TOKEN) updater = Updater(bot=bot) 

5. वेब हुक

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

6. सामान्य ज्ञान

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

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

6. एनालिटिक्स

, . , , , . , .

, , BI-tool Splunk .

, . , .

, . , : @OkkoFaceBot .

, . , .