def command_line(): p = OptionParser() p.add_option('-H', '--host', dest='host', action='store', help='IMAP host connect to') p.add_option('-u', '--username', dest='username', action='store', help='Username to login with') p.add_option('-p', '--password', dest='password', action='store', help='Password to login with') p.add_option('-P', '--port', dest='port', action='store', default=None, help='IMAP port to use (default is 143)') p.add_option('-s', '--ssl', dest='ssl', action='store_true', default=False, help='Use SSL connection') p.add_option('-f', '--file', dest='file', action='store', default=None, help='Config file (same as livetest)') opts, args = p.parse_args() if args: p.error('unexpected arguments %s' % ' '.join(args)) if opts.file: if opts.host or opts.username or opts.password or opts.port or opts.ssl: p.error('If -f/--file is given no other options can be used') # Use the options in the config file opts = parse_config_file(opts.file) else: # Get compulsory options if not given on the command line for opt_name in ('host', 'username', 'password'): if not getattr(opts, opt_name): setattr(opts, opt_name, getpass(opt_name + ': ')) if not opts.port: opts.port = 143 opts.oauth = False # OAUTH not supported on command line return opts
def main(): args = parse_args() cfg = parse_config_file(args.config_file) visualize( tfrecords=args.tfrecords, cfg=cfg )
def main(): args = parse_args() print "Command line arguments:" pprint.pprint(vars(args)) print cfg = parse_config_file(args.config_file) print "Configurations:" pprint.pprint(cfg) print if args.max_number_of_steps != None: cfg.NUM_TRAIN_ITERATIONS = args.max_number_of_steps if args.batch_size != None: cfg.BATCH_SIZE = args.batch_size with open(args.priors) as f: bbox_priors = pickle.load(f) bbox_priors = np.array(bbox_priors).astype(np.float32) train( tfrecords=args.tfrecords, bbox_priors=bbox_priors, logdir=args.logdir, cfg=cfg, pretrained_model_path=args.pretrained_model, fine_tune = args.fine_tune, extract_feats = args.extract_features, trainable_scopes = args.trainable_scopes, use_moving_averages = args.use_moving_averages, restore_moving_averages = args.restore_moving_averages )
def parse_argv(): args = sys.argv[1:] if not args: argv_error('Please specify a host configuration file. See livetest-sample.ini for an example.') ini_path = sys.argv.pop(1) # 2nd arg should be the INI file if not os.path.isfile(ini_path): argv_error('%r is not a livetest INI file' % ini_path) host_config = parse_config_file(ini_path) return host_config
def main(): if options.debug: define('settings', '%s/wechat.conf' % config.PROJDIR) else: define('settings', '') parse_command_line() debug = options.debug config.parse_config_file(options.settings) if not debug: options.debug = False if options.debug: logging.info('Starting server at port %s in debug mode' % options.port) else: logging.info('Starting server at port %s' % options.port) server = HTTPServer(Application(), xheaders=True) server.listen(int(options.port)) IOLoop.instance().start()
def main(): if options.debug: define('settings', '%s/wechat.conf' % config.PROJDIR) else: define('settings', '') parse_command_line() debug = options.debug config.parse_config_file(options.settings) if not debug: options.debug = False if options.debug: logging.info('Starting server at port %s in debug mode' % options.port) else: logging.info('Starting server at port %s' % options.port) server = HTTPServer(Application(), xheaders=True) server.listen(int(options.port)) IOLoop.instance().start()
def main(): logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s: %(message)s [in " "%(funcName)s %(filename)s:%(lineno)d]", datefmt="%H:%M") args = parse_cmdline() if args.debug: logging.getLogger().setLevel(logging.DEBUG) config = parse_config_file(args.config) stdin_pw = handle_stdin() if stdin_pw: config['general']['password'] = stdin_pw run_command(args, config)
def debug(tfrecord_path, config_path = None): tfrecords = [tfrecord_path] cfg = parse_config_file(config_path) graph = tf.Graph() sess = tf.Session(graph = graph) # run a session to look at the images... with sess.as_default(), graph.as_default(): # Input Nodes images, batched_bboxes, batched_num_bboxes, image_ids = inputs.input_nodes( tfrecords=tfrecords, max_num_bboxes = cfg.MAX_NUM_BBOXES, num_epochs=None, batch_size=cfg.BATCH_SIZE, num_threads=cfg.NUM_INPUT_THREADS, add_summaries = True, augment=cfg.AUGMENT_IMAGE, shuffle_batch=False, cfg=cfg ) coord = tf.train.Coordinator() plt.ion() tf.initialize_all_variables().run() threads = tf.train.start_queue_runners(sess=sess, coord=coord) done = False while not done: output = sess.run([images, batched_bboxes]) for image, bboxes in zip(output[0], output[1]): plt.imshow((image * cfg.IMAGE_STD + cfg.IMAGE_MEAN).astype(np.uint8)) # plot the ground truth bounding boxes for bbox in bboxes: xmin, ymin, xmax, ymax = bbox * cfg.INPUT_SIZE plt.plot([xmin, xmax, xmax, xmin, xmin], [ymin, ymin, ymax, ymax, ymin], 'b-') plt.show(block=False) t = raw_input("push button") if t != '': done = True plt.clf()
def main(): args = parse_args() cfg = parse_config_file(args.config_file) if args.batch_size != None: cfg.BATCH_SIZE = args.batch_size if args.model_name != None: cfg.MODEL_NAME = args.model_name extract_and_save(tfrecords=args.tfrecords, checkpoint_path=args.checkpoint_path, save_path=args.save_path, num_iterations=args.batches, feature_keys=args.features, cfg=cfg)
def main(): args = parse_args() print "Command line arguments:" pprint.pprint(vars(args)) print cfg = parse_config_file(args.config_file) print "Configurations:" pprint.pprint(cfg) print with open(args.priors) as f: bbox_priors = pickle.load(f) bbox_priors = np.array(bbox_priors).astype(np.float32) detect_visualize(tfrecords=args.tfrecords, bbox_priors=bbox_priors, checkpoint_path=args.checkpoint_path, cfg=cfg)
def debug(tfrecord_path, config_path): graph = tf.get_default_graph() tfrecords = [tfrecord_path] cfg = parse_config_file(config_path) # Input Nodes images, labels_sparse, instance_ids = construct_network_input_nodes( tfrecords=tfrecords, input_type=cfg.INPUT_TYPE, num_epochs=None, batch_size=cfg.BATCH_SIZE, num_threads=cfg.NUM_INPUT_THREADS, add_summaries = False, augment=cfg.AUGMENT_IMAGE, shuffle_batch=False, cfg=cfg ) coord = tf.train.Coordinator() plt.ion() # run a session to look at the images... with tf.Session() as sess: tf.initialize_all_variables().run() threads = tf.train.start_queue_runners(sess=sess, coord=coord) while True: output = sess.run([images, labels_sparse, instance_ids]) for image, label, image_id in zip(output[0], output[1], output[2]): plt.imshow((image * cfg.IMAGE_STD + cfg.IMAGE_MEAN).astype(np.uint8)) plt.title("Class: %d\tImage: %s" % (label,image_id)) plt.show(block=False) t = raw_input("push button") if t != '': return
def main(): args = parse_args() print "Command line arguments:" pprint.pprint(vars(args)) print cfg = parse_config_file(args.config_file) print "Configurations:" pprint.pprint(cfg) print with open(args.priors) as f: bbox_priors = pickle.load(f) bbox_priors = np.array(bbox_priors).astype(np.float32) eval(tfrecords=args.tfrecords, bbox_priors=bbox_priors, summary_dir=args.summary_dir, checkpoint_path=args.checkpoint_path, max_iterations=args.max_iterations, cfg=cfg)
def main(): # Parse command-line arguments args = parse_args() config_file = args.pop('config', None) no_ssl = args.pop('nossl', False) # Read config file if the option was specified if config_file is not None: opts = config.parse_config_file(config_file) else: opts = config.DEFAULTS # Command-line arguments override config file settings opts.update(args) if no_ssl: opts['ssl'] = False # Check for label rules if 'labels' not in opts or not opts['labels']: raise AppError("Please specify some label definitions") # If the user or password is not specified, prompt for them now for opt in ('user', 'password'): if opt not in opts or opts[opt] is None: opts[opt] = getpass.getpass(opt + ': ') imap_args = opts.copy() del imap_args['folder'] del imap_args['labels'] client = create_imap_client(**imap_args) observer = ConsoleObserver() weighmail(client, opts['folder'], opts['labels'], observer) client.logout()
action='store_true') if len(sys.argv) == 1: parser.print_help() sys.exit(1) args = parser.parse_args() return args if __name__ == '__main__': args = parse_args() print "Called with:" print args cfg = parse_config_file(args.config_file) # Modify the configuration hyper-parameters for prep purposes. cfg.PHASE = "TRAIN" cfg.USE_BATCH_STATISTICS = True print "Configurations:" print cfg with open(args.priors) as f: bbox_priors = pickle.load(f) train( tfrecords=args.tfrecords, bbox_priors=bbox_priors, logdir=args.logdir, cfg=cfg,
def main(): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # parse command line parser = opts_parser() options = parser.parse_args() modelfile = options.modelfile cfg = {} for fn in options.vars: cfg.update(config.parse_config_file(fn)) cfg.update(config.parse_variable_assignments(options.var)) sample_rate = cfg['sample_rate'] frame_len = cfg['frame_len'] fps = cfg['fps'] mel_bands = cfg['mel_bands'] mel_min = cfg['mel_min'] mel_max = cfg['mel_max'] blocklen = cfg['blocklen'] batchsize = cfg['batchsize'] bin_nyquist = frame_len // 2 + 1 bin_mel_max = bin_nyquist * 2 * mel_max // sample_rate # prepare dataset datadir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'datasets', options.dataset) # - load filelist with io.open(os.path.join(datadir, 'filelists', 'train')) as f: filelist = [l.rstrip() for l in f if l.rstrip()] if options.validate: with io.open(os.path.join(datadir, 'filelists', 'valid')) as f: filelist_val = [l.strip() for l in f if l.strip()] filelist.extend(filelist_val) else: filelist_val = [] # - compute spectra print("Computing%s spectra..." % (" or loading" if options.cache_spectra else "")) spects = [] for fn in progress(filelist, 'File '): cache_fn = (options.cache_spectra and os.path.join(options.cache_spectra, fn + '.npy')) spects.append( cached(cache_fn, audio.extract_spect, os.path.join(datadir, 'audio', fn), sample_rate, frame_len, fps)) # - load and convert corresponding labels print("Loading labels...") labels = [] for fn, spect in zip(filelist, spects): fn = os.path.join(datadir, 'labels', fn.rsplit('.', 1)[0] + '.lab') with io.open(fn) as f: segments = [l.rstrip().split() for l in f if l.rstrip()] segments = [(float(start), float(end), label == 'sing') for start, end, label in segments] timestamps = np.arange(len(spect)) / float(fps) labels.append(create_aligned_targets(segments, timestamps, np.bool)) # - prepare mel filterbank filterbank = audio.create_mel_filterbank(sample_rate, frame_len, mel_bands, mel_min, mel_max) filterbank = filterbank[:bin_mel_max].astype(floatX) if options.validate: spects_val = spects[-len(filelist_val):] spects = spects[:-len(filelist_val)] labels_val = labels[-len(filelist_val):] labels = labels[:-len(filelist_val)] # - precompute mel spectra, if needed, otherwise just define a generator mel_spects = (np.log( np.maximum(np.dot(spect[:, :bin_mel_max], filterbank), 1e-7)) for spect in spects) if not options.augment: mel_spects = list(mel_spects) del spects # - load mean/std or compute it, if not computed yet meanstd_file = os.path.join(os.path.dirname(__file__), '%s_meanstd.npz' % options.dataset) try: with np.load(meanstd_file) as f: mean = f['mean'] std = f['std'] except (IOError, KeyError): print("Computing mean and standard deviation...") mean, std = znorm.compute_mean_std(mel_spects) np.savez(meanstd_file, mean=mean, std=std) mean = mean.astype(floatX) istd = np.reciprocal(std).astype(floatX) # - prepare training data generator print("Preparing training data feed...") if not options.augment: # Without augmentation, we just precompute the normalized mel spectra # and create a generator that returns mini-batches of random excerpts mel_spects = [(spect - mean) * istd for spect in mel_spects] batches = augment.grab_random_excerpts(mel_spects, labels, batchsize, blocklen) else: # For time stretching and pitch shifting, it pays off to preapply the # spline filter to each input spectrogram, so it does not need to be # applied to each mini-batch later. spline_order = cfg['spline_order'] if spline_order > 1: from scipy.ndimage import spline_filter spects = [ spline_filter(spect, spline_order).astype(floatX) for spect in spects ] # We define a function to create the mini-batch generator. This allows # us to easily create multiple generators for multithreading if needed. def create_datafeed(spects, labels): # With augmentation, as we want to apply random time-stretching, # we request longer excerpts than we finally need to return. max_stretch = cfg['max_stretch'] batches = augment.grab_random_excerpts( spects, labels, batchsize=batchsize, frames=int(blocklen / (1 - max_stretch))) # We wrap the generator in another one that applies random time # stretching and pitch shifting, keeping a given number of frames # and bins only. max_shift = cfg['max_shift'] batches = augment.apply_random_stretch_shift(batches, max_stretch, max_shift, keep_frames=blocklen, keep_bins=bin_mel_max, order=spline_order, prefiltered=True) # We transform the excerpts to mel frequency and log magnitude. batches = augment.apply_filterbank(batches, filterbank) batches = augment.apply_logarithm(batches) # We apply random frequency filters max_db = cfg['max_db'] batches = augment.apply_random_filters(batches, filterbank, mel_max, max_db=max_db) # We apply normalization batches = augment.apply_znorm(batches, mean, istd) return batches # We start the mini-batch generator and augmenter in one or more # background threads or processes (unless disabled). bg_threads = cfg['bg_threads'] bg_processes = cfg['bg_processes'] if not bg_threads and not bg_processes: # no background processing: just create a single generator batches = create_datafeed(spects, labels) elif bg_threads: # multithreading: create a separate generator per thread batches = augment.generate_in_background( [create_datafeed(spects, labels) for _ in range(bg_threads)], num_cached=bg_threads * 5) elif bg_processes: # multiprocessing: single generator is forked along with processes batches = augment.generate_in_background( [create_datafeed(spects, labels)] * bg_processes, num_cached=bg_processes * 25, in_processes=True) ########################################################################### #-----------Main changes to code to make it work with pytorch-------------# ########################################################################### print("preparing training function...") mdl = model.CNNModel() mdl = mdl.to(device) #Setting up learning rate and learning rate parameters initial_eta = cfg['initial_eta'] eta_decay = cfg['eta_decay'] momentum = cfg['momentum'] eta_decay_every = cfg.get('eta_decay_every', 1) eta = initial_eta #set up loss criterion = torch.nn.BCELoss() #set up optimizer optimizer = torch.optim.SGD(mdl.parameters(), lr=eta, momentum=momentum, nesterov=True) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=eta_decay_every, gamma=eta_decay) #set up optimizer writer = SummaryWriter(os.path.join(modelfile, 'runs')) epochs = cfg['epochs'] epochsize = cfg['epochsize'] batches = iter(batches) #conditions to save model best_val_loss = 100000. best_val_error = 1. for epoch in range(epochs): # - Initialize certain parameters that are used to monitor training err = 0 total_norm = 0 loss_accum = 0 mdl.train(True) # - Compute the L-2 norm of the gradients for p in mdl.parameters(): if p.grad is not None: param_norm = p.grad.data.norm(2) total_norm += param_norm.item()**2 total_norm = total_norm**(1. / 2) # - Start the training for this epoch for batch in progress(range(epochsize), min_delay=0.5, desc='Epoch %d/%d: Batch ' % (epoch + 1, epochs)): data = next(batches) input_data = np.transpose(data[0][:, :, :, np.newaxis], (0, 3, 1, 2)) labels = data[1][:, np.newaxis].astype(np.float32) #map labels to make them softer labels = (0.02 + 0.96 * labels) optimizer.zero_grad() outputs = mdl(torch.from_numpy(input_data).to(device)) loss = criterion(outputs, torch.from_numpy(labels).to(device)) loss.backward() optimizer.step() loss_accum += loss.item() # - Compute validation loss and error if desired if options.validate: from eval import evaluate mdl.train(False) val_loss = 0 preds = [] labs = [] max_len = fps mel_spects_val = (np.log( np.maximum(np.dot(spect[:, :bin_mel_max], filterbank), 1e-7)) for spect in spects_val) mel_spects_val = [(spect - mean) * istd for spect in mel_spects_val] num_iter = 0 for spect, label in zip(mel_spects_val, labels_val): num_excerpts = len(spect) - blocklen + 1 excerpts = np.lib.stride_tricks.as_strided( spect, shape=(num_excerpts, blocklen, spect.shape[1]), strides=(spect.strides[0], spect.strides[0], spect.strides[1])) # - Pass mini-batches through the network and concatenate results for pos in range(0, num_excerpts, batchsize): input_data = np.transpose( excerpts[pos:pos + batchsize, :, :, np.newaxis], (0, 3, 1, 2)) if (pos + batchsize > num_excerpts): label_batch = label[blocklen // 2 + pos:blocklen // 2 + num_excerpts, np.newaxis].astype(np.float32) else: label_batch = label[blocklen // 2 + pos:blocklen // 2 + pos + batchsize, np.newaxis].astype(np.float32) pred = mdl(torch.from_numpy(input_data).to(device)) e = criterion(pred, torch.from_numpy(label_batch).to(device)) preds = np.append(preds, pred[:, 0].cpu().detach().numpy()) labs = np.append(labs, label_batch) val_loss += e.item() num_iter += 1 print("Validation loss: %.3f" % (val_loss / num_iter)) _, results = evaluate(preds, labs) print("Validation error: %.3f" % (1 - results['accuracy'])) if (val_loss / num_iter < best_val_loss and (1 - results['accuracy']) < best_val_error): torch.save(mdl.state_dict(), os.path.join(modelfile, 'model.pth')) best_val_loss = val_loss / num_iter best_val_error = 1 - results['accuracy'] print('New saved model', best_val_loss, best_val_error) #Update the learning rate scheduler.step() print('Training Loss per epoch', loss_accum / epochsize) # - Save parameters for examining writer.add_scalar('Training Loss', loss_accum / epochsize, epoch) writer.add_scalar('Validation loss', val_loss / num_iter, epoch) writer.add_scalar('Gradient norm', total_norm, epoch) writer.add_scalar('Validation error', 1 - results['accuracy']) for param_group in optimizer.param_groups: print(param_group['lr']) if not options.validate: torch.save(mdl.state_dict(), os.path.join(modelfile, 'model.pth'))
def main(): print(torch.cuda.is_available()) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # parse command line parser = opts_parser() options = parser.parse_args() modelfile = options.modelfile lossgradient = options.lossgradient cfg = {} for fn in options.vars: cfg.update(config.parse_config_file(fn)) cfg.update(config.parse_variable_assignments(options.var)) outfile = options.outfile sample_rate = cfg['sample_rate'] frame_len = cfg['frame_len'] fps = cfg['fps'] mel_bands = cfg['mel_bands'] mel_min = cfg['mel_min'] mel_max = cfg['mel_max'] blocklen = cfg['blocklen'] batchsize = cfg['batchsize'] bin_nyquist = frame_len // 2 + 1 bin_mel_max = bin_nyquist * 2 * mel_max // sample_rate # prepare dataset print("Preparing data reading...") datadir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'datasets', options.dataset) # - load filelist with io.open(os.path.join(datadir, 'filelists', 'valid')) as f: filelist = [l.rstrip() for l in f if l.rstrip()] with io.open(os.path.join(datadir, 'filelists', 'test')) as f: filelist += [l.rstrip() for l in f if l.rstrip()] # - load mean/std meanstd_file = os.path.join(os.path.dirname(__file__), '%s_meanstd.npz' % options.dataset) dataloader = DatasetLoader(options.dataset, options.cache_spectra, datadir, input_type=options.input_type, filelist=filelist) mel_spects, labels = dataloader.prepare_batches(sample_rate, frame_len, fps, mel_bands, mel_min, mel_max, blocklen, batchsize, batch_data=False) with np.load(meanstd_file) as f: mean = f['mean'] std = f['std'] mean = mean.astype(floatX) istd = np.reciprocal(std).astype(floatX) mdl = model.CNNModel(input_type='mel_spects_norm', is_zeromean=False, meanstd_file=meanstd_file, device=device) mdl.load_state_dict(torch.load(modelfile)) mdl.to(device) mdl.eval() if (lossgradient != 'None'): mdl_lossgrad = model.CNNModel(input_type=options.input_type, is_zeromean=False, sample_rate=sample_rate, frame_len=frame_len, fps=fps, mel_bands=mel_bands, mel_min=mel_min, mel_max=mel_max, bin_mel_max=bin_mel_max, meanstd_file=meanstd_file, device=device) mdl_lossgrad.load_state_dict(torch.load(lossgradient)) mdl_lossgrad.to(device) mdl_lossgrad.eval() criterion = torch.nn.BCELoss() loss_grad_val = dataloader.prepare_loss_grad_batches( options.loss_grad_save, mel_spects, labels, mdl_lossgrad, criterion, blocklen, batchsize, device) # run prediction loop print("Predicting:") predictions = [] #for spect, g in zip(mel_spects, loss_grad_val): c = 0 for spect in progress(mel_spects, total=len(filelist), desc='File '): if (lossgradient != 'None'): g = loss_grad_val[c] c += 1 # naive way: pass excerpts of the size used during training # - view spectrogram memory as a 3-tensor of overlapping excerpts num_excerpts = len(spect) - blocklen + 1 excerpts = np.lib.stride_tricks.as_strided( spect.astype(floatX), shape=(num_excerpts, blocklen, spect.shape[1]), strides=(spect.strides[0], spect.strides[0], spect.strides[1])) preds = np.zeros((num_excerpts, 1)) count = 0 for pos in range(0, num_excerpts, batchsize): input_data = np.transpose( excerpts[pos:pos + batchsize, :, :, np.newaxis], (0, 3, 1, 2)) input_data = (input_data - mean) * istd if lossgradient != 'None': for i in range(input_data.shape[0]): if (options.lossgrad_algorithm == 'grad'): rank_matrix = np.abs(g[i + pos]) elif (options.lossgrad_algorithm == 'gradxinp'): rank_matrix = np.squeeze(g[i + pos] * input_data[i, :, :, :]) elif (options.lossgrad_algorithm == 'gradorig'): rank_matrix = g[i + pos] if (options.ROAR == 1): v = np.argsort(rank_matrix, axis=None)[-cfg['occlude']:] else: v = np.argsort(rank_matrix, axis=None)[:cfg['occlude']] input_data[i, :, v // 80, v % 80] = 0 else: for i in range(input_data.shape[0]): #print('random') v = np.random.choice(115 * 80, cfg['occlude'], replace=False) input_data[i, :, v // 80, v % 80] = 0 count += 1 #print('Here') #preds = np.vstack(mdl.forward(torch.from_numpy( # np.transpose(excerpts[pos:pos + batchsize,:,:, # np.newaxis],(0,3,1,2))).to(device)).cpu().detach().numpy() # for pos in range(0, num_excerpts, batchsize)) preds[pos:pos + batchsize, :] = mdl( torch.from_numpy(input_data).to( device)).cpu().detach().numpy() print('Here') predictions.append(preds) # save predictions print("Saving predictions") np.savez(outfile, **{fn: pred for fn, pred in zip(filelist, predictions)})
required=True, type=str) parser.add_argument('--export_path', dest='export_path', help='Path to a directory where the exported model will be saved.', required=True, type=str) parser.add_argument('--export_version', dest='export_version', help='Version number of the model.', required=True, type=int) parser.add_argument('--config', dest='config_file', help='Path to the configuration file.', required=True, type=str) args = parser.parse_args() return args if __name__ == '__main__': args = parse_args() print "Called with:" print pprint.pprint(args) cfg = parse_config_file(args.config_file) print "Configurations:" print pprint.pprint(cfg) export(args.checkpoint_path, args.export_path, args.export_version, cfg=cfg)
def main(): print(torch.cuda.is_available()) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # parse command line parser = opts_parser() options = parser.parse_args() modelfile = options.modelfile cfg = {} for fn in options.vars: cfg.update(config.parse_config_file(fn)) cfg.update(config.parse_variable_assignments(options.var)) outfile = options.outfile sample_rate = cfg['sample_rate'] frame_len = cfg['frame_len'] fps = cfg['fps'] mel_bands = cfg['mel_bands'] mel_min = cfg['mel_min'] mel_max = cfg['mel_max'] blocklen = cfg['blocklen'] batchsize = cfg['batchsize'] bin_nyquist = frame_len // 2 + 1 bin_mel_max = bin_nyquist * 2 * mel_max // sample_rate # prepare dataset print("Preparing data reading...") datadir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'datasets', options.dataset) # - load filelist with io.open(os.path.join(datadir, 'filelists', 'valid')) as f: filelist = [l.rstrip() for l in f if l.rstrip()] with io.open(os.path.join(datadir, 'filelists', 'test')) as f: filelist += [l.rstrip() for l in f if l.rstrip()] # - create generator for spectra spects = (cached( options.cache_spectra and os.path.join(options.cache_spectra, fn + '.npy'), audio.extract_spect, os.path.join(datadir, 'audio', fn), sample_rate, frame_len, fps) for fn in filelist) # - pitch-shift if needed if options.pitchshift: import scipy.ndimage spline_order = 2 spects = (scipy.ndimage.affine_transform( spect, (1, 1 / (1 + options.pitchshift / 100.)), output_shape=(len(spect), mel_max), order=spline_order) for spect in spects) # - prepare mel filterbank filterbank = audio.create_mel_filterbank(sample_rate, frame_len, mel_bands, mel_min, mel_max) filterbank = filterbank[:bin_mel_max].astype(floatX) # - define generator for mel spectra spects = (np.log( np.maximum(np.dot(spect[:, :bin_mel_max], filterbank), 1e-7)) for spect in spects) # - load mean/std meanstd_file = os.path.join(os.path.dirname(__file__), '%s_meanstd.npz' % options.dataset) with np.load(meanstd_file) as f: mean = f['mean'] std = f['std'] mean = mean.astype(floatX) istd = np.reciprocal(std).astype(floatX) # - define generator for Z-scoring spects = ((spect - mean) * istd for spect in spects) # - define generator for silence-padding pad = np.tile((np.log(1e-7) - mean) * istd, (blocklen // 2, 1)) spects = (np.concatenate((pad, spect, pad), axis=0) for spect in spects) # - we start the generator in a background thread (not required) spects = augment.generate_in_background([spects], num_cached=1) mdl = model.CNNModel() mdl.load_state_dict(torch.load(modelfile)) mdl.to(device) mdl.eval() # run prediction loop print("Predicting:") predictions = [] for spect in progress(spects, total=len(filelist), desc='File '): # naive way: pass excerpts of the size used during training # - view spectrogram memory as a 3-tensor of overlapping excerpts num_excerpts = len(spect) - blocklen + 1 excerpts = np.lib.stride_tricks.as_strided( spect, shape=(num_excerpts, blocklen, spect.shape[1]), strides=(spect.strides[0], spect.strides[0], spect.strides[1])) # - pass mini-batches through the network and concatenate results preds = np.vstack( mdl( torch.from_numpy( np.transpose( excerpts[pos:pos + batchsize, :, :, np.newaxis], ( 0, 3, 1, 2))).to(device)).cpu().detach().numpy() for pos in range(0, num_excerpts, batchsize)) predictions.append(preds) # save predictions print("Saving predictions") np.savez(outfile, **{fn: pred for fn, pred in zip(filelist, predictions)})
def main(): # parse command line parser = opts_parser() options = parser.parse_args() modelfile = options.modelfile if options.load_spectra != 'memory' and not options.cache_spectra: parser.error('option --load-spectra=%s requires --cache-spectra' % options.load_spectra) # read configuration files and immediate settings cfg = {} for fn in options.vars: cfg.update(config.parse_config_file(fn)) cfg.update(config.parse_variable_assignments(options.var)) # read some settings into local variables sample_rate = cfg['sample_rate'] frame_len = cfg['frame_len'] fps = cfg['fps'] mel_bands = cfg['mel_bands'] mel_min = cfg['mel_min'] mel_max = cfg['mel_max'] blocklen = cfg['blocklen'] batchsize = cfg['batchsize'] bin_nyquist = frame_len // 2 + 1 if cfg['filterbank'] == 'mel_learn': bin_mel_max = bin_nyquist else: bin_mel_max = bin_nyquist * 2 * mel_max // sample_rate # prepare dataset datadir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'datasets', options.dataset) # - load filelist with io.open( os.path.join(datadir, 'filelists', cfg.get('filelist.train', 'train'))) as f: filelist = [l.rstrip() for l in f if l.rstrip()] if options.validate: with io.open( os.path.join(datadir, 'filelists', cfg.get('filelist.valid', 'valid'))) as f: filelist_val = [l.rstrip() for l in f if l.rstrip()] filelist.extend(filelist_val) else: filelist_val = [] # - compute spectra print("Computing%s spectra..." % (" or loading" if options.cache_spectra else "")) spects = [] for fn in progress(filelist, 'File '): cache_fn = (options.cache_spectra and os.path.join(options.cache_spectra, fn + '.npy')) spects.append( cached(cache_fn, audio.extract_spect, os.path.join(datadir, 'audio', fn), sample_rate, frame_len, fps, loading_mode=options.load_spectra)) # - load and convert corresponding labels print("Loading labels...") labels = [] for fn, spect in zip(filelist, spects): fn = os.path.join(datadir, 'labels', fn.rsplit('.', 1)[0] + '.lab') with io.open(fn) as f: segments = [l.rstrip().split() for l in f if l.rstrip()] segments = [(float(start), float(end), label == 'sing') for start, end, label in segments] timestamps = np.arange(len(spect)) / float(fps) labels.append(create_aligned_targets(segments, timestamps, np.bool)) # - split off validation data, if needed if options.validate: spects_val = spects[-len(filelist_val):] spects = spects[:-len(filelist_val)] labels_val = labels[-len(filelist_val):] labels = labels[:-len(filelist_val)] # - prepare training data generator print("Preparing training data feed...") if not options.augment: # Without augmentation, we just create a generator that returns # mini-batches of random excerpts batches = augment.grab_random_excerpts(spects, labels, batchsize, blocklen, bin_mel_max) batches = augment.generate_in_background([batches], num_cached=15) else: # For time stretching and pitch shifting, it pays off to preapply the # spline filter to each input spectrogram, so it does not need to be # applied to each mini-batch later. spline_order = cfg['spline_order'] if spline_order > 1 and options.load_spectra == 'memory': from scipy.ndimage import spline_filter spects = [ spline_filter(spect, spline_order).astype(floatX) for spect in spects ] prefiltered = True else: prefiltered = False # We define a function to create the mini-batch generator. This allows # us to easily create multiple generators for multithreading if needed. def create_datafeed(spects, labels): # With augmentation, as we want to apply random time-stretching, # we request longer excerpts than we finally need to return. max_stretch = cfg['max_stretch'] batches = augment.grab_random_excerpts( spects, labels, batchsize=batchsize, frames=int(blocklen / (1 - max_stretch))) # We wrap the generator in another one that applies random time # stretching and pitch shifting, keeping a given number of frames # and bins only. max_shift = cfg['max_shift'] batches = augment.apply_random_stretch_shift( batches, max_stretch, max_shift, keep_frames=blocklen, keep_bins=bin_mel_max, order=spline_order, prefiltered=prefiltered) # We apply random frequency filters max_db = cfg['max_db'] batches = augment.apply_random_filters(batches, mel_max, max_db) # We apply random loudness changes max_loudness = cfg['max_loudness'] if max_loudness: batches = augment.apply_random_loudness(batches, max_loudness) return batches # We start the mini-batch generator and augmenter in one or more # background threads or processes (unless disabled). bg_threads = cfg['bg_threads'] bg_processes = cfg['bg_processes'] if not bg_threads and not bg_processes: # no background processing: just create a single generator batches = create_datafeed(spects, labels) elif bg_threads: # multithreading: create a separate generator per thread batches = augment.generate_in_background( [create_datafeed(spects, labels) for _ in range(bg_threads)], num_cached=bg_threads * 5) elif bg_processes: # multiprocessing: single generator is forked along with processes batches = augment.generate_in_background( [create_datafeed(spects, labels)] * bg_processes, num_cached=bg_processes * 25, in_processes=True) print("Preparing training function...") # instantiate neural network input_var = T.tensor3('input') inputs = input_var.dimshuffle(0, 'x', 1, 2) # insert "channels" dimension network = model.architecture(inputs, (None, 1, blocklen, bin_mel_max), cfg) print( "- %d layers (%d with weights), %f mio params" % (len(lasagne.layers.get_all_layers(network)), sum(hasattr(l, 'W') for l in lasagne.layers.get_all_layers(network)), lasagne.layers.count_params(network, trainable=True) / 1e6)) print("- weight shapes: %r" % [ l.W.get_value().shape for l in lasagne.layers.get_all_layers(network) if hasattr(l, 'W') and hasattr(l.W, 'get_value') ]) # create cost expression target_var = T.vector('targets') targets = (0.02 + 0.96 * target_var) # map 0 -> 0.02, 1 -> 0.98 targets = targets.dimshuffle(0, 'x') # turn into column vector outputs = lasagne.layers.get_output(network, deterministic=False) cost = T.mean(lasagne.objectives.binary_crossentropy(outputs, targets)) if cfg.get('l2_decay', 0): cost_l2 = lasagne.regularization.regularize_network_params( network, lasagne.regularization.l2) * cfg['l2_decay'] else: cost_l2 = 0 # prepare and compile training function params = lasagne.layers.get_all_params(network, trainable=True) initial_eta = cfg['initial_eta'] eta_decay = cfg['eta_decay'] eta_decay_every = cfg.get('eta_decay_every', 1) patience = cfg.get('patience', 0) trials_of_patience = cfg.get('trials_of_patience', 1) patience_criterion = cfg.get( 'patience_criterion', 'valid_loss' if options.validate else 'train_loss') momentum = cfg['momentum'] first_params = params[:cfg['first_params']] first_params_eta_scale = cfg['first_params_eta_scale'] if cfg['learn_scheme'] == 'nesterov': learn_scheme = lasagne.updates.nesterov_momentum elif cfg['learn_scheme'] == 'momentum': learn_scheme = lasagne.update.momentum elif cfg['learn_scheme'] == 'adam': learn_scheme = lasagne.updates.adam else: raise ValueError('Unknown learn_scheme=%s' % cfg['learn_scheme']) eta = theano.shared(lasagne.utils.floatX(initial_eta)) if not first_params or first_params_eta_scale == 1: updates = learn_scheme(cost + cost_l2, params, eta, momentum) else: grads = theano.grad(cost + cost_l2, params) updates = learn_scheme(grads[len(first_params):], params[len(first_params):], eta, momentum) if first_params_eta_scale > 0: updates.update( learn_scheme(grads[:len(first_params)], first_params, eta * first_params_eta_scale, momentum)) print("Compiling training function...") train_fn = theano.function([input_var, target_var], cost, updates=updates) # prepare and compile validation function, if requested if options.validate: print("Compiling validation function...") import model_to_fcn network_test = model_to_fcn.model_to_fcn(network, allow_unlink=False) outputs_test = lasagne.layers.get_output(network_test, deterministic=True) cost_test = T.mean( lasagne.objectives.binary_crossentropy(outputs_test, targets)) val_fn = theano.function([input_var, target_var], [cost_test, outputs_test]) # run training loop print("Training:") epochs = cfg['epochs'] epochsize = cfg['epochsize'] batches = iter(batches) if options.save_errors: errors = [] if first_params and cfg['first_params_log']: first_params_hist = [] if patience > 0: best_error = np.inf best_state = get_state(network, updates) for epoch in range(epochs): # actual training err = 0 for batch in progress(range(epochsize), min_delay=.5, desc='Epoch %d/%d: Batch ' % (epoch + 1, epochs)): err += train_fn(*next(batches)) if not np.isfinite(err): print("\nEncountered NaN loss in training. Aborting.") sys.exit(1) if first_params and cfg['first_params_log'] and ( batch % cfg['first_params_log'] == 0): first_params_hist.append( tuple(param.get_value() for param in first_params)) np.savez( modelfile[:-4] + '.hist.npz', **{ 'param%d' % i: param for i, param in enumerate(zip(*first_params_hist)) }) # report training loss print("Train loss: %.3f" % (err / epochsize)) if options.save_errors: errors.append(err / epochsize) # compute and report validation loss, if requested if options.validate: val_err = 0 preds = [] max_len = int(fps * cfg.get('val.max_len', 30)) for spect, label in zip(spects_val, labels_val): # pick excerpt of val.max_len seconds in center of file excerpt = slice(max(0, (len(spect) - max_len) // 2), (len(spect) + max_len) // 2) # crop to maximum length and required spectral bins spect = spect[None, excerpt, :bin_mel_max] # crop to maximum length and remove edges lost in the network label = label[excerpt][blocklen // 2:-(blocklen // 2)] e, pred = val_fn(spect, label) val_err += e preds.append((pred[:, 0], label)) print("Validation loss: %.3f" % (val_err / len(filelist_val))) from eval import evaluate _, results = evaluate(*zip(*preds)) print("Validation error: %.3f" % (1 - results['accuracy'])) if options.save_errors: errors.append(val_err / len(filelist_val)) errors.append(1 - results['accuracy']) # update learning rate and/or apply early stopping, if needed if patience > 0: if patience_criterion == 'train_loss': cur_error = err / epochsize elif patience_criterion == 'valid_loss': cur_error = val_err / len(filelist_val) elif patience_criterion == 'valid_error': cur_error = 1 - results['accuracy'] if cur_error <= best_error: best_error = cur_error best_state = get_state(network, updates) patience = cfg['patience'] else: patience -= 1 if patience == 0: if eta_decay_every == 'trial_of_patience' and eta_decay != 1: eta.set_value(eta.get_value() * lasagne.utils.floatX(eta_decay)) restore_state(network, updates, best_state) patience = cfg['patience'] trials_of_patience -= 1 print("Lost patience (%d remaining trials)." % trials_of_patience) if trials_of_patience == 0: break if eta_decay_every != 'trial_of_patience' and eta_decay != 1 and \ (epoch + 1) % eta_decay_every == 0: eta.set_value(eta.get_value() * lasagne.utils.floatX(eta_decay)) # save final network print("Saving final model") np.savez( modelfile, **{ 'param%d' % i: p for i, p in enumerate(lasagne.layers.get_all_param_values(network)) }) with io.open(modelfile + '.vars', 'wb') as f: f.writelines('%s=%s\n' % kv for kv in cfg.items()) if options.save_errors: np.savez(modelfile[:-len('.npz')] + '.err.npz', np.asarray(errors).reshape(epoch + 1, -1))
def main(): # parse command line parser = opts_parser() options = parser.parse_args() modelfile = options.modelfile # read configuration files and immediate settings cfg = {} for fn in options.vars: cfg.update(config.parse_config_file(fn)) cfg.update(config.parse_variable_assignments(options.var)) # prepare dataset datadir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'datasets', options.dataset) print("Preparing training data feed...") with io.open(os.path.join(datadir, 'filelists', 'train')) as f: filelist = [l.rstrip() for l in f if l.rstrip()] train_feed, train_formats = data.prepare_datafeed(filelist, datadir, 'train', cfg) # If told so, we plot some mini-batches on screen. if cfg.get('plot_datafeed'): import matplotlib.pyplot as plt for batch in data.run_datafeed(train_feed, cfg): plt.matshow(np.log(batch['spect'][0]).T, aspect='auto', origin='lower', cmap='hot', interpolation='nearest') plt.colorbar() plt.title(str(batch['label'][0])) plt.show() # We start the mini-batch generator and augmenter in one or more # background threads or processes (unless disabled). bg_threads = cfg['bg_threads'] bg_processes = cfg['bg_processes'] if not bg_threads and not bg_processes: # no background processing: just create a single generator batches = data.run_datafeed(train_feed, cfg) elif bg_threads: # multithreading: create a separate generator per thread batches = augment.generate_in_background([ data.run_datafeed(feed, cfg) for feed in data.split_datafeed(train_feed, bg_threads, cfg) ], num_cached=bg_threads * 2) elif bg_processes: # multiprocessing: single generator is forked along with processes batches = augment.generate_in_background( [data.run_datafeed(train_feed, cfg)] * bg_processes, num_cached=bg_processes * 25, in_processes=True) # If told so, we benchmark the creation of a given number of mini-batches. if cfg.get('benchmark_datafeed'): print("Benchmark: %d mini-batches of %d items " % (cfg['benchmark_datafeed'], cfg['batchsize']), end='') if bg_threads: print("(in %d threads): " % bg_threads) elif bg_processes: print("(in %d processes): " % bg_processes) else: print("(in main thread): ") import time import itertools t0 = time.time() next( itertools.islice(batches, cfg['benchmark_datafeed'], cfg['benchmark_datafeed']), None) t1 = time.time() print(t1 - t0) return # - prepare validation data generator if options.validate: print("Preparing validation data feed...") with io.open(os.path.join(datadir, 'filelists', 'valid')) as f: filelist_val = [l.rstrip() for l in f if l.rstrip()] val_feed, val_formats = data.prepare_datafeed(filelist_val, datadir, 'valid', cfg) if bg_threads or bg_processes: multi = bg_threads or bg_processes val_feed = data.split_datafeed(val_feed, multi, cfg) def run_val_datafeed(): if bg_threads or bg_processes: return augment.generate_in_background( [data.run_datafeed(feed, cfg) for feed in val_feed], num_cached=multi, in_processes=bool(bg_processes)) else: return data.run_datafeed(val_feed, cfg) print("Preparing training function...") # instantiate neural network input_vars = { name: T.TensorType(str(np.dtype(dtype)), (False, ) * len(shape))(name) for name, (dtype, shape) in train_formats.items() } input_shapes = { name: shape for name, (dtype, shape) in train_formats.items() } network = model.architecture(input_vars, input_shapes, cfg) print( "- %d layers (%d with weights), %f mio params" % (len(lasagne.layers.get_all_layers(network)), sum(hasattr(l, 'W') for l in lasagne.layers.get_all_layers(network)), lasagne.layers.count_params(network, trainable=True) / 1e6)) print("- weight shapes: %r" % [ l.W.get_value().shape for l in lasagne.layers.get_all_layers(network) if hasattr(l, 'W') and hasattr(l.W, 'get_value') ]) cost_vars = dict(input_vars) # prepare for born-again-network, if needed if cfg.get('ban'): network2 = model.architecture(input_vars, input_shapes, cfg) with np.load(cfg['ban'], encoding='latin1') as f: lasagne.layers.set_all_param_values( network2, [f['param%d' % i] for i in range(len(f.files))]) cost_vars['pseudo_label'] = lasagne.layers.get_output( network2, deterministic=True) # load pre-trained weights, if needed if cfg.get('init_from'): param_values = [] for fn in cfg['init_from'].split(':'): with np.load(fn, encoding='latin1') as f: param_values.extend(f['param%d' % i] for i in range(len(f.files))) lasagne.layers.set_all_param_values(network, param_values) del param_values # create cost expression outputs = lasagne.layers.get_output(network, deterministic=False) cost = T.mean(model.cost(outputs, cost_vars, 'train', cfg)) if cfg.get('l2_decay', 0): cost_l2 = lasagne.regularization.regularize_network_params( network, lasagne.regularization.l2) * cfg['l2_decay'] else: cost_l2 = 0 # prepare and compile training function params = lasagne.layers.get_all_params(network, trainable=True) initial_eta = cfg['initial_eta'] eta_decay = cfg['eta_decay'] eta_decay_every = cfg.get('eta_decay_every', 1) eta_cycle = tuple(map(float, str(cfg['eta_cycle']).split(':'))) if eta_cycle == (0, ): eta_cycle = (1, ) # so eta_cycle=0 equals disabling it patience = cfg.get('patience', 0) trials_of_patience = cfg.get('trials_of_patience', 1) patience_criterion = cfg.get( 'patience_criterion', 'valid_loss' if options.validate else 'train_loss') momentum = cfg['momentum'] first_params = params[:cfg['first_params']] first_params_eta_scale = cfg['first_params_eta_scale'] if cfg['learn_scheme'] == 'nesterov': learn_scheme = lasagne.updates.nesterov_momentum elif cfg['learn_scheme'] == 'momentum': learn_scheme = lasagne.update.momentum elif cfg['learn_scheme'] == 'adam': learn_scheme = lasagne.updates.adam else: raise ValueError('Unknown learn_scheme=%s' % cfg['learn_scheme']) eta = theano.shared(lasagne.utils.floatX(initial_eta)) if not first_params or first_params_eta_scale == 1: updates = learn_scheme(cost + cost_l2, params, eta, momentum) else: grads = theano.grad(cost + cost_l2, params) updates = learn_scheme(grads[len(first_params):], params[len(first_params):], eta, momentum) if first_params_eta_scale > 0: updates.update( learn_scheme(grads[:len(first_params)], first_params, eta * first_params_eta_scale, momentum)) print("Compiling training function...") train_fn = theano.function(list(input_vars.values()), cost, updates=updates, on_unused_input='ignore') # prepare and compile validation function, if requested if options.validate: print("Compiling validation function...") outputs_test = lasagne.layers.get_output(network, deterministic=True) cost_test = T.mean(model.cost(outputs_test, input_vars, 'valid', cfg)) if isinstance(outputs_test, (list, tuple)): outputs_test = outputs_test[0] val_fn = theano.function([input_vars[k] for k in val_formats], [cost_test, outputs_test], on_unused_input='ignore') # restore previous training state, or create fresh training state state = {} if options.keep_state: statefile = modelfile[:-len('.npz')] + '.state' if os.path.exists(statefile): print("Restoring training state...") state = np.load(modelfile[:-len('.npz')] + '.state', encoding='latin1') restore_state(network, updates, state['network']) epochs = cfg['epochs'] epochsize = cfg['epochsize'] batches = iter(batches) if options.save_errors: errors = state.get('errors', []) if first_params and cfg['first_params_log']: first_params_hist = [] if options.keep_state and os.path.exists(modelfile[:-4] + '.hist.npz'): with np.load(modelfile[:-4] + '.hist.npz') as f: first_params_hist = list( zip(*(f['param%d' % i] for i in range(len(first_params))))) if patience > 0: best_error = state.get('best_error', np.inf) best_state = state.get('best_state') or get_state(network, updates) patience = state.get('patience', patience) trials_of_patience = state.get('trials_of_patience', trials_of_patience) epoch = state.get('epoch', 0) del state # run training loop print("Training:") for epoch in range(epoch, epochs): # actual training err = 0 for batch in progress(range(epochsize), min_delay=.5, desc='Epoch %d/%d: Batch ' % (epoch + 1, epochs)): err += train_fn(**next(batches)) if not np.isfinite(err): print("\nEncountered NaN loss in training. Aborting.") sys.exit(1) if first_params and cfg['first_params_log'] and ( batch % cfg['first_params_log'] == 0): first_params_hist.append( tuple(param.get_value() for param in first_params)) np.savez( modelfile[:-4] + '.hist.npz', **{ 'param%d' % i: param for i, param in enumerate(zip(*first_params_hist)) }) # report training loss print("Train loss: %.3f" % (err / epochsize)) if options.save_errors: errors.append(err / epochsize) # compute and report validation loss, if requested if options.validate: import time t0 = time.time() # predict in mini-batches val_err = 0 val_batches = 0 preds = [] truth = [] for batch in run_val_datafeed(): e, p = val_fn(**batch) val_err += np.sum(e) val_batches += 1 preds.append(p) truth.append(batch['label']) t1 = time.time() # join mini-batches preds = np.concatenate(preds) if len(preds) > 1 else preds[0] truth = np.concatenate(truth) if len(truth) > 1 else truth[0] # show results print("Validation loss: %.3f" % (val_err / val_batches)) from eval import evaluate results = evaluate(preds, truth) print("Validation error: %.3f" % (1 - results['accuracy'])) print("Validation MAP: %.3f" % results['map']) print("(took %.2f seconds)" % (t1 - t0)) if options.save_errors: errors.append(val_err / val_batches) errors.append(1 - results['accuracy']) errors.append(results['map']) # update learning rate and/or apply early stopping, if needed if patience > 0: if patience_criterion == 'train_loss': cur_error = err / epochsize elif patience_criterion == 'valid_loss': cur_error = val_err / val_batches elif patience_criterion == 'valid_error': cur_error = 1 - results['accuracy'] elif patience_criterion == 'valid_map': cur_error = 1 - results['map'] if cur_error <= best_error: best_error = cur_error best_state = get_state(network, updates) patience = cfg['patience'] else: patience -= 1 if patience == 0: if eta_decay_every == 'trial_of_patience' and eta_decay != 1: eta.set_value(eta.get_value() * lasagne.utils.floatX(eta_decay)) restore_state(network, updates, best_state) patience = cfg['patience'] trials_of_patience -= 1 print("Lost patience (%d remaining trials)." % trials_of_patience) if trials_of_patience == 0: break if eta_decay_every != 'trial_of_patience' and eta_decay != 1 and \ (epoch + 1) % eta_decay_every == 0: eta.set_value(eta.get_value() * lasagne.utils.floatX(eta_decay)) if eta_cycle[epoch % len(eta_cycle)] != 1: eta.set_value( eta.get_value() * lasagne.utils.floatX(eta_cycle[epoch % len(eta_cycle)])) # store current training state, if needed if options.keep_state: state = {} state['epoch'] = epoch + 1 state['network'] = get_state(network, updates) if options.save_errors: state['errors'] = errors if patience > 0: state['best_error'] = best_error state['best_state'] = best_state state['patience'] = patience state['trials_of_patience'] = trials_of_patience with open(statefile, 'wb') as f: pickle.dump(state, f, -1) del state # for debugging: print memory use and break into debugger #import resource, psutil #print("Memory usage: %.3f MiB / %.3f MiB" % # (resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024., # psutil.Process().memory_info()[0] / float(1024**2))) #import pdb; pdb.set_trace() # save final network print("Saving final model") save_model(modelfile, network, cfg) if options.save_errors: np.savez(modelfile[:-len('.npz')] + '.err.npz', np.asarray(errors).reshape(epoch + 1, -1))
db_query = '' for key, value in kwargs.iteritems(): db_query += "%s='%s' " % (key, value) try: conn = psycopg2.connect(db_query) cursor = conn.cursor() print "Opened database successfully" except: print "I am unable to connect to the database" return True def db_create(): cursor.execute('''CREATE TABLE HOSTEL (ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, PLACES INT NOT NULL, ADDRESS CHAR(50), PRICE REAL);''') print "Table created successfully" kwargs = parse_config_file("db_access") PostgreSQLCRUD.db_connect(**kwargs) PostgreSQLCRUD.db_create() # conn.commit() # conn.close()
def main(): # parse command line parser = opts_parser() options = parser.parse_args() modelfile = options.modelfile outfile = options.outfile if options.split_pool and options.saliency: parser.error("--split-pool and --saliency cannot be combined.") # read configuration files and immediate settings cfg = {} if os.path.exists(modelfile + '.vars'): options.vars.insert(1, modelfile + '.vars') for fn in options.vars: cfg.update(config.parse_config_file(fn)) cfg.update(config.parse_variable_assignments(options.var)) # read some settings into local variables fps = cfg['fps'] len_min = cfg['len_min'] len_max = cfg['len_max'] # prepare dataset print("Preparing data reading...") datadir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'datasets', options.dataset) # - load filelists filelist = [] for d in options.filelists.split(','): with io.open(os.path.join(datadir, 'filelists', d)) as f: filelist.extend(l.rstrip() for l in f if l.rstrip()) # - create data feed feed, input_formats = data.prepare_datafeed(filelist, datadir, 'test', cfg) # - we start the generator in a background thread if not options.plot: batches = augment.generate_in_background([data.run_datafeed(feed, cfg)], num_cached=1) else: # unless we're plotting; this would mess up the progress counter batches = data.run_datafeed(feed, cfg) print("Preparing prediction function...") # instantiate neural network input_vars = {name: T.TensorType(str(np.dtype(dtype)), (False,) * len(shape))(name) for name, (dtype, shape) in input_formats.items()} input_shapes = {name: shape for name, (dtype, shape) in input_formats.items()} network = model.architecture(input_vars, input_shapes, cfg) if isinstance(network, list) and not options.include_side_outputs: network = network[0] # only use the main output # load saved weights with np.load(modelfile, encoding='latin1') as f: lasagne.layers.set_all_param_values( network, [f['param%d' % i] for i in range(len(f.files))]) # insert guided backprop, if needed for saliency if options.saliency: from gbprop import replace_nonlinearities replace_nonlinearities(network, lasagne.nonlinearities.leaky_rectify) # create output expression(s) if options.split_pool: network_end = network network = next(l for l in lasagne.layers.get_all_layers(network)[::-1] if l.name == 'before_pool') outputs = lasagne.layers.get_output(network, deterministic=True) if options.split_pool: split_input_var = T.tensor4('input2') split_outputs = lasagne.layers.get_output( network_end, {network: split_input_var}, deterministic=True) split_input_vars = [v for v in theano.gof.graph.inputs([split_outputs]) if not isinstance(v, theano.compile.SharedVariable) and not isinstance(v, theano.tensor.Constant)] # create saliency map expression, if needed if options.saliency: saliency = theano.grad(outputs[:, options.saliency].sum(), input_vars['spect']) outputs = outputs + [saliency] if isinstance(outputs, list) else [outputs, saliency] # prepare and compile prediction function print("Compiling prediction function...") test_fn = theano.function(list(input_vars.values()), outputs, on_unused_input='ignore') if options.split_pool: pool_fn = theano.function(split_input_vars, split_outputs, on_unused_input='ignore') # prepare plotting, if needed if options.plot: import matplotlib if os.environ.get('MPLBACKEND'): matplotlib.use(os.environ['MPLBACKEND']) # for old versions import matplotlib.pyplot as plt with open(os.path.join(datadir, 'labels', 'labelset'), 'rb') as f: labelset = [l.rstrip('\r\n') for l in f] # run prediction loop print("Predicting:") predictions = [] for batch in batches: spect = batch.pop('spect') if spect.shape[-2] <= len_max * fps or len_max == 0: # predict on full spectrogram at once preds = test_fn(spect=spect, **batch) else: # predict in segments of len_max, with overlap len_min # drop any reminder shorter than len_min (len_max if len_min == 0) preds = [test_fn(spect=spect[..., pos:pos + len_max * fps, :], **batch) for pos in range(0, (spect.shape[-2] + 1 - (len_min or len_max) * fps), (len_max - len_min) * fps)] if isinstance(preds[0], list): preds = [np.concatenate(p, axis=2 if p[0].ndim > 2 else 0) for p in zip(*preds)] else: preds = np.concatenate(preds, axis=2 if preds[0].ndim > 2 else 0) if cfg['arch.pool'] == 'none' or '_nopool' in cfg['arch.pool']: if isinstance(preds, list): preds = [p[0, :, :, 0].T if p.ndim == 4 else p for p in preds] else: preds = preds[0, :, :, 0].T elif options.split_pool: preds = pool_fn(preds, **batch) predictions.append(preds) if options.plot: if spect.ndim == 4: spect = spect[0] # remove batch axis if spect.ndim == 3: spect = spect[0] # remove channel axis if isinstance(preds, list): preds, sides = preds[0], preds[1:] else: sides = [] fig, axs = plt.subplots(2 + len(sides), 1, sharex=True) axs[0].imshow(np.log1p(1e-3 * spect).T[::-1], cmap='hot', aspect='auto', interpolation='nearest') K = 5 top_k = lme(preds, axis=0).argpartition(preds.shape[1] - 1 - np.arange(K))[::-1][:K] #top_k = (preds * softmax(sides[0], axis=0).mean(axis=1, keepdims=True)).sum(axis=0).argpartition(preds.shape[1] - 1 - np.arange(K))[::-1][:K] #top_k = softmax(preds, axis=-1).max(axis=0).argpartition(preds.shape[1] - 1 - np.arange(K))[::-1][:K] #top_k[-1] = labelset.index('mphbjm') preds = softmax(preds, axis=-1) x = np.arange(len(preds)) * (len(spect) / float(len(preds))) for k in top_k: axs[1].plot(x, preds[:, k], label=labelset[k]) #axs[1].set_ylim(0, 1.1) axs[1].legend(loc='best') for side, ax in zip(sides, axs[2:]): side = softmax(side, axis=0) ax.plot(x, side) plt.show() # save predictions print("Saving predictions") predictions = dict(zip(filelist, predictions)) if outfile.endswith('.pkl'): try: import cPickle as pickle except ImportError: import pickle with io.open(outfile, 'wb') as f: pickle.dump(predictions, f, protocol=-1) else: np.savez(outfile, **predictions)
import time import pynput import pynput.keyboard as keyboard from pynput.keyboard import Key import pyperclip import os import win32clipboard import shutil from config import parse_config_file controller = keyboard.Controller() capture_keys = True config = parse_config_file() # 1. F2 (optional) # 2. Type what is in clipboard # 3. Enter (*) def do_paste_magic(): capture_keys = False controller.release(Key.ctrl_l) time.sleep(0.01) if config['RENAME_PRESS_F2']: press_f2() time.sleep(0.01) time.sleep(0.01) type_string(get_clipboard_text(remove_newline=True) + config['TEXT']) if config['RENAME_PRESS_ENTER']: time.sleep(0.01)
def main(): # parse command line parser = opts_parser() options = parser.parse_args() modelfile = options.modelfile outfile = options.outfile # read configuration files and immediate settings cfg = {} if os.path.exists(modelfile + '.vars'): options.vars.insert(1, modelfile + '.vars') for fn in options.vars: cfg.update(config.parse_config_file(fn)) cfg.update(config.parse_variable_assignments(options.var)) # read some settings into local variables sample_rate = cfg['sample_rate'] frame_len = cfg['frame_len'] fps = cfg['fps'] mel_bands = cfg['mel_bands'] mel_min = cfg['mel_min'] mel_max = cfg['mel_max'] blocklen = cfg['blocklen'] batchsize = cfg['batchsize'] bin_nyquist = frame_len // 2 + 1 bin_mel_max = bin_nyquist * 2 * mel_max // sample_rate # prepare dataset print("Preparing data reading...") datadir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'datasets', options.dataset) # - load filelist filelist = [] for d in options.filelists.split(','): with io.open(os.path.join(datadir, 'filelists', d)) as f: filelist.extend(l.rstrip() for l in f if l.rstrip()) # - create generator for spectra spects = (cached( options.cache_spectra and os.path.join(options.cache_spectra, fn + '.npy'), audio.extract_spect, os.path.join(datadir, 'audio', fn), sample_rate, frame_len, fps) for fn in filelist) # - pitch-shift if needed if options.pitchshift: import scipy.ndimage spline_order = 2 spects = (scipy.ndimage.affine_transform( spect, (1, 1 / (1 + options.pitchshift / 100.)), output_shape=(len(spect), mel_max), order=spline_order) for spect in spects) # - define generator for cropped spectra spects = (spect[:, :bin_mel_max] for spect in spects) # - adjust loudness if needed if options.loudness: spects = (spect * float(10.**(options.loudness / 10.)) for spect in spects) # - define generator for silence-padding pad = np.zeros((blocklen // 2, bin_mel_max), dtype=floatX) spects = (np.concatenate((pad, spect, pad), axis=0) for spect in spects) # - we start the generator in a background thread (not required) spects = augment.generate_in_background([spects], num_cached=1) print("Preparing prediction function...") # instantiate neural network input_var = T.tensor3('input') inputs = input_var.dimshuffle(0, 'x', 1, 2) # insert "channels" dimension network = model.architecture(inputs, (None, 1, blocklen, bin_mel_max), cfg) # load saved weights with np.load(modelfile) as f: lasagne.layers.set_all_param_values( network, [f['param%d' % i] for i in range(len(f.files))]) # performant way: convert to fully-convolutional network if not options.mem_use == 'low': import model_to_fcn network = model_to_fcn.model_to_fcn(network, allow_unlink=True) # create output expression outputs = lasagne.layers.get_output(network, deterministic=True) # prepare and compile prediction function print("Compiling prediction function...") test_fn = theano.function([input_var], outputs) # run prediction loop print("Predicting:") predictions = [] for spect in progress(spects, total=len(filelist), desc='File '): if options.mem_use == 'high': # fastest way: pass full spectrogram through network at once preds = test_fn(spect[np.newaxis]) # insert batch dimension elif options.mem_use == 'mid': # performant way: pass spectrogram in equal chunks of up to one # minute, taking care to overlap by `blocklen // 2` frames and to # not pass a chunk shorter than `blocklen` frames chunks = np.ceil(len(spect) / (fps * 60.)) hopsize = int(np.ceil(len(spect) / chunks)) chunksize = hopsize + blocklen - 1 preds = np.vstack( test_fn(spect[np.newaxis, pos:pos + chunksize]) for pos in range(0, len(spect), hopsize)) else: # naive way: pass excerpts of the size used during training # - view spectrogram memory as a 3-tensor of overlapping excerpts num_excerpts = len(spect) - blocklen + 1 excerpts = np.lib.stride_tricks.as_strided( spect, shape=(num_excerpts, blocklen, spect.shape[1]), strides=(spect.strides[0], spect.strides[0], spect.strides[1])) # - pass mini-batches through the network and concatenate results preds = np.vstack( test_fn(excerpts[pos:pos + batchsize]) for pos in range(0, num_excerpts, batchsize)) predictions.append(preds) if options.plot: if spect.ndim == 3: spect = spect[0] # remove channel axis spect = spect[blocklen // 2:-blocklen // 2] # remove zero padding import matplotlib.pyplot as plt fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True) ax1.imshow(spect.T[::-1], vmin=-3, cmap='hot', aspect='auto', interpolation='nearest') ax2.plot(preds) ax2.set_ylim(0, 1.1) plt.show() # save predictions print("Saving predictions") data = dict(zip(filelist, predictions)) if outfile.endswith('.pkl'): try: import cPickle as pickle except ImportError: import pickle with io.open(outfile, 'wb') as f: pickle.dump(data, f, protocol=-1) else: np.savez(outfile, **data)
def main(): # parse command line parser = opts_parser() options = parser.parse_args() outdir = options.outdir if options.load_spectra != 'memory' and not options.cache_spectra: parser.error('option --load-spectra=%s requires --cache-spectra' % options.load_spectra) # read configuration files and immediate settings cfg = {} for fn in options.vars: cfg.update(config.parse_config_file(fn)) cfg.update(config.parse_variable_assignments(options.var)) # read some settings into local variables sample_rate = cfg['sample_rate'] frame_len = cfg['frame_len'] fps = cfg['fps'] mel_bands = cfg['mel_bands'] mel_min = cfg['mel_min'] mel_max = cfg['mel_max'] # prepare dataset datadir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'datasets', options.dataset) # - load filelist filelist = [] ranges = {} for part in 'train', 'valid', 'test': a = len(filelist) with io.open( os.path.join(datadir, 'filelists', cfg.get('filelist.%s' % part, part))) as f: filelist.extend(l.rstrip() for l in f if l.rstrip()) ranges[part] = slice(a, len(filelist)) # - compute spectra print("Computing%s spectra..." % (" or loading" if options.cache_spectra else "")) spects = [] for fn in progress(filelist, 'File '): cache_fn = (options.cache_spectra and os.path.join(options.cache_spectra, fn + '.npy')) spects.append( cached(cache_fn, audio.extract_spect, os.path.join(datadir, 'audio', fn), sample_rate, frame_len, fps, loading_mode=options.load_spectra)) # - load and convert corresponding labels print("Loading labels...") labels = [] for fn, spect in zip(filelist, spects): fn = os.path.join(datadir, 'labels', fn.rsplit('.', 1)[0] + '.lab') with io.open(fn) as f: segments = [l.rstrip().split() for l in f if l.rstrip()] segments = [(float(start), float(end), label == 'sing') for start, end, label in segments] timestamps = np.arange(len(spect)) / float(fps) labels.append(create_aligned_targets(segments, timestamps, np.bool)) # compute and save different variants of summarized magnitudes print("Saving files...") # - ground truth outfile = os.path.join(outdir, '%s_gt.pkl' % options.dataset) print(outfile) with io.open(outfile, 'wb') as f: pickle.dump({'labels': labels, 'splits': ranges}, f, protocol=-1) # - summarized spectra save_spectral_sums( os.path.join(outdir, '%s_spect_sum.pkl' % options.dataset), spects) # - summarized mel spectra bank = audio.create_mel_filterbank(sample_rate, frame_len, mel_bands, mel_min, mel_max).astype(np.float32) spects = [np.dot(spect[:, ], bank) for spect in spects] save_spectral_sums( os.path.join(outdir, '%s_spect_mel_sum.pkl' % options.dataset), spects) # - summarized log-mel spectra spects = [np.log(np.maximum(1e-7, spect)) for spect in spects] save_spectral_sums( os.path.join(outdir, '%s_spect_mel_log_sum.pkl' % options.dataset), spects) # - summarized standardized log-mel spectra m, s = znorm.compute_mean_std(spects[ranges['train']], axis=0) spects = [((spect - m) / s).astype(np.float32) for spect in spects] save_spectral_sums( os.path.join(outdir, '%s_spect_mel_log_std_sum.pkl' % options.dataset), spects)
def main(): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # parse command line parser = opts_parser() options = parser.parse_args() modelfile = options.modelfile cfg = {} print(options.vars) for fn in options.vars: cfg.update(config.parse_config_file(fn)) cfg.update(config.parse_variable_assignments(options.var)) sample_rate = cfg['sample_rate'] frame_len = cfg['frame_len'] fps = cfg['fps'] mel_bands = cfg['mel_bands'] mel_min = cfg['mel_min'] mel_max = cfg['mel_max'] blocklen = cfg['blocklen'] batchsize = cfg['batchsize'] bin_nyquist = frame_len // 2 + 1 bin_mel_max = bin_nyquist * 2 * mel_max // sample_rate # prepare dataset datadir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'datasets', options.dataset) meanstd_file = os.path.join(os.path.dirname(__file__), '%s_meanstd.npz' % options.dataset) if (options.input_type == 'audio'): dataloader = DatasetLoader(options.dataset, options.cache_spectra, datadir, input_type=options.input_type) batches = dataloader.prepare_audio_batches(sample_rate, frame_len, fps, blocklen, batchsize) else: dataloader = DatasetLoader(options.dataset, options.cache_spectra, datadir, input_type=options.input_type) batches = dataloader.prepare_batches(sample_rate, frame_len, fps, mel_bands, mel_min, mel_max, blocklen, batchsize) validation_data = DatasetLoader(options.dataset, '../ismir2015/experiments/mel_data/', datadir, dataset_split='valid', input_type='mel_spects') mel_spects_val, labels_val = validation_data.prepare_batches( sample_rate, frame_len, fps, mel_bands, mel_min, mel_max, blocklen, batchsize, batch_data=False) mdl = model.CNNModel(model_type=options.model_type, input_type=options.input_type, is_zeromean=False, sample_rate=sample_rate, frame_len=frame_len, fps=fps, mel_bands=mel_bands, mel_min=mel_min, mel_max=mel_max, bin_mel_max=bin_mel_max, meanstd_file=meanstd_file, device=device) mdl = mdl.to(device) #Setting up learning rate and learning rate parameters initial_eta = cfg['initial_eta'] eta_decay = cfg['eta_decay'] momentum = cfg['momentum'] eta_decay_every = cfg.get('eta_decay_every', 1) eta = initial_eta #set up loss criterion = torch.nn.BCELoss() #set up optimizer optimizer = torch.optim.SGD(mdl.parameters(), lr=eta, momentum=momentum, nesterov=True) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=eta_decay_every, gamma=eta_decay) #set up optimizer writer = SummaryWriter(os.path.join(modelfile, 'runs')) epochs = cfg['epochs'] epochsize = cfg['epochsize'] batches = iter(batches) #conditions to save model best_val_loss = 100000. best_val_error = 1. for epoch in range(epochs): # - Initialize certain parameters that are used to monitor training err = 0 total_norm = 0 loss_accum = 0 mdl.train(True) # - Compute the L-2 norm of the gradients for p in mdl.parameters(): if p.grad is not None: param_norm = p.grad.data.norm(2) total_norm += param_norm.item()**2 total_norm = total_norm**(1. / 2) # - Start the training for this epoch for batch in progress(range(epochsize), min_delay=0.5, desc='Epoch %d/%d: Batch ' % (epoch + 1, epochs)): data = next(batches) if (options.input_type == 'audio' or options.input_type == 'stft'): input_data = data[0] else: input_data = np.transpose(data[0][:, :, :, np.newaxis], (0, 3, 1, 2)) labels = data[1][:, np.newaxis].astype(np.float32) #map labels to make them softer if not options.adversarial_training: labels = (0.02 + 0.96 * labels) optimizer.zero_grad() if (options.adversarial_training): mdl.train(False) if (options.input_type == 'stft'): input_data_adv = attacks.PGD( mdl, torch.from_numpy(input_data).to(device), target=torch.from_numpy(labels).to(device), eps=cfg['eps'], step_size=cfg['eps_iter'], iterations=cfg['nb_iter'], use_best=True, random_start=True, clip_min=0, clip_max=1e8).cpu().detach().numpy() else: input_data_adv = attacks.PGD( mdl, torch.from_numpy(input_data).to(device), target=torch.from_numpy(labels).to(device), eps=cfg['eps'], step_size=cfg['eps_iter'], iterations=cfg['nb_iter'], use_best=True, random_start=True).cpu().detach().numpy() mdl.train(True) optimizer.zero_grad() outputs = mdl(torch.from_numpy(input_data_adv).to(device)) else: optimizer.zero_grad() outputs = mdl(torch.from_numpy(input_data).to(device)) #input(outputs.size()) #input(mdl.conv(torch.from_numpy(input_data).to(device)).cpu().detach().numpy().shape) loss = criterion(outputs, torch.from_numpy(labels).to(device)) loss.backward() optimizer.step() print(loss.item()) loss_accum += loss.item() # - Compute validation loss and error if desired if options.validate: mdl.input_type = 'mel_spects' from eval import evaluate mdl.train(False) val_loss = 0 preds = [] labs = [] max_len = fps num_iter = 0 for spect, label in zip(mel_spects_val, labels_val): num_excerpts = len(spect) - blocklen + 1 excerpts = np.lib.stride_tricks.as_strided( spect, shape=(num_excerpts, blocklen, spect.shape[1]), strides=(spect.strides[0], spect.strides[0], spect.strides[1])) # - Pass mini-batches through the network and concatenate results for pos in range(0, num_excerpts, batchsize): input_data = np.transpose( excerpts[pos:pos + batchsize, :, :, np.newaxis], (0, 3, 1, 2)) #if (pos+batchsize>num_excerpts): # label_batch = label[blocklen//2+pos:blocklen//2+num_excerpts, # np.newaxis].astype(np.float32) #else: # label_batch = label[blocklen//2+pos:blocklen//2+pos+batchsize, # np.newaxis].astype(np.float32) if (pos + batchsize > num_excerpts): label_batch = label[pos:num_excerpts, np.newaxis].astype(np.float32) else: label_batch = label[pos:pos + batchsize, np.newaxis].astype(np.float32) pred = mdl(torch.from_numpy(input_data).to(device)) e = criterion(pred, torch.from_numpy(label_batch).to(device)) preds = np.append(preds, pred[:, 0].cpu().detach().numpy()) labs = np.append(labs, label_batch) val_loss += e.item() num_iter += 1 mdl.input_type = options.input_type print("Validation loss: %.3f" % (val_loss / num_iter)) _, results = evaluate(preds, labs) print("Validation error: %.3f" % (1 - results['accuracy'])) if (1 - results['accuracy'] < best_val_error): torch.save(mdl.state_dict(), os.path.join(modelfile, 'model.pth')) best_val_loss = val_loss / num_iter best_val_error = 1 - results['accuracy'] print('New saved model', best_val_loss, best_val_error) #Update the learning rate scheduler.step() print('Training Loss per epoch', loss_accum / epochsize) # - Save parameters for examining writer.add_scalar('Training Loss', loss_accum / epochsize, epoch) writer.add_scalar('Validation loss', val_loss / num_iter, epoch) writer.add_scalar('Gradient norm', total_norm, epoch) writer.add_scalar('Validation error', 1 - results['accuracy']) #for param_group in optimizer.param_groups: #print(param_group['lr']) if not options.validate: torch.save(mdl.state_dict(), os.path.join(modelfile, 'model.pth')) with io.open(os.path.join(modelfile, 'model.vars'), 'w') as f: f.writelines('%s=%s\n' % kv for kv in cfg.items())
def main(): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # parse command line parser = opts_parser() options = parser.parse_args() modelfile = options.modelfile lossgradient = options.lossgradient cfg = {} print(options.vars) print('Model save file:', modelfile) print('Lossgrad file:', lossgradient) for fn in options.vars: cfg.update(config.parse_config_file(fn)) cfg.update(config.parse_variable_assignments(options.var)) sample_rate = cfg['sample_rate'] frame_len = cfg['frame_len'] fps = cfg['fps'] mel_bands = cfg['mel_bands'] mel_min = cfg['mel_min'] mel_max = cfg['mel_max'] blocklen = cfg['blocklen'] batchsize = cfg['batchsize'] print('Occluded amount:',cfg['occlude']) bin_nyquist = frame_len // 2 + 1 bin_mel_max = bin_nyquist * 2 * mel_max // sample_rate # prepare dataset datadir = os.path.join(os.path.dirname(__file__), os.path.pardir, 'datasets', options.dataset) meanstd_file = os.path.join(os.path.dirname(__file__), '%s_meanstd.npz' % options.dataset) dataloader = DatasetLoader(options.dataset, options.cache_spectra, datadir, input_type=options.input_type) batches = dataloader.prepare_batches(sample_rate, frame_len, fps, mel_bands, mel_min, mel_max, blocklen, batchsize) validation_data = DatasetLoader(options.dataset, '../ismir2015/experiments/mel_data/', datadir, dataset_split='valid', input_type='mel_spects') mel_spects_val, labels_val = validation_data.prepare_batches(sample_rate, frame_len, fps, mel_bands, mel_min, mel_max, blocklen, batchsize, batch_data=False) with np.load(meanstd_file) as f: mean = f['mean'] std = f['std'] mean = mean.astype(floatX) istd = np.reciprocal(std).astype(floatX) if(options.input_type=='mel_spects'): mdl = model.CNNModel(input_type='mel_spects_norm', is_zeromean=False, sample_rate=sample_rate, frame_len=frame_len, fps=fps, mel_bands=mel_bands, mel_min=mel_min, mel_max=mel_max, bin_mel_max=bin_mel_max, meanstd_file=meanstd_file, device=device) if(lossgradient!='None'): mdl_lossgrad = model.CNNModel(input_type=options.input_type, is_zeromean=False, sample_rate=sample_rate, frame_len=frame_len, fps=fps, mel_bands=mel_bands, mel_min=mel_min, mel_max=mel_max, bin_mel_max=bin_mel_max, meanstd_file=meanstd_file, device=device) mdl_lossgrad.load_state_dict(torch.load(lossgradient)) mdl_lossgrad.to(device) mdl_lossgrad.eval() mdl = mdl.to(device) #Setting up learning rate and learning rate parameters initial_eta = cfg['initial_eta'] eta_decay = cfg['eta_decay'] momentum = cfg['momentum'] eta_decay_every = cfg.get('eta_decay_every', 1) eta = initial_eta #set up loss criterion = torch.nn.BCELoss() #set up optimizer optimizer = torch.optim.SGD(mdl.parameters(),lr=eta,momentum=momentum,nesterov=True) #optimizer = torch.optim.Adam(mdl.parameters(), lr=eta, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False) scheduler = torch.optim.lr_scheduler.StepLR(optimizer,step_size=eta_decay_every,gamma=eta_decay) #set up optimizer writer = SummaryWriter(os.path.join(modelfile,'runs')) epochs = cfg['epochs'] epochsize = cfg['epochsize'] batches = iter(batches) #conditions to save model best_val_loss = 100000. best_val_error = 1. #loss gradient values for validation data loss_grad_val = validation_data.prepare_loss_grad_batches(options.loss_grad_save, mel_spects_val, labels_val, mdl_lossgrad, criterion, blocklen, batchsize, device) for epoch in range(epochs): # - Initialize certain parameters that are used to monitor training err = 0 total_norm = 0 loss_accum = 0 mdl.train(True) # - Compute the L-2 norm of the gradients for p in mdl.parameters(): if p.grad is not None: param_norm = p.grad.data.norm(2) total_norm += param_norm.item() ** 2 total_norm = total_norm ** (1. / 2) # - Start the training for this epoch for batch in progress(range(epochsize), min_delay=0.5,desc='Epoch %d/%d: Batch ' % (epoch+1, epochs)): data = next(batches) if(options.input_type=='audio' or options.input_type=='stft'): input_data = data[0] else: input_data = np.transpose(data[0][:,:,:,np.newaxis],(0,3,1,2)) labels = data[1][:,np.newaxis].astype(np.float32) input_data_loss = input_data if lossgradient!='None': g = loss_grad(mdl_lossgrad, torch.from_numpy(input_data_loss).to(device).requires_grad_(True), torch.from_numpy(labels).to(device), criterion) g = np.squeeze(g) input_data = (input_data-mean) * istd for i in range(batchsize): if(options.lossgrad_algorithm=='grad'): rank_matrix = np.abs(g[i]) elif(options.lossgrad_algorithm=='gradxinp'): rank_matrix = np.squeeze(g[i]*input_data[i,:,:,:]) elif(options.lossgrad_algorithm=='gradorig'): rank_matrix = g[i] v = np.argsort(rank_matrix, axis=None)[-cfg['occlude']:] input_data[i,:,v//80,v%80] = 0 else: for i in range(batchsize): #print('random') v = np.random.choice(115*80, cfg['occlude'], replace=False) input_data[i,:,v//80,v%80] = 0 input_data = input_data.astype(floatX) labels = (0.02 + 0.96*labels) optimizer.zero_grad() outputs = mdl(torch.from_numpy(input_data).to(device)) loss = criterion(outputs, torch.from_numpy(labels).to(device)) loss.backward() optimizer.step() #print(loss.item()) loss_accum += loss.item() # - Compute validation loss and error if desired if options.validate: #mdl.model_type = 'mel_spects' from eval import evaluate mdl.train(False) val_loss = 0 preds = [] labs = [] max_len = fps num_iter = 0 for spect, label, g in zip(mel_spects_val, labels_val, loss_grad_val): num_excerpts = len(spect) - blocklen + 1 excerpts = np.lib.stride_tricks.as_strided( spect, shape=(num_excerpts, blocklen, spect.shape[1]), strides=(spect.strides[0], spect.strides[0], spect.strides[1])) # - Pass mini-batches through the network and concatenate results for pos in range(0, num_excerpts, batchsize): input_data = np.transpose(excerpts[pos:pos + batchsize,:,:,np.newaxis],(0,3,1,2)) #if (pos+batchsize>num_excerpts): # label_batch = label[blocklen//2+pos:blocklen//2+num_excerpts, # np.newaxis].astype(np.float32) #else: # label_batch = label[blocklen//2+pos:blocklen//2+pos+batchsize, # np.newaxis].astype(np.float32) if (pos+batchsize>num_excerpts): label_batch = label[pos:num_excerpts, np.newaxis].astype(np.float32) else: label_batch = label[pos:pos+batchsize, np.newaxis].astype(np.float32) #input_data_loss = input_data if lossgradient!='None': #grads = loss_grad(mdl_lossgrad, torch.from_numpy(input_data_loss).to(device).requires_grad_(True), torch.from_numpy(label_batch).to(device), criterion) input_data = (input_data-mean) * istd for i in range(input_data.shape[0]): if(options.lossgrad_algorithm=='grad'): rank_matrix = np.abs(g[i]) elif(options.lossgrad_algorithm=='gradxinp'): rank_matrix = np.squeeze(g[i]*input_data[i,:,:,:]) elif(options.lossgrad_algorithm=='gradorig'): rank_matrix = g[i] v = np.argsort(np.abs(rank_matrix), axis=None)[-cfg['occlude']:] input_data[i,:,v//80,v%80] = 0 else: for i in range(input_data.shape[0]): #print('random') v = np.random.choice(115*80, cfg['occlude'], replace=False) input_data[i,:,v//80,v%80] = 0 input_data = input_data.astype(floatX) pred = mdl(torch.from_numpy(input_data).to(device)) e = criterion(pred,torch.from_numpy(label_batch).to(device)) preds = np.append(preds,pred[:,0].cpu().detach().numpy()) labs = np.append(labs,label_batch) val_loss +=e.item() num_iter+=1 #mdl.model_type = 'mel_spects_norm' print("Validation loss: %.3f" % (val_loss / num_iter)) _, results = evaluate(preds,labs) print("Validation error: %.3f" % (1 - results['accuracy'])) if(1-results['accuracy']<best_val_error): torch.save(mdl.state_dict(), os.path.join(modelfile, 'model.pth')) best_val_loss = val_loss/num_iter best_val_error = 1-results['accuracy'] print('New saved model',best_val_loss, best_val_error) #Update the learning rate scheduler.step() print('Training Loss per epoch', loss_accum/epochsize) # - Save parameters for examining writer.add_scalar('Training Loss',loss_accum/epochsize,epoch) if(options.validate): writer.add_scalar('Validation loss', val_loss/num_iter,epoch) writer.add_scalar('Gradient norm', total_norm, epoch) writer.add_scalar('Validation error', 1-results['accuracy']) #for param_group in optimizer.param_groups: #print(param_group['lr']) if not options.validate: torch.save(mdl.state_dict(), os.path.join(modelfile, 'model.pth')) with io.open(os.path.join(modelfile, 'model.vars'), 'w') as f: f.writelines('%s=%s\n' % kv for kv in cfg.items())