🤜🏻 👩‍👧‍👦 🖕🏼 "स्मार्ट होम" अपने हाथों से। भाग 3. Google का उपयोग करके संश्लेषण और आवाज की पहचान ⛰️ 👺 🧙

पिछले लेख में, हम एक बार एक सेकंड में स्नैपशॉट के रूप में अपने वेबकैम से चित्र प्राप्त करने में सक्षम थे। अब यह वादा करने का समय है - आवाज की पहचान और संश्लेषण।

छोटा विषयांतर

इस लेख के साथ शुरुआत करते हुए, मैं अपने सॉफ़्टवेयर का वर्णन करना शुरू करूंगा, जो "स्मार्ट होम" के सभी सबसिस्टमों का समन्वय करता है। मैं यह नोट करना आवश्यक समझता हूं कि मैं पहले ही इस लेख में वर्णित कोड से काफी दूर जा चुका हूं, नए और अधिक कार्यात्मक संस्करण trac- लिंक के माध्यम से मिल सकते हैं। वितरण को GNU GPLv3 के तहत लाइसेंस प्राप्त है। अगर कोई विकास में शामिल होना चाहता है - आपका स्वागत है;)

कुछ जानकारी

वाक् पहचान

जैसा कि मैंने पहले लेख में पहले ही लिखा था, हम ध्वनि संश्लेषण और मान्यता के लिए Google सेवाओं का उपयोग करेंगे। मुझे लगता है कि एंड्रॉइड ओएस चलाने वाले मोबाइल उपकरणों पर आवाज खोज में कई लोग आ गए हैं। एक अतिरिक्त सुविधा के रूप में, यह वही आवाज खोज Google क्रोम ब्राउज़र में जोड़ा गया है। यह ध्यान दिया जाना चाहिए कि कंपनी ने अभी तक इस सेवा के लिए आधिकारिक एपीआई की घोषणा नहीं की है, लेकिन खुले स्रोत क्रोम के लिए धन्यवाद, कारीगरों ने पाया है कि क्या और कहां भेजा जाता है और क्या और कैसे वापस दिया जाता है। यह इस तरह दिखता है:

हम 16000 हर्ट्ज, मोनो की ध्वनि नमूना आवृत्ति के साथ एक वाव-फाइल लिखते हैं
हम परिणामस्वरूप फ़ाइल को फ़्लैक प्रारूप में फिर से बनाते हैं
हम Google Chrome क्लाइंट बनने के बहाने https://www.google.com/speech-api/v1/recognize?xjerr=1&client=chromium&lang=en-RU पते पर फ़ाइल भेजते हैं
हमें JSON प्रारूप में एक प्रतिक्रिया मिलती है

उत्तर कुछ इस प्रकार है:

{"status":0,"id":"84e03bf4efe17fa7856333560d6faba4-1","hypotheses":[{"utterance":" ","confidence":0.85437811}]}

हम केवल पिछले दो क्षेत्रों के उत्तर में रुचि रखते हैं - उच्चारण और आत्मविश्वास । पहला वांछित मान्यता प्राप्त शब्द / वाक्यांश है, दूसरा मान्यता सटीकता है। यदि आत्मविश्वास 0.5 से अधिक है, तो हम मान सकते हैं कि मान्यता विश्वसनीय है।

भाषण संश्लेषण

Google सेवा के माध्यम से भाषण संश्लेषण भी किया जाएगा और, जहां तक मुझे पता है, आधिकारिक एपीआई की घोषणा नहीं की गई है। पाठ से ध्वनि वाक्यांश प्राप्त करने के लिए आपको क्रियाओं का पूरी तरह से जटिल संयोजन बनाने की आवश्यकता है:

फॉर्म का एक अनुरोध सबमिट करें: http://translate.google.com/translate_tts?tl=en&q=text, हेडर में Google Chrome के रूप में दिखाई दे रहा है
एमपी 3 एन्कोडिंग में प्रतिक्रिया स्ट्रीम प्राप्त करें

जैसा कि आप देख सकते हैं, यहां सब कुछ बिल्कुल जटिल नहीं है। अब हम इस जानकारी को प्रोग्रामेटिक रूप से लागू करते हैं।

कुछ कोड

जैसा कि मैंने पहले ही लिखा था, पर्ल में विशेष रूप से लिखा गया दानव हमारे "स्मार्ट होम" के केंद्रीकृत प्रबंधन में संलग्न होगा। मैं कोड की गुणवत्ता के लिए अग्रिम में पूछता हूं कि लात मत मारो, क्योंकि आपका विनम्र नौकर सिर्फ एक सिस्टम प्रशासक है :)
इसलिए, हम उन कार्यों की सीमा निर्धारित करेंगे जो इस सॉफ्टवेयर को करनी चाहिए:

ऑडियो फ़ाइल मान्यता अनुरोध स्वीकार करें
उपकरणों की स्थिति निर्धारित करें, उन्हें कमांड दें
यदि कमांड अनुक्रम का पता चला है तो कुछ क्रिया करें
सेंसर और कैमरों से डेटा के लिए एक निश्चित तरीके से प्रतिक्रिया दें
आंकड़े, रिकॉर्ड और लॉग रखें
स्टेटस, कैमरा देखने, कमांड देने आदि के लिए एक सुविधाजनक वेब-आधारित इंटरफ़ेस है।

शायद मैं कुछ भूल गया या चूक गया, लेकिन, जैसा कि मुझे लगता है, ये स्मार्ट होम सॉफ्टवेयर के मुख्य कार्य हैं। चलिए अब यह सब लागू करना शुरू करते हैं।

एक पर्ल टीसीपी / आईपी डेमॉन बनाने के लिए, नेट :: सर्वर :: फोर्क मॉड्यूल का उपयोग करें। मुझे लगता है कि perl पहले से ही आप से परिचित है।

 #!/usr/bin/perl -w package iON; use strict; use utf8; use base qw(Net::Server::Fork); sub process_request { my $self = shift; while (<STDIN>) { if (/text (\d+)/) { toText($1); next; } if (/quit/i) { print "+OK - Bye-bye ;)\n\n"; last; } print "-ERR - Command not found\n"; logSystem(" : $_", 0); } } iON->run(port => 16000, background => undef, log_level => 4, host => 'localhost'); 1;

यहां जो लिखा गया है, उस पर संक्षेप में जाएं। हम नेट :: सर्वर :: फोर्क मॉड्यूल पर आधारित आईओएन नाम के साथ खुद को एक मॉड्यूल घोषित करते हैं और लॉगहोस्ट के अधिकतम स्तर और "डेमॉन" मोड के बिना स्थानीयहोस्ट पर पोर्ट 16000 पर सर्वर चलाते हैं। अगला, हम process_request () फ़ंक्शन को ओवरलोड करते हैं। वह क्लाइंट से प्राप्त डेटा को संसाधित करने के लिए जिम्मेदार है। हमारे मामले में, यदि सर्वर प्रारूप टेक्स्ट नंबर में पाठ देखता है, तो टॉट फ़ंक्शन को उस संख्या के रूप में मापदंडों के साथ निष्पादित किया जाता है जो क्लाइंट ने हमें भेजा था। पद छोड़ने वाली टीम के साथ, मुझे लगता है कि सब कुछ स्पष्ट है।

टोटेक्स () फ़ंक्शन क्या करता है ? हाँ, वास्तव में, भाषण मान्यता!

 sub toText { my $num = shift; print "+OK - Trying recognize text\n"; my $curl = WWW::Curl::Easy->new; $curl->setopt(CURLOPT_HEADER,1); $curl->setopt(CURLOPT_POST,1); #$curl->setopt(CURLOPT_VERBOSE, 1); my @myheaders=(); $myheaders[0] = "Content-Type: audio/x-flac; rate=16000"; $curl->setopt(CURLOPT_HTTPHEADER, \@myheaders); $curl->setopt(CURLOPT_URL, 'https://www.google.com/speech-api/v1/recognize?xjerr=1&client=chromium&lang=ru-RU'); my $curlf = WWW::Curl::Form->new; $curlf->formaddfile("data/input-$num.flac", 'myfile', "audio/x-flac"); $curl->setopt(CURLOPT_HTTPPOST, $curlf); my $response_body; $curl->setopt(CURLOPT_WRITEDATA,\$response_body); # Starts the actual request my $retcode = $curl->perform; # Looking at the results... if ($retcode == 0) { $response_body =~ /\n\r\n(.*)/g; my $json = $1; my $json_xs = JSON::XS->new(); $json_xs->utf8(1); my @hypo = $json_xs->decode($json)->{'hypotheses'}; my $dost = $hypo[0][0]{'confidence'}; my $text = $hypo[0][0]{'utterance'}; $dost = 0.0 if !defined $dost; $text = "" if !defined $text; print "+OK - Text is: \"$text\", confidence is: $dost\n"; if($dost > 0.5) { checkcmd($text); } { print "+ERR - Confidence is lower, then 0.5\n"; #sayText("  !"); } } else { # Error code, type of error, error message print("+ERR - $retcode ".$curl->strerror($retcode)." ".$curl->errbuf); } system("rm data/input-$num.flac"); }

मैंने विवरणों में वर्णन नहीं किया है - ये बिल्कुल वही कार्य हैं जो पाठ को पहचानने के लिए आवश्यक हैं। Google को इनपुट-नंबर.फ्लैक नामक डेटा उपनिर्देशिका से एक फ़ाइल दी जाती है । यह कैसे बनता है, थोड़ी देर बाद। के बाद - जवाब पढ़ा जाता है, और यदि इसकी विश्वसनीयता 0.5 से अधिक है, तो मान्यता प्राप्त पाठ को चेकसीएमडी () फ़ंक्शन के पैरामीटर के रूप में पारित किया जाता है। सब कुछ के अंत में, ध्वनि फ़ाइल हटा दी जाती है। मैं ध्यान देता हूं कि कर्ल प्रोग्राम को स्थापित करना और हमारी स्क्रिप्ट की शुरुआत में अधिक मॉड्यूल जोड़ना आवश्यक होगा:

 use WWW::Curl::Easy; use WWW::Curl::Form; use JSON::XS;

अब भाषण संश्लेषण के बारे में। यह एक पैरामीटर के रूप में SayText () नामक एक फ़ंक्शन द्वारा नियंत्रित किया जाएगा, जो वास्तविक पाठ लेता है जिसे आवाज देने की आवश्यकता होगी। लेकिन पहले, कुछ लापता मॉड्यूल और वैश्विक चर जोड़ें:

 require Encode; use URI::Escape; use LWP::UserAgent; our $mp3_data;

अब कोड ही:

 sub sayText { my $text = shift; print "+OK - Speaking \"$text\"\n"; my $url = "http://translate.google.com/translate_tts?tl=ru&q=".uri_escape_utf8($text); my $ua = LWP::UserAgent->new( agent => "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/535.2 (KHTML, like Gecko) Chrome/15.0.872.0 Safari/535.2"); $ua->get($url, ':content_cb' => \&callback); open (MP3, "|padsp splay -M") or die "[err] Can't save: $!\n"; print MP3 $mp3_data; close(MP3); $mp3_data = undef; print "+OK - Done!\n"; return; } sub callback { my ($data, $response, $protocol) = @_; $mp3_data .= $data; # }

जैसा कि आप देख सकते हैं, स्ट्रीम के रूप में सर्वर प्रतिक्रिया कॉलबैक () फ़ंक्शन द्वारा संसाधित की जाती है, जो $ mp3_data चर में डेटा जोड़ता है। डेटा को पाइप से स्पलाई प्रोग्राम में स्थानांतरित किया जाता है जिसे पैड्स प्रोग्राम के माध्यम से लॉन्च किया जाता है, जो ओएसएस के अनुकरण के लिए जिम्मेदार है (उबंटू में, ओएसएस काट दिया गया था)। -M स्विच मानक इनपुट से डेटा को चलाने के लिए प्रोग्राम का कारण बनता है।

अब बात करते हैं कि डेटा डायरेक्टरी में फ़्लैक में रहस्यमय फाइलें कहाँ दिखाई देती हैं। यहां सब कुछ सरल है - एक अलग स्क्रिप्ट ऐसा करती है:

 #!/usr/bin/perl use strict; use IO::Socket; while (1) { my $rnd = int(rand(1000)); `rec -q -c 1 -r 16000 ./data/input-$rnd.wav trim 0 4`; `flac -f -s ./data/input-$rnd.wav -o ./data/input-$rnd.flac`; `rm ./data/input-$rnd.wav`; my $sock = new IO::Socket::INET( PeerAddr => "localhost", PeerPort => 16000, Proto => 'tcp') || next; print $sock "text ".$rnd; undef $rnd; }

जैसा कि हम देख सकते हैं, स्क्रिप्ट से बुलाए गए कई प्रोग्राम रिकॉर्डिंग और प्रारूप रूपांतरण करते हैं:

rec ( sox प्रोग्राम वितरण किट से)
flac

रिक कमांड नाम में एक यादृच्छिक संख्या के साथ लघु 4-सेकंड रिकॉर्ड बनाता है, जो कि फ्लैक द्वारा पिन किया जाता है। इसके बाद, हमारे मुख्य डेमॉन से एक कनेक्शन बनाया जाता है और टेक्स्ट कमांड को पास किया जाता है that_same_randomnom_number । मैं 4 सेकंड के छोटे नोट्स क्यों लिख रहा हूं? बात यह है कि कंप्यूटर हमारी आवाज को कैसे रिकॉर्ड करेगा। दो समाधान यहां संभव हैं:

स्थायी रिकॉर्डिंग
एक निश्चित मात्रा से अधिक होने पर एक फ़ाइल रिकॉर्ड करना

दूसरा विकल्प मुझे खराब माइक्रोफोन सहित विभिन्न कारणों से सूट नहीं करता;) हम स्थायी रिकॉर्डिंग के साथ पहले विकल्प के बारे में अधिक विस्तार से विश्लेषण करेंगे। हम अपने रिकॉर्ड को कई छोटे टुकड़ों में तोड़ते हैं जिन्हें हम लगातार मान्यता के लिए Google सर्वर को भेजते हैं। मैंने पाया कि मेरी सभी टीमें अब तक अधिकतम 3-4 सेकंड में आती हैं। यदि हम 1 सेकंड के अंतराल के साथ स्क्रिप्ट की कई (मान लीजिए, 5) प्रतियां चलाते हैं, तो हमें निरंतर आवाज मान्यता मिलती है। इस कार्यक्षमता को हमारे मुख्य कार्यक्रम में जोड़ें:

 for(1..5) { system("perl mic.pl &>/dev/null"); sleep 1; }

अब हमें बस पूरे परिसर के संचालन की जांच करने के लिए checkcmd () फ़ंक्शन को लागू करना होगा । हमें झूठी सकारात्मकता को खत्म करने के लिए लक्षित पते की भी आवश्यकता है।

 sub checkcmd { my $text = shift; if($text =~ //) { sayText("  - $text"); # if $text eq "  "; } }

अब, इसे एक ढेर में डालें। हमें दो स्क्रिप्ट मिलीं, चलो उन्हें srv.pl और mic.pl कहते हैं, साथ ही साथ हमारी ध्वनि फ़ाइलों को संग्रहीत करने के लिए डेटा उपनिर्देशिका।

srv.pl

 #!/usr/bin/perl -w package iON; use strict; use utf8; use WWW::Curl::Easy; use WWW::Curl::Form; use JSON::XS; use URI::Escape; use LWP::UserAgent; require Encode; use base qw(Net::Server::Fork); ##  ################################ $|=1; our $parent = $$; our $mp3_data; ################################ for(1..5) { system("perl mic.pl &>/dev/null"); sleep 1; } ##    ############################### iON->run(port => 16000, background => undef, log_level => 4, host => 'localhost'); ################################ ################################ sub DESTROY { if($$ == $parent) { system("killall perl"); system("rm data/*.flac && rm data/*.wav"); } } ##    ################################ sub process_request { my $self = shift; while (<STDIN>) { if (/text (\d+)/) { toText($1); next; } if (/quit/i) { print "+OK - Bye-bye ;)\n\n"; last; } print "-ERR - Command not found\n"; } } ############################### ############################### sub toText { my $num = shift; print "+OK - Trying recognize text\n"; my $curl = WWW::Curl::Easy->new; $curl->setopt(CURLOPT_HEADER,1); $curl->setopt(CURLOPT_POST,1); #$curl->setopt(CURLOPT_VERBOSE, 1); my @myheaders=(); $myheaders[0] = "Content-Type: audio/x-flac; rate=16000"; $curl->setopt(CURLOPT_HTTPHEADER, \@myheaders); $curl->setopt(CURLOPT_URL, 'https://www.google.com/speech-api/v1/recognize?xjerr=1&client=chromium&lang=ru-RU'); my $curlf = WWW::Curl::Form->new; $curlf->formaddfile("data/input-$num.flac", 'myfile', "audio/x-flac"); $curl->setopt(CURLOPT_HTTPPOST, $curlf); my $response_body; $curl->setopt(CURLOPT_WRITEDATA,\$response_body); # Starts the actual request my $retcode = $curl->perform; # Looking at the results... if ($retcode == 0) { $response_body =~ /\n\r\n(.*)/g; my $json = $1; my $json_xs = JSON::XS->new(); $json_xs->utf8(1); my @hypo = $json_xs->decode($json)->{'hypotheses'}; my $dost = $hypo[0][0]{'confidence'}; my $text = $hypo[0][0]{'utterance'}; $dost = 0.0 if !defined $dost; $text = "" if !defined $text; print "+OK - Text is: \"$text\", confidence is: $dost\n"; if($dost > 0.5) { checkcmd($text); } { print "+ERR - Confidence is lower, then 0.5\n"; } } else { # Error code, type of error, error message print("+ERR - $retcode ".$curl->strerror($retcode)." ".$curl->errbuf); } system("rm data/input-$num.flac"); } ############################### ##    ############################### sub checkcmd { my $text = shift; chomp $text; $text =~ s/ $//g; print "+OK - Got command \"$text\" (Length: ".length($text).")\n"; if($text =~ //) { sayText("  - $text"); } return; } ##  ############################### sub sayText { my $text = shift; print "+OK - Speaking \"$text\"\n"; my $url = "http://translate.google.com/translate_tts?tl=ru&q=".uri_escape_utf8($text); my $ua = LWP::UserAgent->new( agent => "Mozilla/5.0 (Windows NT 5.1) AppleWebKit/535.2 (KHTML, like Gecko) Chrome/15.0.872.0 Safari/535.2"); $ua->get($url, ':content_cb' => \&callback); open (MP3, "|padsp splay -M") or die "[err] Can't save: $!\n"; print MP3 $mp3_data; close(MP3); $mp3_data = undef; print "+OK - Done!\n"; return; } sub callback { my ($data, $response, $protocol) = @_; $mp3_data .= $data; # } ######################################## ######################################## 1;

mic.pl

 #!/usr/bin/perl use strict; use IO::Socket; while (1) { my $rnd = int(rand(1000)); `rec -q -c 1 -r 16000 ./data/input-$rnd.wav trim 0 3`; `flac -f -s ./data/input-$rnd.wav -o ./data/input-$rnd.flac`; `rm ./data/input-$rnd.wav`; my $sock = new IO::Socket::INET( PeerAddr => "localhost", PeerPort => 16000, Proto => 'tcp') || next; print $sock "text ".$rnd; undef $rnd; }

क्या हुआ?

हम अपनी स्क्रिप्ट चलाने का अधिकार देते हैं:

chmod 755 srv.pl mic.pl

Srv.pl स्क्रिप्ट चलाएँ, सभी प्रक्रियाओं की शुरुआत के लिए प्रतीक्षा करें, कहते हैं, कहते हैं: “सिस्टम! एक, दो, तीन! " हम कुछ सेकंड के बाद सुनते हैं: "आपकी टीम - एक, दो, तीन।" यह ध्यान दिया जाना चाहिए कि हमारी टीम कई ध्वनि फ़ाइलों में गिरेगी और, तदनुसार, कई बार निष्पादित की जाएगी। इससे बचने के लिए, आपको अंतिम कमांड पर एक चेक दर्ज करना होगा। इस कार्यक्षमता को अगले भाग में जोड़ें।

कुल मिलाकर

इस लेख में, हमने "स्मार्ट होम" सिस्टम के प्रबंधन के लिए अपने सॉफ़्टवेयर के आधार को लागू किया है। हालांकि यह लगभग कुछ भी नहीं कर सकता है लेकिन भाषण को पहचानता है और संश्लेषित करता है, लेकिन यह अस्थायी है;)

अगले लेख में मैं आपको बताऊंगा कि कैसे कुछ स्वादिष्ट उपहारों और कैमरा देखने के साथ वेब-इंटरफ़ेस को इस सबको जकड़ना है।

UPD: भाग 4

"स्मार्ट होम" अपने हाथों से। भाग 3. Google का उपयोग करके संश्लेषण और आवाज की पहचान