OpenVINO hackathon៖ ការទទួលស្គាល់សំឡេង និងអារម្មណ៍នៅលើ Raspberry Pi

ថ្ងៃទី 30 ខែវិច្ឆិកាដល់ថ្ងៃទី 1 ខែធ្នូនៅ Nizhny Novgorod ត្រូវបានប្រារព្ធឡើង OpenVINO hackathon. អ្នកចូលរួមត្រូវបានស្នើឱ្យបង្កើតគំរូដើមនៃដំណោះស្រាយផលិតផលដោយប្រើប្រអប់ឧបករណ៍ Intel OpenVINO ។ អ្នករៀបចំបានស្នើបញ្ជីប្រធានបទប្រហាក់ប្រហែលដែលអាចត្រូវបានណែនាំនៅពេលជ្រើសរើសកិច្ចការ ប៉ុន្តែការសម្រេចចិត្តចុងក្រោយនៅតែមានជាមួយក្រុម។ លើសពីនេះទៀតការប្រើប្រាស់គំរូដែលមិនត្រូវបានរួមបញ្ចូលនៅក្នុងផលិតផលត្រូវបានលើកទឹកចិត្ត។

នៅក្នុងអត្ថបទនេះ យើងនឹងប្រាប់អ្នកពីរបៀបដែលយើងបានបង្កើតគំរូផលិតផលរបស់យើង ដែលនៅទីបំផុតយើងទទួលបានកន្លែងដំបូង។

ក្រុមជាង 10 បានចូលរួមក្នុងកម្មវិធី hackathon ។ វាជារឿងល្អណាស់ដែលពួកគាត់ខ្លះមកពីតំបន់ផ្សេងៗ។ កន្លែងសម្រាប់ hackathon គឺអគារ "Kremlinsky on Pochain" ដែលជាកន្លែងរូបថតបុរាណរបស់ Nizhny Novgorod ត្រូវបានព្យួរនៅខាងក្នុង ដោយមានការចូលរួមពីអ្នកទស្សនា! (ខ្ញុំរំលឹកអ្នកថានៅពេលនេះការិយាល័យកណ្តាលរបស់ Intel មានទីតាំងនៅ Nizhny Novgorod) ។ អ្នកចូលរួមត្រូវបានផ្តល់ពេល 26 ម៉ោងដើម្បីសរសេរកូដ ហើយនៅចុងបញ្ចប់ពួកគេត្រូវតែបង្ហាញដំណោះស្រាយរបស់ពួកគេ។ អត្ថប្រយោជន៍ដាច់ដោយឡែកមួយគឺវត្តមាននៃវគ្គសាកល្បង ដើម្បីប្រាកដថាអ្វីគ្រប់យ៉ាងដែលបានគ្រោងទុកត្រូវបានអនុវត្តយ៉ាងពិតប្រាកដ និងមិននៅតែមានគំនិតនៅក្នុងបទបង្ហាញ។ ទំនិញ អាហារសម្រន់ អាហារ អ្វីៗក៏នៅទីនោះដែរ!

លើសពីនេះទៀត Intel បានផ្តល់ជម្រើសកាមេរ៉ា Raspberry PI, Neural Compute Stick 2 ។

ការជ្រើសរើសភារកិច្ច

ផ្នែកដ៏លំបាកបំផុតមួយនៃការរៀបចំសម្រាប់ hackathon ទម្រង់ឥតគិតថ្លៃគឺការជ្រើសរើសបញ្ហាប្រឈមមួយ។ ភ្លាមៗនោះ ពួកយើងបានសម្រេចចិត្តមកជាមួយនឹងអ្វីដែលមិនទាន់មាននៅក្នុងផលិតផល ចាប់តាំងពីការប្រកាសបាននិយាយថា នេះជាការស្វាគមន៍យ៉ាងខ្លាំង។

ដោយបានវិភាគ គំរូដែលត្រូវបានរួមបញ្ចូលនៅក្នុងផលិតផលនៅក្នុងការចេញផ្សាយបច្ចុប្បន្ន យើងឈានដល់ការសន្និដ្ឋានថាពួកគេភាគច្រើនដោះស្រាយបញ្ហាចក្ខុវិស័យកុំព្យូទ័រផ្សេងៗ។ ជាងនេះទៅទៀត វាពិតជាលំបាកណាស់ក្នុងការដោះស្រាយបញ្ហាក្នុងវិស័យចក្ខុវិស័យកុំព្យូទ័រដែលមិនអាចដោះស្រាយបានដោយប្រើ OpenVINO ហើយទោះបីជាគេអាចបង្កើតបានក៏ដោយ ក៏វាពិបាកក្នុងការស្វែងរកគំរូដែលបានបណ្តុះបណ្តាលជាមុននៅក្នុងដែនសាធារណៈដែរ។ យើងសម្រេចចិត្តជីកក្នុងទិសដៅមួយផ្សេងទៀត - ឆ្ពោះទៅរកដំណើរការនិយាយ និងការវិភាគ។ ចូរយើងពិចារណាអំពីកិច្ចការដ៏គួរឱ្យចាប់អារម្មណ៍មួយក្នុងការទទួលស្គាល់អារម្មណ៍ពីការនិយាយ។ វាត្រូវតែនិយាយថា OpenVINO មានគំរូដែលកំណត់អារម្មណ៍របស់មនុស្សដោយផ្អែកលើមុខរបស់ពួកគេរួចហើយ ប៉ុន្តែ៖

• តាមទ្រឹស្ដី គេអាចបង្កើតក្បួនដោះស្រាយរួមបញ្ចូលគ្នាដែលនឹងដំណើរការទាំងសំឡេង និងរូបភាព ដែលគួរតែបង្កើនភាពត្រឹមត្រូវ។
• កាមេរ៉ាជាធម្មតាមានមុំមើលតូចចង្អៀត ត្រូវការកាមេរ៉ាច្រើនជាងមួយដើម្បីគ្របដណ្តប់លើផ្ទៃធំ សំឡេងមិនមានដែនកំណត់បែបនេះទេ។

ចូរអភិវឌ្ឍគំនិត៖ ចូរយើងយកគំនិតសម្រាប់ផ្នែកលក់រាយជាមូលដ្ឋាន។ អ្នកអាចវាស់ស្ទង់ការពេញចិត្តរបស់អតិថិជននៅហាងឆេងចេញ។ ប្រសិនបើអតិថិជនណាម្នាក់មិនពេញចិត្តនឹងសេវាកម្មនេះ ហើយចាប់ផ្តើមបញ្ចេញសម្លេងរបស់ពួកគេ អ្នកអាចទូរស័ព្ទទៅអ្នកគ្រប់គ្រងភ្លាមៗដើម្បីសុំជំនួយ។
ក្នុងករណីនេះ យើងត្រូវបន្ថែមការទទួលស្គាល់សំឡេងរបស់មនុស្ស វានឹងអនុញ្ញាតឱ្យយើងបែងចែកបុគ្គលិកហាងពីអតិថិជន និងផ្តល់ការវិភាគសម្រាប់បុគ្គលនីមួយៗ។ ជាការប្រសើរណាស់, លើសពីនេះទៀត, វានឹងអាចធ្វើទៅបានដើម្បីវិភាគអាកប្បកិរិយារបស់បុគ្គលិកហាងខ្លួនឯង, វាយតម្លៃបរិយាកាសនៅក្នុងក្រុម, ស្តាប់ទៅល្អ!

យើងបង្កើតតម្រូវការសម្រាប់ដំណោះស្រាយរបស់យើង៖

• ទំហំតូចនៃឧបករណ៍គោលដៅ
• ប្រតិបត្តិការពេលវេលាពិត
• តម្លៃទាប។
• ការធ្វើមាត្រដ្ឋានងាយស្រួល

ជាលទ្ធផល យើងជ្រើសរើស Raspberry Pi 3 c ជាឧបករណ៍គោលដៅ Intel NCS 2.

នៅទីនេះវាជារឿងសំខាន់ក្នុងការកត់សម្គាល់លក្ខណៈពិសេសដ៏សំខាន់មួយនៃ NCS - វាដំណើរការល្អបំផុតជាមួយស្ថាបត្យកម្ម CNN ស្តង់ដារ ប៉ុន្តែប្រសិនបើអ្នកត្រូវការដំណើរការគំរូជាមួយនឹងស្រទាប់ផ្ទាល់ខ្លួននៅលើវា នោះរំពឹងថានឹងមានកម្រិតទាប។

មានរឿងតូចមួយដែលត្រូវធ្វើ៖ អ្នកត្រូវយកមីក្រូហ្វូន។ មីក្រូហ្វូន USB ធម្មតានឹងដំណើរការ ប៉ុន្តែវាមើលទៅមិនល្អជាមួយ RPI ទេ។ ប៉ុន្តែសូម្បីតែនៅទីនេះ ដំណោះស្រាយតាមព្យញ្ជនៈ "នៅជិត" ។ ដើម្បីថតសំឡេង យើងសម្រេចចិត្តប្រើបន្ទះ Voice Bonnet ពីឧបករណ៍ កញ្ចប់សំឡេង Google AIYដែលមានមីក្រូហ្វូនស្តេរ៉េអូមានខ្សែ។

ទាញយក Raspbian ពី ឃ្លាំងគម្រោង AIY ហើយបញ្ចូលវាទៅក្នុង flash drive សាកល្បងថាមីក្រូហ្វូនដំណើរការដោយប្រើពាក្យបញ្ជាខាងក្រោម (វានឹងថតសំឡេងរយៈពេល 5 វិនាទី ហើយរក្សាទុកវាទៅក្នុងឯកសារ)៖

arecord -d 5 -r 16000 test.wav

ខ្ញុំគួរកត់សំគាល់ភ្លាមៗថា មីក្រូហ្វូនមានភាពរសើបខ្លាំង ហើយចាប់យកសំលេងរំខានបានយ៉ាងល្អ។ ដើម្បីជួសជុលវា សូមចូលទៅកាន់ alsamixer ជ្រើសរើសឧបករណ៍ចាប់យក និងកាត់បន្ថយកម្រិតសញ្ញាបញ្ចូលមកត្រឹម 50-60%។

យើងកែប្រែតួជាមួយនឹងឯកសារ ហើយអ្វីៗក៏សមដែរ អ្នកថែមទាំងអាចបិទវាដោយគម្របទៀតផង។

ការបន្ថែមប៊ូតុងសូចនាករ

ខណៈពេលដែលយក AIY Voice Kit ដាច់ពីគ្នា យើងចាំថាមានប៊ូតុង RGB ដែលជាអំពូល Backlight ដែលអាចគ្រប់គ្រងដោយកម្មវិធី។ យើងស្វែងរក “Google AIY Led” ហើយស្វែងរកឯកសារ៖ https://aiyprojects.readthedocs.io/en/latest/aiy.leds.html
ហេតុអ្វីមិនប្រើប៊ូតុងនេះដើម្បីបង្ហាញអារម្មណ៍ដែលទទួលស្គាល់ យើងមានតែ 7 ថ្នាក់ ហើយប៊ូតុងមាន 8 ពណ៌ គ្រប់គ្រាន់ហើយ!

យើងភ្ជាប់ប៊ូតុងតាមរយៈ GPIO ទៅ Voice Bonnet ផ្ទុកបណ្ណាល័យចាំបាច់ (ពួកគេត្រូវបានដំឡើងរួចហើយនៅក្នុងឧបករណ៍ចែកចាយពីគម្រោង AIY)

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

ចូរបង្កើតពាក្យបញ្ជាដែលអារម្មណ៍នីមួយៗនឹងមានពណ៌ដែលត្រូវគ្នាក្នុងទម្រង់ជា RGB Tuple និងវត្ថុនៃថ្នាក់ 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 នឹងត្រឡប់ True/False សម្រាប់កំណាត់នីមួយៗទាំងនេះ ដែលត្រូវនឹងវត្តមាន ឬអវត្តមាននៃការបោះឆ្នោតនៅក្នុងកំណាត់។

ចូរយើងអនុវត្តតក្កវិជ្ជាខាងក្រោម៖

• យើង​នឹង​បន្ថែម​ទៅ​ក្នុង​បញ្ជី​ដែល​មាន​ការ​បោះ​ឆ្នោត បើ​មិន​មាន​ការ​បោះ​ឆ្នោត​ទេ នោះ​យើង​នឹង​បង្កើន​ចំនួន​ភាគ​ទទេ។
• ប្រសិនបើការរាប់នៃកំណាត់ទទេគឺ>=30 (600 ms) បន្ទាប់មកយើងមើលទំហំនៃបញ្ជីនៃកំណាត់ដែលបង្គរ; ប្រសិនបើវាគឺ> 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 = []

វាដល់ពេលដែលត្រូវរកមើលគំរូដែលបានបណ្តុះបណ្តាលជាមុននៅក្នុងដែនសាធារណៈ សូមចូលទៅកាន់ github, Google ប៉ុន្តែត្រូវចាំថាយើងមានដែនកំណត់លើស្ថាបត្យកម្មដែលបានប្រើ។ នេះគឺជាផ្នែកមួយដែលពិបាកជាង ព្រោះអ្នកត្រូវសាកល្បងម៉ូដែលនៅលើទិន្នន័យបញ្ចូលរបស់អ្នក ហើយលើសពីនេះទៀត បំប្លែងពួកវាទៅជាទម្រង់ខាងក្នុងរបស់ OpenVINO - IR (Intermediate Representation)។ យើងបានសាកល្បងប្រហែល 5-7 ដំណោះស្រាយផ្សេងៗគ្នាពី github ហើយប្រសិនបើគំរូសម្រាប់ការទទួលស្គាល់អារម្មណ៍ដំណើរការភ្លាមៗនោះ ជាមួយនឹងការទទួលស្គាល់សំឡេង យើងត្រូវរង់ចាំយូរជាងនេះ - ពួកគេប្រើស្ថាបត្យកម្មស្មុគស្មាញជាង។

យើងផ្តោតលើចំណុចខាងក្រោម៖

• អារម្មណ៍ពីសំឡេង - https://github.com/alexmuhr/Voice_Emotion
  វាដំណើរការតាមគោលការណ៍ខាងក្រោម៖ អូឌីយ៉ូត្រូវបានកាត់ចូលទៅក្នុងផ្នែកនៃទំហំជាក់លាក់មួយ សម្រាប់វគ្គនីមួយៗដែលយើងជ្រើសរើស MFCC ហើយបន្ទាប់មកបញ្ជូនពួកគេជាការបញ្ចូលទៅ CNN
• ការទទួលស្គាល់សំឡេង - https://github.com/linhdvu14/vggvox-speaker-identification
  នៅទីនេះជំនួសឱ្យ MFCC យើងធ្វើការជាមួយ spectrogram បន្ទាប់ពី FFT យើងបញ្ជូនសញ្ញាទៅ CNN ដែលនៅទិន្នផលយើងទទួលបានតំណាងវ៉ិចទ័រនៃសំឡេង។

បន្ទាប់យើងនឹងនិយាយអំពីការបំប្លែងគំរូដោយចាប់ផ្តើមពីទ្រឹស្តី។ OpenVINO រួមបញ្ចូលម៉ូឌុលជាច្រើន:

• Open Model Zoo ម៉ូដែលដែលអាចប្រើ និងរួមបញ្ចូលនៅក្នុងផលិតផលរបស់អ្នក។
• Model Optimzer អរគុណដែលអ្នកអាចបំប្លែងគំរូពីទម្រង់ក្របខ័ណ្ឌផ្សេងៗ (Tensorflow, ONNX ជាដើម) ទៅជាទម្រង់តំណាងកម្រិតមធ្យម ដែលយើងនឹងធ្វើការបន្ថែមទៀត។
• Inference Engine អនុញ្ញាតឱ្យអ្នកដំណើរការម៉ូដែលក្នុងទម្រង់ IR នៅលើ Intel processors, Myriad chips និង Neural Compute Stick accelerators
• កំណែដែលមានប្រសិទ្ធភាពបំផុតនៃ OpenCV (ជាមួយនឹងការគាំទ្រ Inference Engine)
  គំរូនីមួយៗក្នុងទម្រង់ IR ត្រូវបានពិពណ៌នាដោយឯកសារពីរ៖ .xml និង .bin ។
  ម៉ូដែលត្រូវបានបំប្លែងទៅជាទម្រង់ IR តាមរយៈ Model Optimizer ដូចខាងក្រោម៖

  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 ប៉ុន្តែយើងមិនបានជីកយកវាឆ្ងាយនោះទេ ហើយគ្រាន់តែជួសជុលវាសម្រាប់ម៉ូដែលមួយក្នុងចំណោមគំរូ។
  បន្ទាប់មក យើងព្យាយាមផ្ទុកគំរូដែលបានបំប្លែងរួចជាស្រេចក្នុងទម្រង់ IR តាមរយៈម៉ូឌុល DNN ទៅក្នុង OpenCV ហើយបញ្ជូនបន្តទៅវា។

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

  បន្ទាត់ចុងក្រោយក្នុងករណីនេះអនុញ្ញាតឱ្យអ្នកប្តូរទិសការគណនាទៅ Neural Compute Stick ការគណនាជាមូលដ្ឋានត្រូវបានអនុវត្តនៅលើខួរក្បាល ប៉ុន្តែក្នុងករណី Raspberry Pi នេះនឹងមិនដំណើរការទេ អ្នកនឹងត្រូវការដំបង។

  បន្ទាប់ តក្កវិជ្ជាមានដូចខាងក្រោម៖ យើងបែងចែកអូឌីយ៉ូរបស់យើងទៅជា windows ដែលមានទំហំជាក់លាក់មួយ (សម្រាប់យើងវាគឺ 0.4 s) យើងបំប្លែង windows នីមួយៗទៅជា MFCC ដែលបន្ទាប់មកយើងបញ្ចូលទៅក្នុងក្រឡាចត្រង្គ៖

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

  បន្ទាប់​មក យើង​យក​ថ្នាក់​ធម្មតា​បំផុត​សម្រាប់​គ្រប់​បង្អួច។ ដំណោះស្រាយដ៏សាមញ្ញមួយ ប៉ុន្តែសម្រាប់ការ hackathon អ្នកមិនចាំបាច់បង្កើតអ្វីដែលមិនសមហេតុផលពេកនោះទេ លុះត្រាតែអ្នកមានពេល។ យើង​នៅ​មាន​ការងារ​ជា​ច្រើន​ដែល​ត្រូវ​ធ្វើ ដូច្នេះ​សូម​បន្ត​ទៅ​មុខ - យើង​នឹង​ដោះស្រាយ​ជាមួយ​នឹង​ការ​ស្គាល់​សំឡេង។ វាចាំបាច់ក្នុងការបង្កើតមូលដ្ឋានទិន្នន័យប្រភេទមួយចំនួនដែល spectrograms នៃសំឡេងដែលបានថតទុកមុននឹងត្រូវបានរក្សាទុក។ ដោយសារ​ពេល​វេលា​នៅ​សល់​តិច​តួច យើង​នឹង​ដោះស្រាយ​បញ្ហា​នេះ​ឱ្យ​អស់​ពី​សមត្ថភាព។

  មានន័យថា យើងបង្កើតស្គ្រីបសម្រាប់ថតសម្រង់សំឡេង (វាដំណើរការដូចគ្នានឹងការពិពណ៌នាខាងលើដែរ លុះត្រាតែមានការរំខានពីក្តារចុច វានឹងរក្សាទុកសំឡេងទៅក្នុងឯកសារ)។

  តោះ​សាកល្បង:

  python3 voice_db/record_voice.py test.wav

  យើងថតសំឡេងរបស់មនុស្សជាច្រើននាក់ (ក្នុងករណីរបស់យើង សមាជិកក្រុមបីនាក់)
  បន្ទាប់មកទៀត សម្រាប់សំឡេងដែលបានថតនីមួយៗ យើងធ្វើការផ្លាស់ប្តូរបួនលឿនជាងមុន ទទួលបានវិសាលគម និងរក្សាទុកវាជាអារេ numpy (.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 សម្រាប់ការសន្និដ្ឋាន) ។ យើងលែងមានពេលបន្ថែមម៉ូដែលថ្មីទៀតហើយ ហើយផ្តោតលើការសរសេរគំរូនៃកម្មវិធីគេហទំព័រ។

  កម្មវិធីបណ្តាញ

  ចំណុចសំខាន់មួយ៖ យើងយករ៉ោតទ័រជាមួយយើងពីផ្ទះ ហើយរៀបចំបណ្តាញមូលដ្ឋានរបស់យើង វាជួយភ្ជាប់ឧបករណ៍ និងកុំព្យូទ័រយួរដៃតាមបណ្តាញ។

  ផ្នែកខាងក្រោយគឺជាប៉ុស្តិ៍សារពីចុងដល់ចុងរវាងផ្នែកខាងមុខ និង Raspberry Pi ដោយផ្អែកលើបច្ចេកវិទ្យា websocket (http over tcp protocol)។

  ដំណាក់កាលដំបូងគឺទទួលបានព័ត៌មានដែលបានដំណើរការពី raspberry ពោលគឺអ្នកទស្សន៍ទាយដែលផ្ទុកក្នុង json ដែលត្រូវបានរក្សាទុកក្នុងមូលដ្ឋានទិន្នន័យពាក់កណ្តាលនៃការធ្វើដំណើររបស់ពួកគេ ដូច្នេះស្ថិតិអាចត្រូវបានបង្កើតអំពីផ្ទៃខាងក្រោយអារម្មណ៍របស់អ្នកប្រើប្រាស់សម្រាប់រយៈពេលនេះ។ បន្ទាប់​មក​កញ្ចប់​ព័ត៌មាន​នេះ​ត្រូវ​បាន​ផ្ញើ​ទៅ​ផ្នែក​ខាង​មុខ ដែល​ប្រើ​ការ​ជាវ និង​ទទួល​កញ្ចប់​ព័ត៌មាន​ពី​ចំណុច​ចុង​រន្ធ​បណ្ដាញ។ យន្តការ backend ទាំងមូលត្រូវបានបង្កើតឡើងជាភាសា golang វាត្រូវបានជ្រើសរើសព្រោះវាស័ក្តិសមសម្រាប់កិច្ចការអសមកាលដែល goroutines ដោះស្រាយបានល្អ។
  នៅពេលចូលទៅកាន់ចំណុចបញ្ចប់ អ្នកប្រើប្រាស់ត្រូវបានចុះឈ្មោះ និងបញ្ចូលទៅក្នុងរចនាសម្ព័ន្ធ បន្ទាប់មកសាររបស់គាត់ត្រូវបានទទួល។ ទាំងអ្នកប្រើប្រាស់ និងសារត្រូវបានបញ្ចូលទៅក្នុងមជ្ឈមណ្ឌលទូទៅ ដែលសារត្រូវបានផ្ញើរួចហើយបន្ថែមទៀត (ទៅកាន់ផ្នែកខាងមុខដែលបានជាវ) ហើយប្រសិនបើអ្នកប្រើបិទការតភ្ជាប់ (raspberry ឬផ្នែកខាងមុខ) នោះការជាវរបស់គាត់ត្រូវបានលុបចោល ហើយគាត់ត្រូវបានដកចេញពី មជ្ឈមណ្ឌល។

  
  យើងកំពុងរង់ចាំការតភ្ជាប់ពីខាងក្រោយ

  Front-end គឺជាកម្មវិធីគេហទំព័រដែលសរសេរក្នុង JavaScript ដោយប្រើបណ្ណាល័យ React ដើម្បីបង្កើនល្បឿន និងសម្រួលដំណើរការអភិវឌ្ឍន៍។ គោលបំណងនៃកម្មវិធីនេះគឺដើម្បីមើលឃើញទិន្នន័យដែលទទួលបានដោយប្រើក្បួនដោះស្រាយដែលដំណើរការនៅផ្នែកខាងក្រោយ និងដោយផ្ទាល់នៅលើ Raspberry Pi ។ ទំព័រនេះមានការកំណត់ផ្លូវជាផ្នែក ដែលត្រូវបានអនុវត្តដោយប្រើរ៉ោតទ័រប្រតិកម្ម ប៉ុន្តែទំព័រសំខាន់ដែលចាប់អារម្មណ៍គឺជាទំព័រចម្បង ដែលការផ្សាយបន្តនៃទិន្នន័យត្រូវបានទទួលក្នុងពេលវេលាជាក់ស្តែងពីម៉ាស៊ីនមេដោយប្រើបច្ចេកវិទ្យា WebSocket ។ Raspberry Pi រកឃើញសំឡេង កំណត់ថាតើវាជារបស់មនុស្សជាក់លាក់ណាមួយពីមូលដ្ឋានទិន្នន័យដែលបានចុះឈ្មោះ ហើយផ្ញើបញ្ជីប្រូបាប៊ីលីតេទៅម៉ាស៊ីនភ្ញៀវ។ ម៉ាស៊ីនភ្ញៀវបង្ហាញទិន្នន័យដែលពាក់ព័ន្ធចុងក្រោយបំផុត បង្ហាញរូបតំណាងរបស់បុគ្គលដែលទំនងជានិយាយទៅក្នុងមីក្រូហ្វូន ក៏ដូចជាអារម្មណ៍ដែលគាត់បញ្ចេញពាក្យ។

  
  ទំព័រដើមជាមួយនឹងការព្យាករណ៍ដែលបានធ្វើបច្ចុប្បន្នភាព

  សេចក្តីសន្និដ្ឋាន

  វាមិនអាចបញ្ចប់អ្វីគ្រប់យ៉ាងដូចការគ្រោងទុកនោះទេ យើងគ្រាន់តែមិនមានពេលវេលា ដូច្នេះក្តីសង្ឃឹមចម្បងគឺនៅក្នុងការបង្ហាញ ថាអ្វីៗនឹងដំណើរការ។ ក្នុង​បទ​បង្ហាញ​ពួកគេ​បាន​និយាយ​អំពី​របៀប​ដែល​អ្វីៗ​ដំណើរការ​ទៅ​លើ​គំរូ​អ្វី​ដែល​ពួកគេ​បាន​យក​បញ្ហា​អ្វី​ដែល​ពួកគេ​ជួប​ប្រទះ។ បន្ទាប់គឺជាផ្នែកសាកល្បង - អ្នកជំនាញបានដើរជុំវិញបន្ទប់ដោយចៃដន្យ ហើយចូលទៅជិតក្រុមនីមួយៗដើម្បីមើលគំរូការងារ។ ពួកគេបានសួរសំណួរយើងផងដែរ មនុស្សគ្រប់គ្នាបានឆ្លើយផ្នែករបស់ពួកគេ ពួកគេបានចាកចេញពីគេហទំព័រនៅលើកុំព្យូទ័រយួរដៃ ហើយអ្វីគ្រប់យ៉ាងពិតជាដំណើរការដូចការរំពឹងទុក។

  ខ្ញុំសូមកត់សម្គាល់ថាការចំណាយសរុបនៃដំណោះស្រាយរបស់យើងគឺ $ 150៖

  • Raspberry Pi 3 ~ ៣៥ ដុល្លារ
  • Google AIY Voice Bonnet (អ្នកអាចយកថ្លៃអ្នកនិយាយបាន) ~ 15$
  • Intel NCS 2 ~ 100 ដុល្លារ

  វិធីកែលម្អ៖

  • ប្រើការចុះឈ្មោះពីអតិថិជន - សុំអានអត្ថបទដែលបង្កើតដោយចៃដន្យ
  • បន្ថែមគំរូមួយចំនួនទៀត៖ អ្នកអាចកំណត់ភេទ និងអាយុតាមសំឡេង
  • បំបែកសំឡេងក្នុងពេលដំណាលគ្នា (diarization)

  ឃ្លាំង៖ https://github.com/vladimirwest/OpenEMO

  
  ហត់តែសប្បាយចិត្ត

  សរុបសេចក្តីមក ខ្ញុំសូមថ្លែងអំណរគុណចំពោះអ្នករៀបចំ និងអ្នកចូលរួម។ ក្នុង​ចំណោម​គម្រោង​របស់​ក្រុម​ផ្សេង​ទៀត យើង​ផ្ទាល់​ចូល​ចិត្ត​ដំណោះ​ស្រាយ​សម្រាប់​ការ​ត្រួត​ពិនិត្យ​កន្លែង​ចត​រថយន្ត​ដោយ​ឥត​គិត​ថ្លៃ។ សម្រាប់ពួកយើង វាគឺជាបទពិសោធន៍ដ៏ត្រជាក់នៃការជ្រមុជនៅក្នុងផលិតផល និងការអភិវឌ្ឍន៍។ ខ្ញុំសង្ឃឹមថាព្រឹត្តិការណ៍គួរឱ្យចាប់អារម្មណ៍កាន់តែច្រើននឹងត្រូវបានធ្វើឡើងនៅក្នុងតំបន់ រួមទាំងលើប្រធានបទ AI ផងដែរ។

ប្រភព: www.habr.com