OpenVINO హ్యాకథాన్: రాస్ప్బెర్రీ పైలో వాయిస్ మరియు భావోద్వేగాలను గుర్తించడం

నవంబర్ 30 - డిసెంబర్ 1 నిజ్నీ నొవ్గోరోడ్లో జరిగింది ఓపెన్వినో హ్యాకథాన్. పాల్గొనేవారు Intel OpenVINO టూల్‌కిట్‌ను ఉపయోగించి ఉత్పత్తి పరిష్కారం యొక్క నమూనాను రూపొందించమని కోరారు. నిర్వాహకులు టాస్క్‌ను ఎంచుకునేటప్పుడు మార్గనిర్దేశం చేయగల సుమారు అంశాల జాబితాను ప్రతిపాదించారు, అయితే తుది నిర్ణయం జట్లపైనే ఉంటుంది. అదనంగా, ఉత్పత్తిలో చేర్చని నమూనాల ఉపయోగం ప్రోత్సహించబడింది.

ఈ వ్యాసంలో మేము ఉత్పత్తి యొక్క మా నమూనాను ఎలా సృష్టించాము అనే దాని గురించి మీకు తెలియజేస్తాము, దానితో మేము చివరికి మొదటి స్థానంలో నిలిచాము.

హ్యాకథాన్‌లో 10కి పైగా జట్లు పాల్గొన్నాయి. వీరిలో కొందరు ఇతర ప్రాంతాల నుంచి రావడం విశేషం. హ్యాకథాన్ కోసం వేదిక "క్రెమ్లిన్స్కీ ఆన్ పోచైన్" కాంప్లెక్స్, ఇక్కడ నిజ్నీ నొవ్‌గోరోడ్ యొక్క పురాతన ఛాయాచిత్రాలు పరివారంలో వేలాడదీయబడ్డాయి! (ప్రస్తుతం ఇంటెల్ యొక్క కేంద్ర కార్యాలయం నిజ్నీ నొవ్‌గోరోడ్‌లో ఉందని నేను మీకు గుర్తు చేస్తున్నాను). పాల్గొనేవారికి కోడ్ వ్రాయడానికి 26 గంటల సమయం ఇవ్వబడింది మరియు చివరికి వారు తమ పరిష్కారాన్ని సమర్పించవలసి ఉంటుంది. ఒక ప్రత్యేక ప్రయోజనం ఏమిటంటే, ప్రణాళికాబద్ధమైన ప్రతిదీ వాస్తవానికి అమలు చేయబడిందని మరియు ప్రెజెంటేషన్‌లో ఆలోచనలుగా ఉండకుండా చూసుకోవడానికి డెమో సెషన్ ఉండటం. సరుకులు, చిరుతిళ్లు, ఆహారం, అన్నీ కూడా ఉన్నాయి!

అదనంగా, ఇంటెల్ ఐచ్ఛికంగా కెమెరాలు, రాస్ప్బెర్రీ PI, న్యూరల్ కంప్యూట్ స్టిక్ 2 అందించింది.

విధి ఎంపిక

ఉచిత-ఫారమ్ హ్యాకథాన్ కోసం సిద్ధం చేయడంలో చాలా కష్టమైన భాగాలలో ఒకటి సవాలును ఎంచుకోవడం. ఇది అత్యంత స్వాగతించదగినది అని ప్రకటనలో పేర్కొన్నందున, ఉత్పత్తిలో ఇంకా లేని దానితో మేము వెంటనే ముందుకు రావాలని నిర్ణయించుకున్నాము.

విశ్లేషించారు మోడల్, ప్రస్తుత విడుదలలో ఉత్పత్తిలో చేర్చబడినవి, వాటిలో చాలా వరకు వివిధ కంప్యూటర్ దృష్టి సమస్యలను పరిష్కరిస్తాయని మేము నిర్ధారణకు వచ్చాము. అంతేకాకుండా, OpenVINOని ఉపయోగించి పరిష్కరించలేని కంప్యూటర్ దృష్టి రంగంలో సమస్యతో రావడం చాలా కష్టం, మరియు ఒకదానిని కనుగొనగలిగినప్పటికీ, పబ్లిక్ డొమైన్‌లో ముందస్తు శిక్షణ పొందిన నమూనాలను కనుగొనడం కష్టం. మేము మరొక దిశలో త్రవ్వాలని నిర్ణయించుకున్నాము - స్పీచ్ ప్రాసెసింగ్ మరియు విశ్లేషణల వైపు. ప్రసంగం నుండి భావోద్వేగాలను గుర్తించే ఆసక్తికరమైన పనిని పరిశీలిద్దాం. OpenVINO ఇప్పటికే ఒక వ్యక్తి యొక్క భావోద్వేగాలను వారి ముఖం ఆధారంగా నిర్ణయించే మోడల్‌ని కలిగి ఉందని చెప్పాలి, కానీ:

• సిద్ధాంతంలో, ధ్వని మరియు ఇమేజ్ రెండింటిపై పని చేసే మిశ్రమ అల్గోరిథంను సృష్టించడం సాధ్యమవుతుంది, ఇది ఖచ్చితత్వాన్ని పెంచుతుంది.
• కెమెరాలు సాధారణంగా ఇరుకైన వీక్షణ కోణాన్ని కలిగి ఉంటాయి; పెద్ద ప్రాంతాన్ని కవర్ చేయడానికి ఒకటి కంటే ఎక్కువ కెమెరాలు అవసరం; ధ్వనికి అలాంటి పరిమితి లేదు.

ఆలోచనను అభివృద్ధి చేద్దాం: రిటైల్ విభాగానికి సంబంధించిన ఆలోచనను ప్రాతిపదికగా తీసుకుందాం. మీరు స్టోర్ చెక్‌అవుట్‌లలో కస్టమర్ సంతృప్తిని కొలవవచ్చు. కస్టమర్‌లలో ఒకరు సేవతో అసంతృప్తి చెంది, వారి స్వరాన్ని పెంచడం ప్రారంభించినట్లయితే, మీరు సహాయం కోసం వెంటనే నిర్వాహకుడిని కాల్ చేయవచ్చు.
ఈ సందర్భంలో, మేము మానవ వాయిస్ గుర్తింపును జోడించాలి, ఇది కస్టమర్‌ల నుండి స్టోర్ ఉద్యోగులను వేరు చేయడానికి మరియు ప్రతి వ్యక్తికి విశ్లేషణలను అందించడానికి మాకు అనుమతిస్తుంది. బాగా, అదనంగా, స్టోర్ ఉద్యోగుల ప్రవర్తనను స్వయంగా విశ్లేషించడం, బృందంలోని వాతావరణాన్ని అంచనా వేయడం సాధ్యమవుతుంది, బాగుంది!

మేము మా పరిష్కారం కోసం అవసరాలను రూపొందిస్తాము:

• లక్ష్యం పరికరం యొక్క చిన్న పరిమాణం
• రియల్ టైమ్ ఆపరేషన్
• తక్కువ ధర
• సులువు స్కేలబిలిటీ

ఫలితంగా, మేము లక్ష్య పరికరంగా Raspberry Pi 3 cని ఎంచుకుంటాము ఇంటెల్ NCS 2.

ఇక్కడ NCS యొక్క ఒక ముఖ్యమైన లక్షణాన్ని గమనించడం ముఖ్యం - ఇది ప్రామాణిక CNN ఆర్కిటెక్చర్‌లతో ఉత్తమంగా పని చేస్తుంది, అయితే మీరు దానిపై అనుకూల లేయర్‌లతో మోడల్‌ను అమలు చేయవలసి వస్తే, తక్కువ-స్థాయి ఆప్టిమైజేషన్‌ను ఆశించండి.

కేవలం ఒక చిన్న విషయం మాత్రమే ఉంది: మీరు మైక్రోఫోన్‌ని పొందాలి. సాధారణ USB మైక్రోఫోన్ పని చేస్తుంది, కానీ అది RPIతో కలిసి బాగా కనిపించదు. కానీ ఇక్కడ కూడా పరిష్కారం అక్షరాలా "సమీపంలో ఉంది." వాయిస్ రికార్డ్ చేయడానికి మేము కిట్ నుండి వాయిస్ బోనెట్ బోర్డ్‌ను ఉపయోగించాలని నిర్ణయించుకున్నాము Google AIY వాయిస్ కిట్, దానిపై వైర్డు స్టీరియో మైక్రోఫోన్ ఉంది.

నుండి Raspbian డౌన్‌లోడ్ చేసుకోండి AIY ప్రాజెక్ట్స్ రిపోజిటరీ మరియు దానిని ఫ్లాష్ డ్రైవ్‌కు అప్‌లోడ్ చేయండి, కింది ఆదేశాన్ని ఉపయోగించి మైక్రోఫోన్ పనిచేస్తుందో లేదో పరీక్షించండి (ఇది 5 సెకన్ల నిడివితో ఆడియోను రికార్డ్ చేసి ఫైల్‌లో సేవ్ చేస్తుంది):

arecord -d 5 -r 16000 test.wav

మైక్రోఫోన్ చాలా సున్నితంగా ఉంటుందని మరియు శబ్దాన్ని బాగా తీసుకుంటుందని నేను వెంటనే గమనించాలి. దీన్ని పరిష్కరించడానికి, ఆల్సమిక్సర్‌కి వెళ్లి, క్యాప్చర్ పరికరాలను ఎంచుకుని, ఇన్‌పుట్ సిగ్నల్ స్థాయిని 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 టుపుల్ మరియు క్లాస్ 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 నుండి స్ట్రీమ్‌ను క్యాప్చర్ చేయడానికి pyaudioని ఉపయోగిస్తాము. అదనంగా, మేము క్యూను సృష్టిస్తాము, దానికి మేము వాయిస్ ఎక్సెర్ప్ట్‌లను అసమకాలికంగా జోడిస్తాము మరియు తీసివేస్తాము.

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 (ఇంటర్మీడియట్ రిప్రజెంటేషన్). మేము github నుండి 5-7 విభిన్న పరిష్కారాలను ప్రయత్నించాము మరియు భావోద్వేగాలను గుర్తించే మోడల్ వెంటనే పని చేస్తే, వాయిస్ గుర్తింపుతో మనం ఎక్కువసేపు వేచి ఉండవలసి ఉంటుంది - అవి మరింత క్లిష్టమైన నిర్మాణాలను ఉపయోగిస్తాయి.

మేము ఈ క్రింది వాటిపై దృష్టి పెడతాము:

• స్వరం నుండి భావోద్వేగాలు - https://github.com/alexmuhr/Voice_Emotion
  ఇది క్రింది సూత్రం ప్రకారం పని చేస్తుంది: ఆడియో ఒక నిర్దిష్ట పరిమాణంలోని గద్యాలై కత్తిరించబడుతుంది, వీటిలో ప్రతి ఒక్కదానికి మేము ఎంచుకుంటాము MFCC ఆపై వాటిని CNNకి ఇన్‌పుట్‌గా సమర్పించండి
• స్వర గుర్తింపు - https://github.com/linhdvu14/vggvox-speaker-identification
  ఇక్కడ, MFCCకి బదులుగా, మేము స్పెక్ట్రోగ్రామ్‌తో పని చేస్తాము, FFT తర్వాత మేము CNNకి సిగ్నల్‌ను అందిస్తాము, ఇక్కడ అవుట్‌పుట్ వద్ద మేము వాయిస్ యొక్క వెక్టర్ ప్రాతినిధ్యం పొందుతాము.

తరువాత మేము సిద్ధాంతంతో ప్రారంభించి, నమూనాలను మార్చడం గురించి మాట్లాడుతాము. OpenVINO అనేక మాడ్యూళ్ళను కలిగి ఉంది:

• మోడల్ జూని తెరవండి, మోడల్‌లను ఉపయోగించుకోవచ్చు మరియు మీ ఉత్పత్తిలో చేర్చవచ్చు
• మోడల్ ఆప్టిమ్‌జర్, మీరు వివిధ ఫ్రేమ్‌వర్క్ ఫార్మాట్‌ల (టెన్సార్‌ఫ్లో, ONNX మొదలైనవి) నుండి మోడల్‌ను ఇంటర్మీడియట్ రిప్రజెంటేషన్ ఫార్మాట్‌లోకి మార్చడానికి ధన్యవాదాలు, దీనితో మేము మరింత పని చేస్తాము
• ఇంటెల్ ప్రాసెసర్‌లు, మిరియడ్ చిప్స్ మరియు న్యూరల్ కంప్యూట్ స్టిక్ యాక్సిలరేటర్‌లలో 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లో ఉన్నట్లు కనిపిస్తోంది, కానీ మేము అంత దూరం తవ్వలేదు మరియు మోడల్‌లలో ఒకదాని కోసం దాన్ని పరిష్కరించాము.
  తర్వాత, DNN మాడ్యూల్ ద్వారా IR ఫార్మాట్‌లో ఇప్పటికే మార్చబడిన మోడల్‌ను 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లో ప్యాక్ చేయబడిన ప్రిడిక్టర్లు, వారి ప్రయాణంలో సగం వరకు డేటాబేస్లో సేవ్ చేయబడతాయి, తద్వారా కాలానికి వినియోగదారు యొక్క భావోద్వేగ నేపథ్యం గురించి గణాంకాలు రూపొందించబడతాయి. ఈ ప్యాకెట్ అప్పుడు ఫ్రంటెండ్‌కి పంపబడుతుంది, ఇది సబ్‌స్క్రిప్షన్‌ని ఉపయోగిస్తుంది మరియు వెబ్‌సాకెట్ ఎండ్‌పాయింట్ నుండి ప్యాకెట్‌లను అందుకుంటుంది. మొత్తం బ్యాకెండ్ మెకానిజం గోలాంగ్ భాషలో నిర్మించబడింది; ఇది ఎసిన్క్రోనస్ టాస్క్‌లకు బాగా సరిపోతుంది కాబట్టి ఇది ఎంపిక చేయబడింది, ఇది గోరౌటీన్‌లు బాగా నిర్వహిస్తుంది.
  ఎండ్‌పాయింట్‌ను యాక్సెస్ చేస్తున్నప్పుడు, వినియోగదారు నమోదు చేయబడి, నిర్మాణంలోకి ప్రవేశించారు, ఆపై అతని సందేశం స్వీకరించబడుతుంది. వినియోగదారు మరియు సందేశం రెండూ ఒక సాధారణ హబ్‌లోకి ప్రవేశించబడ్డాయి, దాని నుండి సందేశాలు ఇప్పటికే మరింత (చందా చేసిన ముందు వైపుకు) పంపబడ్డాయి మరియు వినియోగదారు కనెక్షన్‌ను (కోరిందకాయ లేదా ముందు) మూసివేస్తే, అతని సభ్యత్వం రద్దు చేయబడుతుంది మరియు అతను దాని నుండి తీసివేయబడతాడు హబ్.

  
  మేము వెనుక నుండి కనెక్షన్ కోసం ఎదురు చూస్తున్నాము

  ఫ్రంట్-ఎండ్ అనేది అభివృద్ధి ప్రక్రియను వేగవంతం చేయడానికి మరియు సరళీకృతం చేయడానికి రియాక్ట్ లైబ్రరీని ఉపయోగించి జావాస్క్రిప్ట్‌లో వ్రాయబడిన వెబ్ అప్లికేషన్. ఈ అప్లికేషన్ యొక్క ఉద్దేశ్యం బ్యాక్-ఎండ్ వైపు మరియు నేరుగా రాస్‌ప్‌బెర్రీ పైలో నడుస్తున్న అల్గారిథమ్‌లను ఉపయోగించి పొందిన డేటాను దృశ్యమానం చేయడం. పేజీ రియాక్ట్-రూటర్‌ని ఉపయోగించి సెక్షనల్ రూటింగ్ అమలు చేయబడింది, అయితే ఆసక్తి ఉన్న ప్రధాన పేజీ ప్రధాన పేజీ, ఇక్కడ వెబ్‌సాకెట్ సాంకేతికతను ఉపయోగించి సర్వర్ నుండి నిజ సమయంలో డేటా యొక్క నిరంతర స్ట్రీమ్ స్వీకరించబడుతుంది. Raspberry Pi ఒక వాయిస్‌ని గుర్తిస్తుంది, అది నమోదిత డేటాబేస్ నుండి నిర్దిష్ట వ్యక్తికి చెందినదో కాదో నిర్ధారిస్తుంది మరియు క్లయింట్‌కు సంభావ్యత జాబితాను పంపుతుంది. క్లయింట్ తాజా సంబంధిత డేటాను ప్రదర్శిస్తుంది, మైక్రోఫోన్‌లో ఎక్కువగా మాట్లాడే వ్యక్తి యొక్క అవతార్‌ను అలాగే అతను పదాలను ఉచ్చరించే భావోద్వేగాన్ని ప్రదర్శిస్తుంది.

  
  నవీకరించబడిన అంచనాలతో హోమ్ పేజీ

  తీర్మానం

  ప్రణాళిక ప్రకారం ప్రతిదీ పూర్తి చేయడం సాధ్యం కాదు, మాకు సమయం లేదు, కాబట్టి ప్రతిదీ పని చేస్తుందనే ప్రధాన ఆశ డెమోలో ఉంది. ప్రెజెంటేషన్‌లో వారు ప్రతిదీ ఎలా పని చేస్తారు, వారు ఏ నమూనాలను తీసుకున్నారు, వారు ఏ సమస్యలను ఎదుర్కొన్నారు అనే దాని గురించి మాట్లాడారు. తదుపరిది డెమో భాగం - నిపుణులు యాదృచ్ఛిక క్రమంలో గది చుట్టూ నడిచారు మరియు పని చేసే నమూనాను చూడటానికి ప్రతి బృందాన్ని సంప్రదించారు. వారు మమ్మల్ని కూడా ప్రశ్నలు అడిగారు, ప్రతి ఒక్కరూ తమ వంతుగా సమాధానమిచ్చారు, వారు ల్యాప్‌టాప్‌లో వెబ్‌ను విడిచిపెట్టారు మరియు ప్రతిదీ నిజంగా ఊహించిన విధంగా పనిచేసింది.

  మా పరిష్కారం యొక్క మొత్తం ధర $150 అని నేను గమనించాను:

  • రాస్ప్బెర్రీ పై 3 ~ $35
  • Google AIY వాయిస్ బానెట్ (మీరు రెస్పీకర్ రుసుము తీసుకోవచ్చు) ~ 15$
  • ఇంటెల్ NCS 2 ~ 100$

  ఎలా మెరుగుపరచాలి:

  • క్లయింట్ నుండి నమోదును ఉపయోగించండి - యాదృచ్ఛికంగా రూపొందించబడిన వచనాన్ని చదవమని అడగండి
  • మరికొన్ని మోడల్‌లను జోడించండి: మీరు వాయిస్ ద్వారా లింగం మరియు వయస్సును నిర్ణయించవచ్చు
  • ఏకకాలంలో ధ్వనించే స్వరాలను వేరు చేయండి (డయారైజేషన్)

  రిపోజిటరీ: https://github.com/vladimirwest/OpenEMO

  
  మేము అలసిపోయాము కాని సంతోషంగా ఉన్నాము

  ముగింపులో, నేను నిర్వాహకులకు మరియు పాల్గొనేవారికి ధన్యవాదాలు చెప్పాలనుకుంటున్నాను. ఇతర బృందాల ప్రాజెక్ట్‌లలో, ఉచిత పార్కింగ్ స్థలాలను పర్యవేక్షించే పరిష్కారాన్ని మేము వ్యక్తిగతంగా ఇష్టపడ్డాము. మాకు, ఇది ఉత్పత్తి మరియు అభివృద్ధిలో మునిగిపోవడం యొక్క అద్భుతమైన అనుభవం. AI అంశాలతో సహా ప్రాంతాలలో మరిన్ని ఆసక్తికరమైన కార్యక్రమాలు జరుగుతాయని నేను ఆశిస్తున్నాను.

మూలం: www.habr.com