def main():
args = create_parser(usage).parse_args()
args.tags_file = abspath(args.tags_file) if args.tags_file else None
args.folder = abspath(args.folder)
args.output_folder = abspath(args.output_folder)
noise_min, noise_max = args.noise_ratio_low, args.noise_ratio_high
data = TrainData.from_both(args.tags_file, args.folder, args.folder)
noise_data = NoiseData(args.noise_folder)
print('Data:', data)
def translate_filename(source: str, n=0) -> str:
assert source.startswith(args.folder)
relative_file = source[len(args.folder):].strip(os.path.sep)
if n > 0:
base, ext = splitext(relative_file)
relative_file = base + '.' + str(n) + ext
return join(args.output_folder, relative_file)
all_filenames = sum(data.train_files + data.test_files, [])
for i, filename in enumerate(all_filenames):
print('{0:.2%} \r'.format(i / (len(all_filenames) - 1)), end='', flush=True)
audio = load_audio(filename)
for n in range(args.inflation_factor):
altered = noise_data.noised_audio(audio, noise_min + (noise_max - noise_min) * random())
output_filename = translate_filename(filename, n)
makedirs(dirname(output_filename), exist_ok=True)
save_audio(output_filename, altered)
print('Done!')
if args.tags_file and args.tags_file.startswith(args.folder):
shutil.copy2(args.tags_file, translate_filename(args.tags_file))
def main():
args = TrainData.parse_args(create_parser(usage))
inject_params(args.model)
save_params(args.model)
data = TrainData.from_both(args.db_file, args.db_folder, args.data_dir)
print('Data:', data)
(inputs, outputs), test_data = data.load(True, not args.no_validation)
print('Inputs shape:', inputs.shape)
print('Outputs shape:', outputs.shape)
if test_data:
print('Test inputs shape:', test_data[0].shape)
print('Test outputs shape:', test_data[1].shape)
if 0 in inputs.shape or 0 in outputs.shape:
print('Not enough data to train')
exit(1)
model = create_model(args.model, args.no_validation, args.extra_metrics)
model.summary()
from keras.callbacks import ModelCheckpoint
checkpoint = ModelCheckpoint(args.model, monitor=args.metric_monitor,
save_best_only=args.save_best)
try:
model.fit(inputs, outputs, 5000, args.epochs, validation_data=test_data,
callbacks=[checkpoint])
except KeyboardInterrupt:
print()
finally:
model.save(args.model)
def main():
args = TrainData.parse_args(create_parser(usage))
inject_params(args.model)
data = TrainData.from_both(args.tags_file, args.tags_folder, args.folder)
train, test = data.load(args.use_train, not args.use_train, shuffle=False)
inputs, targets = train if args.use_train else test
filenames = sum(data.train_files if args.use_train else data.test_files,
[])
predictions = Listener.find_runner(args.model)(args.model).predict(inputs)
stats = Stats(predictions, targets, filenames)
print('Data:', data)
if not args.no_filenames:
fp_files = stats.calc_filenames(False, True, args.threshold)
fn_files = stats.calc_filenames(False, False, args.threshold)
print('=== False Positives ===')
print('\n'.join(fp_files))
print()
print('=== False Negatives ===')
print('\n'.join(fn_files))
print()
print(stats.counts_str(args.threshold))
print()
print(stats.summary_str(args.threshold))
def main():
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
stdout = sys.stdout
sys.stdout = sys.stderr
parser = create_parser(usage)
parser.add_argument('-v',
'--version',
action='version',
version=__version__)
parser.add_argument(
'chunk_size',
type=int,
nargs='?',
default=-1,
help='Number of bytes to read before making a prediction.'
'Higher values are less computationally expensive')
parser.usage = parser.format_usage().strip().replace('usage: ',
'') + ' < audio.wav'
args = parser.parse_args()
if sys.stdin.isatty():
parser.error('Please pipe audio via stdin using < audio.wav')
listener = Listener(args.model_name, args.chunk_size)
try:
while True:
conf = listener.update(sys.stdin.buffer)
stdout.buffer.write((str(conf) + '\n').encode('ascii'))
stdout.buffer.flush()
except (EOFError, KeyboardInterrupt):
pass
def _main():
parser = create_parser(usage)
parser.add_argument('file_label',
nargs='?',
help='File label (Ex. recording-##)')
args = parser.parse_args()
show_input()
args.file_label = args.file_label or input(
"File label (Ex. recording-##): ")
args.file_label = args.file_label + (''
if '#' in args.file_label else '-##')
hide_input()
p = pyaudio.PyAudio()
while True:
print('Press space to record (esc to exit)...')
if not wait_to_continue():
break
print('Recording...')
d = record_until_key(p, args)
name = next_name(args.file_label)
save_audio(name, d, args)
print('Saved as ' + name)
p.terminate()
def main():
args = create_parser(usage).parse_args()
import numpy as np
model_data = {
name: Stats.from_np_dict(data)
for name, data in np.load(args.input_file)['data'].item().items()
}
model_name = args.model_key or basename(splitext(args.model)[0])
if model_name not in model_data:
print("Could not find model '{}' in saved models in stats file: {}".
format(model_name, list(model_data)))
raise SystemExit(1)
stats = model_data[model_name]
save_spots = (stats.outputs != 0) & (stats.outputs != 1)
if save_spots.sum() == 0:
print('No data (or all NaN)')
return
stats.outputs = stats.outputs[save_spots]
stats.targets = stats.targets[save_spots]
inv = -np.log(1 / stats.outputs - 1)
pos = np.extract(stats.targets > 0.5, inv)
pos_mu = pos.mean().item()
pos_std = sqrt(np.mean((pos - pos_mu)**2)) * args.smoothing
print('Peak: {:.2f} mu, {:.2f} std'.format(pos_mu, pos_std))
pr = inject_params(args.model)
pr.__dict__.update(threshold_config=((pos_mu, pos_std), ))
save_params(args.model)
print('Saved params to {}.params'.format(args.model))
def main():
args = create_parser(usage).parse_args()
print('chunk_size: ', args.chunk_size)
def on_activation():
activate_notify()
if args.save_dir:
global chunk_num
nm = join(args.save_dir, args.save_prefix + session_id + '.' + str(chunk_num) + '.wav')
save_audio(nm, audio_buffer)
print()
print('Saved to ' + nm + '.')
chunk_num += 1
def on_prediction(conf):
print('!' if conf > 0.8 else '.', end='', flush=True)
listener = Listener(args.model, args.chunk_size)
audio_buffer = np.zeros(listener.pr.buffer_samples, dtype=float)
def get_prediction(chunk):
nonlocal audio_buffer
audio = buffer_to_audio(chunk)
audio_buffer = np.concatenate((audio_buffer[len(audio):], audio))
return listener.update(chunk)
engine = ListenerEngine(listener, args.chunk_size)
engine.get_prediction = get_prediction
runner = PreciseRunner(engine, args.threshold, on_activation=on_activation,
on_prediction=on_prediction)
runner.start()
Event().wait() # Wait forever
def main():
args = TrainData.parse_args(create_parser(usage))
data = TrainData.from_both(args.tags_file, args.tags_folder, args.folder)
data_files = data.train_files if args.use_train else data.test_files
listener = PocketsphinxListener(args.key_phrase, args.dict_file,
args.hmm_folder, args.threshold)
print('Data:', data)
stats = test_pocketsphinx(listener, data_files)
show_stats(stats, not args.no_filenames)
def __init__(self):
super().__init__(create_parser(usage))
self.bb = BlackBoxOptimizer(file=self.args.trials_name)
if not self.test:
data = TrainData.from_both(self.args.tags_file,
self.args.tags_folder, self.args.folder)
_, self.test = data.load(False, True)
from keras.callbacks import ModelCheckpoint
for i in list(self.callbacks):
if isinstance(i, ModelCheckpoint):
self.callbacks.remove(i)
def __init__(self):
parser = create_parser(usage)
super().__init__(parser)
if self.args.invert_samples:
parser.error('--invert-samples should be left blank')
self.args.samples_file = (self.args.samples_file
or '{model_base}.samples.json').format(
model_base=self.model_base)
self.samples, self.hash_to_ind = self.load_sample_data(
self.args.samples_file, self.train)
self.metrics_fiti = Fitipy(self.model_base + '.logs',
'sampling-metrics.txt')
def main():
args = TrainData.parse_args(create_parser(usage))
for i in (join(args.folder, 'not-wake-word', 'generated'),
join(args.folder, 'test', 'not-wake-word', 'generated')):
makedirs(i, exist_ok=True)
trainer = IncrementalTrainer(args)
try:
trainer.train_incremental()
except KeyboardInterrupt:
print()
def main():
parser = create_parser(usage)
parser.add_argument(
'models',
nargs='*',
help='List of model filenames in format: wake-word.yy-mm-dd.net')
args = TrainData.parse_args(parser)
if not (bool(args.pocketsphinx_dict) == bool(args.pocketsphinx_folder) ==
bool(args.pocketsphinx_wake_word)):
parser.error('Must pass all or no Pocketsphinx arguments')
data = TrainData.from_both(args.tags_file, args.tags_folder, args.folder)
data_files = data.train_files if args.use_train else data.test_files
print('Data:', data)
metrics = {}
if args.pocketsphinx_dict and args.pocketsphinx_folder and args.pocketsphinx_wake_word:
if not isfile(args.pocketsphinx_dict):
parser.error('No such file: ' + args.pocketsphinx_dict)
if not isdir(args.pocketsphinx_folder):
parser.error('No such folder: ' + args.pocketsphinx_folder)
listener = PocketsphinxListener(args.pocketsphinx_wake_word,
args.pocketsphinx_dict,
args.pocketsphinx_folder,
args.pocketsphinx_threshold)
stats = test_pocketsphinx(listener, data_files)
metrics[args.pocketsphinx_dict] = stats_to_dict(stats)
for model_name in args.models:
print('Calculating', model_name + '...')
inject_params(model_name)
train, test = data.load(args.use_train, not args.use_train)
inputs, targets = train if args.use_train else test
predictions = Listener.find_runner(model_name)(model_name).predict(
inputs)
stats = Stats(predictions, targets, sum(data_files, []))
print('----', model_name, '----')
print(stats.counts_str())
print()
print(stats.summary_str())
print()
metrics[model_name] = stats.to_dict(args.threshold)
print('Writing to:', args.output)
with open(args.output, 'w') as f:
json.dump(metrics, f)
def main():
args = TrainData.parse_args(create_parser(usage))
inject_params(args.model)
data = TrainData.from_both(args.tags_file, args.tags_folder, args.folder)
train, test = data.load(args.use_train, not args.use_train, shuffle=False)
inputs, targets = train if args.use_train else test
filenames = sum(data.train_files if args.use_train else data.test_files,
[])
predictions = Listener.find_runner(args.model)(args.model).predict(inputs)
stats = calc_stats(filenames, targets, predictions)
print('Data:', data)
show_stats(stats, not args.no_filenames)
def main():
args = TrainData.parse_args(create_parser(usage))
inject_params(args.model)
data = TrainData.from_both(args.db_file, args.db_folder, args.data_dir)
train, test = data.load(args.use_train, not args.use_train)
inputs, targets = train if args.use_train else test
filenames = sum(data.train_files if args.use_train else data.test_files,
[])
predictions = load_precise_model(args.model).predict(inputs)
stats = calc_stats(filenames, targets, predictions)
print('Data:', data)
show_stats(stats, not args.no_filenames)
def main():
args = create_parser(usage).parse_args()
def on_activation():
Popen(['aplay', '-q', 'data/activate.wav'])
def on_prediction(conf):
print('!' if conf > 0.5 else '.', end='', flush=True)
runner = PreciseRunner(ListenerEngine(
PocketsphinxListener(args.key_phrase, args.dict_file, args.hmm_folder,
args.threshold, args.chunk_size)),
3,
on_activation=on_activation,
on_prediction=on_prediction)
runner.start()
Event().wait() # Wait forever
def main():
args = create_parser(usage).parse_args()
sensitivity = 0.5
def on_activation():
activate_notify()
if args.save_dir:
global chunk_num
nm = join(
args.save_dir,
args.save_prefix + session_id + '.' + str(chunk_num) + '.wav')
save_audio(nm, audio_buffer)
print()
print('Saved to ' + nm + '.')
chunk_num += 1
def on_prediction(conf):
if args.light_mode:
print('!' if conf > 0.7 else '.', end='', flush=True)
else:
max_width = 80
width = min(get_terminal_size()[0], max_width)
units = int(round(conf * width))
bar = 'X' * units + '-' * (width - units)
cutoff = round((1.0 - sensitivity) * width)
print(bar[:cutoff] + bar[cutoff:].replace('X', 'x'))
listener = Listener(args.model, args.chunk_size)
audio_buffer = np.zeros(listener.pr.buffer_samples, dtype=float)
def get_prediction(chunk):
nonlocal audio_buffer
audio = buffer_to_audio(chunk)
audio_buffer = np.concatenate((audio_buffer[len(audio):], audio))
return listener.update(chunk)
engine = ListenerEngine(listener, args.chunk_size)
engine.get_prediction = get_prediction
runner = PreciseRunner(engine,
args.threshold,
sensitivity=sensitivity,
on_activation=on_activation,
on_prediction=on_prediction)
runner.start()
Event().wait() # Wait forever
def __init__(self):
super().__init__(create_parser(usage))
for i in (join(self.args.folder, 'not-wake-word', 'generated'),
join(self.args.folder, 'test', 'not-wake-word',
'generated')):
makedirs(i, exist_ok=True)
self.trained_fns = load_trained_fns(self.args.model)
self.audio_buffer = np.zeros(pr.buffer_samples, dtype=float)
if not isfile(self.args.model):
params = ModelParams(skip_acc=self.args.no_validation,
extra_metrics=self.args.extra_metrics)
create_model(self.args.model, params).save(self.args.model)
self.listener = Listener(self.args.model,
self.args.chunk_size,
runner_cls=KerasRunner)
def main():
args = create_parser(usage).parse_args()
def on_activation():
activate_notify()
if args.save_dir:
global chunk_num
nm = join(
args.save_dir,
args.save_prefix + session_id + '.' + str(chunk_num) + '.wav')
save_audio(nm, audio_buffer)
print()
print('Saved to ' + nm + '.')
chunk_num += 1
def on_prediction(conf):
global detecting_flag
# print('!' if conf > 0.5 else '.', end='', flush=True)
if conf > 0.5:
detecting_flag = True
if conf < 0.5 and detecting_flag:
print(colored("Yeah! I'm Here.", 'green'))
detecting_flag = False
sunshine_model = './ok-sunshine.net'
listener = Listener(sunshine_model, args.chunk_size)
audio_buffer = np.zeros(listener.pr.buffer_samples, dtype=float)
def get_prediction(chunk):
nonlocal audio_buffer
audio = buffer_to_audio(chunk)
audio_buffer = np.concatenate((audio_buffer[len(audio):], audio))
return listener.update(chunk)
engine = ListenerEngine(listener, args.chunk_size)
engine.get_prediction = get_prediction
runner = PreciseRunner(engine,
args.threshold,
on_activation=on_activation,
on_prediction=on_prediction)
runner.start()
Event().wait() # Wait forever
def __init__(self):
super().__init__(create_parser(usage))
for i in (join(self.args.folder, 'not-wake-word', 'generated'),
join(self.args.folder, 'test', 'not-wake-word',
'generated')):
makedirs(i, exist_ok=True)
self.trained_fns = load_trained_fns(self.args.model)
self.audio_buffer = np.zeros(pr.buffer_samples, dtype=float)
params = ModelParams(skip_acc=self.args.no_validation,
extra_metrics=self.args.extra_metrics,
loss_bias=1.0 - self.args.sensitivity)
model = create_model(self.args.model, params)
self.listener = Listener(self.args.model,
self.args.chunk_size,
runner_cls=KerasRunner)
self.listener.runner = KerasRunner(self.args.model)
self.listener.runner.model = model
self.samples_since_train = 0
def _main():
parser = create_parser(usage)
parser.add_argument('file_label',
nargs='?',
help='File label (Ex. recording-##)')
args = parser.parse_args()
show_input()
args.file_label = args.file_label or input(
"File label (Ex. recording-##): ")
args.file_label = args.file_label + (''
if '#' in args.file_label else '-##')
hide_input()
p = pyaudio.PyAudio()
print("================================================")
info = p.get_host_api_info_by_index(0)
numdevices = info.get('deviceCount')
for i in range(0, numdevices):
if (p.get_device_info_by_host_api_device_index(
0, i).get('maxInputChannels')) > 0:
print("Input Device id ", i, " - ",
p.get_device_info_by_host_api_device_index(0, i).get('name'),
p.get_device_info_by_index(i).get('defaultSampleRate'))
print("================================================")
while True:
print('Press space to record (esc to exit)...')
if not wait_to_continue():
break
print('Recording...')
d = record_until_key(p, args)
name = next_name(args.file_label)
save_audio(name, d, args)
print('Saved as ' + name)
p.terminate()
def __init__(self):
parser = create_parser(usage)
self.args = args = TrainData.parse_args(parser)
self.audio_buffer = np.zeros(pr.buffer_samples, dtype=float)
self.vals_buffer = np.zeros(pr.buffer_samples, dtype=float)
params = ModelParams(skip_acc=args.no_validation,
extra_metrics=args.extra_metrics,
loss_bias=1.0 - args.sensitivity)
self.model = create_model(args.model, params)
self.listener = Listener('',
args.chunk_size,
runner_cls=lambda x: None)
from keras.callbacks import ModelCheckpoint, TensorBoard
checkpoint = ModelCheckpoint(args.model,
monitor=args.metric_monitor,
save_best_only=args.save_best)
epoch_fiti = Fitipy(splitext(args.model)[0] + '.epoch')
self.epoch = epoch_fiti.read().read(0, int)
def on_epoch_end(a, b):
self.epoch += 1
epoch_fiti.write().write(self.epoch, str)
self.model_base = splitext(self.args.model)[0]
self.callbacks = [
checkpoint,
TensorBoard(log_dir=self.model_base + '.logs', ),
LambdaCallback(on_epoch_end=on_epoch_end)
]
self.data = TrainData.from_both(args.tags_file, args.tags_folder,
args.folder)
pos_files, neg_files = self.data.train_files
self.neg_files_it = iter(cycle(neg_files))
self.pos_files_it = iter(cycle(pos_files))
def main():
args = create_parser(usage).parse_args()
def on_activation():
activate_notify()
# TODO: trigger VMSE
def on_prediction(conf):
if args.basic_mode:
print('!' if conf > 0.7 else '.', end='', flush=True)
else:
max_width = 80
width = min(get_terminal_size()[0], max_width)
units = int(round(conf * width))
bar = 'X' * units + '-' * (width - units)
cutoff = round((1.0 - args.sensitivity) * width)
print(bar[:cutoff] + bar[cutoff:].replace('X', 'x'))
listener = Listener(args.model, args.chunk_size)
audio_buffer = np.zeros(listener.pr.buffer_samples, dtype=float)
def get_prediction(chunk):
nonlocal audio_buffer
audio = buffer_to_audio(chunk)
audio_buffer = np.concatenate((audio_buffer[len(audio):], audio))
return listener.update(chunk)
engine = ListenerEngine(listener, args.chunk_size)
engine.get_prediction = get_prediction
runner = PreciseRunner(engine,
args.trigger_level,
sensitivity=args.sensitivity,
on_activation=on_activation,
on_prediction=on_prediction)
runner.start()
Event().wait() # Wait forever
def main():
args = TrainData.parse_args(create_parser(usage))
inject_params(args.model)
data = TrainData.from_both(args.tags_file, args.tags_folder, args.folder)
#print(data)
#print(args.use_train)
train, test = data.load(args.use_train, not args.use_train)
#print(train)
#print(test)
inputs, targets = train if args.use_train else test
#print(inputs)
filenames = sum(data.train_files if args.use_train else data.test_files,
[])
#for i in range(0, len(targets)):
# print(filenames[i], "\t", targets[i])
print(args.model)
predictions = Listener.find_runner(args.model)(args.model).predict(inputs)
#for i, filename in enumerate(filenames):
#print(filename, "\t", predictions[i], targets[i])
#print(predictions[i])
#print (predictions)
#print (len(predictions))
stats = calc_stats(filenames, targets, predictions)
print('Data:', data)
show_stats(stats, not args.no_filenames)
def main():
args = create_parser(usage).parse_args()
github = load_github()
summaries = {}
repo = SkillRepo(path=join(gettempdir(), 'mycroft-skills-repo'))
for skill_entry in MycroftSkillsManager(repo=repo).list():
if not skill_entry.url:
continue
print('Generating {}...'.format(skill_entry.name))
try:
summary = generate_summary(github, skill_entry)
except GithubException as e:
print('Failed to generate summary:', repr(e))
continue
summaries[skill_entry.name] = summary
if args.output_file:
with open(args.output_file, 'w') as f:
json.dump(summaries, f)
else:
print(json.dumps(summaries, indent=4))
if args.upload:
upload_summaries(github, summaries)
def main():
args = create_parser(usage).parse_args()
model_name = args.model.replace('.net', '')
convert(args.model, args.out.format(model=model_name))
def main():
args = create_parser(usage).parse_args()
num_seen_file = Fitipy(args.cache_file + '.num')
topics_cache = args.cache_file + '.topics.json'
if not isfile(topics_cache):
print('Generating topics...')
with open(topics_cache, 'w') as f:
json.dump(get_keywords_uiuc(), f)
with open(topics_cache) as f:
topics = json.load(f)
num_seen = num_seen_file.read().read(0, int)
with open(args.auth_file) as f:
auth = yaml.load(f)
email = auth['username']
password = auth['password']
server = auth.get('pop3_host', 'pop3.' + email.split('@')[-1])
client = StatelessClass(EmailReceiver,
email=email,
password=password,
server=server) # type: EmailReceiver
print('Waiting for emails...')
while True:
num_messages = len(client.get_list())
if num_messages < num_seen:
num_seen = num_messages
num_seen_file.write().write(num_seen)
if num_messages <= num_seen:
time.sleep(1)
continue
for msg_id in range(num_seen + 1, num_messages + 1):
email = client.get_email(msg_id)
print('Found new email from {} titled {}.'.format(
email['From'], email['Subject']))
email_txt = '\n'.join(email['text'])
email_txt = BeautifulSoup(email_txt).text
email_txt = re.sub(r'https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))', '',
email_txt)
freq = calc_freq(email_txt, topics)
tags = relevant_topics(freq)
print('Found the following tags:', ', '.join(tags))
events = Event.find()
matched_events = [
event for event in events if event.get('emailSrc') and
SequenceMatcher(a=event['emailSrc'], b=email_txt).ratio() > 0.9
]
if matched_events:
print('Ignoring, similar to {} other emails'.format(
len(matched_events)))
else:
Event.add({
'name': email['Subject'],
'description': email_txt,
'location': '',
'time': int(time.time()),
'tags': tags,
'emailSrc': email_txt
})
num_seen += 1
num_seen_file.write().write(num_seen, str)
def main():
args = create_parser(usage).parse_args()
os.chdir(os.getcwd() + "/Precise")
def on_activation_normal():
print("activated\n", flush=True)
def on_activation_safe():
global chunk_num
nm = join(
args.save_dir,
args.save_prefix + session_id + '.' + str(chunk_num) + '.wav')
save_audio(nm, audio_buffer)
print()
print('Saved to ' + nm + '.')
chunk_num += 1
def on_prediction(conf):
max_width = 80
width = min(get_terminal_size()[0], max_width)
units = int(round(conf * width))
bar = 'X' * units + '-' * (width - units)
cutoff = round((1.0 - args.sensitivity) * width)
print(bar[:cutoff] + bar[cutoff:].replace('X', 'x') + "\n", flush=True)
def get_prediction(chunk):
nonlocal audio_buffer
audio = buffer_to_audio(chunk)
audio_buffer = np.concatenate((audio_buffer[len(audio):], audio))
return listener.update(chunk)
while True:
line = sys.stdin.readline().rstrip()
if ("start" in line):
if (os.path.isfile("./model.pb")):
listener = Listener("model.pb", args.chunk_size)
else:
listener = Listener("model.net", args.chunk_size)
engine = ListenerEngine(listener, args.chunk_size)
if ("visual" not in line):
if (line == "start normal"):
runner = PreciseRunner(engine,
args.trigger_level,
sensitivity=args.sensitivity,
on_activation=on_activation_normal)
elif (line == "start safe"):
runner = PreciseRunner(engine,
args.trigger_level,
sensitivity=args.sensitivity,
on_activation=on_activation_safe)
else:
if (line == "start normal visual"):
audio_buffer = np.zeros(listener.pr.buffer_samples,
dtype=float)
engine.get_prediction = get_prediction
runner = PreciseRunner(engine,
args.trigger_level,
sensitivity=args.sensitivity,
on_activation=on_activation_normal,
on_prediction=on_prediction)
elif (line == "start safe visual"):
audio_buffer = np.zeros(listener.pr.buffer_samples,
dtype=float)
engine.get_prediction = get_prediction
runner = PreciseRunner(engine,
args.trigger_level,
sensitivity=args.sensitivity,
on_activation=on_activation_safe,
on_prediction=on_prediction)
runner.start()
elif (line == "stop"):
runner.stop()
elif (line == "running"):
print(runner.running)
def main():
args = create_parser(usage).parse_args()
filenames = glob(join(args.folder, '*.wav'))
shuffle(filenames)
wav_id = -1
stream = None
stop_event = Event()
stop_event.set()
p = PyAudio()
atexit.register(p.terminate)
def play_audio(audio_file):
nonlocal stream
if stream:
stop_event.clear()
stop_event.wait()
stream.stop_stream()
stream.close()
stream = None
audio = load_audio(audio_file)[-pr.buffer_samples:]
audio /= 2 * min(audio.mean() + 4 * audio.std(), abs(audio).max())
stream = p.open(format=paFloat32,
channels=1,
rate=pr.sample_rate,
output=True)
stream.start_stream()
def write_audio():
data = audio.astype('float32').tostring()
chunk_size = 1024
for pos in range(chunk_size, len(data) + chunk_size, chunk_size):
if not stop_event.is_set():
stop_event.set()
return
stream.write(data[pos - chunk_size:pos])
while stop_event.is_set():
sleep(chunk_size / pr.sample_rate)
stop_event.set()
Thread(target=write_audio, daemon=True).start()
tags_file = Fitipy(args.tags_file)
tags = tags_file.read().dict()
def submit():
nonlocal wav_id
if wav_id >= 0:
tags[basename(splitext(filenames[wav_id])[0])] = float(
slider.get())
tags_file.write().dict(tags)
wav_id += 1
play_audio(filenames[wav_id])
submit()
master = Tk()
label = Label(master, text='0')
label.pack()
def on_slider_change(x):
label['text'] = str(int(float(x)))
slider = Scale(master, from_=0, to=100, command=on_slider_change)
slider.pack()
Button(master, text='Submit', command=submit).pack()
Button(master,
text='Replay',
command=lambda: play_audio(filenames[wav_id])).pack()
mainloop()
stream.stop_stream()
stream.close()
def main():
parser = create_parser(usage)
parser.add_argument(
'models',
nargs='*',
help='Either Keras (.net) or TensorFlow (.pb) models to test')
args = TrainData.parse_args(parser)
if not args.models and not args.input_file and args.folder:
args.input_file = args.folder
if bool(args.models) == bool(args.input_file):
parser.error('Please specify either a list of models or an input file')
if not args.output_file:
load_plt() # Error early if matplotlib not installed
import numpy as np
if args.models:
data = TrainData.from_both(args.tags_file, args.tags_folder,
args.folder)
print('Data:', data)
filenames = sum(
data.train_files if args.use_train else data.test_files, [])
loader = CachedDataLoader(
partial(data.load,
args.use_train,
not args.use_train,
shuffle=False))
model_data = calc_stats(args.models, loader, args.use_train, filenames)
else:
model_data = {
name: Stats.from_np_dict(data)
for name, data in np.load(args.input_file)['data'].item().items()
}
for name, stats in model_data.items():
print('=== {} ===\n{}\n\n{}\n'.format(name, stats.counts_str(),
stats.summary_str()))
if args.output_file:
np.savez(args.output_file,
data={
name: stats.to_np_dict()
for name, stats in model_data.items()
})
else:
plt = load_plt()
decoder = ThresholdDecoder(pr.threshold_config, pr.threshold_center)
thresholds = [
decoder.encode(i)
for i in np.linspace(0.0, 1.0, args.resolution)[1:-1]
]
for model_name, stats in model_data.items():
x = [stats.false_positives(i) for i in thresholds]
y = [stats.false_negatives(i) for i in thresholds]
plt.plot(x, y, marker='x', linestyle='-', label=model_name)
if args.labels:
for x, y, threshold in zip(x, y, thresholds):
plt.annotate('{:.4f}'.format(threshold), (x, y))
plt.legend()
plt.xlabel('False Positives')
plt.ylabel('False Negatives')
plt.show()
def __init__(self):
self.args = create_parser(usage).parse_args()
inject_params(self.args.model)
self.runner = Listener.find_runner(self.args.model)(self.args.model)
self.audio_buffer = np.zeros(pr.buffer_samples, dtype=float)