OpenVINO хакатон: разпознаване на глас и емоции на Raspberry Pi

30 ноември - 1 декември в Нижни Новгород се проведе OpenVINO хакатон. Участниците бяха помолени да създадат прототип на продуктово решение с помощта на инструментариума Intel OpenVINO. Организаторите предложиха списък с приблизителни теми, от които може да се ръководи при избора на задача, но окончателното решение оставаше на отборите. Освен това се насърчава използването на модели, които не са включени в продукта.

В тази статия ще ви разкажем как създадохме нашия прототип на продукта, с който в крайна сметка заехме първо място.

В хакатона участваха над 10 отбора. Хубаво е, че някои от тях идват от други региони. Мястото на хакатона беше комплексът „Кремлински на Почайн“, където вътре бяха окачени древни снимки на Нижни Новгород в антураж! (Напомням ви, че в момента централният офис на Intel се намира в Нижни Новгород). На участниците бяха дадени 26 часа да напишат код, а накрая трябваше да представят своето решение. Отделно предимство беше наличието на демо сесия, за да се уверите, че всичко планирано е реално изпълнено и не остават идеи в презентацията. Стоки, закуски, храна, всичко също беше там!

В допълнение, Intel предоставя като опция камери, Raspberry PI, Neural Compute Stick 2.

Избор на задача

Една от най-трудните части от подготовката за хакатон в свободна форма е изборът на предизвикателство. Веднага решихме да измислим нещо, което все още не беше в продукта, тъй като в съобщението се казваше, че това е много добре дошло.

Като анализира модел, които са включени в продукта в текущата версия, стигаме до извода, че повечето от тях решават различни проблеми с компютърното зрение. Освен това е много трудно да се измисли проблем в областта на компютърното зрение, който не може да бъде решен с помощта на OpenVINO, а дори и да може да бъде измислен, трудно е да се намерят предварително обучени модели в публичното пространство. Решаваме да копаем в друга посока – към обработка на реч и анализ. Нека разгледаме една интересна задача за разпознаване на емоции от речта. Трябва да се каже, че OpenVINO вече има модел, който определя емоциите на човек въз основа на лицето му, но:

• На теория е възможно да се създаде комбиниран алгоритъм, който да работи както върху звук, така и върху изображение, което трябва да даде увеличение на точността.
• Камерите обикновено имат тесен ъгъл на видимост; за покриване на голяма площ са необходими повече от една камера; звукът няма такова ограничение.

Нека да развием идеята: да вземем за основа идеята за сегмента на дребно. Можете да измерите удовлетвореността на клиентите на касата в магазина. Ако някой от клиентите е недоволен от обслужването и започне да повишава тон, можете веднага да се обадите на администратора за помощ.
В този случай трябва да добавим разпознаване на човешки глас, това ще ни позволи да разграничим служителите на магазина от клиентите и да предоставим анализи за всеки отделен човек. Е, освен това ще бъде възможно да се анализира поведението на самите служители на магазина, да се оцени атмосферата в екипа, звучи добре!

Ние формулираме изискванията за нашето решение:

• Малък размер на целевото устройство
• Операция в реално време
• Ниска цена
• Лесна мащабируемост

В резултат на това избираме Raspberry Pi 3 c като целево устройство Intel NCS 2.

Тук е важно да се отбележи една важна характеристика на NCS - тя работи най-добре със стандартни CNN архитектури, но ако трябва да стартирате модел с персонализирани слоеве върху него, тогава очаквайте оптимизация на ниско ниво.

Има само едно малко нещо, което трябва да направите: трябва да вземете микрофон. Обикновен USB микрофон ще свърши работа, но няма да изглежда добре заедно с RPI. Но дори и тук решението буквално „се намира наблизо“. За да записваме глас, решаваме да използваме платката Voice Bonnet от комплекта Гласов комплект Google AIY, на който има жичен стерео микрофон.

Изтеглете Raspbian от Хранилище на AIY проекти и го качете на флаш устройство, проверете дали микрофонът работи, като използвате следната команда (тя ще запише аудио с дължина 5 секунди и ще го запази във файл):

arecord -d 5 -r 16000 test.wav

Веднага трябва да отбележа, че микрофонът е много чувствителен и улавя добре шума. За да поправите това, нека отидем на alsamixer, изберете устройства за заснемане и намалете нивото на входния сигнал до 50-60%.

Модифицираме тялото с пила и всичко става, дори можете да го затворите с капак

Добавяне на индикаторен бутон

Докато разглобяваме AIY Voice Kit, помним, че има RGB бутон, чиято подсветка може да се управлява софтуерно. Търсим „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

Нека създадем dict, в който всяка емоция ще има съответен цвят под формата на 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 работим със спектрограма, след FFT подаваме сигнала към CNN, където на изхода получаваме векторно представяне на гласа.

След това ще говорим за конвертиране на модели, като започнем с теорията. OpenVINO включва няколко модула:

• Отворете Model Zoo, моделите от които могат да бъдат използвани и включени във вашия продукт
• Model Optimzer, благодарение на който можете да конвертирате модел от различни рамкови формати (Tensorflow, ONNX и т.н.) във формат Intermediate Representation, с който ще работим по-нататък
• Inference Engine ви позволява да изпълнявате модели в IR формат на процесори Intel, чипове Myriad и ускорители Neural Compute Stick
• Най-ефективната версия на 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 това няма да работи, ще ви трябва стик.

  След това логиката е следната: разделяме нашето аудио на прозорци с определен размер (за нас това е 0.4 s), преобразуваме всеки от тези прозорци в MFCC, който след това подаваме към мрежата:

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

  След това нека вземем най-често срещания клас за всички прозорци. Просто решение, но за хакатон не е нужно да измисляте нещо твърде неясно, само ако имате време. Имаме още много работа, така че да продължим - ще се заемем с гласовото разпознаване. Необходимо е да се създаде някаква база данни, в която да се съхраняват спектрограми на предварително записани гласове. Тъй като остава малко време, ще разрешим този проблем възможно най-добре.

  А именно, ние създаваме скрипт за запис на гласов откъс (работи по същия начин, както е описано по-горе, само когато бъде прекъснат от клавиатурата, той ще запази гласа във файл).

  Да опитаме:

  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 през tcp протокол).

  Първият етап е да се получи обработена информация от raspberry, тоест предиктори, опаковани в json, които се записват в базата данни по средата на тяхното пътуване, така че да може да се генерира статистика за емоционалния фон на потребителя за периода. След това този пакет се изпраща до интерфейса, който използва абонамент и получава пакети от крайната точка на websocket. Целият бекенд механизъм е изграден на езика golang; той е избран, защото е много подходящ за асинхронни задачи, с които goroutines се справят добре.
  При достъп до крайната точка потребителят се регистрира и въвежда в структурата, след което се получава неговото съобщение. И потребителят, и съобщението се въвеждат в общ хъб, от който съобщенията вече се изпращат по-нататък (към абонирания фронт), и ако потребителят затвори връзката (малина или фронт), тогава неговият абонамент се анулира и той се премахва от главината.

  
  Чакаме връзка отзад

  Front-end е уеб приложение, написано на JavaScript, използващо библиотеката React за ускоряване и опростяване на процеса на разработка. Целта на това приложение е да визуализира данни, получени с помощта на алгоритми, работещи в задната част и директно на Raspberry Pi. Страницата има секционно маршрутизиране, реализирано с помощта на react-router, но основната страница, която представлява интерес, е главната страница, където се получава непрекъснат поток от данни в реално време от сървъра с помощта на технологията WebSocket. Raspberry Pi открива глас, определя дали той принадлежи на конкретно лице от регистрираната база данни и изпраща списък с вероятности на клиента. Клиентът показва най-актуалните релевантни данни, показва аватара на човека, който най-вероятно е говорил в микрофона, както и емоцията, с която той произнася думите.

  
  Начална страница с актуализирани прогнози

  Заключение

  Не беше възможно да завършим всичко, както беше планирано, просто нямахме време, така че основната надежда беше в демото, че всичко ще работи. В презентацията те разказаха как работи всичко, какви модели са взели, какви проблеми са срещнали. Следваше демонстрационната част - експерти обикаляха стаята в произволен ред и се приближаваха до всеки екип, за да разгледат работещия прототип. Те също ни зададоха въпроси, всеки отговори на своята част, оставиха мрежата на лаптопа и всичко наистина работи според очакванията.

  Нека отбележа, че общата цена на нашето решение беше $150:

  • Raspberry Pi 3 ~ $35
  • Google AIY Voice Bonnet (можете да вземете такса за говорител) ~ 15 $
  • Intel NCS 2 ~ 100$

  Как да подобрим:

  • Използвайте регистрация от клиента - поискайте да прочетете текста, който се генерира на случаен принцип
  • Добавете още няколко модела: можете да определите пола и възрастта по глас
  • Разделяне на едновременно звучащи гласове (диаризация)

  Хранилище: https://github.com/vladimirwest/OpenEMO

  
  Уморени, но щастливи сме

  В заключение искам да благодаря на организаторите и участниците. Сред проектите на други екипи лично на нас ни допадна решението за следене на свободните места за паркиране. За нас това беше изключително готино изживяване на потапяне в продукта и разработката. Надявам се, че все повече и повече интересни събития ще се провеждат в регионите, включително по теми, свързани с ИИ.

Източник: www.habr.com