ओपनविनो हैकथॉन: रास्पबेरी पाई पर आवाज और भावनाओं को पहचानना

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

इस लेख में हम आपको बताएंगे कि हमने उत्पाद का प्रोटोटाइप कैसे बनाया, जिसके साथ हमने अंततः पहला स्थान हासिल किया।

हैकथॉन में 10 से अधिक टीमों ने भाग लिया। यह अच्छा है कि उनमें से कुछ अन्य क्षेत्रों से आए हैं। हैकथॉन का स्थान "क्रेमलिंस्की ऑन पोचेन" कॉम्प्लेक्स था, जहां निज़नी नोवगोरोड की प्राचीन तस्वीरें एक घेरे में लटकाई गई थीं! (मैं आपको याद दिला दूं कि फिलहाल इंटेल का केंद्रीय कार्यालय निज़नी नोवगोरोड में स्थित है)। प्रतिभागियों को कोड लिखने के लिए 26 घंटे का समय दिया गया और अंत में उन्हें अपना समाधान प्रस्तुत करना था। एक अलग फायदा यह था कि डेमो सत्र की उपस्थिति यह सुनिश्चित करती थी कि जो भी योजना बनाई गई थी वह वास्तव में लागू की गई थी और प्रस्तुति में विचार नहीं रह गए थे। सामान, नाश्ता, भोजन, सब कुछ वहाँ भी था!

इसके अलावा, इंटेल ने वैकल्पिक रूप से कैमरे, रास्पबेरी पीआई, न्यूरल कंप्यूट स्टिक 2 प्रदान किए।

कार्य चयन

फ्री-फॉर्म हैकथॉन की तैयारी के सबसे कठिन हिस्सों में से एक चुनौती चुनना है। हमने तुरंत कुछ ऐसा लाने का फैसला किया जो अभी तक उत्पाद में नहीं था, क्योंकि घोषणा में कहा गया था कि यह अत्यधिक स्वागत योग्य है।

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

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

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

हम अपने समाधान के लिए आवश्यकताएँ तैयार करते हैं:

• लक्ष्य डिवाइस का छोटा आकार
• वास्तविक समय संचालन
• कम कीमत
• आसान मापनीयता

परिणामस्वरूप, हम लक्ष्य डिवाइस के रूप में रास्पबेरी पाई 3 सी का चयन करते हैं इंटेल एनसीएस 2.

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

बस एक छोटा सा काम करना है: आपको एक माइक्रोफ़ोन लेना होगा। एक नियमित USB माइक्रोफ़ोन काम करेगा, लेकिन RPI के साथ यह अच्छा नहीं लगेगा। लेकिन यहां भी समाधान सचमुच "पास में ही है।" आवाज रिकॉर्ड करने के लिए, हम किट से वॉयस बोनट बोर्ड का उपयोग करने का निर्णय लेते हैं Google एआईवाई वॉयस किट, जिस पर एक वायर्ड स्टीरियो माइक्रोफोन है।

रास्पबियन को यहां से डाउनलोड करें AIY प्रोजेक्ट रिपॉजिटरी और इसे फ्लैश ड्राइव पर अपलोड करें, परीक्षण करें कि माइक्रोफ़ोन निम्नलिखित कमांड का उपयोग करके काम करता है (यह 5 सेकंड लंबा ऑडियो रिकॉर्ड करेगा और इसे एक फ़ाइल में सहेजेगा):

arecord -d 5 -r 16000 test.wav

मुझे तुरंत ध्यान देना चाहिए कि माइक्रोफ़ोन बहुत संवेदनशील है और शोर को अच्छी तरह से पकड़ लेता है। इसे ठीक करने के लिए, आइए एल्सामिक्सर पर जाएं, कैप्चर डिवाइस चुनें और इनपुट सिग्नल स्तर को 50-60% तक कम करें।

हम एक फ़ाइल के साथ बॉडी को संशोधित करते हैं और सब कुछ फिट हो जाता है, आप इसे ढक्कन के साथ भी बंद कर सकते हैं

एक संकेतक बटन जोड़ना

AIY वॉयस किट को अलग करते समय, हमें याद आया कि इसमें एक RGB बटन है, जिसकी बैकलाइट को सॉफ्टवेयर द्वारा नियंत्रित किया जा सकता है। हम "Google AIY Led" खोजते हैं और दस्तावेज़ पाते हैं: https://aiyprojects.readthedocs.io/en/latest/aiy.leds.html
मान्यता प्राप्त भावना को प्रदर्शित करने के लिए इस बटन का उपयोग क्यों न करें, हमारे पास केवल 7 वर्ग हैं, और बटन में 8 रंग हैं, बस इतना ही!

हम बटन को GPIO के माध्यम से वॉयस बोनट से कनेक्ट करते हैं, आवश्यक लाइब्रेरी लोड करते हैं (वे पहले से ही AIY परियोजनाओं से वितरण किट में स्थापित हैं)

from aiy.leds import Leds, Color
from aiy.leds import RgbLeds

आइए एक नियम बनाएं जिसमें प्रत्येक भावना का RGB टुपल के रूप में एक संबंधित रंग और aiy.leds.Leds वर्ग का एक ऑब्जेक्ट होगा, जिसके माध्यम से हम रंग को अपडेट करेंगे:

led_dict = {'neutral': (255, 255, 255), 'happy': (0, 255, 0), 'sad': (0, 255, 255), 'angry': (255, 0, 0), 'fearful': (0, 0, 0), 'disgusted':  (255, 0, 255), 'surprised':  (255, 255, 0)} 
leds = Leds()

और अंत में, किसी भावना की प्रत्येक नई भविष्यवाणी के बाद, हम बटन के रंग को उसके अनुसार (कुंजी द्वारा) अपडेट करेंगे।

leds.update(Leds.rgb_on(led_dict.get(classes[prediction])))

बटन, जलाओ!

आवाज के साथ काम करना

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

चूंकि webrtcvad में आपूर्ति किए गए टुकड़े के आकार पर एक सीमा है - यह 10/20/30ms के बराबर होना चाहिए, और भावनाओं को पहचानने के लिए मॉडल का प्रशिक्षण (जैसा कि हम बाद में सीखेंगे) 48kHz डेटासेट पर किया गया था, हम करेंगे 48000×20ms/1000×1(मोनो)=960 बाइट्स आकार के टुकड़े कैप्चर करें। Webrtcvad इनमें से प्रत्येक खंड के लिए सही/गलत लौटाएगा, जो खंड में वोट की उपस्थिति या अनुपस्थिति से मेल खाता है।

आइए निम्नलिखित तर्क लागू करें:

• हम उन खंडों को सूची में जोड़ देंगे जहां वोट है; यदि कोई वोट नहीं है, तो हम खाली खंडों के काउंटर को बढ़ा देंगे।
• यदि खाली टुकड़ों का काउंटर >=30 (600 एमएस) है, तो हम संचित टुकड़ों की सूची के आकार को देखते हैं; यदि यह >250 है, तो हम इसे कतार में जोड़ते हैं; यदि नहीं, तो हम मानते हैं कि लंबाई स्पीकर की पहचान करने के लिए इसे मॉडल में फीड करने के लिए रिकॉर्ड पर्याप्त नहीं है।
• यदि खाली टुकड़ों का काउंटर अभी भी <30 है, और संचित टुकड़ों की सूची का आकार 300 से अधिक है, तो हम अधिक सटीक भविष्यवाणी के लिए टुकड़े को कतार में जोड़ देंगे। (क्योंकि समय के साथ भावनाएँ बदलती रहती हैं)

 def to_queue(frames):
    d = np.frombuffer(b''.join(frames), dtype=np.int16)
    return d

framesQueue = queue.Queue()
def framesThreadBody():
    CHUNK = 960
    FORMAT = pyaudio.paInt16
    CHANNELS = 1
    RATE = 48000

    p = pyaudio.PyAudio()
    vad = webrtcvad.Vad()
    vad.set_mode(2)
    stream = p.open(format=FORMAT,
                channels=CHANNELS,
                rate=RATE,
                input=True,
                frames_per_buffer=CHUNK)
    false_counter = 0
    audio_frame = []
    while process:
        data = stream.read(CHUNK)
        if not vad.is_speech(data, RATE):
            false_counter += 1
            if false_counter >= 30:
                if len(audio_frame) > 250:              
                    framesQueue.put(to_queue(audio_frame,timestamp_start))
                    audio_frame = []
                    false_counter = 0

        if vad.is_speech(data, RATE):
            false_counter = 0
            audio_frame.append(data)
            if len(audio_frame) > 300:                
                    framesQueue.put(to_queue(audio_frame,timestamp_start))
                    audio_frame = []

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

हम निम्नलिखित पर ध्यान केंद्रित करते हैं:

• वाणी से भाव - https://github.com/alexmuhr/Voice_Emotion
  यह निम्नलिखित सिद्धांत के अनुसार काम करता है: ऑडियो को एक निश्चित आकार के अंशों में काटा जाता है, इनमें से प्रत्येक अंश के लिए हम चयन करते हैं एमएफसीसी और फिर उन्हें सीएनएन को इनपुट के रूप में सबमिट करें
• आवाज़ पहचान - https://github.com/linhdvu14/vggvox-speaker-identification
  यहां, एमएफसीसी के बजाय, हम एक स्पेक्ट्रोग्राम के साथ काम करते हैं, एफएफटी के बाद हम सीएनएन को सिग्नल फीड करते हैं, जहां आउटपुट पर हमें आवाज का वेक्टर प्रतिनिधित्व मिलता है।

आगे हम सिद्धांत से शुरू करके मॉडलों को परिवर्तित करने के बारे में बात करेंगे। OpenVINO में कई मॉड्यूल शामिल हैं:

• मॉडल चिड़ियाघर खोलें, जिसके मॉडल का उपयोग किया जा सकता है और आपके उत्पाद में शामिल किया जा सकता है
• मॉडल ऑप्टिमाइज़र, जिसकी बदौलत आप एक मॉडल को विभिन्न फ्रेमवर्क प्रारूपों (टेन्सरफ़्लो, ओएनएनएक्स आदि) से इंटरमीडिएट प्रतिनिधित्व प्रारूप में परिवर्तित कर सकते हैं, जिसके साथ हम आगे काम करेंगे
• इंफ़रेंस इंजन आपको इंटेल प्रोसेसर, असंख्य चिप्स और न्यूरल कंप्यूट स्टिक एक्सेलेरेटर पर आईआर प्रारूप में मॉडल चलाने की अनुमति देता है
• OpenCV का सबसे कुशल संस्करण (इंफ़रेंस इंजन समर्थन के साथ)
  आईआर प्रारूप में प्रत्येक मॉडल को दो फाइलों द्वारा वर्णित किया गया है: .xml और .bin।
  मॉडल ऑप्टिमाइज़र के माध्यम से मॉडल को आईआर प्रारूप में निम्नानुसार परिवर्तित किया जाता है:

  python /opt/intel/openvino/deployment_tools/model_optimizer/mo_tf.py --input_model speaker.hdf5.pb --data_type=FP16 --input_shape [1,512,1000,1]

  --data_type आपको उस डेटा प्रारूप का चयन करने की अनुमति देता है जिसके साथ मॉडल काम करेगा। FP32, FP16, INT8 समर्थित हैं। इष्टतम डेटा प्रकार चुनने से अच्छे प्रदर्शन को बढ़ावा मिल सकता है।
  --input_shape इनपुट डेटा के आयाम को इंगित करता है। ऐसा लगता है कि इसे गतिशील रूप से बदलने की क्षमता C++ API में मौजूद है, लेकिन हमने इतनी दूर तक खोज नहीं की है और इसे केवल एक मॉडल के लिए तय किया है।
  इसके बाद, आइए डीएनएन मॉड्यूल के माध्यम से आईआर प्रारूप में पहले से परिवर्तित मॉडल को ओपनसीवी में लोड करने और इसे अग्रेषित करने का प्रयास करें।

  import cv2 as cv
  emotionsNet = cv.dnn.readNet('emotions_model.bin',
                            'emotions_model.xml')
  emotionsNet.setPreferableTarget(cv.dnn.DNN_TARGET_MYRIAD)

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

  अगला, तर्क इस प्रकार है: हम अपने ऑडियो को एक निश्चित आकार की विंडो में विभाजित करते हैं (हमारे लिए यह 0.4 s है), हम इनमें से प्रत्येक विंडो को MFCC में परिवर्तित करते हैं, जिसे हम फिर ग्रिड में फीड करते हैं:

  emotionsNet.setInput(MFCC_from_window)
  result = emotionsNet.forward()

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

  अर्थात्, हम ध्वनि अंश रिकॉर्ड करने के लिए एक स्क्रिप्ट बनाते हैं (यह ऊपर बताए गए तरीके से ही काम करता है, केवल कीबोर्ड द्वारा बाधित होने पर ही यह ध्वनि को फ़ाइल में सहेजेगा)।

  आओ कोशिश करते हैं:

  python3 voice_db/record_voice.py test.wav

  हम कई लोगों की आवाज़ें रिकॉर्ड करते हैं (हमारे मामले में, टीम के तीन सदस्य)
  इसके बाद, प्रत्येक रिकॉर्ड की गई आवाज के लिए हम तेजी से फूरियर रूपांतरण करते हैं, एक स्पेक्ट्रोग्राम प्राप्त करते हैं और इसे एक सुन्न सरणी (.npy) के रूप में सहेजते हैं:

  for file in glob.glob("voice_db/*.wav"):
          spec = get_fft_spectrum(file)
          np.save(file[:-4] + '.npy', spec)

  फ़ाइल में अधिक विवरण create_base.py
  परिणामस्वरूप, जब हम मुख्य स्क्रिप्ट चलाते हैं, तो हमें शुरुआत में ही इन स्पेक्ट्रोग्राम से एम्बेडिंग प्राप्त होगी:

  for file in glob.glob("voice_db/*.npy"):
      spec = np.load(file)
      spec = spec.astype('float32')
      spec_reshaped = spec.reshape(1, 1, spec.shape[0], spec.shape[1])
      srNet.setInput(spec_reshaped)
      pred = srNet.forward()
      emb = np.squeeze(pred)

  ध्वनि खंड से एम्बेडिंग प्राप्त करने के बाद, हम यह निर्धारित करने में सक्षम होंगे कि डेटाबेस में सभी आवाजों के लिए मार्ग से कोसाइन दूरी लेकर यह किसका है (जितनी छोटी, उतनी अधिक संभावना) - डेमो के लिए हम सीमा निर्धारित करते हैं से 0.3):

          dist_list = cdist(emb, enroll_embs, metric="cosine")
          distances = pd.DataFrame(dist_list, columns = df.speaker)

  अंत में, मैं यह नोट करना चाहूंगा कि अनुमान की गति तेज थी और इससे 1-2 और मॉडल जोड़ना संभव हो गया (7 सेकंड लंबे नमूने के लिए अनुमान में 2.5 का समय लगा)। अब हमारे पास नए मॉडल जोड़ने का समय नहीं था और हमने वेब एप्लिकेशन का प्रोटोटाइप लिखने पर ध्यान केंद्रित किया।

  वेब अनुप्रयोग

  एक महत्वपूर्ण बिंदु: हम घर से अपने साथ एक राउटर लेते हैं और अपना स्थानीय नेटवर्क सेट करते हैं, यह नेटवर्क पर डिवाइस और लैपटॉप को कनेक्ट करने में मदद करता है।

  बैकएंड फ्रंट और रास्पबेरी पाई के बीच एक एंड-टू-एंड संदेश चैनल है, जो वेबसॉकेट तकनीक (http ओवर टीसीपी प्रोटोकॉल) पर आधारित है।

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

  
  हम पीछे से कनेक्शन का इंतज़ार कर रहे हैं

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

  
  अद्यतन भविष्यवाणियों वाला होम पेज

  निष्कर्ष

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

  मुझे ध्यान दें कि हमारे समाधान की कुल लागत $150 थी:

  • रास्पबेरी पाई 3 ~ $35
  • Google AIY वॉयस बोनट (आप रिस्पीकर शुल्क ले सकते हैं) ~15$
  • इंटेल एनसीएस 2 ~ 100$

  कैसे बेहतर बनाए:

  • क्लाइंट से पंजीकरण का उपयोग करें - यादृच्छिक रूप से उत्पन्न पाठ को पढ़ने के लिए कहें
  • कुछ और मॉडल जोड़ें: आप आवाज से लिंग और उम्र निर्धारित कर सकते हैं
  • एक साथ बजने वाली आवाजों को अलग करना (डायराइजेशन)

  भंडार: https://github.com/vladimirwest/OpenEMO

  
  हम थके हुए हैं लेकिन खुश हैं

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

स्रोत: www.habr.com