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 load_for(self, model: str) -> Tuple[list, list]: """Injects the model parameters, reloading if they changed, and returning the data""" inject_params(model) if self.prev_cache != pr.vectorization_md5_hash(): self.prev_cache = pr.vectorization_md5_hash() self.data = self.loader() return self.data
def load_precise_model(model_name: str) -> Any: """Loads a Keras model from file, handling custom loss function""" if not model_name.endswith('.net'): print('Warning: Unknown model type, ', model_name) inject_params(model_name) return load_keras().models.load_model(model_name)
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 __init__(self, parser=None): parser = parser or ArgumentParser() add_to_parser(parser, self.usage, True) args = TrainData.parse_args(parser) self.args = args = self.process_args(args) or args if args.invert_samples and not args.samples_file: parser.error( 'You must specify --samples-file when using --invert-samples') if args.samples_file and not isfile(args.samples_file): parser.error('No such file: ' + (args.invert_samples or args.samples_file)) if not 0.0 <= args.sensitivity <= 1.0: parser.error('sensitivity must be between 0.0 and 1.0') output_folder = os.path.join(args.folder, splitext(args.model)[0]) if not os.path.exists(output_folder): print('Creating output folder:', output_folder) os.makedirs(output_folder) args.model = os.path.join(output_folder, args.model) inject_params(args.model) save_params(args.model) self.train, self.test = self.load_data(self.args) set_loss_bias(1.0 - args.sensitivity) params = ModelParams(skip_acc=args.no_validation, extra_metrics=args.extra_metrics) self.model = create_model(args.model, params) self.model.summary() from keras.callbacks import ModelCheckpoint, TensorBoard checkpoint = ModelCheckpoint(args.model, monitor=args.metric_monitor, save_best_only=args.save_best) epoch_file = splitext(args.model)[0] epoch_file = os.path.join(epoch_file + '.epoch') epoch_fiti = Fitipy(epoch_file) 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] if args.samples_file: self.samples, self.hash_to_ind = self.load_sample_data( args.samples_file, self.train) else: self.samples = set() self.hash_to_ind = {} self.callbacks = [ checkpoint, TensorBoard(log_dir=self.model_base + '.logs', ), LambdaCallback(on_epoch_end=on_epoch_end) ]
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.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() 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 = 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 __init__(self, model_name: str, chunk_size: int = -1, runner_cls: type = None): self.window_audio = np.array([]) self.pr = inject_params(model_name) self.mfccs = np.zeros((self.pr.n_features, self.pr.n_mfcc)) self.chunk_size = chunk_size runner_cls = runner_cls or self.find_runner(model_name) self.runner = runner_cls(model_name) self.threshold_decoder = ThresholdDecoder(self.pr.threshold_config, pr.threshold_center)
def __init__(self, args): super().__init__(args) if args.invert_samples and not args.samples_file: raise ValueError( 'You must specify --samples-file when using --invert-samples') if args.samples_file and not isfile(args.samples_file): raise ValueError('No such file: ' + (args.invert_samples or args.samples_file)) if not 0.0 <= args.sensitivity <= 1.0: raise ValueError('sensitivity must be between 0.0 and 1.0') inject_params(args.model) save_params(args.model) params = ModelParams(skip_acc=args.no_validation, extra_metrics=args.extra_metrics, loss_bias=1.0 - args.sensitivity, freeze_till=args.freeze_till) self.model = create_model(args.model, params) self.train, self.test = self.load_data(self.args) 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] if args.samples_file: self.samples, self.hash_to_ind = self.load_sample_data( args.samples_file, self.train) else: self.samples = set() self.hash_to_ind = {} self.callbacks = [ checkpoint, TensorBoard(log_dir=self.model_base + '.logs', ), LambdaCallback(on_epoch_end=on_epoch_end) ]
def run(self): args = self.args 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 self.is_pocketsphinx: script = PocketsphinxTestScript.create( key_phrase=args.pocketsphinx_wake_word, dict_file=args.pocketsphinx_dict, hmm_folder=args.pocketsphinx_folder, threshold=args.pocketsphinx_threshold) ww_files, nww_files = data_files script.run_test(ww_files, 'Wake Word', 1.0) script.run_test(nww_files, 'Not Wake Word', 0.0) stats = script.get_stats() metrics[args.pocketsphinx_dict] = stats.to_dict(args.threshold) 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 __init__(self, model_name: str, chunk_size: int = -1, runner_cls: type = None): self.window_audio = np.array([]) self.pr = inject_params(model_name) self.features = np.zeros((self.pr.n_features, self.pr.feature_size)) self.chunk_size = chunk_size runner_cls = runner_cls or self.find_runner(model_name) self.runner = runner_cls(model_name) self.mfcc = import_module('speechpy.feature').mfcc
def __init__(self, model_name: str, chunk_size: int = -1, runner_cls: type = None): print('model_name: ', model_name) print('chunk_size: ', chunk_size) self.window_audio = np.array([]) self.pr = inject_params(model_name) self.mfccs = np.zeros((self.pr.n_features, self.pr.n_mfcc)) self.chunk_size = chunk_size runner_cls = runner_cls or self.find_runner(model_name) self.runner = runner_cls(model_name)
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 __init__(self, args): self.args = args self.trained_fns = load_trained_fns(args.model) pr = inject_params(args.model) self.audio_buffer = np.zeros(pr.buffer_samples, dtype=float) from keras.callbacks import ModelCheckpoint self.checkpoint = ModelCheckpoint(args.model, monitor=args.metric_monitor, save_best_only=args.save_best) data = TrainData.from_tags(args.tags_file, args.tags_folder) self.tags_data = data.load(True, not args.no_validation) if not isfile(args.model): create_model(args.model, args.no_validation, args.extra_metrics).save(args.model) self.listener = Listener(args.model, args.chunk_size, runner_cls=KerasRunner)
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)
def __init__(self, args): super().__init__(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)