def test_asr_kaldi(self):
asr = ASR(engine=ASR_ENGINE_NNET3)
wavf = wave.open(TEST_WAVE_EN, 'rb')
# check format
self.assertEqual(wavf.getnchannels(), 1)
self.assertEqual(wavf.getsampwidth(), 2)
# process file in 250ms chunks
chunk_frames = 250 * wavf.getframerate() / 1000
tot_frames = wavf.getnframes()
num_frames = 0
while num_frames < tot_frames:
finalize = False
if (num_frames + chunk_frames) < tot_frames:
nframes = chunk_frames
else:
nframes = tot_frames - num_frames
finalize = True
frames = wavf.readframes(nframes)
num_frames += nframes
samples = struct.unpack_from('<%dh' % nframes, frames)
s, l = asr.decode(samples, finalize, wavf.getframerate())
wavf.close()
self.assertEqual(s.strip(), TEST_WAVE_EN_TS)
def __init__(self,
source=None,
volume=None,
aggressiveness=None,
model_dir=None,
lang=None,
config=CONFIG):
EventEmitter.__init__(self)
self.config = config
# ensure default values
for k in CONFIG["listener"]:
if k not in self.config["listener"]:
self.config["listener"][k] = CONFIG["listener"][k]
volume = volume or self.config["listener"]["default_volume"]
aggressiveness = aggressiveness or self.config["listener"][
"default_aggressiveness"]
model_dir = model_dir or self.config["listener"]["default_model_dir"]
self.lang = lang or self.config["lang"]
if "-" in self.lang:
self.lang = self.lang.split("-")[0]
if "{lang}" in model_dir:
model_dir = model_dir.format(lang=self.lang)
if not isdir(model_dir):
if model_dir in self._default_models:
logging.error(
"you need to install the package: "
"kaldi-chain-zamia-speech-{lang}".format(lang=self.lang))
raise ModelNotFound
self.rec = PulseRecorder(source_name=source, volume=volume)
self.vad = VAD(aggressiveness=aggressiveness)
logging.info("Loading model from %s ..." % model_dir)
self.asr = ASR(engine=ASR_ENGINE_NNET3,
model_dir=model_dir,
kaldi_beam=self.config["listener"]["default_beam"],
kaldi_acoustic_scale=self.config["listener"]
["default_acoustic_scale"],
kaldi_frame_subsampling_factor=self.config["listener"]
["default_frame_subsampling_factor"])
self._hotwords = dict(self.config["hotwords"])
def test_asr_pocketsphinx(self):
asr = ASR(engine=ASR_ENGINE_POCKETSPHINX,
model_dir=POCKETSPHINX_MODELDIR,
model_name=POCKETSPHINX_MODELNAME)
wavf = wave.open(TEST_WAVE_EN, 'rb')
# check format
self.assertEqual(wavf.getnchannels(), 1)
self.assertEqual(wavf.getsampwidth(), 2)
# process file in 250ms chunks
chunk_frames = 250 * wavf.getframerate() / 1000
tot_frames = wavf.getnframes()
num_frames = 0
while num_frames < tot_frames:
finalize = False
if (num_frames + chunk_frames) < tot_frames:
nframes = chunk_frames
else:
nframes = tot_frames - num_frames
finalize = True
frames = wavf.readframes(nframes)
num_frames += nframes
samples = struct.unpack_from('<%dh' % nframes, frames)
s, l = asr.decode(wavf.getframerate(), samples, finalize)
if not finalize:
self.assertEqual(s, None)
wavf.close()
self.assertEqual(s.strip(), TEST_WAVE_EN_TS_PS)
class KaldiWWSpotter(EventEmitter):
_default_models = ["/opt/kaldi/model/kaldi-generic-en-tdnn_250",
"/opt/kaldi/model/kaldi-generic-de-tdnn_250"]
def __init__(self, source=None, volume=None, aggressiveness=None,
model_dir=None, lang=None, config=CONFIG):
EventEmitter.__init__(self)
self.config = config
# ensure default values
for k in CONFIG["listener"]:
if k not in self.config["listener"]:
self.config["listener"][k] = CONFIG["listener"][k]
volume = volume or self.config["listener"]["default_volume"]
aggressiveness = aggressiveness or self.config["listener"][
"default_aggressiveness"]
model_dir = model_dir or self.config["listener"]["default_model_dir"]
self.lang = lang or self.config["lang"]
if "-" in self.lang:
self.lang = self.lang.split("-")[0]
if "{lang}" in model_dir:
model_dir = model_dir.format(lang=self.lang)
if not isfile(model_dir):
if model_dir in self._default_models:
logging.error("you need to install the package: "
"kaldi-chain-zamia-speech-{lang}".format(
lang=self.lang))
raise ModelNotFound
self.rec = PulseRecorder(source_name=source, volume=volume)
self.vad = VAD(aggressiveness=aggressiveness)
logging.info("Loading model from %s ..." % model_dir)
self.asr = ASR(engine=ASR_ENGINE_NNET3, model_dir=model_dir,
kaldi_beam=self.config["listener"]["default_beam"],
kaldi_acoustic_scale=self.config["listener"][
"default_acoustic_scale"],
kaldi_frame_subsampling_factor=self.config["listener"][
"default_frame_subsampling_factor"])
self._hotwords = dict(self.config["hotwords"])
def add_hotword(self, name, config=None):
config = config or {"transcriptions": [name], "intent": name}
self._hotwords[name] = config
def remove_hotword(self, name):
if name in self._hotwords.keys():
self._hotwords.pop(name)
@property
def hotwords(self):
return self._hotwords
def _detection_event(self, message_type, message_data):
serialized_message = json.dumps(
{"type": message_type, "data": message_data})
logging.debug(serialized_message)
self.emit(message_type, serialized_message)
def _process_transcription(self, user_utt, confidence=0.99):
for hotw in self.hotwords:
if not self.hotwords[hotw].get("active"):
continue
rule = self.hotwords[hotw].get("rule", "sensitivity")
s = 1 - self.hotwords[hotw].get("sensitivity", 0.2)
confidence = (confidence + s) / 2
for w in self.hotwords[hotw]["transcriptions"]:
if (w in user_utt and rule == "in") or \
(user_utt.startswith(w) and rule == "start") or \
(user_utt.endswith(w) and rule == "end") or \
(fuzzy_match(w,
user_utt) >= s and rule == "sensitivity") or \
(w == user_utt and rule == "equal"):
yield {"hotword": hotw,
"utterance": user_utt,
"confidence": confidence,
"intent": self.hotwords[hotw]["intent"]}
def _detect_ww(self, user_utt, confidence=0.99):
for hw_data in self._process_transcription(user_utt, confidence):
sound = self.hotwords[hw_data["hotword"]].get("sound")
if sound and isfile(sound):
play_sound(sound)
self._detection_event("hotword", hw_data)
def decode_wav_file(self, wav_file):
user_utt, confidence = self.asr.decode_wav_file(wav_file)
confidence = 1 - exp(-1 * confidence)
return user_utt, confidence
def wav_file_hotwords(self, wav_file):
user_utt, confidence = self.decode_wav_file(wav_file)
return list(self._process_transcription(user_utt, confidence))
def run(self):
self.rec.start_recording()
logging.info("Listening")
while True:
samples = self.rec.get_samples()
audio, finalize = self.vad.process_audio(samples)
if not audio:
continue
logging.debug('decoding audio len=%d finalize=%s audio=%s' % (
len(audio), repr(finalize), audio[0].__class__))
user_utt, confidence = self.asr.decode(audio, finalize,
stream_id="mic")
confidence = 1 - exp(-1 * confidence)
if finalize and user_utt:
self._detection_event("transcription",
{"utterance": user_utt,
"confidence": confidence})
self._detect_ww(user_utt, confidence)
rec = PulseRecorder (source_name=source, volume=volume)
#
# VAD
#
vad = VAD(aggressiveness=aggressiveness)
#
# ASR
#
print "Loading model from %s ..." % model_dir
asr = ASR(engine = ASR_ENGINE_NNET3, model_dir = model_dir,
kaldi_beam = DEFAULT_BEAM, kaldi_acoustic_scale = DEFAULT_ACOUSTIC_SCALE,
kaldi_frame_subsampling_factor = DEFAULT_FRAME_SUBSAMPLING_FACTOR)
#
# main
#
rec.start_recording()
print "Please speak."
while True:
samples = rec.get_samples()
MODELDIR = '/opt/kaldi/model/kaldi-generic-en-tdnn_250'
VOLUME = 150
class Intent(Enum):
HELLO = 1
LIGHT = 2
RADIO = 3
print("Initializing...")
radio_on = False
lights_on = False
asr = ASR(model_dir=MODELDIR)
rec = PulseRecorder(volume=VOLUME)
vad = VAD()
tts = TTS(engine="espeak", voice="en")
utt_map = {}
def add_utt(utterance, intent):
utt_map[utterance] = intent
add_utt("hello computer", Intent.HELLO)
add_utt("switch on the lights", Intent.LIGHT)
add_utt("switch off the lights", Intent.LIGHT)
add_utt("switch on the radio", Intent.RADIO)
# kernal.setup_align_utterances(lang=lang)
paint_main()
logging.debug ('AI kernal initialized.')
#
# context
#
cur_context = kernal.find_prev_context(USER_URI)
#
# ASR
#
misc.message_popup(stdscr, 'Initializing...', 'Init ASR...')
asr = ASR(engine = ASR_ENGINE_NNET3, model_dir = kaldi_model_dir, model_name = kaldi_model)
paint_main()
logging.debug ('ASR initialized.')
#
# main loop
#
while True:
paint_main()
c = stdscr.getch()
if c == ord('q'):
break
elif c == ord('r'):
#
# setup AI DB, Kernal and Context
#
kernal = AIKernal.from_ini_file()
for skill in kernal.all_skills:
kernal.consult_skill(skill)
kernal.setup_nlp_model()
ctx = kernal.create_context()
logging.debug('AI kernal initialized.')
#
# ASR
#
asr = ASR(model_dir=options.asr_model)
logging.debug('ASR initialized.')
#
# TTS
#
tts = TTS(engine="espeak", voice="en")
#
# main loop
#
print(chr(27) + "[2J")
while True:
lang = kernal.nlp_model.lang
ctx = AIContext(USER_URI,
kernal.session,
lang,
DEMO_REALM,
kernal,
test_mode=False)
logging.debug('AI kernal initialized.')
#
# ASR
#
asr = ASR(engine=ASR_ENGINE_NNET3,
model_dir=kaldi_model_dir,
model_name=kaldi_model,
kaldi_beam=kaldi_beam,
kaldi_acoustic_scale=kaldi_acoustic_scale,
kaldi_frame_subsampling_factor=kaldi_frame_subsampling_factor)
logging.debug('ASR initialized.')
#
# TTS
#
tts = TTS(host_tts=tts_host,
port_tts=tts_port,
locale=tts_locale,
voice=tts_voice,
engine=tts_engine,
speed=tts_speed,
pitch=tts_pitch)
logging.debug('AI kernal initialized.')
#
# context
#
cur_context = kernal.find_prev_context(USER_URI)
#
# ASR
#
misc.message_popup(stdscr, 'Initializing...', 'Init ASR...')
asr = ASR(engine=ASR_ENGINE_NNET3,
model_dir=kaldi_model_dir,
model_name=kaldi_model,
kaldi_beam=kaldi_beam,
kaldi_acoustic_scale=kaldi_acoustic_scale,
kaldi_frame_subsampling_factor=kaldi_frame_subsampling_factor)
paint_main()
logging.debug('ASR initialized.')
#
# main loop
#
while True:
paint_main()
c = stdscr.getch()
if c == ord('q'):
#!/usr/bin/env python3
from nltools.asr import ASR
MODELDIR = '/opt/kaldi/model/kaldi-generic-en-tdnn_250'
WAVFILE = 'dw961.wav'
asr = ASR(model_dir=MODELDIR)
s, l = asr.decode_wav_file(WAVFILE)
print("Decoded %s: %s" % (WAVFILE, s))
def test_asr_kaldi_wavefile(self):
asr = ASR(engine=ASR_ENGINE_NNET3)
s, l = asr.decode_wav_file(TEST_WAVE_EN)
self.assertEqual(s.strip(), TEST_WAVE_EN_TS)
def test_asr_pocketsphinx_wavefile(self):
asr = ASR(engine=ASR_ENGINE_POCKETSPHINX,
model_dir=POCKETSPHINX_MODELDIR,
model_name=POCKETSPHINX_MODELNAME)
s, l = asr.decode_wav_file(TEST_WAVE_EN)
self.assertEqual(s.strip(), TEST_WAVE_EN_TS_PS)
#
# setup AI DB, Kernal and Context
#
kernal = AIKernal.from_ini_file()
for skill in kernal.all_skills:
kernal.consult_skill (skill)
kernal.setup_nlp_model()
ctx = kernal.create_context()
logging.debug ('AI kernal initialized.')
#
# ASR
#
asr = ASR(model_dir = options.asr_model)
logging.debug ('ASR initialized.')
#
# TTS
#
tts = TTS(engine="espeak", voice="en")
#
# main loop
#
print(chr(27) + "[2J")
while True:
