OpenVINO hackathon: tuvastame häält ja emotsioone Raspberry Pi-l

30. november – 1. detsember toimus Nizhni Novgorodis OpenVINO hackathon. Osalejad pidid looma toote lahenduse prototüübi, kasutades Intel OpenVINO tööriistu. Korraldajad pakkusid välja nimekirja näidisteemadest, millele ülesande valimisel õnnestuda, kuid lõpliku otsuse langetamine jäi meeskondade kätte. Samuti julgustati kasutama mudeleid, mis ei kuulu tootesse.

Artiklis räägime, kuidas me oma toote prototüübi lõime, millega lõpuks esikoht saavutati.

Hackathonil osales üle 10 meeskonna. On tore, et mõned neist tulid teistest piirkondadest. Hackathoni toimumispaik oli valitud kompleks „Kreml Počainas”, kus olid seintel vanad fotod Nizhni Novgorodist, luues erilise õhkkonna! (meenutan, et praegu asub ettevõtte Intel keskasutus just Nizhni Novgorodis). Koodi kirjutamiseks anti osalejatele 26 tundi, lõpus tuli esitada oma lahendus. Erakordne pluss oli demoesitluse olemasolu, et veenduda, et kõik, mis oli planeeritud, on tõeliselt teostatud, mitte ainult ideed esitlustes. Kaupade, suupistete ja toidu osas oli samuti kõik olemas!

Lisaks pakkus ettevõte Intel soovi korral kaamerad, Raspberry PI ja Neural Compute Stick 2.

Ülesande valik

Üks keerukamaid osi hackathoni ettevalmistamisel avatud temaatikaga on ülesande valik. Otsustasime kohe välja mõelda midagi, mida tootest veel ei leidu, kuna kuulutuses öeldi, et seda teretatakse.

Analüüsides mudeleid, mis on toodud tootes praeguses väljaandes, jõuame järeldusele, et enamik neist lahendab erinevaid arvutinägemise ülesandeid. Tõsi, on väga keeruline välja mõelda arvutinägemise valdkonda kuuluvat ülesannet, mida ei saa lahendada OpenVINO abil, ja kui selline võiks isegi olla, on raske leida avalikkusele kergesti ligipääsetavaid eelõppinud mudeleid. Seetõttu mõtleme uurida ka teisest suunast — häälprotsessimise ja analüüsi suunas. Kaaluveame huvitavat ülesannet emotsioonide tuvastamisel hääle kaudu. Tuleb öelda, et OpenVINO-s on juba mudel, mis määrab inimese emotsioone näo järgi, kuid:

• Teoreetiliselt on võimalik luua kombineeritud algoritm, mis töötab nii heli kui ka pildi järgi, mis peaks tooma täpsuse suurenemist.
• Kaameratel on tavaliselt kitsas vaatenurk, et katta suuremat ala, mistõttu on vajalik rohkem kui üks kaamera; helil ei ole selliseid piiranguid.

Arendame ideed: võtame aluseks idee jaeturu segmendi jaoks. Saame määrata ostja rahulolu kaupluse kassade juures. Kui mõni ostjatest on teenindusega rahulolematu ja hakkab tooni tõstma, saab kohe kutsuda administraatori appi.
Sel juhul on vajalik lisada hääletuvastus, mis võimaldab meil eristada poe töötajaid ostjatest ning anda analüüsi igale indiviidile. Lisaks saab analüüsida poe töötajate käitumist ja hinnata kollektiivi atmosfääri, kõlab hästi!

Määrame nõuded meie lahendusele:

• Sihtseadmest väike suurus
• Töö reaalses ajas
• Madal hind
• Lihtne skaleeritavus

Kokkuvõttes valime sihtseadmeks Raspberry Pi 3 koos Intel NCS 2.

Siin on oluline märkida, et NCS töötab kõige paremini standardsete CNN arhitektuuridega; kui soovite käivitada sellel mudelit kohandatud kihtidega, oodake madalamat optimeerimist.

Tuleb leida mikrofon. Sobib ka tavaline USB-mikrofon, kuigi see ei näe RPI kõrval hea välja. Kuid ka siin on lahendus sõna otseses mõttes „käeulatuses“. Hääle salvestamiseks otsustame kasutada Voice Bonnet plaati komplektist Google AIY Voice Kit, millel on solderdatud stereomikrofon.

Laadime Raspbiani alla AIY projektide hoidlast ja salvestame selle mälupulgale, testime, kas mikrofon töötab järgmise käsuga (see salvestab 5 sekundi pikkuse heli ja salvestab faili):

arecord -d 5 -r 16000 test.wav

Tähtis on märkida, et mikrofon on väga tundlik ja püüab hästi üles häälest. Selle parandamiseks siseneme alsamixerisse, valime Capture seadmed ja vähendame sisendsignaali taset 50-60%-ni.

Viimistleme korpuse viiliga ja kõik mahub sinna, isegi kaane saab kinni panna.

Lisame indikaatornupu.

AIY Voice Kit'i lahti võttes meenutame, et seal on RGB-nupp, mille valgustust saab programmiliselt juhtida. Otsime "Google AIY Led" ja leiame dokumentatsiooni: https://aiyprojects.readthedocs.io/en/latest/aiy.leds.html
Miks mitte kasutada seda nuppu tuvastatud emotsiooni kuvamiseks, meil on kokku 7 klassi ja nupul on 8 värvi, mis on just piisavalt!

Ühendame nupu GPIO kaudu Voice Bonnet'iga, laadime vajalikud teegid (need on juba AIY projektide jaotisesse installitud).

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

Loome dict'i, kus iga emotsioon vastab värvile RGB Tuple'ina ja aiy.leds.Leds klassi objektile, mille kaudu värvi uuendame:

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()

Ja lõpuks, pärast iga uue emotsioonide ennustuse tegemist uuendame nuppude värvi vastavalt sellele (võtme järgi).

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

Nupp, põle!

Töötame häälega

Kasutame pyaudio helivoogude salvestamiseks mikrofonilt ja webrtcvad müravaba filtriks ning hääle tuvastamiseks. Lisaks loome järjekorra, kuhu lisame ja sealt eemaldame helilõike asünkroonselt.

Kuna webrtcvad-il on piirang suuruse kohta, peab sisestatud fragment olema 10/20/30 ms, ja emotsioonide tuvastamise mudelit õpetati (nagu me hiljem saame teada) 48 kHz andmestikul, siis salvestame fragmente suurusega 48000 × 20 ms / 1000 × 1 (mono) = 960 baiti. Webrtcvad tagastab True/False iga sellise fragmendi kohta, mis vastab hääle olemasolule või puudumisele fragmendis.

Rakendame järgmise loogika:

• Lisame listi need fragmendid, kus on hääl; kui häält ei ole, siis suurendame tühjade fragmentide loendurit.
• Kui tühi chunkide loendur on >=30 (600 ms), vaatame kogunenud chunkide lehe suurust; kui see on >250, siis lisame järjekorda, kui ei, arvame, et salvestuse pikkus pole piisav, et esitada see mudelile kõneleja tuvastamiseks.
• Kui tühi chunkide loendur on endiselt < 30 ja kogunenud chunkide lehe suurus ületab 300, siis lisame lõigu järjekorda täpsema prognoosi jaoks. (Sest aja jooksul emotsioonid muutuvad.)

 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 = []

On saanud aeg otsida avatud juurdepääsuga eeltreenitud mudeleid, läheme githubi, guugeldame, kuid peame meeles, et meil on arhitektuuri osas piirang. See on üsna keeruline osa, kuna tuleb mudeleid testida oma sisendandmetega ning lisaks konverteerida need OpenVINO sisemiseks vorminguks — IR (Intermediate Representation). Proovisime umbes 5-7 erinevat lahendust githubis, ja kui emotsioonide tuvastamise mudel töötas kohe, siis häältuvastamisega pidime kauem vaeva nägema — seal kasutatakse keerukamaid arhitektuure.

Peatume järgmistel:

• Häälest saadud emotsioonid — https://github.com/alexmuhr/Voice_Emotion
  See töötab järgmise põhimõtte järgi: heli lõigatakse kindla suurusega lõikudeks, igaühe jaoks eraldame MFCC ja edastame need CNN-i sisendisse.
• Häältuvastus — https://github.com/linhdvu14/vggvox-speaker-identification
  Siin töötame spektraalogrammiga, pärast FFT edastame signaali CNN-i, kus saame väljundis hääle vekt esinduse.

Järgmisena räägime mudelite konverteerimisest, alustame teooriast. OpenVINO sisaldab mitmeid mooduleid:

• Open Model Zoo, mille mudeleid saab kasutada ja oma toodetesse integreerida.
• Model Optimizer, mis võimaldab konverteerida mudeleid erinevate raamistike formaatidest (Tensorflow, ONNX jms) Intermediate Representation formaati, millega me edasi töötame.
• Inference Engine võimaldab käivitada mudeleid IR formaadis Intel protsessoritel, Myriad kiipidel ja Neural Compute Stick kiirenditel.
• Kõige tõhusam OpenCV versioon (Inference Engine'i toega).
  Iga IR formaadis mudel on kirjeldatud kahe failiga: .xml ja .bin.
  Mudeleid konverteeritakse IR formaati Model Optimizer abil järgmiselt:

  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 valib andmeformaadi, millega mudel töötleb. Toetatakse FP32, FP16, INT8. Optimaalse andmeformaadi valik võib anda märkimisväärse jõudluse suurenemise.
  --input_shape näitab sisendi mõõtmeid. C++ API-s on tõenäoliselt olemas võimalus seda dünaamiliselt muuta, kuid me ei süvenenud sellesse nii sügavale ja fikseerisime selle ühe mudeli puhul lihtsalt.
  Seejärel proovime laadida juba konverteeritud mudelit IR formaadis OpenCV DNN mooduli kaudu ja teha sellele forward.

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

  Antud juhul suudab viimane rida suunata arvutused Neural Compute Stickile, kuna algselt viiakse arvutused läbi protsessoril, kuid Raspberry Pi puhul see ei toimi, seetõttu on vajalik stick.

  Seejärel käib loogika järgmiselt: jagame oma audio kindla suurusega akendeks (meie puhul on see 0,4 s), igaühe neist akendest teisendame MFCC-ks, mida seejärel edastame võrku:

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

  Võtame seejärel kõigi akende jaoks kõige sagedamini esineva klassi. Lihtne lahendus, kuid hakatoni jaoks ei ole vaja midagi liiga keerulist välja mõelda, välja arvatud juhul, kui aega on. Meil on veel palju tööd, seega liigume edasi — mõistame häältuvastust. Peame looma mingi andmebaasi, kuhu salvestatakse eelnevalt salvestatud häälte spektraalid. Kuna aega on jäänud vähe, lahendame selle küsimuse nii nagu oskame.

  Nimelt loome skripti, et salvestada häälest lõiku (see töötab sama moodi nagu eelnevalt kirjeldatud, kuid katkemise korral klaviatuurilt salvestab see hääle faili).

  Proovime.:

  python3 voice_db/record_voice.py test.wav

  Salvestame mitme inimese hääli (meie puhul kolme meeskonnaliikme hääli)
  Seejärel teeme iga salvestatud hääle jaoks kiire fourier' analüüsi, saame spektraaldiagrammi ja salvestame numpy massiivina (.npy):

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

  Lisainfot failis create_base.py
  Tulemuseks, kui käivitame põhiskripti, saame alguses need spektrite embeddid:

  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)

  Pärast embeedi saamist kõlavatest katkestustest saame määrata, kellele see kuulub, võtme cosinus kauguse katkestusest kõigi häältelt andmebaasis (mida madalam, seda tõenäolisem) — demo jaoks oleme seadnud läve 0.3):

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

  Lõpuks märgin, et infereerimise kiirus oli kiire ja lubas lisada veel 1-2 mudelit (7-sekundilise näidise infereerimiseks kulus 2.5). Uute mudelite lisamine jäi meil juba hiljaks ja keskendusime veebirakenduse prototüübi kirjutamisele.

  Veebirakendus

  Oluline punkt: võtame kodust kaasa ruuteri ja seadistame oma kohalikku võrku, mis aitab seadmeid ja sülearvuteid omavahel ühenduda.

  Backend on pidev sõnumite kanali ühendus frondi ja Raspberry Pi vahel, mis põhineb websocket-tehnoloogial (http üle tcp protokolli).

  Esimene etapp on töödeldud teabe saamine Raspberry Pi'lt, see tähendab, et JSON-formaadis ennustused salvestatakse andmebaasi nende teekonna keskel, et saaksime luua statistikat kasutaja emotsionaalse tausta kohta ajaperioodil. Edasi saadetakse see pakett frondi, mis kasutab tellimist ja pakettide vastuvõtmist websocketsi lõpp-punktist. Kogu backend mehhanism on üles ehitatud Go keeles, kuna see sobib hästi asünkroonsete ülesannete jaoks, millega gorangiinid hästi toime tulevad.
  Lõpp-punkti juurde pääsemisel registreeritakse kasutaja ja lisatakse struktuuri, seejärel toimub tema sõnumi saamine. N nii kasutaja kui sõnum lisatakse ühiselt hub-i, kust sõnumid saadetakse edasi (registreeritud frontile), ja kui kasutaja ühenduse lõpetab (raspberry või front), siis tema tellimus tühistatakse ja ta eemaldatakse hub-ist.

  
  Ootame ühendust tagaplaaniga

  Front-end on web-rakendus, mis on kirjutatud JavaScriptis, kasutades raamatukogu React, et kiirendada ja lihtsustada arendusprotsessi. Selle rakenduse eesmärk on andmete visualiseerimine, mis on saadud back-end'i pool töötavate algoritmide ja Raspberry Pi kaudu. Lehel on jaotiste vahel suunamine, mis on rakendatud react-router'i abil, kuid peamine huvi keskendub avalehele, kus reaalajas voolab pidev andmevoog serverist WebSocketi tehnoloogia kaudu. Raspberry Pi tuvastab häält, määrab, kellele see kuulub registreeritud andmebaasis, ja saadab kliendile tõenäosuste loendi. Klient kuvab viimased asjakohased andmed, kuvab inimese avatar, kellel on suurim tõenäosus mikrofoniga rääkida, samuti emotsiooni, millega ta sõnu ütleb.

  
  Avaleht uuenevate ennustustega

  Kokkuvõte

  Kahjuks ei õnnestunud meil kõike plaanitud lõpule viia, ajaliselt lihtsalt ei jõudnud, seega oli peamine lootus demoon, et kõik töötab. Esitlusel räägiti, kuidas kõik on korraldatud, milliseid mudeleid kasutati ja millega silmitsi seisti. Järgnes demooni osa — eksperdid liikusid saalis vabalt ringi ja lähenesid igale meeskonnale, et vaadata töötavat prototüüpi. Nad küsisid küsimusi ka meilt, igaüks vastas oma osa kohta, sülearvutites oli veeb ja kõik tõepoolest töötas, nagu oodati.

  Tõstan esile, et meie lahenduse kogukulu oli 150$:

  • Raspberry Pi 3 ~ 35$
  • Google AIY Voice Bonnet (võite võtta respeakeri plaadi) ~ 15$
  • Intel NCS 2 ~ 100$

  Kuidas parandada:

  • Kasuta kliendi registreerimist — küsi, et lugeda teksti, mida genereerime juhuslikult
  • Lisada veel mõned mudelid: hääle järgi saab määrata soo ja vanuse
  • Erinevate häälte eristamine, kui need kõlavad samal ajal (diarisatsioon)

  Repositoorium: https://github.com/vladimirwest/OpenEMO

  
  Väsinud, kuid õnnelikud oleme

  Lõpetuseks tahaksime tänada korraldajate ja osalejate eest. Teiste tiimide projektidest meeldis meile isiklikult lahendus parkimiskohtade jälgimiseks. See oli meile äärmiselt äge kogemus toote ja arenduse maailmas. Loodan, et piirkondades toimub üha rohkem huvitavaid üritusi, sealhulgas AI-teemalisi.

Allikas: habr.com