def transform_audio_to_text(filename): user = expanduser("~") path = user + "/DTAI_Internship/src/speech_recognizer_node/data/" lm_file = path + "generated_language_model.lm" dict_file = path + "generated_dictionary.dic" hmm_file = user + "/.local/lib/python2.7/site-packages/pocketsphinx/model/en-us" model_path = get_model_path() data_path = get_data_path() config = { 'hmm': os.path.join(model_path, 'en-us'), 'lm': os.path.join(model_path, lm_file), 'dict': os.path.join(model_path, dict_file) } ps = Pocketsphinx(**config) ps.decode(audio_file=os.path.join(data_path, filename), buffer_size=2048, no_search=False, full_utt=False) text = ps.hypothesis() print(text) return text
class TestRawDecoder(TestCase): def __init__(self, *args, **kwargs): self.ps = Pocketsphinx() self.ps.decode() super(TestRawDecoder, self).__init__(*args, **kwargs) def test_raw_decoder_lookup_word(self): self.assertEqual(self.ps.lookup_word('hello'), 'HH AH L OW') self.assertEqual(self.ps.lookup_word('abcdf'), None) def test_raw_decoder_hypothesis(self): self.assertEqual(self.ps.hypothesis(), 'go forward ten meters') self.assertEqual(self.ps.score(), -7066) self.assertEqual(self.ps.confidence(), 0.04042641466841839) def test_raw_decoder_segments(self): self.assertEqual( self.ps.segments(), ['<s>', '<sil>', 'go', 'forward', 'ten', 'meters', '</s>']) def test_raw_decoder_best_hypothesis(self): self.assertEqual(self.ps.best(), [('go forward ten meters', -28034), ('go for word ten meters', -28570), ('go forward and majors', -28670), ('go forward and meters', -28681), ('go forward and readers', -28685), ('go forward ten readers', -28688), ('go forward ten leaders', -28695), ('go forward can meters', -28695), ('go forward and leaders', -28706), ('go for work ten meters', -28722)])
def pocket(): ps = Pocketsphinx() language_directory = os.path.dirname(os.path.realpath(__file__)) print language_directory acoustic_parameters_directory = os.path.join(language_directory, "acoustic-model") language_model_file = os.path.join(language_directory, "language-model.lm.bin") phoneme_dictionary_file = os.path.join(language_directory, "pronounciation-dictionary.dict") config = Decoder.default_config() config.set_string("-hmm", acoustic_parameters_directory) # set the path of the hidden Markov model (HMM) parameter files config.set_string("-lm", language_model_file) config.set_string("-dict", phoneme_dictionary_file) decoder = Decoder(config) with sr.AudioFile(s_dir + "/a bad situation could become dramatically worse. /a bad situation could become dramatically worse. .wav") as source: audio_data = r.record(source) decoder.start_utt() decoder.process_raw(audio_data, False, True) decoder.end_utt() print decoder.hyp() ps.decode( audio_file=os.path.join(s_dir, 'a bad situation could become dramatically worse. /a bad situation could become dramatically worse. .wav'), buffer_size=2048, no_search=False, full_utt=False) print(ps.hypothesis()) # => ['<s>', '<sil>', 'go', 'forward', 'ten', 'meters', '</s>'] #pocket()
class TestRawDecoder(TestCase): def __init__(self, *args, **kwargs): self.ps = Pocketsphinx() self.ps.decode() super(TestRawDecoder, self).__init__(*args, **kwargs) def test_raw_decoder_lookup_word(self): self.assertEqual(self.ps.lookup_word('hello'), 'HH AH L OW') self.assertEqual(self.ps.lookup_word('abcdf'), None) def test_raw_decoder_hypothesis(self): self.assertEqual(self.ps.hypothesis(), 'go forward ten meters') self.assertEqual(self.ps.score(), -7066) self.assertEqual(self.ps.confidence(), 0.04042641466841839) def test_raw_decoder_segments(self): self.assertEqual(self.ps.segments(), [ '<s>', '<sil>', 'go', 'forward', 'ten', 'meters', '</s>' ]) def test_raw_decoder_best_hypothesis(self): self.assertEqual(self.ps.best(), [ ('go forward ten meters', -28034), ('go for word ten meters', -28570), ('go forward and majors', -28670), ('go forward and meters', -28681), ('go forward and readers', -28685), ('go forward ten readers', -28688), ('go forward ten leaders', -28695), ('go forward can meters', -28695), ('go forward and leaders', -28706), ('go for work ten meters', -28722) ])
def __init__(self, mode): # state self.micbuf = np.zeros((0, 4), 'uint16') self.outbuf = None self.buffer_stuff = 0 self.mode = mode self.playchan = 0 self.playsamp = 0 # check mode if not (mode == "echo" or mode == "record" or mode == "record4"): error("argument not recognised") # robot name topic_base_name = "/" + os.getenv("MIRO_ROBOT_NAME") # publish topic = topic_base_name + "/control/stream" print ("publish", topic) self.pub_stream = rospy.Publisher(topic, Int16MultiArray, queue_size=0) # subscribe topic = topic_base_name + "/sensors/stream" print ("subscribe", topic) self.sub_stream = rospy.Subscriber(topic, UInt16MultiArray, self.callback_stream, queue_size=1, tcp_nodelay=True) # subscribe topic = topic_base_name + "/sensors/mics" print ("subscribe", topic) self.sub_mics = rospy.Subscriber(topic, Int16MultiArray, self.callback_mics, queue_size=5, tcp_nodelay=True) # report print "recording from 4 microphones for", RECORD_TIME, "seconds..." ####### Speech Recongnition using Pocket-Sphinx ######### model_path = get_model_path() data_path = get_data_path() config = { 'hmm' : os.path.join(model_path, 'en-us'), # Hidden Markov Model, Speech Recongnition model - trained probability scoring system 'lm': os.path.join(model_path, 'en-us.lm.bin'), #language model 'dict' : os.path.join(model_path, 'cmudict-en-us.dict') # language dictionary } ps = Pocketsphinx(**config) ps.decode( audio_file=("/tmp/input.wav"), #add temp input.wav file buffer_size=2048, no_search= False, full_utt=False) print("Recognized: ") print((ps.hypothesis())) ## output print("END")
def test_lattice(self): ps = Pocketsphinx() ps.decode() lattice = ps.get_lattice() self.assertEqual(lattice.write('tests/goforward.lat'), None) lattice = ps.get_lattice() self.assertEqual(lattice.write_htk('tests/goforward.htk'), None)
class SpeechProcessor: def __init__(self, hmm='data/spanish/CIEMPIESS_Spanish_Models_581h/Models/modelo', lm='data/spanish/CIEMPIESS_Spanish_Models_581h/Models/leng.lm.bin', dict='data/spanish/CIEMPIESS_Spanish_Models_581h/Models/dicc.dic', grammar='data/gramatica-tp2.gram', dataPath='tmp/'): self.data_path = dataPath config = { 'hmm': hmm, 'lm': lm, 'dict': dict } #model_path = get_model_path() self.ps = Pocketsphinx(**config) # Switch to JSGF grammar jsgf = Jsgf(grammar) rule = jsgf.get_rule('tp2.grammar') fsg = jsgf.build_fsg(rule, self.ps.get_logmath(), 7.5) self.ps.set_fsg('tp2', fsg) self.ps.set_search('tp2') # Síntesis self.tts_authenticator = IAMAuthenticator('cq9_4YcCXxClw2AfgUhbokFktZ-xSRT4kcHS2akcZ05J') self.tts = TextToSpeechV1(authenticator=self.tts_authenticator) self.tts.set_service_url('https://stream.watsonplatform.net/text-to-speech/api') def sintetizar(self, outFileName, msg): if len(msg) > 0: with open(outFileName, 'wb') as audio_file: audio_file.write( self.tts.synthesize( msg, voice='es-LA_SofiaV3Voice', accept='audio/wav' ).get_result().content) def reconocer(self, inFileName='audio.wav'): # Reconocimiento print(self.data_path) self.ps.decode( audio_file=os.path.join(self.data_path,inFileName), buffer_size=2048, no_search=False, full_utt=False ) return self.ps.segments(), self.ps.best(count=3)
class TestPhoneme(TestCase): def __init__(self, *args, **kwargs): self.ps = Pocketsphinx( lm=False, dic=False, allphone='deps/pocketsphinx/model/en-us/en-us-phone.lm.bin', lw=2.0, pip=0.3, beam=1e-200, pbeam=1e-20, mmap=False ) self.ps.decode() super(TestPhoneme, self).__init__(*args, **kwargs) def test_phoneme_hypothesis(self): self.assertEqual( self.ps.hypothesis(), 'SIL G OW F AO R W ER D T AE N M IY IH ZH ER Z S V SIL' ) def test_phoneme_best_phonemes(self): self.assertEqual(self.ps.segments(), [ 'SIL', 'G', 'OW', 'F', 'AO', 'R', 'W', 'ER', 'D', 'T', 'AE', 'N', 'M', 'IY', 'IH', 'ZH', 'ER', 'Z', 'S', 'V', 'SIL' ])
def test_jsgf(self): ps = Pocketsphinx(lm='deps/pocketsphinx/test/data/turtle.lm.bin', dic='deps/pocketsphinx/test/data/turtle.dic') # Decoding with 'turtle' language model ps.decode() self.assertEqual(ps.hypothesis(), 'go forward ten meters') # Switch to JSGF grammar jsgf = Jsgf('deps/pocketsphinx/test/data/goforward.gram') rule = jsgf.get_rule('goforward.move2') fsg = jsgf.build_fsg(rule, ps.get_logmath(), 7.5) ps.set_fsg('goforward', fsg) ps.set_search('goforward') # Decoding with 'goforward' grammar ps.decode() self.assertEqual(ps.hypothesis(), 'go forward ten meters')
def test_jsgf(self): ps = Pocketsphinx( lm='deps/pocketsphinx/test/data/turtle.lm.bin', dic='deps/pocketsphinx/test/data/turtle.dic' ) # Decoding with 'turtle' language model ps.decode() self.assertEqual(ps.hypothesis(), 'go forward ten meters') # Switch to JSGF grammar jsgf = Jsgf('deps/pocketsphinx/test/data/goforward.gram') rule = jsgf.get_rule('goforward.move2') fsg = jsgf.build_fsg(rule, ps.get_logmath(), 7.5) ps.set_fsg('goforward', fsg) ps.set_search('goforward') # Decoding with 'goforward' grammar ps.decode() self.assertEqual(ps.hypothesis(), 'go forward ten meters')
class TestPhoneme(TestCase): def __init__(self, *args, **kwargs): self.ps = Pocketsphinx( lm=False, dic=False, allphone='deps/pocketsphinx/model/en-us/en-us-phone.lm.bin', lw=2.0, pip=0.3, beam=1e-200, pbeam=1e-20, mmap=False ) self.ps.decode() super(TestPhoneme, self).__init__(*args, **kwargs) def test_phoneme_hypothesis(self): self.assertEqual( self.ps.hypothesis(), 'SIL G OW F AO R D T AE N NG IY ZH ER S SIL' ) def test_phoneme_best_phonemes(self): self.assertEqual(self.ps.segments(), [ 'SIL', 'G', 'OW', 'F', 'AO', 'R', 'D', 'T', 'AE', 'N', 'NG', 'IY', 'ZH', 'ER', 'S', 'SIL' ])
def test_lm(self): ps = Pocketsphinx( dic='deps/pocketsphinx/test/data/defective.dic', mmap=False ) # Decoding with 'defective' dictionary ps.decode() self.assertEqual(ps.hypothesis(), '') # Switch to 'turtle' language model turtle_lm = 'deps/pocketsphinx/test/data/turtle.lm.bin' lm = NGramModel(ps.get_config(), ps.get_logmath(), turtle_lm) ps.set_lm('turtle', lm) ps.set_search('turtle') # Decoding with 'turtle' language model ps.decode() self.assertEqual(ps.hypothesis(), '') # The word 'meters' isn't in the loaded dictionary # Let's add it manually ps.add_word('foobie', 'F UW B IY', False) ps.add_word('meters', 'M IY T ER Z', True) # Decoding with 'turtle' language model ps.decode() self.assertEqual(ps.hypothesis(), 'foobie meters meters')
def test_lm(self): ps = Pocketsphinx(dic='deps/pocketsphinx/test/data/defective.dic', mmap=False) # Decoding with 'defective' dictionary ps.decode() self.assertEqual(ps.hypothesis(), '') # Switch to 'turtle' language model turtle_lm = 'deps/pocketsphinx/test/data/turtle.lm.bin' lm = NGramModel(ps.get_config(), ps.get_logmath(), turtle_lm) ps.set_lm('turtle', lm) ps.set_search('turtle') # Decoding with 'turtle' language model ps.decode() self.assertEqual(ps.hypothesis(), '') # The word 'meters' isn't in the loaded dictionary # Let's add it manually ps.add_word('foobie', 'F UW B IY', False) ps.add_word('meters', 'M IY T ER Z', True) # Decoding with 'turtle' language model ps.decode() self.assertEqual(ps.hypothesis(), 'foobie meters meters')
config = { 'hmm': os.path.join(model_path, 'en-us'), 'lm': os.path.join(model_path, 'en-us.lm.bin'), 'dict': os.path.join(model_path, 'cmudict-en-us.dict') } #place the .wav fie in the directory of data_path # /home/krishna/anaconda3/lib/python3.7/site-packages/pocketsphinx/data ps = Pocketsphinx(**config) ps.decode( audio_file=os.path.join(data_path, filename_wav_extn), buffer_size=2048, no_search=False, full_utt=False ) #print(ps.segments()) #save the detailed segments of the words, #which will contain details word, probablity, start_time and end_time #print('Detailed segments:', *ps.segments(detailed=True), sep='\n') # with open('output_segments_obama_farewell_speech.txt', 'a') as f: # print(*ps.segments(detailed=True), sep='\n', file=f) with open(filename_output_segments, 'a') as f: print(*ps.segments(detailed=True), sep='\n', file=f)
class SpeechToText: ''' Предназначен для распознавания речи с помощью PocketSphinx. 1. mode - может иметь два значения: from_file и from_microphone 1.1. from_file - распознавание речи из .wav файла (частота дискретизации >=16кГц, 16bit, моно) 1.2. from_microphone - распознавание речи с микрофона 2. name_dataset - имя набора данных, на основе которого построена языковая модель: plays_ru, subtitles_ru или conversations_ru ''' def __init__(self, mode='from_microphone', name_dataset='plays_ru'): self.current_dirname = os.path.dirname(os.path.realpath(__file__)) self.work_mode = mode model_path = get_model_path() if not (name_dataset == 'plays_ru' or name_dataset == 'subtitles_ru' or name_dataset == 'conversations_ru'): print( '\n[E] Неверное значение name_dataset. Возможные варианты: plays_ru, subtitles_ru или conversations_ru\n' ) return if self.work_mode == 'from_file': config = { 'hmm': os.path.join(model_path, 'zero_ru.cd_cont_4000'), 'lm': os.path.join(model_path, 'ru_bot_' + name_dataset + '.lm'), 'dict': os.path.join(model_path, 'ru_bot_' + name_dataset + '.dic') } self.speech_from_file = Pocketsphinx(**config) elif self.work_mode == 'from_microphone': self.speech_from_microphone = LiveSpeech( verbose=False, sampling_rate=16000, buffer_size=2048, no_search=False, full_utt=False, hmm=os.path.join(model_path, 'zero_ru.cd_cont_4000'), lm=os.path.join(model_path, 'ru_bot_' + name_dataset + '.lm'), dic=os.path.join(model_path, 'ru_bot_' + name_dataset + '.dic')) else: print( '[E] Неподдерживаемый режим работы, проверьте значение аргумента mode.' ) # Добавить фильтры шума, например с помощью sox def get(self, f_name_audio=None): ''' Распознавание речи с помощью PocketSphinx. Режим задаётся при создании объекта класса (из файла или с микрофона). 1. f_name_audio - имя .wav или .opus файла с речью (для распознавания из файла, частота дискретизации >=16кГц, 16bit, моно) 2. возвращает строку с распознанной речью ''' if self.work_mode == 'from_file': if f_name_audio is None: print( '[E] В режиме from_file необходимо указывать имя .wav или .opus файла.' ) return filename_audio_raw = f_name_audio[:f_name_audio.find('.')] + '.raw' filename_audio_wav = f_name_audio[:f_name_audio.find('.')] + '.wav' audio_format = f_name_audio[f_name_audio.find('.') + 1:] # Конвертирование .opus файла в .wav if audio_format == 'opus': command_line = "yes | ffmpeg -i '" + f_name_audio + "' '" + filename_audio_wav + "'" proc = subprocess.Popen(command_line, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = proc.communicate() if err.decode().find(f_name_audio + ':') != -1: return 'error' # Конвертирование .wav файла в .raw audio_file = AudioSegment.from_wav(self.current_dirname + '/' + filename_audio_wav) audio_file = audio_file.set_frame_rate(16000) audio_file.export(self.current_dirname + '/' + filename_audio_raw, format='raw') # Создание декодера и распознавание self.speech_from_file.decode(audio_file=self.current_dirname + '/' + filename_audio_raw, buffer_size=2048, no_search=False, full_utt=False) return self.speech_from_file.hypothesis() elif self.work_mode == 'from_microphone': for phrase in self.speech_from_microphone: return str(phrase)
import os from pocketsphinx import Pocketsphinx, get_model_path, get_data_path model_path = get_model_path() data_path = get_data_path() config = { 'hmm': os.path.join(model_path, 'en-us'), 'lm': r'C:\Users\BZT\Desktop\speech_segment\5446.lm', 'dict': r'C:\Users\BZT\Desktop\speech_segment\5446.dic' } ps = Pocketsphinx(**config) ps.decode( audio_file= r'C:\Users\BZT\Desktop\speech_segment\speech_segment\Ses01F_impro01_M013.wav', buffer_size=2048, no_search=False, full_utt=False) # print(ps.segments()) # => ['<s>', '<sil>', 'go', 'forward', 'ten', 'meters', '</s>'] # print('Detailed segments:', *ps.segments(detailed=True), sep='\n') for sample in ps.segments(detailed=True): for subsample in sample: print(subsample, end='\t') print() print(ps.hypothesis()) # => go forward ten meters # print(ps.probability()) # => -32079 # print(ps.score()) # => -7066 # print(ps.confidence()) # => 0.04042641466841839
def __init__(self, vocabulary, hmm_dir="/usr/local/share/" + "pocketsphinx/model/hmm/en_US/hub4wsj_sc_8k"): """ Initiates the pocketsphinx instance. Arguments: vocabulary -- a PocketsphinxVocabulary instance hmm_dir -- the path of the Hidden Markov Model (HMM) """ self._logger = logging.getLogger(__name__) # quirky bug where first import doesn't work # try: # import pocketsphinx as ps # except Exception: # import pocketsphinx as ps from pocketsphinx import Pocketsphinx with tempfile.NamedTemporaryFile(prefix='psdecoder_', suffix='.log', delete=False) as f: self._logfile = f.name self._logger.debug("Initializing PocketSphinx Decoder with hmm_dir " + "'%s'", hmm_dir) # Perform some checks on the hmm_dir so that we can display more # meaningful error messages if neccessary if not os.path.exists(hmm_dir): msg = ("hmm_dir '%s' does not exist! Please make sure that you " + "have set the correct hmm_dir in your profile.") % hmm_dir self._logger.error(msg) raise RuntimeError(msg) # Lets check if all required files are there. Refer to: # http://cmusphinx.sourceforge.net/wiki/acousticmodelformat # for details missing_hmm_files = [] for fname in ('mdef', 'feat.params', 'means', 'noisedict', 'transition_matrices', 'variances'): if not os.path.exists(os.path.join(hmm_dir, fname)): missing_hmm_files.append(fname) mixweights = os.path.exists(os.path.join(hmm_dir, 'mixture_weights')) sendump = os.path.exists(os.path.join(hmm_dir, 'sendump')) if not mixweights and not sendump: # We only need mixture_weights OR sendump missing_hmm_files.append('mixture_weights or sendump') if missing_hmm_files: self._logger.warning("hmm_dir '%s' is missing files: %s. Please " + "make sure that you have set the correct " + "hmm_dir in your profile.", hmm_dir, ', '.join(missing_hmm_files)) # self._decoder = ps.Decoder(hmm=hmm_dir, logfn=self._logfile, # **vocabulary.decoder_kwargs) config = { 'hmm': hmm_dir, 'logfn': self._logfile } config.update(**vocabulary.decoder_kwargs) ps = Pocketsphinx(**config) self._decoder = ps.decode()
import os from pocketsphinx import AudioFile, Pocketsphinx, get_model_path, get_data_path model_path = get_model_path() data_path = get_data_path() config = { 'samprate': 8000.0, 'hmm': os.path.join(model_path, 'zero_ru.cd_cont_4000'), 'lm': os.path.join(model_path, 'ru.lm.bin'), 'dict': os.path.join(model_path, 'ru.dic') } ps = Pocketsphinx(**config) ps.decode(audio_file=os.path.join(data_path, 'decoder-test.wav'), buffer_size=2048, no_search=False, full_utt=False) print(ps.hypothesis())
def __init__(self): # state self.micbuf = np.zeros((0, 4), 'uint16') self.spkrbuf = None self.buffer_stuff = 0 # robot name topic_base = "/" + os.getenv("MIRO_ROBOT_NAME") + "/" # publish topic = topic_base + "control/stream" print ("publish", topic) self.pub_stream = rospy.Publisher(topic, Int16MultiArray, queue_size=0) # subscribe topic = topic_base + "sensors/stream" print ("subscribe", topic) self.sub_stream = rospy.Subscriber(topic, UInt16MultiArray, self.callback_stream) # subscribe topic = topic_base + "sensors/mics" print ("subscribe", topic) self.sub_mics = rospy.Subscriber(topic, Int16MultiArray, self.callback_mics) # report print "recording on 4 microphone channels..." ####### Speech Recongnition using Pocket-Sphinx ######### #obtain audio from microphone r = sr.Recognizer() with sr.callback_mics() as source: print("Say Hello") audio = r.listen(source) #write audio as a wav file with open("./tmp/input.wav", "wb") as f: f.write(audio.get_wav_data()) model_path = get_model_path() data_path = get_data_path() config = { 'hmm' : os.path.join(model_path, 'en-us'), # Hidden Markov Model, Speech Recongnition model - trained probability scoring system 'lm': os.path.join(model_path, 'en-us.lm.bin'), #language model 'dict' : os.path.join(model_path, 'cmudict-en-us.dict') # language dictionary } ps = Pocketsphinx(**config) ps.decode( audio_file=os.path.join(data_path, "./tmp/input.wav"),#add temp input.wav file buffer_size=2048 no_search= False, full_utt=False ) print(ps.hypothesis()) ## output
def loop(self): # loop while not rospy.core.is_shutdown(): # if recording finished if not self.outbuf is None: # write output file print("writing output file") outfilename = '/tmp/input.wav' file = wave.open(outfilename, 'wb') file.setparams((1, 4, 20000, 0, 'NONE', 'not compressed')) print("Starting Reshape") x = np.reshape(self.outbuf[:, [0, 0]], (-1)) print("writing frames") print(len(x)) values = [] for s in x: packed_value = struct.pack('<h', s) values.append(packed_value) #file.writeframes(struct.pack('<h', s)) #close file value_str = b''.join(values) file.writeframes(value_str) print("Closing file") file.close() model_path = get_model_path() data_path = get_data_path() config = { 'hmm': os.path.join( model_path, 'en-us' ), # Hidden Markov Model, Speech Recongnition model - trained probability scoring system 'lm': os.path.join(model_path, 'en-us.lm.bin'), #language model 'dict': os.path.join( model_path, 'cmudict-en-us.dict') #, # language dictionary #'samprate' : 16000 } #cmd= "ffmpeg -y -i /tmp/output.wav -ar 8000 -af asetrate=16000*" + pitch + ",aresample=16000,atempo=" + tempo + " -ac 1 /tmp/outputConv.wav" #cmd = "ffmpeg -y -i /tmp/input.wav -f s32le -acodec pcm_s32le -ar 16000 -ac 1 /tmp/inputConv.wav" #cmd = "sox /tmp/input.wav -r 16000 inputConv.wav" #cmd = "ffmpeg -i /tmp/input.wav -ar 16000 /tmp/inputConv.wav" print("Converting via FFMPEG") cmd = "ffmpeg -y -i /tmp/input.wav -f s16le -acodec pcm_s16le -ar 16000 -af 'aresample=20000' -ac 1 /tmp/inputConv.wav -loglevel quiet" os.system(cmd) print("Decoding Via Pocketsphinx") ps = Pocketsphinx(**config) ps.decode( audio_file=( "/tmp/inputConv.wav"), #add temp input.wav file buffer_size=8192, no_search=False, full_utt=False) print("Recognized: ") print(ps.hypothesis()) ## output ## Speech Analysis, (what to start?) if ps.hypothesis() == "hello": mml.say("Hello there human") # Change this to whatever elif ps.hypothesis().find("how are you") >= 0: mml.say("I'm always good") print("END") self.micbuf = np.zeros((0, 4), 'uint16') self.outbuf = None self.buffer_stuff = 0 self.playchan = 0 self.playsamp = 0 # state time.sleep(0.02)
if ("TURN ON THE LIGHT" in speech): playwave(os.path.join(voice_path, 'beep_lo.wav')) print("turn on the light") return "light on" elif ("TURN OFF THE LIGHT" in speech): playwave(os.path.join(voice_path, 'beep_lo.wav')) print("turn off the light") return "light off" else: return "null" if __name__ == "__main__": ps.decode(audio_file=os.path.join(voice_path, "baby.wav"), buffer_size=2048, no_search=False, full_utt=False) best_result = ps.best(count=10) speech = [] for phrase in best_result: speech.append(phrase[0]) time.sleep(3) while True: if "HI BABY" in speech: print("recognise right") playwave(os.path.join(voice_path, 'beep_hi.wav'))
from pocketsphinx import Pocketsphinx, get_model_path, get_data_path import sys model_path = get_model_path() data_path = get_data_path() print "config set" config = { 'hmm': os.path.join(model_path, 'en-us'), 'lm': os.path.join(model_path, 'en-us.lm.bin'), 'dict': os.path.join(model_path, 'cmudict-en-us.dict') } ps = Pocketsphinx(**config) print "decoging" ps.decode(audio_file=sys.argv[1], buffer_size=2048, no_search=False, full_utt=False) print "decoded" print(ps.segments() ) # => ['<s>', '<sil>', 'go', 'forward', 'ten', 'meters', '</s>'] print "DETAILED SHIT" print(ps.segments(detailed=True)) # => [ # word, prob, start_frame, end_frame # ('<s>', 0, 0, 24) # ('<sil>', -3778, 25, 45) # ('go', -27, 46, 63) # ('forward', -38, 64, 116) # ('ten', -14105, 117, 152) # ('meters', -2152, 153, 211) # ('</s>', 0, 212, 260) # ]
from pocketsphinx import Pocketsphinx ps = Pocketsphinx(verbose=True) ps.decode() print(ps.hypothesis())
# This file will take in a raw formatted audio # Using pocket Sphinx we are able to get the probably of probable words # Then it will display all of the details about the raw -> audio model_path = get_model_path() data_path = get_data_path() config = { 'hmm': os.path.join(model_path, 'en-us'), 'lm': os.path.join(model_path, 'en-us.lm.bin'), 'dict': os.path.join(model_path, 'cmudict-en-us.dict') } ps = Pocketsphinx(**config) ps.decode(audio_file=os.path.join(data_path, 'output.raw'), buffer_size=2048, no_search=False, full_utt=False) # => ['<s>', '<sil>', 'go', 'forward', 'ten', 'meters', '</s>'] print(ps.segments()) print('Detailed segments:', *ps.segments(detailed=True), sep='\n') # => [ # word, prob, start_frame, end_frame # ('<s>', 0, 0, 24) # ('<sil>', -3778, 25, 45) # ('go', -27, 46, 63) # ('forward', -38, 64, 116) # ('ten', -14105, 117, 152) # ('meters', -2152, 153, 211) # ('</s>', 0, 212, 260) # ]
class Sphinx(Thread): def __init__(self): Thread.__init__(self) self.ready = False def run(self): print_important("Info! Thread sphinx started.") self.config = { 'verbose': True, 'hmm': os.path.join('s2m', 'core', 'sphinx', 'fr'), 'lm': os.path.join('s2m', 'core', 'sphinx', 'fr.lm.dmp'), 'dict': os.path.join('s2m', 'core', 'sphinx', 's2m.dict'), 'jsgf': os.path.join('s2m', 'core', 'sphinx', 's2m.jsgf'), } self.pocketsphinx = Pocketsphinx(**self.config) self.ready = True def get_silence(self, duration): if duration < 0.25: return '[veryshortsil]' elif duration < 0.5: return '[shortsil]' elif duration < 1.5: return '[sil]' elif duration < 3.: return '[longsil]' else: return '[verylongsil]' def get_segment_string(self, segments): segment_list = [] last_silence = 0 spoken_duration = 0 word_count = 0 for segment in segments: if segment.word in ['<s>', '</s>']: continue elif segment.word == '<sil>': last_silence += segment.end_frame - segment.start_frame else: if last_silence > 0: segment_list.append(last_silence) last_silence = 0 spoken_duration += segment.end_frame - segment.start_frame segment_list.append(segment.word) word_count += 1 if word_count == 0: return '' avg_word_duration = spoken_duration / word_count return ' '.join((self.get_silence(s / avg_word_duration) if type(s) is int else nobrackets(s)) for s in segment_list) def to_text(self, filename, erase=False): if not self.ready: raise EnvironmentError('Initialization of sphinx not finished.') FILLER_WORDS = ['<s>', '<sil>', '</s>'] try: self.pocketsphinx.decode(filename) except Exception as e: print("An error was raised by sphinx while decoding file '%r', parsing aborted" % filename) text = " ".join( [s for s in self.pocketsphinx.segments() if s not in FILLER_WORDS]) text = nobrackets(text) segment_string = self.get_segment_string(self.pocketsphinx.seg()) nbest = [nobrackets(w[0]) for w in self.pocketsphinx.best(count=10)[1:]] if erase: os.remove(loc) return segment_string, nbest
# Code retested by KhalsaLabs # You can use your own audio file in code # Raw or wav files would work perfectly # For mp3 files, you need to modify code (add codex) from __future__ import print_function import os from pocketsphinx import Pocketsphinx, get_model_path, get_data_path model_path = get_model_path() data_path = get_data_path() config = { 'hmm': os.path.join(model_path, 'en-us'), 'lm': os.path.join(model_path, 'en-us.lm.bin'), 'dict': os.path.join(model_path, 'cmudict-en-us.dict') } ps = Pocketsphinx(**config) ps.decode( audio_file=os.path.join(data_path, 'test1.wav'), # add your audio file here buffer_size=2048, no_search=False, full_utt=False) print(ps.hypothesis())
model_path = get_model_path() data_path = get_data_path() AUDIO=os.path.join(data_path, opt.audio) config = { 'samprate' : 16000, 'allphone' : os.path.join(model_path, 'en-us-phone.lm.bin'), 'remove_silence':False } ps = Pocketsphinx(**config) ps.decode( audio_file=AUDIO, buffer_size=1024, no_search=False, full_utt=False ) #define stream chunk chunk = 1024 #open the audio files (bytes) f = open(opt.audio,"rb") #instantiate PyAudio p = pyaudio.PyAudio() #open stream stream = p.open(format = 8,