Notice

Recent Posts

Recent Comments

Link

Today

Total

04-20 07:15

Archives

관리 메뉴

Jeongchul Kim

음성인식 STT 한글 음성인식 Annyang API 본문

Web프로그래밍

음성인식 STT 한글 음성인식 Annyang API

김 정출 2017. 7. 3. 02:13

음성인식 STT 한글 음성인식 Annyang API

구글 클라우드 스피치 음성인식 Google Cloud Speech API 사용법 http://jeongchul.tistory.com/544

한글 음성인식 웹 사이트를 만들어봅시다.

음성인식으로 대표적으로 annyang API가 있습니다.

깃허브 사이트는 다음과 같습니다.

https://github.com/TalAter/annyang

간단히 테스트 demo 사이트를 만들어봅니다.

<!DOCTYPE html>
<html>
<head>
<script src='http://cdnjs.cloudflare.com/ajax/libs/annyang/2.6.0/annyang.min.js'></script>
<script>
annyang.start({ autoRestart: false, continuous: true })
var recognition = annyang.getSpeechRecognizer();
var final_transcript = '';
recognition.interimResults = true;
recognition.onresult = function(event) {
var interim_transcript = '';
final_transcript = '';
for (var i = event.resultIndex; i < event.results.length; ++i) {
if (event.results[i].isFinal) {
final_transcript += event.results[i][0].transcript;
console.log("final_transcript="+final_transcript);
//annyang.trigger(final_transcript); //If the sentence is "final" for the Web Speech API, we can try to trigger the sentence
} else {
interim_transcript += event.results[i][0].transcript;
console.log("interim_transcript="+interim_transcript);
}
}
document.getElementById('result').innerHTML = '중간값:='+interim_transcript+'<br/>결과값='+final_transcript;
console.log('interim='+interim_transcript+'|final='+final_transcript);
};
</script>
</head>
<body class="" id="grid">
<br/><br/>
한국어 음성 처리 테스트<br/><br/>
<div id='result'>
결과가 없습니다.
</div>
</body>
</html>

$ vi text.html

html 파일을 브라우저로 열어보고 테스트를 하면 영어(English)만 가능한 것을 확인할 수 있습니다.

annyang.js 의 스크립트를 다운받아 수정을 해봅니다.

annyang.js를 다운받습니다.

https://github.com/TalAter/annyang/blob/master/src/annyang.js

다운받은 annyang.js에서 recognition.lang = 'en-US'; 를 recognition.lang = 'ko';

ko(Korean)으로 변경합니다.

source에서 주석을 제외한 코드 부분은 다음과 같습니다.

//! annyang
//! version : 2.6.0
//! author : Tal Ater @TalAter
//! license : MIT
//! https://www.TalAter.com/annyang/
(function (root, factory) {

....

//! annyang
//! version : 2.6.0
//! author : Tal Ater @TalAter
//! license : MIT
//! https://www.TalAter.com/annyang/
(function (root, factory) {
'use strict';
if (typeof define === 'function' && define.amd) { // AMD + global
   define([], function () {
     return (root.annyang = factory(root));
   });
} else if (typeof module === 'object' && module.exports) { // CommonJS
   module.exports = factory(root);
} else { // Browser globals
   root.annyang = factory(root);
}
}(typeof window !== 'undefined' ? window : this, function (root, undefined) {
'use strict';

var annyang;

// Get the SpeechRecognition object, while handling browser prefixes
var SpeechRecognition = root.SpeechRecognition ||
                         root.webkitSpeechRecognition ||
                         root.mozSpeechRecognition ||
                         root.msSpeechRecognition ||
                         root.oSpeechRecognition;

// Check browser support
// This is done as early as possible, to make it as fast as possible for unsupported browsers
if (!SpeechRecognition) {
   return null;
}

var commandsList = [];
var recognition;
var callbacks = { start: [], error: [], end: [], soundstart: [], result: [], resultMatch: [], resultNoMatch: [], errorNetwork: [], errorPermissionBlocked: [], errorPermissionDenied: [] };
var autoRestart;
var lastStartedAt = 0;
var autoRestartCount = 0;
var debugState = false;
var debugStyle = 'font-weight: bold; color: #00f;';
var pauseListening = false;
var isListening = false;

// The command matching code is a modified version of Backbone.Router by Jeremy Ashkenas, under the MIT license.
var optionalParam = /\s*$(.*?)$\s*/g;
var optionalRegex = /($\?:[^)]+$)\?/g;
var namedParam    = /(\(\?)?:\w+/g;
var splatParam    = /\*\w+/g;
var escapeRegExp = /[\-{}\[\]+?.,\\\^$|#]/g;
var commandToRegExp = function(command) {
   command = command.replace(escapeRegExp, '\\$&')
                 .replace(optionalParam, '(?:$1)?')
                 .replace(namedParam, function(match, optional) {
                   return optional ? match : '([^\\s]+)';
                 })
                 .replace(splatParam, '(.*?)')
                 .replace(optionalRegex, '\\s*$1?\\s*');
   return new RegExp('^' + command + '$', 'i');
};

// This method receives an array of callbacks to iterate over, and invokes each of them
var invokeCallbacks = function(callbacks, ...args) {
   callbacks.forEach(function(callback) {
     callback.callback.apply(callback.context, args);
   });
};

var isInitialized = function() {
   return recognition !== undefined;
};

// method for logging in developer console when debug mode is on
var logMessage = function(text, extraParameters) {
   if (text.indexOf('%c') === -1 && !extraParameters) {
     console.log(text);
   } else {
     console.log(text, extraParameters || debugStyle);
   }
};

var initIfNeeded = function() {
   if (!isInitialized()) {
     annyang.init({}, false);
   }
};

var registerCommand = function(command, callback, originalPhrase) {
   commandsList.push({ command, callback, originalPhrase });
   if (debugState) {
     logMessage('Command successfully loaded: %c'+originalPhrase, debugStyle);
   }
};

var parseResults = function(results) {
   invokeCallbacks(callbacks.result, results);
   var commandText;
   // go over each of the 5 results and alternative results received (we've set maxAlternatives to 5 above)
   for (let i = 0; i<results.length; i++) {
     // the text recognized
     commandText = results[i].trim();
     if (debugState) {
       logMessage('Speech recognized: %c'+commandText, debugStyle);
     }

     // try and match recognized text to one of the commands on the list
     for (let j = 0, l = commandsList.length; j < l; j++) {
       var currentCommand = commandsList[j];
       var result = currentCommand.command.exec(commandText);
       if (result) {
         var parameters = result.slice(1);
         if (debugState) {
           logMessage('command matched: %c'+currentCommand.originalPhrase, debugStyle);
           if (parameters.length) {
             logMessage('with parameters', parameters);
           }
         }
         // execute the matched command
         currentCommand.callback.apply(this, parameters);
         invokeCallbacks(callbacks.resultMatch, commandText, currentCommand.originalPhrase, results);
         return;
       }
     }
   }
   invokeCallbacks(callbacks.resultNoMatch, results);
};

annyang = {

   init: function(commands, resetCommands = true) {
     // Abort previous instances of recognition already running
     if (recognition && recognition.abort) {
       recognition.abort();
     }

     // initiate SpeechRecognition
     recognition = new SpeechRecognition();

     // Set the max number of alternative transcripts to try and match with a command
     recognition.maxAlternatives = 5;

     // In HTTPS, turn off continuous mode for faster results.
     // In HTTP, turn on continuous mode for much slower results, but no repeating security notices
     recognition.continuous = root.location.protocol === 'http:';

     // Sets the language to the default 'en-US'. This can be changed with annyang.setLanguage()
     recognition.lang = 'ko';

     recognition.onstart = function() {
       isListening = true;
       invokeCallbacks(callbacks.start);
     };

     recognition.onsoundstart = function() {
       invokeCallbacks(callbacks.soundstart);
     };

     recognition.onerror = function(event) {
       invokeCallbacks(callbacks.error, event);
       switch (event.error) {
       case 'network':
         invokeCallbacks(callbacks.errorNetwork, event);
         break;
       case 'not-allowed':
       case 'service-not-allowed':
         // if permission to use the mic is denied, turn off auto-restart
         autoRestart = false;
         // determine if permission was denied by user or automatically.
         if (new Date().getTime()-lastStartedAt < 200) {
           invokeCallbacks(callbacks.errorPermissionBlocked, event);
         } else {
           invokeCallbacks(callbacks.errorPermissionDenied, event);
         }
         break;
       }
     };

     recognition.onend = function() {
       isListening = false;
       invokeCallbacks(callbacks.end);
       // annyang will auto restart if it is closed automatically and not by user action.
       if (autoRestart) {
         // play nicely with the browser, and never restart annyang automatically more than once per second
         var timeSinceLastStart = new Date().getTime()-lastStartedAt;
         autoRestartCount += 1;
         if (autoRestartCount % 10 === 0) {
           if (debugState) {
             logMessage('Speech Recognition is repeatedly stopping and starting. See http://is.gd/annyang_restarts for tips.');
           }
         }
         if (timeSinceLastStart < 1000) {
           setTimeout(function() {
             annyang.start({ paused: pauseListening });
           }, 1000-timeSinceLastStart);
         } else {
           annyang.start({ paused: pauseListening });
         }
       }
     };

     recognition.onresult = function(event) {
       if(pauseListening) {
         if (debugState) {
           logMessage('Speech heard, but annyang is paused');
         }
         return false;
       }

       // Map the results to an array
       var SpeechRecognitionResult = event.results[event.resultIndex];
       var results = [];
       for (let k = 0; k<SpeechRecognitionResult.length; k++) {
         results[k] = SpeechRecognitionResult[k].transcript;
       }

       parseResults(results);
     };

     // build commands list
     if (resetCommands) {
       commandsList = [];
     }
     if (commands.length) {
       this.addCommands(commands);
     }
   },

   start: function(options) {
     initIfNeeded();
     options = options || {};
     if (options.paused !== undefined) {
       pauseListening = !!options.paused;
     } else {
       pauseListening = false;
     }
     if (options.autoRestart !== undefined) {
       autoRestart = !!options.autoRestart;
     } else {
       autoRestart = true;
     }
     if (options.continuous !== undefined) {
       recognition.continuous = !!options.continuous;
     }

     lastStartedAt = new Date().getTime();
     try {
       recognition.start();
     } catch(e) {
       if (debugState) {
         logMessage(e.message);
       }
     }
   },
abort
    */
   abort: function() {
     autoRestart = false;
     autoRestartCount = 0;
     if (isInitialized()) {
       recognition.abort();
     }
   },

   pause: function() {
     pauseListening = true;
   },

   resume: function() {
     annyang.start();
   },

   debug: function(newState = true) {
     debugState = !!newState;
   },

   setLanguage: function(language) {
     initIfNeeded();
     recognition.lang = language;
   },

   addCommands: function(commands) {
     var cb;

     initIfNeeded();

     for (let phrase in commands) {
       if (commands.hasOwnProperty(phrase)) {
         cb = root[commands[phrase]] || commands[phrase];
         if (typeof cb === 'function') {
           // convert command to regex then register the command
           registerCommand(commandToRegExp(phrase), cb, phrase);
         } else if (typeof cb === 'object' && cb.regexp instanceof RegExp) {
           // register the command
           registerCommand(new RegExp(cb.regexp.source, 'i'), cb.callback, phrase);
         } else {
           if (debugState) {
             logMessage('Can not register command: %c'+phrase, debugStyle);
           }
           continue;
         }
       }
     }
   },

   removeCommands: function(commandsToRemove) {
     if (commandsToRemove === undefined) {
       commandsList = [];
     } else {
       commandsToRemove = Array.isArray(commandsToRemove) ? commandsToRemove : [commandsToRemove];
       commandsList = commandsList.filter(command => {
         for (let i = 0; i<commandsToRemove.length; i++) {
           if (commandsToRemove[i] === command.originalPhrase) {
             return false;
           }
         }
         return true;
       });
     }
   },

   addCallback: function(type, callback, context) {
     var cb = root[callback] || callback;
     if (typeof cb === 'function' && callbacks[type] !== undefined) {
       callbacks[type].push({callback: cb, context: context || this});
     }
   },

   removeCallback: function(type, callback) {
     var compareWithCallbackParameter = function(cb) {
       return cb.callback !== callback;
     };
     // Go over each callback type in callbacks store object
     for (let callbackType in callbacks) {
       if (callbacks.hasOwnProperty(callbackType)) {
         // if this is the type user asked to delete, or he asked to delete all, go ahead.
         if (type === undefined || type === callbackType) {
           // If user asked to delete all callbacks in this type or all types
           if (callback === undefined) {
             callbacks[callbackType] = [];
           } else {
             // Remove all matching callbacks
             callbacks[callbackType] = callbacks[callbackType].filter(compareWithCallbackParameter);
           }
         }
       }
     }
   },

   isListening: function() {
     return isListening && !pauseListening;
   },

   getSpeechRecognizer: function() {
     return recognition;
   },

   trigger: function(sentences) {
     if(!annyang.isListening()) {
       if (debugState) {
         if (!isListening) {
           logMessage('Cannot trigger while annyang is aborted');
         } else {
           logMessage('Speech heard, but annyang is paused');
         }
       }
       return;
     }

     if (!Array.isArray(sentences)) {
       sentences = [sentences];
     }

     parseResults(sentences);
   }
};

return annyang;

}));

작성한 javascript 파일로 연동하기 위해 html 부분도 다시 수정을 합니다.

기존의 <script src='http://cdnjs.cloudflare.com/ajax/libs/annyang/2.6.0/annyang.min.js'></script>를 삭제하고 <script src=’annyang.js’></script>로 수정합니다.

<!DOCTYPE html>
<html>
<head>
<script src='annyang.js'></script>
<script>
   annyang.start({ autoRestart: false, continuous: true })
   var recognition = annyang.getSpeechRecognizer();
   var final_transcript = '';
   recognition.interimResults = true;
   recognition.onresult = function(event) {
       var interim_transcript = '';
       final_transcript = '';
       for (var i = event.resultIndex; i < event.results.length; ++i) {
           if (event.results[i].isFinal) {
               final_transcript += event.results[i][0].transcript;
               console.log("final_transcript="+final_transcript);
               //annyang.trigger(final_transcript); //If the sentence is "final" for the Web Speech API, we can try to trigger the sentence
           } else {
               interim_transcript += event.results[i][0].transcript;
               console.log("interim_transcript="+interim_transcript);
           }
       }
       document.getElementById('result').innerHTML = '중간값:='+interim_transcript+'<br/>결과값='+final_transcript;
       console.log('interim='+interim_transcript+'|final='+final_transcript);
   };
</script>
</head>
<body class="" id="grid">
<br/><br/>
한국어 음성 처리 테스트<br/><br/>
<div id='result'>
결과가 없습니다.
</div>
</body>
</html>

한국어 인식이 잘되는 것을 확인할 수 있습니다.

Annyang

시작하는 가장 빠른 방법은 annyang 홈페이지 를 방문하는 것입니다.

annyang에 대해 좀 더 자세히 알아 보려면 다음을 읽어보십시오.

API 참조

init (명령, [resetCommands = true])

인식 할 명령 목록으로 annyang을 초기화하십시오.

예 :

var commands = {'hello :name': helloFunction};
var commands2 = {'hi': helloFunction};

// initialize annyang, overwriting any previously added commands
annyang.init(commands, true);
// adds an additional command without removing the previous commands
annyang.init(commands2, false);

v1.1.0부터 더 이상 init ()를 호출 할 필요가 없습니다. 원하는 때마다 듣고 () 언제든지 () 원하는만큼 자주 addCommands ()를 시작하십시오.

더 이상 사용되지 않습니다.

참조 : Commands 객체

start([options])

듣기 시작. 몇 가지 명령을 먼저 추가 한 후 호출하는 것이 좋지만 필수는 아닙니다.

다음 옵션을 지원하는 선택적 옵션 객체를받습니다.

autoRestart (부울, 기본값 : true) 침묵이나 창 충돌로 인해 간접적으로 닫히면 안양이 다시 시작해야합니까?
continuous (boolean) 연속 모드를 계속 켜거나 끌 수 있습니다. 안양 (Annyang)은 이것에 대해 상당히 똑똑하기 때문에 자신이하는 일을 안다면 이것을 설정하십시오.
paused (boolean, default : true) 일시 중지 모드에서 시작합니다.

예 :

// Start listening, don't restart automatically
annyang.start({ autoRestart: false });
// Start listening, don't restart automatically, stop recognition after first phrase recognized
annyang.start({ autoRestart: false, continuous: false });

abort()

듣기를 멈추고 마이크를 통한 음성 인식을 멈춥니다.

또는 SpeechRecognition 엔진을 중지하거나 마이크를 닫지 않고 명령에 응답하는 annyang을 일시적으로 일시 중지하려면 대신 일시 중지 ()를 사용하십시오.

참조 : pause ()

pause()

듣기를 일시 중지합니다. annyang은 브라우저의 SpeechRecognition 엔진이나 마이크를 끄지 않고 명령에 대한 응답을 중지합니다 (이력서 또는 시작 메서드가 호출 될 때까지).

또는 SpeechRecognition 엔진을 중지하고 마이크를 닫으려면 대신 abort ()를 사용하십시오.

참고 : abort ()

resume()

결과가 일치 할 때 듣기를 다시 시작하고 명령 콜백 실행을 복원합니다. SpeechRecognition이 중단 (중지됨)되면 시작하십시오.

setLanguage (language)

사용자가 말할 언어를 설정합니다.이 메서드를 호출하지 않으면 기본값이 'en-US'로 설정됩니다.

참조 : 언어

addCommands (명령)

Annyang이 응답 할 명령을 추가하십시오. init ()과 구문이 비슷하지만 기존 명령을 제거하지 않습니다.

예 :

var commands = {'hello :name': helloFunction, 'howdy': helloFunction};
var commands2 = {'hi': helloFunction};
annyang.addCommands(commands);
annyang.addCommands(commands2);
// annyang will now listen to all three commands

removeCommands ([commandsToRemove])

기존 명령을 제거하십시오. 하나의 문구, 여러 개의 문구 또는 체계적으로 호출됩니다. 모든 명령을 제거하려면 매개 변수를 전달하지 마십시오.

예 :

var commands = {'hello': helloFunction, 'howdy': helloFunction, 'hi': helloFunction};

// Remove all existing commands
annyang.removeCommands();
// Add some commands
annyang.addCommands(commands);
// Don't respond to hello
annyang.removeCommands('hello');
// Don't respond to howdy or hi
annyang.removeCommands(['howdy', 'hi']);

addCallback (유형, 콜백, [컨텍스트])

다음 이벤트 중 하나가 발생하면 호출 할 콜백 함수를 추가하십시오.

start - 브라우저의 음성 인식 엔진이 청취를 시작하자마자 실행됩니다.
soundstart- 소리 (어쩌면 음성)가 감지 되 자마자 발사됩니다. 음성 인식이 시작될 때마다 한 번씩 실행됩니다. https://is.gd/annyang_sound_start를 참조 하십시오.
error - 브라우저의 Speech Recogntion 엔진이 오류를 반환하면 시작됩니다.이 일반 오류 콜백 뒤에는보다 정확한 오류 콜백이 표시됩니다 (둘 다 정의되면 실행됩니다). 첫 번째 인수로 오류 이벤트와 함께 콜백 함수가 호출됩니다.
errorNetwork - 네트워크 오류로 인해 음성 인식이 실패 할 때 발생합니다. 첫 번째 인수로 오류 이벤트와 함께 콜백 함수가 호출됩니다.
errorPermissionBlocked- 브라우저가 음성 인식 사용 권한 요청을 차단하면 시작됩니다. 오류 이벤트를 첫 번째 인수로 사용하여 콜백 함수가 호출됩니다.
errorPermissionDenied- 사용자가 음성 인식 사용 권한 요청을 차단하면 시작됩니다. 오류 이벤트를 첫 번째 인수로 사용하여 콜백 함수가 호출됩니다.
end - 브라우저의 음성 인식 엔진이 중지되면 시작됩니다.
result- 연설이 확인 되 자마자 해고당했습니다. 이 일반 콜백 뒤에는 resultMatch또는 resultNoMatch콜백이옵니다. 이 이벤트에 대한 콜백 함수는 사용자가 첫 번째 인수로 말할 수있는 가능한 구문 배열로 호출됩니다
resultMatch - annyang이 사용자가 말한 것과 등록 된 명령을 일치시킬 수있을 때 시작됩니다.이 이벤트에 대한 콜백 함수는 다음 순서로 세 개의 인수로 호출됩니다. * 사용자가 명령과 일치하는 구를 말합니다. * 일치 한 명령 * 사용자가 말한 가능한 대체 구문의 배열
resultNoMatch- 사용자가 등록한 명령 중 하나와 일치하지 않는다고 말하면 발동됩니다. 이 이벤트에 대한 콜백 함수는 사용자가 첫 번째 인수로 말할 수있는 가능한 구문의 배열로 호출됩니다

예 :

annyang.addCallback('error', function() {
$('.myErrorText').text('There was an error!');
});

annyang.addCallback('resultMatch', function(userSaid, commandText, phrases) {
console.log(userSaid); // sample output: 'hello'
console.log(commandText); // sample output: 'hello (there)'
console.log(phrases); // sample output: ['hello', 'halo', 'yellow', 'polo', 'hello kitty']
});

// pass local context to a global function called notConnected
annyang.addCallback('errorNetwork', notConnected, this);

removeCallback (유형, 콜백)

이벤트에서 콜백을 제거합니다.

해당 이벤트 유형에서 해당 콜백 명령을 제거하려면 이벤트 이름과 콜백 명령을 전달하십시오.
해당 이벤트 유형에서 모든 콜백 명령을 제거하려면 이벤트 이름 만 전달하십시오.
모든 이벤트 유형에서 해당 콜백 명령을 제거하려면 이벤트 이름과 콜백 명령으로 undefined를 전달하십시오.
모든 이벤트 유형에서 모든 콜백 명령을 제거하는 매개 변수를 전달하지 않습니다.

예 :

annyang.addCallback('start', myFunction1);
annyang.addCallback('start', myFunction2);
annyang.addCallback('end', myFunction1);
annyang.addCallback('end', myFunction2);
// Remove all callbacks from all events:
annyang.removeCallback();
// Remove all callbacks attached to end event:
annyang.removeCallback('end');
// Remove myFunction2 from being called on start:
annyang.removeCallback('start', myFunction2);
// Remove myFunction1 from being called on all events:
annyang.removeCallback(undefined, myFunction1);

isListening ()

음성 인식이 현재 유효한 경우 true를 반환합니다. 음성 인식이 꺼져 있거나 양양이 일시 중지 된 경우 false를 반환합니다.

getSpeechRecognizer ()

annyang이 사용하는 브라우저의 SpeechRecognition 객체의 인스턴스를 반환합니다. 브라우저의 음성 인식 엔진에 직접 액세스하려는 경우에 유용합니다.

반환:

SpeechRecognition 브라우저의 음성 인식기는 현재 annyang에서 사용하고 있습니다.

trigger(string|array)

인식되는 음성을 시뮬레이트합니다. 이것은 음성 인식이 음성을 감지 할 때와 동일한 이벤트 및 동작을 트리거합니다.

단일 문장을 포함하는 문자열 또는 명령 중 하나가 일치 할 때까지 순서대로 검사 할 여러 문장을 포함하는 배열을 사용할 수 있습니다 (음성 인식 대안이 구문 분석되는 방식과 유사)

예 :

annyang.trigger('Time for some thrilling heroics');
annyang.trigger(
['Time for some thrilling heroics', 'Time for some thrilling aerobics']
);

저작자표시

'Web프로그래밍' 카테고리의 다른 글

NodeJS Express 웹서버 Webserver (0)	2017.08.22
Javascript 02 Javascript 객체 및 이벤트 처리 (0)	2016.04.29
Javascript 01 Javascript의 개요 (0)	2016.04.29
CSS 05 CSS3 좌표계 (0)	2016.04.29
CSS 04 CSS3 선택자 (0)	2016.04.27

'Web프로그래밍' Related Articles

Comments

Jeongchul Kim

음성인식 STT 한글 음성인식 Annyang API 본문

음성인식 STT 한글 음성인식 Annyang API

Annyang

API 참조

init (명령, [resetCommands = true])

예 :

start([options])

예 :

abort()

pause()

resume()

setLanguage (language)

addCommands (명령)

예 :

removeCommands ([commandsToRemove])

예 :

addCallback (유형, 콜백, [컨텍스트])

예 :

removeCallback (유형, 콜백)

예 :

isListening ()

getSpeechRecognizer ()

반환:

trigger(string|array)

예 :

'Web프로그래밍' 카테고리의 다른 글

티스토리툴바