मुझे Google स्पीच-टू-टेक्स्ट एपीआई का उपयोग करके ट्विलियो फोन कॉल्स से कुछ रीयल टाइम ट्रांसक्रिप्शन करने की आवश्यकता है और मैंने कुछ डेमो ऐप्स का पालन किया है जो इसे सेट अप करने का तरीका दिखाते हैं। मेरा आवेदन .net कोर 3.1 में है और मैं एक ट्विलियो परिभाषित कॉलबैक विधि के साथ वेबहुक का उपयोग कर रहा हूं। मीडिया को ट्विलियो से कॉलबैक के माध्यम से पुनर्प्राप्त करने पर इसे बेस 64 में एन्कोडेड में कच्चे ऑडियो के रूप में पारित किया जाता है जैसा कि आप यहां देख सकते हैं।

https://www.twilio.com/docs/voice/twiml/stream

मैंने लाइव ट्रांसक्राइबिंग पर यह डेमो भी है और मैं सी#में केस स्टेटमेंट की नकल करने की कोशिश कर रहा हूं। सब कुछ सही ढंग से जुड़ता है और मीडिया और पेलोड मेरे ऐप में ट्विलियो से ठीक है।

ऑडियो स्ट्रिंग को तब बाइट में परिवर्तित किया जाता है [] उस कार्य को पास करने के लिए जिसे ऑडियो को ट्रांसक्रिप्ट करने की आवश्यकता होती है

 byte[] audioBytes = Convert.FromBase64String(info);

मैं Google डॉक्स के आधार पर उदाहरणों का अनुसरण कर रहा हूं जो या तो फ़ाइल या ऑडियो इनपुट (जैसे माइक्रोफ़ोन) से स्ट्रीम होते हैं। जहां मेरा उपयोग मामला अलग है, मेरे पास पहले से ही ऑडियो के प्रत्येक खंड के लिए बाइट हैं। मेरे द्वारा संदर्भित उदाहरण यहां देखे जा सकते हैं। स्ट्रीमिंग इनपुट से ऑडियो ट्रांसक्राइब करना

कच्चे ऑडियो बाइट्स का उपयोग करते हुए बाद में मेरा कार्यान्वयन नीचे दिया गया है। जब ट्विलियो वेबसोकेट कनेक्शन मीडिया इवेंट से टकराता है तो नीचे दिया गया यह कार्य हिट हो जाता है। मैं इसमें सीधे पेलोड पास करता हूं। मेरे कंसोल लॉगिंग से मैं प्रिंट रिस्पॉन्स हिट... कंसोल लॉग पर जा रहा हूं, लेकिन यह while (await responseStream.MoveNextAsync()) ब्लॉक में नहीं जाएगा और कंसोल में ट्रांसक्रिप्ट लॉग करेगा। मुझे कोई त्रुटि वापस नहीं मिलती है (जो एप्लिकेशन को तोड़ देती है।) क्या ऐसा करना भी संभव है? मैंने बाइट्स को मेमोरीस्ट्रीम ऑब्जेक्ट में लोड करने और उन्हें पास करने का भी प्रयास किया है क्योंकि Google दस्तावेज़ उदाहरण भी करते हैं।

    static async Task<object> StreamingRecognizeAsync(byte[] audioBytes)
    {

        var speech = SpeechClient.Create();
        var streamingCall = speech.StreamingRecognize();
        // Write the initial request with the config.
        await streamingCall.WriteAsync(
            new StreamingRecognizeRequest()
            {
                StreamingConfig = new StreamingRecognitionConfig()
                {
                    Config = new RecognitionConfig()
                    {
                        Encoding =
                        RecognitionConfig.Types.AudioEncoding.Mulaw,
                        SampleRateHertz = 8000,
                        LanguageCode = "en",

                    },
                    InterimResults = true,
                    SingleUtterance = true
                }
            }); ;
        // Print responses as they arrive.
        Task printResponses = Task.Run(async () =>
        {
            Console.WriteLine("Print Responses hit...");
            var responseStream = streamingCall.GetResponseStream();

            while (await responseStream.MoveNextAsync())
            {
                StreamingRecognizeResponse response = responseStream.Current;
                Console.WriteLine("Response stream moveNextAsync Hit...");
                foreach (StreamingRecognitionResult result in response.Results)
                {
                    foreach (SpeechRecognitionAlternative alternative in result.Alternatives)
                    {
                        Console.WriteLine("Google transcript " + alternative.Transcript);
                    }
                }
            }
        });
        //using (MemoryStream memStream = new MemoryStream(audioBytes))
        //{
        //    var buffer = new byte[32 * 1024];
        //    int bytesRead;
        //    while ((bytesRead = await memStream.ReadAsync(audioBytes, 0, audioBytes.Length)) > 0)
        //    {
        //        await streamingCall.WriteAsync(
        //            new StreamingRecognizeRequest()
        //            {
        //                AudioContent = Google.Protobuf.ByteString
        //                .CopyFrom(buffer, 0, bytesRead),
        //            });
        //    }
        //}

        await streamingCall.WriteAsync(
                   new StreamingRecognizeRequest()
                   {
                       AudioContent = Google.Protobuf.ByteString
                       .CopyFrom(audioBytes),
                   });
        await streamingCall.WriteCompleteAsync();
        await printResponses;
        return 0;
    }
0
HighlanderGrog 14 अप्रैल 2020, 23:56

1 उत्तर

सबसे बढ़िया उत्तर

इस सब के बाद, मैंने पाया कि यह कोड ठीक काम करता है, बस इसे तोड़ने और ट्विलियो स्ट्रीम जीवनचक्र में विभिन्न घटनाओं में कॉल करने की आवश्यकता है। कॉन्फिग सेक्शन को कनेक्टेड इवेंट के दौरान रखा जाना चाहिए। प्रिंट संदेश कार्य को मीडिया ईवेंट में रखने की आवश्यकता है। फिर, जब वेबसोकेट Twilio से बंद हो जाता है, तो WriteCompleteAsync को स्टॉप इवेंट में रखा जाना चाहिए।

विचार करने के लिए एक अन्य महत्वपूर्ण वस्तु यह सुनिश्चित करने के लिए Google एसटीटी को भेजे जा रहे अनुरोधों की संख्या है कि बहुत सारे अनुरोध कोटा को ओवरलोड नहीं कर रहे हैं जो कि (अभी के लिए) 300 अनुरोध / मिनट लगता है।

0
HighlanderGrog 24 अप्रैल 2020, 21:57