def rasa_nlu():
m1 = MicrophoneModule(5000)
m2 = GoogleASRModule("en-US")
m3 = CallbackModule(callback=lambda x: print("%s (%f) - %s" % (
x.text, x.confidence, x.final)))
m4 = RasaNLUModule("data/rasa/models/nlu/default/current")
m5 = CallbackModule(callback=lambda x: print(x.act, "-", x.concepts))
m1.subscribe(m2)
m2.subscribe(m3)
m2.subscribe(m4)
m4.subscribe(m5)
m4.setup()
m2.setup()
m1.setup()
m3.setup()
m5.setup()
print("All setup")
m1.run(run_setup=False)
m2.run(run_setup=False)
m3.run(run_setup=False)
m4.run(run_setup=False)
m5.run(run_setup=False)
input()
m1.stop()
m2.stop()
m3.stop()
m4.stop()
m5.stop()
def repeat_demo():
m1 = MicrophoneModule(5000)
m2 = GoogleASRModule("en-US")
m3 = TextDispatcherModule()
m4 = GoogleTTSModule("en-US", "en-US-Wavenet-A")
m5 = AudioDispatcherModule(5000)
m6 = StreamingSpeakerModule(5000)
m1.subscribe(m2)
m2.subscribe(m3)
m3.subscribe(m4)
m4.subscribe(m5)
m5.subscribe(m6)
m1.setup()
m2.setup()
m3.setup()
m4.setup()
m5.setup()
m6.setup()
print("All setup")
m1.run(run_setup=False)
m2.run(run_setup=False)
m3.run(run_setup=False)
m4.run(run_setup=False)
m5.run(run_setup=False)
m6.run(run_setup=False)
input()
m1.stop()
m2.stop()
m3.stop()
m4.stop()
m5.stop()
m6.stop()
class Hearing(object):
"""
The Hearing component of the Spoken Dialog System.
Components:
- MicrophoneModule
- ASRModule
- IncrementalizeASRModule
"""
CACHE_DIR = "/tmp"
def __init__(
self,
chunk_time=None,
chunk_size=None,
sample_rate=16000,
bytes_per_sample=2,
language="en-US",
nchunks=20,
use_asr=True,
use_iasr=False,
record=False,
debug=False,
bypass=False,
cache_dir="/tmp",
):
self.sample_rate = sample_rate
assert (chunk_time is not None or chunk_size
is not None), "please provide either chunk_time or chunk_size"
if chunk_size is not None:
self.chunk_size = int(chunk_size)
self.chunk_time = chunk_size / sample_rate
else:
self.chunk_time = chunk_time
self.chunk_size = int(chunk_time * sample_rate)
self.bytes_per_sample = bytes_per_sample
self.use_asr = use_asr
self.use_iasr = use_iasr
self.record = record
self.debug = debug
self.cache_dir = cache_dir
if self.use_iasr:
self.use_asr = True
# Components that are always used
if bypass:
self.in_mic = MicrophoneOutputBypass(
chunk_size=self.chunk_size,
rate=self.sample_rate,
sample_width=self.bytes_per_sample,
)
else:
self.in_mic = MicrophoneModule(
chunk_size=self.chunk_size,
rate=self.sample_rate,
sample_width=self.bytes_per_sample,
)
self.vad_frames = VADFrames(
chunk_time=self.chunk_time,
sample_rate=self.sample_rate,
mode=3,
debug=debug,
)
self.in_mic.subscribe(self.vad_frames)
# Optional Components
if self.use_asr:
self.asr = GoogleASRModule(
language=language,
nchunks=nchunks, # m chunks to trigger a new prediction
rate=self.sample_rate,
)
self.in_mic.subscribe(self.asr)
if self.use_iasr:
self.iasr = IncrementalizeASRModule(
threshold=0.8
) # Gets only the newly added words at each increment
self.asr.subscribe(self.iasr)
if self.record:
self.cache_dir = join(cache_dir, "hearing")
makedirs(self.cache_dir, exist_ok=True)
print("Hearing: ", self.cache_dir)
wav_filename = join(self.cache_dir, "user_audio.wav")
self.audio_record = AudioRecorderModule(
wav_filename, rate=sample_rate, sample_width=bytes_per_sample)
self.in_mic.subscribe(self.audio_record)
if self.debug:
self.asr_debug = ASRDebugModule()
if self.use_asr:
self.asr.subscribe(self.asr_debug)
logging.info(f"{self.name}: Initialized @ {time.time()}")
@property
def name(self):
return self.__class__.__name__
def __repr__(self):
s = "\n" + "=" * 40
s += "\n" + self.__class__.__name__
s += f"\nsample_rate: {self.sample_rate}"
s += f"\nchunk_time: {self.chunk_time}"
s += f"\nchunk_size: {self.chunk_size}"
s += f"\nbytes_per_sample: {self.bytes_per_sample}"
s += f"\nrecord: {self.record}"
s += f"\nuse_asr: {self.use_asr}"
s += f"\ndebug: {self.debug}"
s += "\n" + "=" * 40
return s
def setup(self, **kwargs):
self.in_mic.setup(**kwargs)
if self.use_asr:
self.asr.setup(**kwargs)
if self.use_iasr:
self.iasr.setup(**kwargs)
if self.record:
self.audio_record.setup(**kwargs)
logging.info(f"{self.name}: Setup")
def run(self, **kwargs):
self.in_mic.run(**kwargs)
self.vad_frames.run(**kwargs)
if self.use_asr:
self.asr.run(**kwargs)
if self.use_iasr:
self.iasr.run(**kwargs)
if self.record:
self.audio_record.run(**kwargs)
if self.debug:
if self.use_asr:
self.asr_debug.run(**kwargs)
# self.iasr_debug.run(run_setup=run_setup)
logging.info(f"{self.name}: run @ {time.time()}")
def stop(self, **kwargs):
self.in_mic.stop(**kwargs)
self.vad_frames.stop(**kwargs)
if self.use_asr:
self.asr.stop(**kwargs)
if self.use_iasr:
self.iasr.stop(**kwargs)
if self.record:
self.audio_record.stop(**kwargs)
if self.debug:
if self.use_asr:
self.asr_debug.stop(**kwargs)
logging.info(f"{self.name}: stop_components @ {time.time()}")