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-ზე, აირჩიეთ Capture devices და შევამციროთ შეყვანის სიგნალის დონე 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

მოდით შევქმნათ დიქტა, რომელშიც თითოეულ ემოციას ექნება შესაბამისი ფერი 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 (შუალედური წარმომადგენლობა). ჩვენ ვცადეთ დაახლოებით 5-7 სხვადასხვა გადაწყვეტა github-ისგან და თუ ემოციების ამოცნობის მოდელი მაშინვე იმუშავებდა, მაშინ ხმის ამოცნობით უფრო მეტხანს მოგვიწია ლოდინი - ისინი იყენებენ უფრო რთულ არქიტექტურებს.

ჩვენ ყურადღებას ვამახვილებთ შემდეგზე:

• ემოციები ხმიდან - https://github.com/alexmuhr/Voice_Emotion
  ის მუშაობს შემდეგი პრინციპით: აუდიო იჭრება გარკვეული ზომის პასაჟებად, თითოეული ამ პასაჟისთვის ჩვენ ვირჩევთ MFCC და შემდეგ წარუდგინეთ ისინი CNN-ს შეყვანის სახით
• Ხმის ამოცნობა - https://github.com/linhdvu14/vggvox-speaker-identification
  აქ MFCC-ის ნაცვლად ვმუშაობთ სპექტროგრამით, FFT-ის შემდეგ სიგნალს ვაწვდით CNN-ს, სადაც გამოსავალზე ვიღებთ ხმის ვექტორულ წარმოდგენას.

შემდეგ ვისაუბრებთ მოდელების კონვერტაციაზე, დაწყებული თეორიით. OpenVINO მოიცავს რამდენიმე მოდულს:

• გახსენით მოდელის ზოოპარკი, მოდელები, რომლებიდანაც შეიძლება გამოყენებულ იქნას და შევიდეს თქვენს პროდუქტში
• Model Optimzer, რომლის წყალობითაც შეგიძლიათ მოდელი გადაიყვანოთ სხვადასხვა ჩარჩო ფორმატებიდან (Tensorflow, ONNX და ა.შ.) შუალედური წარმოდგენის ფორმატში, რომლითაც ჩვენ შემდგომში ვიმუშავებთ.
• 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 წმ), ვაქცევთ თითოეულ ამ ფანჯარას 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 დასკვნა). ჩვენ აღარ გვქონდა დრო ახალი მოდელების დასამატებლად და ორიენტირებული ვიყავით ვებ აპლიკაციის პროტოტიპის დაწერაზე.

  ვებ აპლიკაცია

  მნიშვნელოვანი პუნქტი: ჩვენთან ერთად ვიღებთ როუტერს სახლიდან და ვაყენებთ ჩვენს ლოკალურ ქსელს, ის გვეხმარება მოწყობილობისა და ლეპტოპების ქსელში დაკავშირებაში.

  Backend არის ბოლოდან ბოლომდე შეტყობინების არხი წინა და Raspberry Pi-ს შორის, რომელიც დაფუძნებულია websocket ტექნოლოგიაზე (http over tcp პროტოკოლი).

  პირველი ეტაპი არის დამუშავებული ინფორმაციის მიღება ჟოლოდან, ანუ json-ში შეფუთული პროგნოზირებიდან, რომლებიც ინახება მონაცემთა ბაზაში მათი მოგზაურობის ნახევარში, რათა მოხდეს სტატისტიკის გენერირება მომხმარებლის ემოციური ფონის შესახებ ამ პერიოდისთვის. ეს პაკეტი შემდეგ იგზავნება ფრონტენდში, რომელიც იყენებს გამოწერას და იღებს პაკეტებს ვებსოკეტის ბოლო წერტილიდან. მთელი backend მექანიზმი აგებულია გოლანგის ენაზე; ის არჩეულია იმიტომ, რომ კარგად შეეფერება ასინქრონულ ამოცანებს, რომლებსაც გორუტინები კარგად უმკლავდებიან.
  საბოლოო წერტილზე წვდომისას მომხმარებელი რეგისტრირდება და შედის სტრუქტურაში, შემდეგ მიიღება მისი შეტყობინება. მომხმარებელიც და შეტყობინებაც შედის საერთო ჰაბში, საიდანაც შეტყობინებები უკვე იგზავნება შემდგომ (გამოწერილ ფრონტზე), ხოლო თუ მომხმარებელი დახურავს კავშირს (ჟოლო ან წინა), მაშინ მისი გამოწერა უქმდება და ის ამოღებულია. კერა.

  
  ჩვენ ველოდებით კავშირს უკნიდან

  Front-end არის JavaScript-ში დაწერილი ვებ აპლიკაცია React ბიბლიოთეკის გამოყენებით, რათა დააჩქაროს და გაამარტივოს განვითარების პროცესი. ამ აპლიკაციის მიზანია მოპოვებული მონაცემების ვიზუალიზაცია უკანა მხარეს და პირდაპირ Raspberry Pi-ზე გაშვებული ალგორითმების გამოყენებით. გვერდს აქვს სექციური მარშრუტიზაცია, რომელიც განხორციელებულია რეაქტ-როუტერის გამოყენებით, მაგრამ ინტერესის მთავარი გვერდი არის მთავარი გვერდი, სადაც მონაცემთა უწყვეტი ნაკადი მიიღება რეალურ დროში სერვერიდან 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