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

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

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

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

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

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

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

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

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

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

Формираме изискванията към нашето решение:

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

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

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

Работата е малка: нужно е да се сдобием с микрофон. Подходящ е и обикновен USB-микрофон, въпреки че няма да изглежда добре в комбинация с RPI. Но и тук решението буквално "лежи под ръка". За запис на гласа решаваме да използваме платката Voice Bonnet от набора Google AIY Voice Kit, на която е монтиран стерео микрофон.

Сваляме 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 projects)

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/30 ms, а обучението на модела за разпознаване на емоции (както ще разберем по-късно) е проведено с датасет 48 kHz, ще улавяме чанкове с размер 48000×20 ms/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, гуглим, но помним, че имаме ограничение на използваната архитектура. Това е доста сложна част, тъй като трябва да тестваме моделите на собствените си входни данни, а освен това, да ги конвертираме във вътрешния формат на 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 включва няколко модула:

• Open Model Zoo, модели от който можем да използваме и включваме в продукта си
• Model Optimizer, благодарение на който можем да пре конвертираме модела от различни формати на фреймворците (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 и да направим forward на него.

  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с), всеки от тези прозорци ще преобразуваме в 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, които по средата на пътя си се запазват в база данни, за да можем да формираме статистика за емоционалния фон на потребителя за периода. След това този пакет се изпраща на фронтенда, който използва абонаменти и получаване на пакети от ендпоинта на вебсокета. Целият механизъм на бекенда е изграден на езика golang, като изборът падна върху него, защото добре се справя с асинхронни задачи, с които горутините отлично се справят.
  При достъп до ендпоинта потребителят се регистрира и се записва в структурата, след което се получава съобщението му. И потребителят, и съобщението се записват в общия хъб, откъдето съобщенията вече се изпращат напред (на подписания фронт), а ако потребителят затвори връзката (Raspberry или фронта), абонаментът му се анулира и той се премахва от хъба.

  
  Очакваме свързване с бекенда

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

  
  Главна страница с обновяеми предсказания

  Заключение

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

  Ще отбележа, че общата стойност на нашето решение беше 150$:

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

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

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

  Репозиториум: https://github.com/vladimirwest/OpenEMO

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

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

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