ઓપનવિનો હેકાથોન: રાસ્પબેરી પી પર અવાજ અને લાગણીઓને ઓળખવી

નવેમ્બર 30 - ડિસેમ્બર 1 નિઝની નોવગોરોડમાં યોજાયો હતો ઓપનવિનો હેકાથોન. સહભાગીઓને Intel OpenVINO ટૂલકીટનો ઉપયોગ કરીને પ્રોડક્ટ સોલ્યુશનનો પ્રોટોટાઇપ બનાવવા માટે કહેવામાં આવ્યું હતું. આયોજકોએ અંદાજિત વિષયોની સૂચિની દરખાસ્ત કરી હતી જે કાર્ય પસંદ કરતી વખતે માર્ગદર્શન આપી શકે છે, પરંતુ અંતિમ નિર્ણય ટીમો પાસે રહ્યો. વધુમાં, ઉત્પાદનમાં સમાવિષ્ટ ન હોય તેવા મોડલના ઉપયોગને પ્રોત્સાહન આપવામાં આવ્યું હતું.

આ લેખમાં અમે તમને જણાવીશું કે અમે ઉત્પાદનનો અમારો પ્રોટોટાઇપ કેવી રીતે બનાવ્યો, જેની સાથે અમે આખરે પ્રથમ સ્થાન મેળવ્યું.

હેકાથોનમાં 10 થી વધુ ટીમોએ ભાગ લીધો હતો. તે સરસ છે કે તેમાંના કેટલાક અન્ય પ્રદેશોમાંથી આવ્યા છે. હેકાથોન માટેનું સ્થળ "પોચેન પર ક્રેમલિન્સ્કી" સંકુલ હતું, જ્યાં નિઝની નોવગોરોડના પ્રાચીન ફોટોગ્રાફ્સ અંદર એક મંડળમાં લટકાવવામાં આવ્યા હતા! (હું તમને યાદ કરાવું છું કે આ ક્ષણે ઇન્ટેલનું કેન્દ્રિય કાર્યાલય નિઝની નોવગોરોડમાં સ્થિત છે). સહભાગીઓને કોડ લખવા માટે 26 કલાકનો સમય આપવામાં આવ્યો હતો અને અંતે તેઓએ તેમનો ઉકેલ રજૂ કરવાનો હતો. એક અલગ ફાયદો એ ડેમો સત્રની હાજરી હતી તેની ખાતરી કરવા માટે કે આયોજિત દરેક વસ્તુ વાસ્તવમાં અમલમાં આવી છે અને પ્રસ્તુતિમાં વિચારો બાકી નથી. વેપાર, નાસ્તો, ખોરાક, બધું પણ ત્યાં હતું!

વધુમાં, Intel વૈકલ્પિક રીતે કેમેરા, રાસ્પબેરી PI, ન્યુરલ કોમ્પ્યુટ સ્ટિક 2 પ્રદાન કરે છે.

કાર્ય પસંદગી

ફ્રી-ફોર્મ હેકાથોનની તૈયારીના સૌથી મુશ્કેલ ભાગોમાંનો એક પડકાર પસંદ કરવાનું છે. અમે તરત જ કંઈક એવી વસ્તુ સાથે આવવાનું નક્કી કર્યું જે હજી સુધી ઉત્પાદનમાં નથી, કારણ કે જાહેરાતમાં કહેવામાં આવ્યું હતું કે આ ખૂબ આવકારદાયક છે.

વિશ્લેષણ કર્યા મોડેલો, જે વર્તમાન પ્રકાશનમાં ઉત્પાદનમાં સમાવવામાં આવેલ છે, અમે નિષ્કર્ષ પર આવીએ છીએ કે તેમાંના મોટાભાગના કમ્પ્યુટર દ્રષ્ટિની વિવિધ સમસ્યાઓ હલ કરે છે. તદુપરાંત, કોમ્પ્યુટર વિઝનના ક્ષેત્રમાં એવી સમસ્યા સાથે આવવું ખૂબ જ મુશ્કેલ છે કે જે OpenVINO નો ઉપયોગ કરીને ઉકેલી શકાતી નથી, અને જો કોઈની શોધ થઈ શકે તો પણ, જાહેર ડોમેનમાં પૂર્વ-પ્રશિક્ષિત મોડેલ્સ શોધવા મુશ્કેલ છે. અમે બીજી દિશામાં ખોદવાનું નક્કી કરીએ છીએ - સ્પીચ પ્રોસેસિંગ અને એનાલિટિક્સ તરફ. ચાલો વાણીમાંથી લાગણીઓને ઓળખવાનું એક રસપ્રદ કાર્ય ધ્યાનમાં લઈએ. એવું કહેવું આવશ્યક છે કે OpenVINO પાસે પહેલેથી જ એક મોડેલ છે જે વ્યક્તિની લાગણીઓને તેના ચહેરાના આધારે નક્કી કરે છે, પરંતુ:

• સિદ્ધાંતમાં, એક સંયુક્ત અલ્ગોરિધમ બનાવવું શક્ય છે જે અવાજ અને છબી બંને પર કામ કરશે, જે ચોકસાઈમાં વધારો આપવો જોઈએ.
• કેમેરામાં સામાન્ય રીતે જોવાનો ખૂણો સાંકડો હોય છે; મોટા વિસ્તારને આવરી લેવા માટે એક કરતા વધુ કેમેરાની જરૂર પડે છે; અવાજમાં આવી મર્યાદા હોતી નથી.

ચાલો વિચાર વિકસાવીએ: ચાલો રિટેલ સેગમેન્ટ માટેના વિચારને આધાર તરીકે લઈએ. તમે સ્ટોર ચેકઆઉટ પર ગ્રાહક સંતોષ માપી શકો છો. જો કોઈ ગ્રાહક સેવાથી અસંતુષ્ટ છે અને તેમનો સ્વર વધારવાનું શરૂ કરે છે, તો તમે તરત જ એડમિનિસ્ટ્રેટરને મદદ માટે કૉલ કરી શકો છો.
આ કિસ્સામાં, અમારે માનવ અવાજની ઓળખ ઉમેરવાની જરૂર છે, આ અમને ગ્રાહકોથી સ્ટોર કર્મચારીઓને અલગ પાડવા અને દરેક વ્યક્તિ માટે વિશ્લેષણ પ્રદાન કરવાની મંજૂરી આપશે. સારું, આ ઉપરાંત, સ્ટોરના કર્મચારીઓની વર્તણૂકનું વિશ્લેષણ કરવું શક્ય બનશે, ટીમમાં વાતાવરણનું મૂલ્યાંકન કરવું, સારું લાગે છે!

અમે અમારા ઉકેલ માટેની આવશ્યકતાઓ ઘડીએ છીએ:

• લક્ષ્ય ઉપકરણનું નાનું કદ
• વાસ્તવિક સમય કામગીરી
• ઓછી કિંમત
• સરળ માપનીયતા

પરિણામે, અમે લક્ષ્ય ઉપકરણ તરીકે Raspberry Pi 3 c પસંદ કરીએ છીએ ઇન્ટેલ એનસીએસ 2.

અહીં NCS ની એક મહત્વપૂર્ણ વિશેષતાની નોંધ લેવી મહત્વપૂર્ણ છે - તે પ્રમાણભૂત CNN આર્કિટેક્ચર સાથે શ્રેષ્ઠ કાર્ય કરે છે, પરંતુ જો તમારે તેના પર કસ્ટમ સ્તરો સાથે મોડેલ ચલાવવાની જરૂર હોય, તો પછી નીચા-સ્તરના ઑપ્ટિમાઇઝેશનની અપેક્ષા રાખો.

કરવા માટે માત્ર એક નાની વસ્તુ છે: તમારે માઇક્રોફોન મેળવવાની જરૂર છે. નિયમિત યુએસબી માઇક્રોફોન કરશે, પરંતુ તે RPI સાથે સારું દેખાશે નહીં. પરંતુ અહીં પણ ઉકેલ શાબ્દિક રીતે "નજીકમાં આવેલો છે." વૉઇસ રેકોર્ડ કરવા માટે, અમે કીટમાંથી વૉઇસ બોનેટ બોર્ડનો ઉપયોગ કરવાનું નક્કી કરીએ છીએ Google AIY વૉઇસ કિટ, જેના પર વાયર્ડ સ્ટીરિયો માઇક્રોફોન છે.

પરથી રાસ્પબિયન ડાઉનલોડ કરો 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])))

બટન, બર્ન!

અવાજ સાથે કામ

અમે અવાજને ફિલ્ટર કરવા અને અવાજ શોધવા માટે માઇક્રોફોન અને webrtcvadમાંથી સ્ટ્રીમ મેળવવા માટે પ્યાડિયોનો ઉપયોગ કરીશું. વધુમાં, અમે એક કતાર બનાવીશું જેમાં અમે અસુમેળ રીતે અવાજના અવતરણો ઉમેરી અને દૂર કરીશું.

webrtcvad દ્વારા પૂરા પાડવામાં આવેલ ટુકડાના કદ પર મર્યાદા હોવાથી - તે 10/20/30ms ની બરાબર હોવી જોઈએ, અને લાગણીઓને ઓળખવા માટે મોડેલની તાલીમ (જેમ કે આપણે પછીથી જાણીશું) 48kHz ડેટાસેટ પર હાથ ધરવામાં આવી હતી, અમે 48000×20ms/1000×1(મોનો)=960 બાઇટ્સ કદના હિસ્સાને કેપ્ચર કરો. Webrtcvad આ દરેક હિસ્સા માટે સાચું/ખોટું પરત કરશે, જે હિસ્સામાં મતની હાજરી અથવા ગેરહાજરીને અનુરૂપ છે.

ચાલો નીચેના તર્કનો અમલ કરીએ:

• જ્યાં વોટ હશે તે હિસ્સાને અમે યાદીમાં ઉમેરીશું; જો ત્યાં કોઈ મત નથી, તો અમે ખાલી હિસ્સાના કાઉન્ટરને વધારીશું.
• જો ખાલી હિસ્સાનું કાઉન્ટર >=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 = []

સાર્વજનિક ડોમેનમાં પૂર્વ-પ્રશિક્ષિત મોડેલ્સ જોવાનો સમય છે, ગીથબ, ગૂગલ પર જાઓ, પરંતુ યાદ રાખો કે અમારી પાસે ઉપયોગમાં લેવાતા આર્કિટેક્ચર પર મર્યાદા છે. આ એક ખૂબ જ મુશ્કેલ ભાગ છે, કારણ કે તમારે તમારા ઇનપુટ ડેટા પરના મોડલ્સનું પરીક્ષણ કરવું પડશે, અને વધુમાં, તેમને OpenVINO ના આંતરિક ફોર્મેટમાં કન્વર્ટ કરો - IR (મધ્યવર્તી પ્રતિનિધિત્વ). અમે ગીથબમાંથી લગભગ 5-7 જુદા જુદા સોલ્યુશન્સનો પ્રયાસ કર્યો, અને જો લાગણીઓને ઓળખવા માટેનું મોડેલ તરત જ કામ કરે, તો અવાજની ઓળખ સાથે અમારે વધુ રાહ જોવી પડી - તે વધુ જટિલ આર્કિટેક્ચરનો ઉપયોગ કરે છે.

અમે નીચેના પર ધ્યાન કેન્દ્રિત કરીએ છીએ:

• અવાજમાંથી લાગણીઓ - https://github.com/alexmuhr/Voice_Emotion
  તે નીચેના સિદ્ધાંત અનુસાર કાર્ય કરે છે: ઑડિઓ ચોક્કસ કદના ફકરાઓમાં કાપવામાં આવે છે, આ દરેક ફકરાઓ માટે અમે પસંદ કરીએ છીએ MFCC અને પછી CNN પર ઇનપુટ તરીકે સબમિટ કરો
• અવાજ ઓળખ - https://github.com/linhdvu14/vggvox-speaker-identification
  અહીં, MFCC ને બદલે, અમે સ્પેક્ટ્રોગ્રામ સાથે કામ કરીએ છીએ, FFT પછી અમે CNN ને સિગ્નલ ફીડ કરીએ છીએ, જ્યાં આઉટપુટ પર અમને વૉઇસનું વેક્ટર પ્રતિનિધિત્વ મળે છે.

આગળ આપણે સિદ્ધાંતથી શરૂ કરીને મોડેલોને કન્વર્ટ કરવા વિશે વાત કરીશું. OpenVINO માં ઘણા મોડ્યુલો શામેલ છે:

• મોડલ ઝૂ ખોલો, જેમાંથી તમારા ઉત્પાદનમાં ઉપયોગ અને સમાવેશ કરી શકાય તેવા મોડલ
• મોડલ ઑપ્ટિમઝર, જેનો આભાર તમે વિવિધ ફ્રેમવર્ક ફોર્મેટ્સ (ટેન્સરફ્લો, ઓએનએનએક્સ વગેરે) માંથી મોડલને ઇન્ટરમીડિયેટ રિપ્રેઝન્ટેશન ફોર્મેટમાં કન્વર્ટ કરી શકો છો, જેની સાથે અમે આગળ કામ કરીશું.
• ઇન્ફરન્સ એન્જિન તમને ઇન્ટેલ પ્રોસેસર્સ, અસંખ્ય ચિપ્સ અને ન્યુરલ કોમ્પ્યુટ સ્ટિક એક્સિલરેટર્સ પર IR ફોર્મેટમાં મોડલ ચલાવવાની મંજૂરી આપે છે.
• OpenCV નું સૌથી કાર્યક્ષમ સંસ્કરણ (ઇન્ફરન્સ એન્જિન સપોર્ટ સાથે)
  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)

  આ કિસ્સામાં છેલ્લી લાઇન તમને ન્યુરલ કોમ્પ્યુટ સ્ટિક પર ગણતરીઓ રીડાયરેક્ટ કરવાની મંજૂરી આપે છે, પ્રોસેસર પર મૂળભૂત ગણતરીઓ કરવામાં આવે છે, પરંતુ રાસ્પબેરી પીના કિસ્સામાં આ કામ કરશે નહીં, તમારે એક લાકડીની જરૂર પડશે.

  આગળ, તર્ક નીચે મુજબ છે: અમે અમારા ઑડિઓને ચોક્કસ કદની વિન્ડોઝમાં વિભાજીત કરીએ છીએ (અમારા માટે તે 0.4 સે છે), અમે આ દરેક વિન્ડોને MFCC માં કન્વર્ટ કરીએ છીએ, જેને અમે પછી ગ્રીડમાં ફીડ કરીએ છીએ:

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

  આગળ, ચાલો બધી વિન્ડો માટે સૌથી સામાન્ય વર્ગ લઈએ. એક સરળ ઉપાય છે, પરંતુ હેકાથોન માટે તમારે બહુ અસ્પષ્ટ કંઈક લાવવાની જરૂર નથી, ફક્ત જો તમારી પાસે સમય હોય. અમારે હજુ ઘણું કામ કરવાનું બાકી છે, તો ચાલો આગળ વધીએ - અમે વૉઇસ રેકગ્નિશન સાથે કામ કરીશું. અમુક પ્રકારનો ડેટાબેઝ બનાવવો જરૂરી છે જેમાં પ્રી-રેકોર્ડેડ વોઈસના સ્પેક્ટ્રોગ્રામ સ્ટોર કરવામાં આવશે. થોડો સમય બાકી હોવાથી, અમે આ સમસ્યાનું શક્ય તેટલું શ્રેષ્ઠ ઉકેલ લાવીશું.

  એટલે કે, અમે વૉઇસ એક્સ્પ્ટ રેકોર્ડ કરવા માટે એક સ્ક્રિપ્ટ બનાવીએ છીએ (તે ઉપર વર્ણવ્યા પ્રમાણે જ કામ કરે છે, જ્યારે કીબોર્ડથી વિક્ષેપ આવે ત્યારે જ તે વૉઇસને ફાઇલમાં સાચવશે).

  ચાલો પ્રયત્ન કરીએ:

  python3 voice_db/record_voice.py test.wav

  અમે ઘણા લોકોના અવાજો રેકોર્ડ કરીએ છીએ (અમારા કિસ્સામાં, ટીમના ત્રણ સભ્યો)
  આગળ, દરેક રેકોર્ડ કરેલ અવાજ માટે અમે ઝડપી ફોરિયર ટ્રાન્સફોર્મ કરીએ છીએ, સ્પેક્ટ્રોગ્રામ મેળવીએ છીએ અને તેને નમ્પી એરે (.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 લે છે). અમારી પાસે હવે નવા મોડલ્સ ઉમેરવાનો સમય નથી અને વેબ એપ્લિકેશનનો પ્રોટોટાઇપ લખવા પર ધ્યાન કેન્દ્રિત કર્યું છે.

  વેબ એપ્લિકેશન

  એક મહત્વપૂર્ણ મુદ્દો: અમે ઘરેથી અમારી સાથે રાઉટર લઈએ છીએ અને અમારું સ્થાનિક નેટવર્ક સેટ કરીએ છીએ, તે નેટવર્ક પર ઉપકરણ અને લેપટોપને કનેક્ટ કરવામાં મદદ કરે છે.

  બેકએન્ડ એ ફ્રન્ટ અને રાસ્પબેરી પાઈ વચ્ચેની એન્ડ-ટુ-એન્ડ મેસેજ ચેનલ છે, જે વેબસોકેટ ટેક્નોલોજી (http ઓવર tcp પ્રોટોકોલ) પર આધારિત છે.

  પ્રથમ તબક્કો રાસ્પબેરીમાંથી પ્રોસેસ્ડ માહિતી પ્રાપ્ત કરવાનો છે, એટલે કે json માં પેક કરાયેલા આગાહીકારો, જે તેમની મુસાફરી દરમિયાન ડેટાબેઝમાં સાચવવામાં આવે છે જેથી સમયગાળા માટે વપરાશકર્તાની ભાવનાત્મક પૃષ્ઠભૂમિ વિશે આંકડાઓ જનરેટ કરી શકાય. આ પેકેટ પછી ફ્રન્ટએન્ડ પર મોકલવામાં આવે છે, જે સબસ્ક્રિપ્શનનો ઉપયોગ કરે છે અને વેબસોકેટ એન્ડપોઇન્ટમાંથી પેકેટો મેળવે છે. સમગ્ર બેકએન્ડ મિકેનિઝમ ગોલાંગ ભાષામાં બનેલ છે; તે પસંદ કરવામાં આવ્યું હતું કારણ કે તે અસુમેળ કાર્યો માટે યોગ્ય છે, જે ગોરોટીન સારી રીતે હેન્ડલ કરે છે.
  અંતિમ બિંદુને ઍક્સેસ કરતી વખતે, વપરાશકર્તા નોંધાયેલ છે અને બંધારણમાં દાખલ થાય છે, પછી તેનો સંદેશ પ્રાપ્ત થાય છે. વપરાશકર્તા અને સંદેશ બંને એક સામાન્ય હબમાં દાખલ કરવામાં આવે છે, જ્યાંથી સંદેશાઓ પહેલાથી જ આગળ મોકલવામાં આવે છે (સબ્સ્ક્રાઇબ કરેલ ફ્રન્ટ પર), અને જો વપરાશકર્તા કનેક્શન (રાસ્પબેરી અથવા ફ્રન્ટ) બંધ કરે છે, તો તેનું સબ્સ્ક્રિપ્શન રદ કરવામાં આવે છે અને તેને દૂર કરવામાં આવે છે. હબ

  
  અમે પાછળથી કનેક્શનની રાહ જોઈ રહ્યા છીએ

  ફ્રન્ટ-એન્ડ એ ડેવલપમેન્ટ પ્રક્રિયાને ઝડપી બનાવવા અને સરળ બનાવવા માટે રિએક્ટ લાઇબ્રેરીનો ઉપયોગ કરીને JavaScriptમાં લખેલી વેબ એપ્લિકેશન છે. આ એપ્લિકેશનનો હેતુ બેક-એન્ડ બાજુ અને સીધા રાસ્પબેરી પી પર ચાલતા અલ્ગોરિધમનો ઉપયોગ કરીને મેળવેલા ડેટાની કલ્પના કરવાનો છે. પૃષ્ઠમાં રિએક્ટ-રાઉટરનો ઉપયોગ કરીને વિભાગીય રૂટીંગ અમલમાં મૂકવામાં આવ્યું છે, પરંતુ રસનું મુખ્ય પૃષ્ઠ મુખ્ય પૃષ્ઠ છે, જ્યાં વેબસોકેટ તકનીકનો ઉપયોગ કરીને સર્વરમાંથી વાસ્તવિક સમયમાં ડેટાનો સતત પ્રવાહ પ્રાપ્ત થાય છે. Raspberry Pi અવાજ શોધે છે, તે રજિસ્ટર્ડ ડેટાબેઝમાંથી કોઈ ચોક્કસ વ્યક્તિનો છે કે કેમ તે નિર્ધારિત કરે છે અને ક્લાયન્ટને સંભવિતતાની સૂચિ મોકલે છે. ક્લાયંટ નવીનતમ સંબંધિત ડેટા પ્રદર્શિત કરે છે, તે વ્યક્તિનો અવતાર દર્શાવે છે જેણે સંભવતઃ માઇક્રોફોનમાં વાત કરી હતી, તેમજ તે લાગણી કે જેની સાથે તે શબ્દો ઉચ્ચાર કરે છે.

  
  અપડેટેડ અનુમાનો સાથે હોમ પેજ

  નિષ્કર્ષ

  યોજના મુજબ બધું પૂર્ણ કરવું શક્ય ન હતું, અમારી પાસે ફક્ત સમય નહોતો, તેથી મુખ્ય આશા ડેમોમાં હતી, કે બધું કાર્ય કરશે. પ્રેઝન્ટેશનમાં તેઓએ બધું કેવી રીતે કાર્ય કરે છે, તેઓએ કયા મોડલ લીધા, તેમને કઈ સમસ્યાઓનો સામનો કરવો પડ્યો તે વિશે વાત કરી. આગળ ડેમો ભાગ હતો - નિષ્ણાતો રેન્ડમ ક્રમમાં રૂમની આસપાસ ફરતા હતા અને કાર્યકારી પ્રોટોટાઇપ જોવા માટે દરેક ટીમનો સંપર્ક કર્યો હતો. તેઓએ અમને પ્રશ્નો પણ પૂછ્યા, દરેકે તેમના ભાગનો જવાબ આપ્યો, તેઓએ લેપટોપ પર વેબ છોડી દીધું, અને બધું ખરેખર અપેક્ષા મુજબ કામ કર્યું.

  મને નોંધ લેવા દો કે અમારા સોલ્યુશનની કુલ કિંમત $150 હતી:

  • રાસ્પબેરી પાઇ 3 ~ $35
  • Google AIY વૉઇસ બોનેટ (તમે રિસ્પીકર ફી લઈ શકો છો) ~ 15$
  • ઇન્ટેલ NCS 2 ~ 100$

  કેવી રીતે સુધારવું:

  • ક્લાયંટ તરફથી નોંધણીનો ઉપયોગ કરો - રેન્ડમલી જનરેટ થયેલ ટેક્સ્ટ વાંચવા માટે કહો
  • થોડા વધુ મોડલ્સ ઉમેરો: તમે અવાજ દ્વારા લિંગ અને ઉંમર નક્કી કરી શકો છો
  • વારાફરતી અવાજોને અલગ કરો (ડાયરાઇઝેશન)

  ભંડાર: https://github.com/vladimirwest/OpenEMO

  
  થાકેલા પણ ખુશ છીએ

  નિષ્કર્ષમાં, હું આયોજકો અને સહભાગીઓનો આભાર કહેવા માંગુ છું. અન્ય ટીમોના પ્રોજેક્ટ્સમાં, અમને મફત પાર્કિંગ જગ્યાઓ પર દેખરેખ રાખવાનો ઉકેલ વ્યક્તિગત રીતે ગમ્યો. અમારા માટે, તે ઉત્પાદન અને વિકાસમાં નિમજ્જનનો ખૂબ જ સરસ અનુભવ હતો. હું આશા રાખું છું કે AI વિષયો સહિત પ્રદેશોમાં વધુને વધુ રસપ્રદ કાર્યક્રમો યોજાશે.

સોર્સ: www.habr.com