האקתון OpenVINO: זיהוי קול ורגשות ב-Raspberry Pi

30 בנובמבר - 1 בדצמבר בניז'ני נובגורוד התקיים האקתון OpenVINO. המשתתפים התבקשו ליצור אב טיפוס של פתרון מוצר באמצעות ערכת הכלים OpenVINO של Intel. המארגנים הציעו רשימה של נושאים משוערים שניתן להנחות אותם בעת בחירת משימה, אך ההחלטה הסופית נותרה בידי הצוותים. בנוסף, עודדו השימוש בדגמים שאינם כלולים במוצר.

במאמר זה נספר לכם כיצד יצרנו את אב הטיפוס שלנו למוצר, איתו תפסנו בסופו של דבר את המקום הראשון.

יותר מ-10 צוותים השתתפו בהאקתון. זה נחמד שחלקם הגיעו מאזורים אחרים. מקום ההאקתון היה מתחם "קרמלינסקי על פוצ'יין", שבו נתלו בפנים תצלומים עתיקים של ניז'ני נובגורוד, בפמליה! (אני מזכיר לכם שכרגע המשרד המרכזי של אינטל נמצא בניז'ני נובגורוד). המשתתפים קיבלו 26 שעות לכתוב קוד, ובסופם היה עליהם להציג את הפתרון שלהם. יתרון נפרד היה הנוכחות של סשן הדגמה כדי לוודא שכל מה שתוכנן אכן מיושם ולא נשאר רעיונות במצגת. סחורה, חטיפים, אוכל, גם הכל היה שם!

בנוסף, אינטל סיפקה אופציונלית מצלמות, Raspberry PI, Neural Compute Stick 2.

בחירת משימות

אחד החלקים הקשים ביותר בהכנה להאקתון בצורה חופשית הוא בחירת אתגר. החלטנו מיד להמציא משהו שעדיין לא היה במוצר, שכן בהודעה נאמר שזה מאוד מבורך.

לאחר ניתוח מודלים, הכלולים במוצר במהדורה הנוכחית, אנו מגיעים למסקנה שרובם פותרים בעיות ראייה ממוחשבת שונות. יתרה מכך, קשה מאוד להגיע לבעיה בתחום הראייה הממוחשבת שלא ניתן לפתור באמצעות OpenVINO, וגם אם ניתן להמציא אותה, קשה למצוא מודלים מאומנים מראש ברשות הרבים. אנחנו מחליטים לחפור לכיוון אחר - לכיוון עיבוד דיבור וניתוח. הבה נשקול משימה מעניינת של זיהוי רגשות מתוך דיבור. יש לומר שלOpenVINO כבר יש מודל שקובע את הרגשות של אדם על סמך הפנים שלו, אבל:

• בתיאוריה, אפשר ליצור אלגוריתם משולב שיעבוד גם על הסאונד וגם על התמונה, מה שאמור לתת עלייה ברמת הדיוק.
• למצלמות יש בדרך כלל זווית צפייה צרה; נדרשת יותר ממצלמה אחת כדי לכסות שטח גדול; לצליל אין מגבלה כזו.

בואו לפתח את הרעיון: בואו ניקח את הרעיון למגזר הקמעונאי כבסיס. אתה יכול למדוד את שביעות רצון הלקוחות בקופות החנות. אם אחד הלקוחות לא מרוצה מהשירות ומתחיל להרים את הטון שלו, אתה יכול מיד להתקשר למנהל לעזרה.
במקרה זה, עלינו להוסיף זיהוי קולי אנושי, זה יאפשר לנו להבחין בין עובדי חנות ללקוחות ולספק אנליטיקה לכל אדם. ובכן, בנוסף, ניתן יהיה לנתח את התנהגות עובדי החנות עצמם, להעריך את האווירה בצוות, נשמע טוב!

אנו מגבשים את הדרישות לפתרון שלנו:

• גודל קטן של מכשיר היעד
• תפעול בזמן אמת
• מחיר נמוך
• מדרגיות קלה

כתוצאה מכך, אנו בוחרים את Raspberry Pi 3 c כמכשיר היעד אינטל NCS 2.

כאן חשוב לציין תכונה אחת חשובה של NCS - זה עובד הכי טוב עם ארכיטקטורות CNN סטנדרטיות, אבל אם אתה צריך להריץ מודל עם שכבות מותאמות אישית עליו, אז צפה לאופטימיזציה ברמה נמוכה.

יש רק דבר אחד קטן לעשות: אתה צריך להשיג מיקרופון. מיקרופון USB רגיל יתאים, אבל הוא לא ייראה טוב יחד עם ה-RPI. אבל גם כאן הפתרון ממש "טמון בקרבת מקום". כדי להקליט קול, אנו מחליטים להשתמש בלוח קול מכסה המנוע מהערכה ערכת קול AIY של גוגל, שעליו יש מיקרופון סטריאו קווי.

הורד את Raspbian מ מאגר פרויקטים של AIY והעלה אותו לכונן הבזק, בדוק שהמיקרופון עובד באמצעות הפקודה הבאה (הוא יקליט אודיו באורך 5 שניות וישמור אותו בקובץ):

arecord -d 5 -r 16000 test.wav

עלי לציין מיד שהמיקרופון רגיש מאוד וקולט רעשים היטב. כדי לתקן זאת, הבה נעבור אל alsamixer, נבחר בהתקני לכידת ונפחית את רמת אות הכניסה ל-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 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 אלפיות השנייה), אז אנחנו מסתכלים על גודל רשימת הנתחים המצטברים; אם הוא >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 (ייצוג ביניים). ניסינו בערך 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 Optimzer, שבזכותו ניתן להמיר מודל מפורמטים שונים של מסגרת (Tensorflow, ONNX וכו') לפורמט ייצוג ביניים, איתו נעבוד בהמשך
• Inference Engine מאפשר לך להריץ דגמים בפורמט IR על מעבדי אינטל, שבבים רבים ומאיצי Neural Compute Stick
• הגרסה היעילה ביותר של OpenCV (עם תמיכה במנוע Inference)
  כל דגם בפורמט IR מתואר על ידי שני קבצים: .xml ו-.bin.
  מודלים מומרים לפורמט IR באמצעות כלי אופטימיזציית המודלים באופן הבא:

  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 שניות), אנו ממירים כל אחד מהחלונות הללו ל-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 over tcp).

  השלב הראשון הוא קבלת מידע מעובד מפטל, כלומר מנבאים ארוזים ב-json, שנשמרים במסד הנתונים באמצע הדרך שלהם, כך שניתן להפיק סטטיסטיקות על הרקע הרגשי של המשתמש לתקופה. חבילה זו נשלחת לאחר מכן ל-frontend, המשתמש במנוי ומקבל מנות מנקודת הקצה של websocket. כל מנגנון הקצה האחורי בנוי בשפת הגולנג; הוא נבחר בגלל שהוא מתאים למשימות אסינכרוניות, שהגורוטינים מתמודדים בהן היטב.
  בכניסה לנקודת הקצה המשתמש נרשם ונכנס למבנה ואז מתקבלת הודעתו. גם המשתמש וגם ההודעה מוכנסים לרכזת משותפת, שממנו כבר נשלחות הודעות הלאה (לחזית המנוי), ואם המשתמש סוגר את החיבור (פטל או חזית), אזי המנוי שלו מתבטל והוא מוסר מ הרכזת.

  
  אנחנו מחכים לחיבור מאחור

  Front-end הוא יישום אינטרנט שנכתב ב-JavaScript באמצעות ספריית React כדי להאיץ ולפשט את תהליך הפיתוח. מטרת אפליקציה זו היא לדמיין נתונים שהושגו באמצעות אלגוריתמים הפועלים בצד האחורי וישיר על ה-Raspberry Pi. לדף יש ניתוב חלקי המיושם באמצעות react-router, אך העמוד הראשי המעניין הוא העמוד הראשי, שבו זרם רציף של נתונים מתקבל בזמן אמת מהשרת באמצעות טכנולוגיית WebSocket. Raspberry Pi מזהה קול, קובע אם הוא שייך לאדם ספציפי ממסד הנתונים הרשום, ושולח רשימת הסתברויות ללקוח. הלקוח מציג את הנתונים הרלוונטיים העדכניים ביותר, מציג את האווטאר של האדם שסביר להניח שדיבר למיקרופון, כמו גם את הרגש שבו הוא מבטא את המילים.

  
  עמוד בית עם תחזיות מעודכנות

  מסקנה

  אי אפשר היה להשלים הכל כמתוכנן, פשוט לא היה לנו זמן, אז התקווה העיקרית הייתה בהדגמה, שהכל יעבוד. במצגת הם דיברו על איך הכל עובד, אילו דגמים הם לקחו, באילו בעיות הם נתקלו. לאחר מכן היה חלק ההדגמה - מומחים הסתובבו בחדר בסדר אקראי ופנו לכל צוות כדי לבחון את אב הטיפוס העובד. הם שאלו אותנו גם שאלות, כל אחד ענה על חלקו, הם השאירו את האינטרנט על המחשב הנייד, והכל באמת עבד כמצופה.

  הרשו לי לציין שהעלות הכוללת של הפתרון שלנו הייתה 150$:

  • Raspberry Pi 3 ~ 35 דולר
  • מצנפת קול AIY של גוגל (אתה יכול לקחת עמלת רמקולים) ~ 15$
  • Intel NCS 2 ~ 100$

  איך לשפר:

  • השתמש ברישום מהלקוח - בקשו לקרוא את הטקסט שנוצר באופן אקראי
  • הוסף עוד כמה דגמים: אתה יכול לקבוע מין וגיל לפי קול
  • הפרד קולות שנשמעים בו זמנית (יומן)

  מאגר: https://github.com/vladimirwest/OpenEMO

  
  אנחנו עייפים אבל שמחים

  לסיכום, אני רוצה להגיד תודה למארגנים ולמשתתפים. בין הפרויקטים של צוותים אחרים, אהבנו באופן אישי את הפתרון לניטור מקומות חניה פנויים. עבורנו זו הייתה חוויה מגניבה להפליא של התעמקות במוצר ובפיתוח. אני מקווה שעוד ועוד אירועים מעניינים יתקיימו באזורים, כולל בנושאי AI.

מקור: www.habr.com