def convert(parser): args = parser.parse_args() torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) if params.rnn_type == 'gru' and params.rnn_act_type != 'tanh': print("ERROR: GRU does not currently support activations other than tanh") sys.exit() if params.rnn_type == 'rnn' and params.rnn_act_type != 'relu': print("ERROR: We should be using ReLU RNNs") sys.exit() print("=======================================================") for arg in vars(args): print("***%s = %s " % (arg.ljust(25), getattr(args, arg))) print("=======================================================") save_folder = args.save_folder try: os.makedirs(save_folder) except OSError as e: if e.errno == errno.EEXIST: print('Directory already exists.') else: raise with open(params.labels_path) as label_file: labels = str(''.join(json.load(label_file))) audio_conf = dict(sample_rate=params.sample_rate, window_size=params.window_size, window_stride=params.window_stride, window=params.window, noise_dir=params.noise_dir, noise_prob=params.noise_prob, noise_levels=(params.noise_min, params.noise_max)) val_batch_size = min(8,params.batch_size_val) print("Using bs={} for validation. Parameter found was {}".format(val_batch_size,params.batch_size_val)) train_dataset = SpectrogramDataset(audio_conf=audio_conf, manifest_filepath=params.train_manifest, labels=labels, normalize=True, augment=params.augment) test_dataset = SpectrogramDataset(audio_conf=audio_conf, manifest_filepath=params.val_manifest, labels=labels, normalize=True, augment=False) train_loader = AudioDataLoader(train_dataset, batch_size=params.batch_size, num_workers=(1 if params.cuda else 1)) test_loader = AudioDataLoader(test_dataset, batch_size=val_batch_size, num_workers=(1 if params.cuda else 1)) rnn_type = params.rnn_type.lower() assert rnn_type in supported_rnns, "rnn_type should be either lstm, rnn or gru" model = DeepSpeech(rnn_hidden_size = params.hidden_size, nb_layers = params.hidden_layers, labels = labels, rnn_type = supported_rnns[rnn_type], audio_conf = audio_conf, bidirectional = False, rnn_activation = params.rnn_act_type, bias = params.bias) parameters = model.parameters() if args.continue_from: print("Loading checkpoint model %s" % args.continue_from) package = torch.load(args.continue_from) model.load_state_dict(package['state_dict']) if params.cuda: model = model.cuda() if params.cuda: model = torch.nn.DataParallel(model).cuda() print(model) print("Number of parameters: %d" % DeepSpeech.get_param_size(model)) #################################################### # Begin ONNX conversion #################################################### model.train(False) # Input to the model data = next(iter(train_loader)) inputs, targets, input_percentages, target_sizes = data inputs = Variable(inputs, requires_grad=False) target_sizes = Variable(target_sizes, requires_grad=False) targets = Variable(targets, requires_grad=False) if params.cuda: inputs = inputs.cuda() x = inputs print(x.size()) # Export the model onnx_file_path = osp.join(osp.dirname(args.continue_from),osp.basename(args.continue_from).split('.')[0]+".onnx") print("Saving new ONNX model to: {}".format(onnx_file_path)) torch.onnx.export(model, # model being run inputs, # model input (or a tuple for multiple inputs) onnx_file_path, # where to save the model (can be a file or file-like object) export_params=True, # store the trained parameter weights inside the model file verbose=False)
batch_size=args.batch_size, num_replicas=args.world_size, rank=args.rank) train_loader = AudioDataLoader(train_dataset, num_workers=args.num_workers, batch_sampler=train_sampler) test_loader = AudioDataLoader(test_dataset, batch_size=args.batch_size, num_workers=args.num_workers) if (not args.no_shuffle and start_epoch != 0) or args.no_sorta_grad: print("Shuffling batches for the following epochs") train_sampler.shuffle(start_epoch) if args.cuda: model.cuda() if args.distributed: model = torch.nn.parallel.DistributedDataParallel( model, device_ids=(int(args.gpu_rank), ) if args.rank else None) print(model) print("Number of parameters: %d" % DeepSpeech.get_param_size(model)) batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() for epoch in range(start_epoch, args.epochs): model.train() end = time.time()
train_loader = AudioDataLoader(train_dataset, num_workers=args.num_workers, batch_sampler=train_sampler) test_loader = AudioDataLoader(test_dataset, batch_size=args.batch_size, num_workers=args.num_workers) if (not args.no_shuffle and start_epoch != 0) or args.no_sorta_grad: print("Shuffling batches for the following epochs") train_sampler.shuffle(start_epoch) if args.cuda and not args.distributed: model_teacher = torch.nn.DataParallel(model_teacher).cuda() model_student = torch.nn.DataParallel(model_student).cuda() elif args.cuda and args.distributed: model_teacher.cuda() model_teacher = torch.nn.parallel.DistributedDataParallel( model_teacher, device_ids=(args.gpu_rank, ) if args.rank else None) model_student.cuda() model_student = torch.nn.parallel.DistributedDataParallel( model_student, device_ids=(args.gpu_rank, ) if args.rank else None) print(model_student) print("Number of parameters: %d" % DeepSpeech.get_param_size(model_student)) batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() for epoch in range(start_epoch, args.epochs):
def train_main(args): args.distributed = args.world_size > 1 main_proc = True if args.distributed: if args.gpu_rank: torch.cuda.set_device(int(args.gpu_rank)) dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size, rank=args.rank) main_proc = args.rank == 0 # Only the first proc should save models save_folder = args.save_folder loss_results, cer_results, wer_results = torch.Tensor(args.epochs), torch.Tensor(args.epochs), torch.Tensor( args.epochs) best_wer = None if args.visdom and main_proc: from visdom import Visdom viz = Visdom() opts = dict(title=args.id, ylabel='', xlabel='Epoch', legend=['Loss', 'WER', 'CER']) viz_window = None epochs = torch.arange(1, args.epochs + 1) if args.tensorboard and main_proc: os.makedirs(args.log_dir, exist_ok=True) from tensorboardX import SummaryWriter tensorboard_writer = SummaryWriter(args.log_dir) os.makedirs(save_folder, exist_ok=True) avg_loss, start_epoch, start_iter = 0, 0, 0 if args.continue_from: # Starting from previous model print("Loading checkpoint model %s" % args.continue_from) package = torch.load(args.continue_from, map_location=lambda storage, loc: storage) model = DeepSpeech.load_model_package(package) labels = DeepSpeech.get_labels(model) audio_conf = DeepSpeech.get_audio_conf(model) parameters = model.parameters() optimizer = torch.optim.SGD(parameters, lr=args.lr, momentum=args.momentum, nesterov=True) if not args.finetune: # Don't want to restart training if args.cuda: model.cuda() optimizer.load_state_dict(package['optim_dict']) start_epoch = int(package.get('epoch', 1)) - 1 # Index start at 0 for training start_iter = package.get('iteration', None) if start_iter is None: start_epoch += 1 # We saved model after epoch finished, start at the next epoch. start_iter = 0 else: start_iter += 1 avg_loss = int(package.get('avg_loss', 0)) loss_results, cer_results, wer_results = package['loss_results'], package[ 'cer_results'], package['wer_results'] if main_proc and args.visdom and \ package[ 'loss_results'] is not None and start_epoch > 0: # Add previous scores to visdom graph x_axis = epochs[0:start_epoch] y_axis = torch.stack( (loss_results[0:start_epoch], wer_results[0:start_epoch], cer_results[0:start_epoch]), dim=1) viz_window = viz.line( X=x_axis, Y=y_axis, opts=opts, ) if main_proc and args.tensorboard and \ package[ 'loss_results'] is not None and start_epoch > 0: # Previous scores to tensorboard logs for i in range(start_epoch): values = { 'Avg Train Loss': loss_results[i], 'Avg WER': wer_results[i], 'Avg CER': cer_results[i] } tensorboard_writer.add_scalars(args.id, values, i + 1) else: with open(args.labels_path) as label_file: labels = str(''.join(json.load(label_file))) audio_conf = dict(sample_rate=args.sample_rate, window_size=args.window_size, window_stride=args.window_stride, window=args.window, noise_dir=args.noise_dir, noise_prob=args.noise_prob, noise_levels=(args.noise_min, args.noise_max)) rnn_type = args.rnn_type.lower() assert rnn_type in supported_rnns, "rnn_type should be either lstm, rnn or gru" model = DeepSpeech(rnn_hidden_size=args.hidden_size, nb_layers=args.hidden_layers, labels=labels, rnn_type=supported_rnns[rnn_type], audio_conf=audio_conf, bidirectional=args.bidirectional) parameters = model.parameters() optimizer = torch.optim.SGD(parameters, lr=args.lr, momentum=args.momentum, nesterov=True) criterion = CTCLoss() decoder = GreedyDecoder(labels) train_dataset = SpectrogramDataset(audio_conf=audio_conf, manifest_filepath=args.train_manifest, labels=labels, normalize=True, augment=args.augment) test_dataset = SpectrogramDataset(audio_conf=audio_conf, manifest_filepath=args.val_manifest, labels=labels, normalize=True, augment=False) if not args.distributed: train_sampler = BucketingSampler(train_dataset, batch_size=args.batch_size) else: train_sampler = DistributedBucketingSampler(train_dataset, batch_size=args.batch_size, num_replicas=args.world_size, rank=args.rank) train_loader = AudioDataLoader(train_dataset, num_workers=args.num_workers, batch_sampler=train_sampler) test_loader = AudioDataLoader(test_dataset, batch_size=args.batch_size, num_workers=args.num_workers) if (not args.no_shuffle and start_epoch != 0) or args.no_sorta_grad: print("Shuffling batches for the following epochs") train_sampler.shuffle(start_epoch) if args.cuda: model.cuda() if args.distributed: model = torch.nn.parallel.DistributedDataParallel(model, device_ids=(int(args.gpu_rank),) if args.rank else None) print(model) print("Number of parameters: %d" % DeepSpeech.get_param_size(model)) batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() for epoch in range(start_epoch, args.epochs): model.train() end = time.time() start_epoch_time = time.time() for i, (data) in enumerate(train_loader, start=start_iter): if i == len(train_sampler): break inputs, targets, input_percentages, target_sizes = data input_sizes = input_percentages.mul_(int(inputs.size(3))).int() # measure data loading time data_time.update(time.time() - end) if args.cuda: inputs = inputs.cuda() out, output_sizes = model(inputs, input_sizes) out = out.transpose(0, 1) # TxNxH loss = criterion(out, targets, output_sizes, target_sizes) loss = loss / inputs.size(0) # average the loss by minibatch inf = float("inf") if args.distributed: loss_value = reduce_tensor(loss, args.world_size)[0] else: loss_value = loss.item() if loss_value == inf or loss_value == -inf: print("WARNING: received an inf loss, setting loss value to 0") loss_value = 0 avg_loss += loss_value losses.update(loss_value, inputs.size(0)) # compute gradient optimizer.zero_grad() loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_norm) # SGD step optimizer.step() # measure elapsed time batch_time.update(time.time() - end) end = time.time() if not args.silent: print('Epoch: [{0}][{1}/{2}]\t' 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' 'Data {data_time.val:.3f} ({data_time.avg:.3f})\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format( (epoch + 1), (i + 1), len(train_sampler), batch_time=batch_time, data_time=data_time, loss=losses)) if args.checkpoint_per_batch > 0 and i > 0 and (i + 1) % args.checkpoint_per_batch == 0 and main_proc: file_path = '%s/deepspeech_checkpoint_epoch_%d_iter_%d.pth' % (save_folder, epoch + 1, i + 1) print("Saving checkpoint model to %s" % file_path) torch.save(DeepSpeech.serialize(model, optimizer=optimizer, epoch=epoch, iteration=i, loss_results=loss_results, wer_results=wer_results, cer_results=cer_results, avg_loss=avg_loss), file_path) del loss del out avg_loss /= len(train_sampler) epoch_time = time.time() - start_epoch_time print('Training Summary Epoch: [{0}]\t' 'Time taken (s): {epoch_time:.0f}\t' 'Average Loss {loss:.3f}\t'.format(epoch + 1, epoch_time=epoch_time, loss=avg_loss)) start_iter = 0 # Reset start iteration for next epoch total_cer, total_wer = 0, 0 model.eval() with torch.no_grad(): for i, (data) in tqdm(enumerate(test_loader), total=len(test_loader)): inputs, targets, input_percentages, target_sizes = data input_sizes = input_percentages.mul_(int(inputs.size(3))).int() # unflatten targets split_targets = [] offset = 0 for size in target_sizes: split_targets.append(targets[offset:offset + size]) offset += size if args.cuda: inputs = inputs.cuda() out, output_sizes = model(inputs, input_sizes) decoded_output, _ = decoder.decode(out.data, output_sizes) target_strings = decoder.convert_to_strings(split_targets) wer, cer = 0, 0 for x in range(len(target_strings)): transcript, reference = decoded_output[x][0], target_strings[x][0] wer += decoder.wer(transcript, reference) / float(len(reference.split())) cer += decoder.cer(transcript, reference) / float(len(reference)) total_cer += cer total_wer += wer del out wer = total_wer / len(test_loader.dataset) cer = total_cer / len(test_loader.dataset) wer *= 100 cer *= 100 loss_results[epoch] = avg_loss wer_results[epoch] = wer cer_results[epoch] = cer print('Validation Summary Epoch: [{0}]\t' 'Average WER {wer:.3f}\t' 'Average CER {cer:.3f}\t'.format(epoch + 1, wer=wer, cer=cer)) if args.visdom and main_proc: x_axis = epochs[0:epoch + 1] y_axis = torch.stack( (loss_results[0:epoch + 1], wer_results[0:epoch + 1], cer_results[0:epoch + 1]), dim=1) if viz_window is None: viz_window = viz.line( X=x_axis, Y=y_axis, opts=opts, ) else: viz.line( X=x_axis.unsqueeze(0).expand(y_axis.size(1), x_axis.size(0)).transpose(0, 1), # Visdom fix Y=y_axis, win=viz_window, update='replace', ) if args.tensorboard and main_proc: values = { 'Avg Train Loss': avg_loss, 'Avg WER': wer, 'Avg CER': cer } tensorboard_writer.add_scalars(args.id, values, epoch + 1) if args.log_params: for tag, value in model.named_parameters(): tag = tag.replace('.', '/') tensorboard_writer.add_histogram(tag, to_np(value), epoch + 1) tensorboard_writer.add_histogram(tag + '/grad', to_np(value.grad), epoch + 1) if args.checkpoint and main_proc: file_path = '%s/deepspeech_%d.pth' % (save_folder, epoch + 1) torch.save(DeepSpeech.serialize(model, optimizer=optimizer, epoch=epoch, loss_results=loss_results, wer_results=wer_results, cer_results=cer_results), file_path) # anneal lr optim_state = optimizer.state_dict() optim_state['param_groups'][0]['lr'] = optim_state['param_groups'][0]['lr'] / args.learning_anneal optimizer.load_state_dict(optim_state) print('Learning rate annealed to: {lr:.6f}'.format(lr=optim_state['param_groups'][0]['lr'])) if (best_wer is None or best_wer > wer) and main_proc: print("Found better validated model, saving to %s" % args.model_path) torch.save(DeepSpeech.serialize(model, optimizer=optimizer, epoch=epoch, loss_results=loss_results, wer_results=wer_results, cer_results=cer_results), args.model_path) best_wer = wer avg_loss = 0 if not args.no_shuffle: print("Shuffling batches...") train_sampler.shuffle(epoch)
def main(): args = parser.parse_args() torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) args.checks_per_epoch = max(1,args.checks_per_epoch) if params.rnn_type == 'gru' and params.rnn_act_type != 'tanh': print("ERROR: GRU does not currently support activations other than tanh") sys.exit() if params.rnn_type == 'rnn' and params.rnn_act_type != 'relu': print("ERROR: We should be using ReLU RNNs") sys.exit() print("=======================================================") for arg in vars(args): print("***%s = %s " % (arg.ljust(25), getattr(args, arg))) print("=======================================================") save_folder = args.save_folder loss_results, cer_results, wer_results = torch.Tensor(params.epochs), torch.Tensor(params.epochs), torch.Tensor(params.epochs) best_wer = None try: os.makedirs(save_folder) except OSError as e: if e.errno == errno.EEXIST: print('Directory already exists.') else: raise criterion = CTCLoss() with open(params.labels_path) as label_file: labels = str(''.join(json.load(label_file))) audio_conf = dict(sample_rate=params.sample_rate, window_size=params.window_size, window_stride=params.window_stride, window=params.window, noise_dir=params.noise_dir, noise_prob=params.noise_prob, noise_levels=(params.noise_min, params.noise_max)) val_batch_size = min(8,params.batch_size_val) print("Using bs={} for validation. Parameter found was {}".format(val_batch_size,params.batch_size_val)) train_dataset = SpectrogramDataset(audio_conf=audio_conf, manifest_filepath=params.train_manifest, labels=labels, normalize=True, augment=params.augment) test_dataset = SpectrogramDataset(audio_conf=audio_conf, manifest_filepath=params.val_manifest, labels=labels, normalize=True, augment=False) train_loader = AudioDataLoader(train_dataset, batch_size=params.batch_size, num_workers=1) test_loader = AudioDataLoader(test_dataset, batch_size=val_batch_size, num_workers=1) rnn_type = params.rnn_type.lower() assert rnn_type in supported_rnns, "rnn_type should be either lstm, rnn or gru" model = DeepSpeech(rnn_hidden_size = params.hidden_size, nb_layers = params.hidden_layers, labels = labels, rnn_type = supported_rnns[rnn_type], audio_conf = audio_conf, bidirectional = False, rnn_activation = params.rnn_act_type, bias = params.bias) parameters = model.parameters() optimizer = torch.optim.SGD(parameters, lr=params.lr, momentum=params.momentum, nesterov=True, weight_decay = params.l2) decoder = GreedyDecoder(labels) if args.continue_from: print("Loading checkpoint model %s" % args.continue_from) package = torch.load(args.continue_from) model.load_state_dict(package['state_dict']) model = model.cuda() optimizer.load_state_dict(package['optim_dict']) start_epoch = int(package.get('epoch', 1)) - 1 # Python index start at 0 for training start_iter = package.get('iteration', None) if start_iter is None: start_epoch += 1 # Assume that we saved a model after an epoch finished, so start at the next epoch. start_iter = 0 else: start_iter += 1 avg_loss = int(package.get('avg_loss', 0)) if args.start_epoch != -1: start_epoch = args.start_epoch loss_results[:start_epoch], cer_results[:start_epoch], wer_results[:start_epoch] = package['loss_results'][:start_epoch], package[ 'cer_results'][:start_epoch], package['wer_results'][:start_epoch] print(loss_results) epoch = start_epoch else: avg_loss = 0 start_epoch = 0 start_iter = 0 avg_training_loss = 0 if params.cuda: model = torch.nn.DataParallel(model).cuda() # model = torch.nn.parallel.DistributedDataParallel(model).cuda() print(model) print("Number of parameters: %d" % DeepSpeech.get_param_size(model)) batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() ctc_time = AverageMeter() for epoch in range(start_epoch, params.epochs): model.train() end = time.time() for i, (data) in enumerate(train_loader, start=start_iter): if i == len(train_loader): break inputs, targets, input_percentages, target_sizes = data # measure data loading time data_time.update(time.time() - end) inputs = Variable(inputs, requires_grad=False) target_sizes = Variable(target_sizes, requires_grad=False) targets = Variable(targets, requires_grad=False) if params.cuda: inputs = inputs.cuda() out = model(inputs) out = out.transpose(0, 1) # TxNxH seq_length = out.size(0) sizes = Variable(input_percentages.mul_(int(seq_length)).int(), requires_grad=False) ctc_start_time = time.time() loss = criterion(out, targets, sizes, target_sizes) ctc_time.update(time.time() - ctc_start_time) loss = loss / inputs.size(0) # average the loss by minibatch loss_sum = loss.data.sum() inf = float("inf") if loss_sum == inf or loss_sum == -inf: print("WARNING: received an inf loss, setting loss value to 0") loss_value = 0 else: loss_value = loss.data[0] avg_loss += loss_value losses.update(loss_value, inputs.size(0)) # compute gradient # print(torch.cuda.memory_allocated()) optimizer.zero_grad() loss.backward() torch.nn.utils.clip_grad_norm(model.parameters(), params.max_norm) # SGD step optimizer.step() if params.cuda: torch.cuda.synchronize() # measure elapsed time batch_time.update(time.time() - end) end = time.time() print('Epoch: [{0}][{1}/{2}]\t' 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' 'Data {data_time.val:.3f} ({data_time.avg:.3f})\t' 'CTC Time {ctc_time.val:.3f} ({ctc_time.avg:.3f})\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format( (epoch + 1), (i + 1), len(train_loader), batch_time=batch_time, data_time=data_time, ctc_time=ctc_time, loss=losses)) # del loss # del out if (i+1) % int((len(train_loader)/args.checks_per_epoch)) == 0: print('Training Summary Epoch: [{0}]\t' 'Average Loss {loss:.3f}\t' .format(epoch + 1, loss=avg_loss/5000, )) start_iter = 0 # Reset start iteration for next epoch total_cer, total_wer = 0, 0 if args.checkpoint: file_path = '%s/deepspeech_%d_temp.pth.tar' % (save_folder, epoch + 1) torch.save(DeepSpeech.serialize(model, optimizer=optimizer, epoch=epoch, loss_results=loss_results, wer_results=999, cer_results=999), file_path) do_save = True try: model.eval() wer, cer = eval_model(model, test_loader, decoder) except RuntimeError as e: print("skipping eval model checkpoint.... ") do_save = False loss_results[epoch] = avg_loss wer_results[epoch] = wer cer_results[epoch] = cer print('Validation Summary Epoch: [{0}]\t' 'Average WER {wer:.3f}\t' 'Average CER {cer:.3f}\t'.format( epoch + 1, wer=wer, cer=cer)) if args.checkpoint and do_save: file_path = '%s/deepspeech_%d.pth.tar' % (save_folder, epoch + 1) torch.save(DeepSpeech.serialize(model, optimizer=optimizer, epoch=epoch, loss_results=loss_results, wer_results=wer_results, cer_results=cer_results), file_path) # anneal lr optim_state = optimizer.state_dict() optim_state['param_groups'][0]['lr'] = optim_state['param_groups'][0]['lr'] / params.learning_anneal optimizer.load_state_dict(optim_state) print('Learning rate annealed to: {lr:.6f}'.format(lr=optim_state['param_groups'][0]['lr'])) if best_wer is None or best_wer > wer: print("Found better validated model, saving to %s" % args.model_path) torch.save(DeepSpeech.serialize(model, optimizer=optimizer, epoch=epoch, loss_results=loss_results, wer_results=wer_results, cer_results=cer_results) , args.model_path) best_wer = wer model.train() del loss del out avg_loss /= len(train_loader) print('Training Summary Epoch: [{0}]\t' 'Average Loss {loss:.3f}\t' .format( epoch + 1, loss=avg_loss, )) start_iter = 0 # Reset start iteration for next epoch total_cer, total_wer = 0, 0 model.eval() wer, cer = eval_model( model, test_loader, decoder) loss_results[epoch] = avg_loss wer_results[epoch] = wer cer_results[epoch] = cer print('Validation Summary Epoch: [{0}]\t' 'Average WER {wer:.3f}\t' 'Average CER {cer:.3f}\t'.format( epoch + 1, wer=wer, cer=cer)) if args.checkpoint: file_path = '%s/deepspeech_%d.pth.tar' % (save_folder, epoch + 1) torch.save(DeepSpeech.serialize(model, optimizer=optimizer, epoch=epoch, loss_results=loss_results, wer_results=wer_results, cer_results=cer_results), file_path) # anneal lr optim_state = optimizer.state_dict() optim_state['param_groups'][0]['lr'] = optim_state['param_groups'][0]['lr'] / params.learning_anneal optimizer.load_state_dict(optim_state) print('Learning rate annealed to: {lr:.6f}'.format(lr=optim_state['param_groups'][0]['lr'])) if best_wer is None or best_wer > wer: print("Found better validated model, saving to %s" % args.model_path) torch.save(DeepSpeech.serialize(model, optimizer=optimizer, epoch=epoch, loss_results=loss_results, wer_results=wer_results, cer_results=cer_results) , args.model_path) best_wer = wer avg_loss = 0 model.train() #If set to exit at a given accuracy, exit if params.exit_at_acc and (best_wer <= args.acc): break print("=======================================================") print("***Best WER = ", best_wer) for arg in vars(args): print("***%s = %s " % (arg.ljust(25), getattr(args, arg))) print("=======================================================")
def main(): args = parser.parse_args() torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) if params.rnn_type == 'gru' and params.rnn_act_type != 'tanh': print("ERROR: GRU does not currently support activations other than tanh") sys.exit() if params.rnn_type == 'rnn' and params.rnn_act_type != 'relu': print("ERROR: We should be using ReLU RNNs") sys.exit() print("=======================================================") for arg in vars(args): print("***%s = %s " % (arg.ljust(25), getattr(args, arg))) print("=======================================================") save_folder = args.save_folder loss_results, cer_results, wer_results = torch.Tensor(params.epochs), torch.Tensor(params.epochs), torch.Tensor(params.epochs) best_wer = None try: os.makedirs(save_folder) except OSError as e: if e.errno == errno.EEXIST: print('Directory already exists.') else: raise with open(params.labels_path) as label_file: labels = str(''.join(json.load(label_file))) rnn_type = params.rnn_type.lower() assert rnn_type in supported_rnns, "rnn_type should be either lstm, rnn or gru" model = DeepSpeech(rnn_hidden_size = params.hidden_size, nb_layers = params.hidden_layers, labels = labels, rnn_type = supported_rnns[rnn_type], audio_conf = None, bidirectional = True, rnn_activation = params.rnn_act_type, bias = params.bias) parameters = model.parameters() optimizer = torch.optim.SGD(parameters, lr=params.lr, momentum=params.momentum, nesterov=False, weight_decay = params.l2) cuda = torch.device('cuda') criterion = torch.nn.CTCLoss(reduction='none').to(cuda) avg_loss = 0 start_epoch = 0 start_iter = 0 avg_training_loss = 0 if params.cuda: model.cuda() print(model) print("Number of parameters: %d" % DeepSpeech.get_param_size(model)) batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() ctc_time = AverageMeter() forward_time = AverageMeter() backward_time = AverageMeter() filename = "/scratch-ml00/wang603/deepspeechData/deepspeech_train.pickle" batchedData = user_defined_input.Batch(filename) def train_one_epoch(epoch): avg_loss = 0 for i in range(batchedData.numBatches): # if i == 1: return end = time.time() inputs, targets, input_percentages, target_sizes = batchedData.batch(last=False) # making all inputs Tensor inputs = torch.from_numpy(inputs) targets = torch.from_numpy(targets) input_percentages = torch.from_numpy(input_percentages) target_sizes = torch.from_numpy(target_sizes) # measure data loading time data_time.update(time.time() - end) inputs = Variable(inputs, requires_grad=False) target_sizes = Variable(target_sizes, requires_grad=False) targets = Variable(targets, requires_grad=False) if params.cuda: inputs = inputs.cuda() # measure forward pass time forward_start_time = time.time() out = model(inputs) # out = out.transpose(0, 1) # TxNxH seq_length = out.size(0) sizes = Variable(input_percentages.mul_(int(seq_length)).int(), requires_grad=False) # measure ctc loss computing time ctc_start_time = time.time() out = out.log_softmax(2) #.detach().requires_grad_() # print(sizes.shape) # print(out.shape) loss = criterion(out, targets, sizes, target_sizes) ctc_time.update(time.time() - ctc_start_time) loss = loss / inputs.size(0) # average the loss by minibatch loss_sum = loss.sum() inf = float("inf") if loss_sum == inf or loss_sum == -inf: print("WARNING: received an inf loss, setting loss value to 0") loss_value = 0 else: loss_value = loss_sum.data.item() avg_loss += loss_value losses.update(loss_value, inputs.size(0)) forward_time.update(time.time() - forward_start_time) # measure backward pass time backward_start_time = time.time() # compute gradient optimizer.zero_grad() loss_sum.backward() torch.nn.utils.clip_grad_norm(model.parameters(), params.max_norm) # SGD step optimizer.step() if params.cuda: torch.cuda.synchronize() backward_time.update(time.time() - backward_start_time) # measure elapsed time batch_time.update(time.time() - end) if (i % 20 == 0): print('Epoch: [{0}][{1}/{2}]\t' 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' 'Data {data_time.val:.3f} ({data_time.avg:.3f})\t' 'Forward {forward_time.val:.3f} ({forward_time.avg:.3f})\t' 'CTC Time {ctc_time.val:.3f} ({ctc_time.avg:.3f})\t' 'Backward {backward_time.val:.3f} ({backward_time.avg:.3f})\t' 'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format( (epoch + 1), (i + 1), batchedData.numBatches, batch_time=batch_time, data_time=data_time, forward_time=forward_time, ctc_time=ctc_time, backward_time=backward_time, loss=losses)) del loss del out avg_loss /= batchedData.numBatches # len(train_loader) print('Training Summary Epoch: [{0}]\t' 'Average Loss {loss:.3f}\t' .format(epoch + 1, loss=avg_loss, )) return avg_loss model.train() loss_save = [] time_save = [] for epoch in range(start_epoch, args.epochs): startTime = time.time() loss_save.append(train_one_epoch(epoch)) endTime = time.time() time_save.append(endTime - startTime) print("epoch {} used {} seconds".format(epoch, endTime - startTime)) time_save.sort() median_time = time_save[int(args.epochs / 2)] with open(args.write_to, "w") as f: f.write("unit: " + "1 epoch\n") for loss in loss_save: f.write("{}\n".format(loss)) f.write("run time: " + str(0.0) + " " + str(median_time) + "\n")
if not args.distributed: train_sampler = BucketingSampler(train_dataset, batch_size=args.batch_size) else: train_sampler = DistributedBucketingSampler(train_dataset, batch_size=args.batch_size, num_replicas=args.world_size, rank=args.rank) train_loader = AudioDataLoader(train_dataset, num_workers=args.num_workers, batch_sampler=train_sampler) test_loader = AudioDataLoader(test_dataset, batch_size=args.batch_size, num_workers=args.num_workers) if (not args.no_shuffle and start_epoch != 0) or args.no_sorta_grad: print("Shuffling batches for the following epochs") train_sampler.shuffle(start_epoch) if args.cuda: model.cuda() if args.distributed: model = torch.nn.parallel.DistributedDataParallel(model, device_ids=(int(args.gpu_rank),) if args.rank else None) print(model) print("Number of parameters: %d" % DeepSpeech.get_param_size(model)) batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() for epoch in range(start_epoch, args.epochs): model.train() end = time.time() start_epoch_time = time.time()