def _setup_iterators(config, batch_size, train_data, validation_data, test_data): if isinstance(config['loaderjob'], int) and config['loaderjob'] > 1: train_iterator = MultiprocessIterator(train_data, batch_size, n_processes=config['loaderjob']) validation_iterator = MultiprocessIterator( validation_data, batch_size, n_processes=config['loaderjob'], repeat=False, shuffle=False) test_iterator = MultiprocessIterator(test_data, batch_size, n_processes=config['loaderjob'], repeat=False, shuffle=False) else: train_iterator = SerialIterator(train_data, batch_size) validation_iterator = SerialIterator(validation_data, batch_size, repeat=False, shuffle=False) test_iterator = SerialIterator(test_data, batch_size, repeat=False, shuffle=False) return train_iterator, validation_iterator, test_iterator
def Evaluation(splits='validation'): # FOR SEMANTIC SEGMENTATION TASK, SET args.minibatch TO 1 # Creat data generator for dataset, split in zip(args.dataset.split('+'), splits.split('+')): for image_size in args.scales_ts: batch_tuple = MultiprocessIterator(DataChef.GetExample( datasets[dataset][split], False, dataset, image_size), args.minibatch, n_prefetch=2, n_processes=args.nb_processes, shared_mem=20000000, repeat=False, shuffle=False) # Keep the log in history if dataset in ['LIP', 'MSCOCO', 'PASCAL_SBD']: history = { dataset: { 'loss': [], 'miou': [], 'pixel_accuracy': [], 'mean_class_accuracy': [], 'image_size': image_size } } elif dataset in ['WIDER', 'BAPD']: history = { dataset: { 'loss': [], 'prediction': [], 'groundtruth': [], 'image_size': image_size } } # Evaluate for dataBatch in batch_tuple: dataBatch = zip(*dataBatch) # Prepare batch data IMG = np.array_split(np.array(dataBatch[0]), len(Model), axis=0) LBL = np.array_split(np.array(dataBatch[1]), len(Model), axis=0) # Forward for device_id, img, lbl in zip(range(len(Model)), IMG, LBL): Model[device_id](img, lbl, dataset, train=False) # Aggregate reporters from all GPUs reporters = [] for i in range(len(Model)): reporters.append(Model[i].reporter) Model[i].reporter = {} # clear reporter # History for reporter in reporters: for k in reporter[dataset].keys(): history[dataset][k].append(reporter[dataset][k]) # Report DataChef.Report(history, args.report_interval * len(args.GPUs), split=split)
def main(): parser = argparse.ArgumentParser() parser.add_argument("--model", default=None) parser.add_argument("--gpu", type=int, default=0) parser.add_argument("--batch_size", type=int, default=4) parser.add_argument("--data_dir", type=str, default="./datasets") parser.add_argument("--data_list", type=str, default="train.txt") parser.add_argument("--n_class", type=int, default=5) parser.add_argument("--n_steps", type=int, default=100) parser.add_argument("--snapshot_dir", type=str, default="./snapshots") parser.add_argument("--save_steps", type=int, default=50) args = parser.parse_args() print(args) if not os.path.exists(args.snapshot_dir): os.makedirs(args.snapshot_dir) model = RefineResNet(n_class=args.n_class) if args.model is not None: serializers.load_npz(args.model, model) if args.gpu >= 0: cuda.get_device(args.gpu).use() model.to_gpu() xp = cuda.cupy else: xp = np optimizer = Adam() #optimizer = MomentumSGD() optimizer.setup(model) optimizer.add_hook(WeightDecay(1e-5), "hook_wd") train_dataset = ImageDataset(args.data_dir, args.data_list, crop_size=(320, 320)) train_iterator = MultiprocessIterator(train_dataset, batch_size=args.batch_size, repeat=True, shuffle=True) step = 0 for zipped_batch in train_iterator: step += 1 x = Variable(xp.array([zipped[0] for zipped in zipped_batch])) y = Variable( xp.array([zipped[1] for zipped in zipped_batch], dtype=xp.int32)) pred = xp.array(model(x).data, dtype=xp.float32) loss = F.softmax_cross_entropy(pred, y) optimizer.update(F.softmax_cross_entropy, pred, y) print("Step: {}, Loss: {}".format(step, loss.data)) if step % args.save_steps == 0: serializers.save_npz( os.path.join(args.snapshot_dir, "model_{}.npz".format(step)), model) if step >= args.n_steps: break
def load_image_dataset_iterators(filepath, batch_size, max_horizontal_factor, scaled_size, crop_size, p_blur, blur_max_ksize, p_add_lines, max_num_lines, shuffle_train=True): dataset = chainer.datasets.ImageDataset(filepath) train_raw, valid_raw = chainer.datasets.split_dataset(dataset, 16500) valid_raw, test_raw = chainer.datasets.split_dataset(valid_raw, 500) test, _ = chainer.datasets.split_dataset(test_raw, 100) transform = Transform( max_horizontal_factor, scaled_size, crop_size, p_blur, blur_max_ksize) train = chainer.datasets.TransformDataset(train_raw, transform) valid = chainer.datasets.TransformDataset(valid_raw, transform) test = chainer.datasets.TransformDataset(test_raw, transform) it_train = MultiprocessIterator(train, batch_size, True, shuffle_train, 5) it_valid = MultiprocessIterator(valid, batch_size, True, False, 1, 5) it_test = MultiprocessIterator(test, batch_size, True, False, 1, 1) return it_train, it_valid, it_test
def get_test_data_source(ds_metainfo, batch_size, num_workers): transform = ds_metainfo.test_transform(ds_metainfo=ds_metainfo) dataset = ds_metainfo.dataset_class(root=ds_metainfo.root_dir_path, mode="test", transform=transform) iterator = MultiprocessIterator(dataset=dataset, batch_size=batch_size, repeat=False, shuffle=False, n_processes=num_workers, shared_mem=300000000) return { # "transform": transform, "iterator": iterator, "ds_len": len(dataset) }
def setup_support( batch_size: int, gpu: Optional[int], model: Model, dataset: chainer.dataset.DatasetMixin, ): optimizer = _create_optimizer(model) train_iter = MultiprocessIterator(dataset, batch_size) if gpu is not None: model.to_gpu(gpu) updater = StandardUpdater( device=gpu, iterator=train_iter, optimizer=optimizer, converter=concat_optional, ) reporter = chainer.Reporter() reporter.add_observer('main', model) return updater, reporter
def Evaluation(): # Creat data generator batch_tuple = MultiprocessIterator(DataChef.ReID10D( args, args.project_folder + '/evaluation_list/' + args.eval_split + '.txt', image_size=args.scales_tr[0]), args.minibatch, n_prefetch=2, n_processes=args.nb_processes, shared_mem=20000000, repeat=False, shuffle=False) # Keep the log in history history = {args.dataset: {'features': []}} for dataBatch in batch_tuple: dataBatch = zip(*dataBatch) # Prepare batch data IMG = np.array_split(np.array(dataBatch[0]), len(Model), axis=0) LBL = np.array_split(np.array(dataBatch[1]), len(Model), axis=0) # Forward for device_id, img, lbl in zip(range(len(Model)), IMG, LBL): Model[device_id](img, lbl, args.dataset, train=False) # Aggregate reporters from all GPUs reporters = [] for i in range(len(Model)): reporters.append(Model[i].reporter) Model[i].reporter = {} # clear reporter # History for reporter in reporters: for k in reporter[args.dataset].keys(): history[args.dataset][k].append(reporter[args.dataset][k]) # storing features to an outputfile features = np.concatenate(history[args.dataset]['features'], axis=0) outfile = '%s/evaluation_features/%s_@%s_%s.csv' % ( args.project_folder, args.dataset, args.checkpoint, args.eval_split) np.savetxt(outfile, features, delimiter=',', fmt='%0.12e')
config = create_from_json(arguments.config_json_path) arguments.output.mkdir(exist_ok=True) config.save_as_json((arguments.output / 'config.json').absolute()) # model if config.train.gpu >= 0: cuda.get_device_from_id(config.train.gpu).use() predictor, discriminator = create(config.model) models = { 'predictor': predictor, 'discriminator': discriminator, } # dataset dataset = create_dataset(config.dataset) train_iter = MultiprocessIterator(dataset['train'], config.train.batchsize) test_iter = MultiprocessIterator(dataset['test'], config.train.batchsize, repeat=False, shuffle=False) train_eval_iter = MultiprocessIterator(dataset['train_eval'], config.train.batchsize, repeat=False, shuffle=False) # optimizer def create_optimizer(model): optimizer = optimizers.Adam(alpha=0.0002, beta1=0.5, beta2=0.999) optimizer.setup(model) return optimizer
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', '-g', type=int, default=0, help='GPU ID (negative value indicates CPU)' ) # open_crf layer only works for CPU mode parser.add_argument( "--model", "-m", help="pretrained model file path") # which contains pretrained target parser.add_argument("--pretrained_model", "-pre", default="resnet101") parser.add_argument("--memcached_host", default="127.0.0.1") parser.add_argument('--mean', default=config.ROOT_PATH + "BP4D/idx/mean_rgb.npy", help='image mean .npy file') parser.add_argument('--proc_num', type=int, default=10, help="multiprocess fetch data process number") parser.add_argument('--two_stream_mode', type=TwoStreamMode, choices=list(TwoStreamMode), help='spatial/ temporal/ spatial_temporal') parser.add_argument('--batch', '-b', type=int, default=5, help='mini batch size') args = parser.parse_args() if not args.model.endswith("model.npz"): return mode_dict = extract_mode(args.model) database = mode_dict["database"] fold = mode_dict["fold"] split_idx = mode_dict["split_idx"] backbone = mode_dict["backbone"] spatial_edge_mode = mode_dict["spatial_edge_mode"] temporal_edge_mode = mode_dict["temporal_edge_mode"] use_paper_num_label = mode_dict["use_paper_num_label"] use_roi_align = mode_dict["use_roi_align"] use_label_dep_rnn_layer = mode_dict["label_dep_rnn_layer"] sample_frame = mode_dict["sample_frame"] conv_rnn_type = mode_dict["conv_rnn_type"] use_feature_map = (conv_rnn_type != ConvRNNType.conv_rcnn) and ( conv_rnn_type != ConvRNNType.fc_lstm) use_au_rcnn_loss = (conv_rnn_type == ConvRNNType.conv_rcnn) adaptive_AU_database(database) paper_report_label, class_num = squeeze_label_num_report( database, use_paper_num_label) paper_report_label_idx = list(paper_report_label.keys()) if not paper_report_label_idx: paper_report_label_idx = None class_num = len(config.AU_SQUEEZE) else: class_num = len(paper_report_label_idx) model_print_dict = OrderedDict() for key, value in mode_dict.items(): model_print_dict[key] = str(value) print(""" {0} ====================================== INFO: {1} ====================================== """.format(args.model, json.dumps(model_print_dict, sort_keys=True, indent=8))) if backbone == 'resnet101': au_rcnn = AU_RCNN_Resnet101( pretrained_model=args.pretrained_model, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], mean_file=args.mean, classify_mode=use_au_rcnn_loss, n_class=class_num, use_roi_align=use_roi_align, use_feature_map_res45=use_feature_map, use_feature_map_res5=(conv_rnn_type != ConvRNNType.fc_lstm or conv_rnn_type == ConvRNNType.sep_conv_lstm), temporal_length=sample_frame) elif backbone == 'resnet50': au_rcnn = AU_RCNN_Resnet50(pretrained_model=args.pretrained_model, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], mean_file=args.mean, classify_mode=use_au_rcnn_loss, n_class=class_num, use_roi_align=use_roi_align, use_feature_map=use_feature_map) au_rcnn_train_chain = AU_RCNN_ROI_Extractor(au_rcnn) # if use_label_dep_rnn_layer: # use_space = (spatial_edge_mode != SpatialEdgeMode.no_edge) # use_temporal = (temporal_edge_mode != TemporalEdgeMode.no_temporal) # label_dependency_layer = LabelDependencyLayer(database, out_size=class_num, train_mode=False, # label_win_size=2, x_win_size=1, # label_dropout_ratio=0.0, use_space=use_space, # use_temporal=use_temporal) if conv_rnn_type == ConvRNNType.conv_lstm: space_time_conv_lstm = SpaceTimeConv( None, use_label_dep_rnn_layer, class_num, spatial_edge_mode=spatial_edge_mode, temporal_edge_mode=temporal_edge_mode, conv_rnn_type=conv_rnn_type) loss_head_module = space_time_conv_lstm elif conv_rnn_type == ConvRNNType.fc_lstm: space_time_fc_lstm = SpaceTimeSepFcLSTM( database, class_num, spatial_edge_mode=spatial_edge_mode, temporal_edge_mode=temporal_edge_mode) loss_head_module = space_time_fc_lstm elif conv_rnn_type == ConvRNNType.conv_rcnn: au_rcnn_train_loss = AU_RCNN_TrainChainLoss() loss_head_module = au_rcnn_train_loss elif conv_rnn_type == ConvRNNType.sep_conv_lstm: space_time_sep_conv_lstm = SpaceTimeSepConv( database, class_num, spatial_edge_mode=spatial_edge_mode, temporal_edge_mode=temporal_edge_mode) loss_head_module = space_time_sep_conv_lstm model = Wrapper(au_rcnn_train_chain, loss_head_module, database, sample_frame, use_feature_map=use_feature_map, gpu=args.gpu) chainer.serializers.load_npz(args.model, model) print("loading {}".format(args.model)) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu(args.gpu) mc_manager = PyLibmcManager(args.memcached_host) img_dataset = AUDataset( database=database, fold=fold, split_name='test', # FIXME split_index=split_idx, mc_manager=mc_manager, train_all_data=False) video_dataset = AU_video_dataset( au_image_dataset=img_dataset, sample_frame=sample_frame, train_mode=False, #FIXME paper_report_label_idx=paper_report_label_idx, fetch_use_parrallel_iterator=True) video_dataset = TransformDataset(video_dataset, Transform3D(au_rcnn, mirror=False)) # test_iter = SerialIterator(video_dataset, batch_size=sample_frame * args.batch, # repeat=False, shuffle=False) test_iter = MultiprocessIterator(video_dataset, batch_size=sample_frame * args.batch, n_processes=args.proc_num, repeat=False, shuffle=False, n_prefetch=10, shared_mem=10000000) with chainer.no_backprop_mode(), chainer.using_config( 'cudnn_deterministic', True), chainer.using_config('train', False): npz_path = os.path.dirname( args.model) + os.path.sep + "pred_" + os.path.basename( args.model)[:os.path.basename(args.model).rindex("_")] + ".npz" print("npz_path: {}".format(npz_path)) au_evaluator = ActionUnitEvaluator( test_iter, model, args.gpu, database=database, paper_report_label=paper_report_label, converter=lambda batch, device: concat_examples_not_labels( batch, device, padding=0), sample_frame=sample_frame, output_path=npz_path) observation = au_evaluator.evaluate() with open(os.path.dirname(args.model) + os.path.sep + "evaluation_result_{0}.json".format(os.path.basename(args.model)\ [:os.path.basename(args.model).rindex("_")] ), "w") as file_obj: file_obj.write( json.dumps(observation, indent=4, separators=(',', ': '))) file_obj.flush()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--batch_size', '-b', type=int, default=1, help='each batch size will be a new file') parser.add_argument('--gpu', '-g', type=int, default=0, help='gpu that used to extract feature') parser.add_argument("--mirror", action="store_true", help="whether to mirror") parser.add_argument("--out_dir", '-o', default="/home/machen/dataset/extract_features/") parser.add_argument( "--model", '-m', help="the AU R-CNN pretrained model file to load to extract feature") parser.add_argument("--trainval_test", '-tt', help="train or test") parser.add_argument("--database", default="BP4D") parser.add_argument( '--use_memcached', action='store_true', help='whether use memcached to boost speed of fetch crop&mask') parser.add_argument('--proc_num', type=int, default=10) parser.add_argument('--memcached_host', default='127.0.0.1') parser.add_argument('--mean_rgb', default=config.ROOT_PATH + "BP4D/idx/mean_rgb.npy", help='image mean .npy file') parser.add_argument('--mean_flow', default=config.ROOT_PATH + "BP4D/idx/mean_flow.npy", help='image mean .npy file') args = parser.parse_args() adaptive_AU_database(args.database) mc_manager = None if args.use_memcached: from collections_toolkit.memcached_manager import PyLibmcManager mc_manager = PyLibmcManager(args.memcached_host) if mc_manager is None: raise IOError("no memcached found listen in {}".format( args.memcached_host)) return_dict = extract_mode(args.model) database = return_dict["database"] fold = return_dict["fold"] split_idx = return_dict["split_idx"] backbone = return_dict["backbone"] use_paper_num_label = return_dict["use_paper_num_label"] roi_align = return_dict["use_roi_align"] two_stream_mode = return_dict["two_stream_mode"] T = return_dict["T"] class_num = len(config.paper_use_BP4D) if database == "BP4D" else len( config.paper_use_DISFA) paper_report_label_idx = sorted(list(config.AU_SQUEEZE.keys())) if use_paper_num_label: paper_report_label, class_num = squeeze_label_num_report( database, True) paper_report_label_idx = list(paper_report_label.keys()) assert two_stream_mode == TwoStreamMode.rgb_flow if two_stream_mode == TwoStreamMode.rgb_flow: au_rcnn_train_chain_list = [] au_rcnn_rgb = AU_RCNN_Resnet101(pretrained_model=backbone, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], use_roi_align=roi_align, use_optical_flow_input=False, temporal_length=T) au_rcnn_optical_flow = AU_RCNN_Resnet101(pretrained_model=backbone, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], use_roi_align=roi_align, use_optical_flow_input=True, temporal_length=T) au_rcnn_train_chain_rgb = AU_RCNN_ROI_Extractor(au_rcnn_rgb) au_rcnn_train_chain_optical_flow = AU_RCNN_ROI_Extractor( au_rcnn_optical_flow) au_rcnn_train_chain_list.append(au_rcnn_train_chain_rgb) au_rcnn_train_chain_list.append(au_rcnn_train_chain_optical_flow) model = Wrapper(au_rcnn_train_chain_list, class_num, database, T, two_stream_mode=two_stream_mode, gpus=[args.gpu, args.gpu]) assert os.path.exists(args.model) print("loading model file : {}".format(args.model)) chainer.serializers.load_npz(args.model, model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() if isinstance(model, FasterRCNNResnet101): model.to_gpu(args.gpu) img_dataset = AUDataset(database=database, L=T, fold=fold, split_name=args.trainval_test, split_index=split_idx, mc_manager=mc_manager, train_all_data=False, paper_report_label_idx=paper_report_label_idx, jump_exists=True, npz_dir=args.out_dir) mirror_list = [ False, ] if args.mirror and args.trainval_test == 'trainval': mirror_list.append(True) for mirror in mirror_list: train_dataset = TransformDataset( img_dataset, Transform(T, mean_rgb_path=args.mean_rgb, mean_flow_path=args.mean_flow, mirror=mirror)) if args.proc_num > 1: dataset_iter = MultiprocessIterator(train_dataset, batch_size=args.batch_size, n_processes=args.proc_num, repeat=False, shuffle=False, n_prefetch=10, shared_mem=10000000) else: dataset_iter = SerialIterator(train_dataset, batch_size=args.batch_size, repeat=False, shuffle=False) with chainer.no_backprop_mode(), chainer.using_config( 'cudnn_deterministic', True), chainer.using_config('train', False): model_dump = DumpRoIFeature( dataset_iter, model, args.gpu, database, converter=lambda batch, device: concat_examples_not_string( batch, device, padding=0), output_path=args.out_dir, trainval_test=args.trainval_test, fold_split_idx=split_idx, mirror_data=mirror) model_dump.evaluate()
def main(): parser = argparse.ArgumentParser() parser.add_argument('train_type', choices=['source_only', 'target_only', 'bousmalis']) parser.add_argument('--batchsize', '-b', type=int, default=128, help='Number of images in each mini-batch') parser.add_argument('--epoch', '-e', type=int, default=20, help='Number of sweeps over the dataset to train') parser.add_argument('--frequency', '-f', type=int, default=-1, help='Frequency of taking a snapshot') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--resume', '-r', default='', help='Resume the training from snapshot') parser.add_argument('--n_processes', type=int, default=12) args = parser.parse_args() print('GPU: {}'.format(args.gpu)) print('# Minibatch-size: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('') # Set up a neural network to train # Classifier reports softmax cross entropy loss and accuracy at every # iteration, which will be used by the PrintReport extension below. model = L.Classifier(DigitClassifier()) if args.gpu >= 0: # Make a specified GPU current chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() # Copy the model to the GPU # Setup an optimizer optimizer = chainer.optimizers.Adam() optimizer.setup(model) # Load the MNIST dataset if args.train_type == 'source_only': train, _ = chainer.datasets.get_mnist(ndim=3) train = TransformDataset(train, transform=gray2rgb) train = TransformDataset(train, transform=scale) elif args.train_type == 'target_only': train = get_mnist_m('train', withlabel=True) train = TransformDataset(train, transform=scale) test = get_mnist_m('test', withlabel=True) test = TransformDataset(test, transform=scale) train_iter = MultiprocessIterator(train, args.batchsize, n_processes=args.n_processes) test_iter = MultiprocessIterator(test, args.batchsize, n_processes=args.n_processes, repeat=False, shuffle=False) # Set up a trainer updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) # Evaluate the model with the test dataset for each epoch trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu)) # Dump a computational graph from 'loss' variable at the first iteration # The "main" refers to the target link of the "main" optimizer. trainer.extend(extensions.dump_graph('main/loss')) # Take a snapshot for each specified epoch frequency = args.epoch if args.frequency == -1 else max(1, args.frequency) trainer.extend(extensions.snapshot(), trigger=(frequency, 'epoch')) # Write a log of evaluation statistics for each epoch trainer.extend(extensions.LogReport()) # Save two plot images to the result dir if extensions.PlotReport.available(): trainer.extend( extensions.PlotReport(['main/loss', 'validation/main/loss'], 'epoch', file_name='loss.png')) trainer.extend( extensions.PlotReport( ['main/accuracy', 'validation/main/accuracy'], 'epoch', file_name='accuracy.png')) # Exponential learning weight decay trainer.extend(extensions.ExponentialShift('alpha', params['alpha_decay_rate'], optimizer=optimizer), trigger=(params['alpha_decay_steps'], 'iteration')) # Print selected entries of the log to stdout # Here "main" refers to the target link of the "main" optimizer again, and # "validation" refers to the default name of the Evaluator extension. # Entries other than 'epoch' are reported by the Classifier link, called by # either the updater or the evaluator. trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time' ])) # Print a progress bar to stdout trainer.extend(extensions.ProgressBar()) if args.resume: # Resume from a snapshot chainer.serializers.load_npz(args.resume, trainer) # Run the training trainer.run()
def main(): print("chainer cudnn enabled: {}".format(chainer.cuda.cudnn_enabled)) parser = argparse.ArgumentParser( description='Action Unit R-CNN training example:') parser.add_argument('--pid', '-pp', default='/tmp/AU_R_CNN/') parser.add_argument('--gpu', '-g', default="0", help='GPU ID, multiple GPU split by comma, \ ' 'Note that BPTT updater do not support multi-GPU') parser.add_argument('--lr', '-l', type=float, default=0.001) parser.add_argument('--out', '-o', default='result', help='Output directory') parser.add_argument('--database', default='BP4D', help='Output directory: BP4D/DISFA/BP4D_DISFA') parser.add_argument('--seed', '-s', type=int, default=0) parser.add_argument('--iteration', '-i', type=int, default=70000) parser.add_argument('--epoch', '-e', type=int, default=20) parser.add_argument('--batch_size', '-bs', type=int, default=20) parser.add_argument('--snapshot', '-snap', type=int, default=1000) parser.add_argument('--need_validate', action='store_true', help='do or not validate during training') parser.add_argument('--mean', default=config.ROOT_PATH + "BP4D/idx/mean_rgb.npy", help='image mean .npy file') parser.add_argument('--feature_model', default="resnet101", help="vgg16/vgg19/resnet101 for train") parser.add_argument('--extract_len', type=int, default=1000) parser.add_argument('--optimizer', default='RMSprop', help='optimizer: RMSprop/AdaGrad/Adam/SGD/AdaDelta') parser.add_argument('--pretrained_model', default='resnet101', help='imagenet/vggface/resnet101/*.npz') parser.add_argument('--pretrained_model_args', nargs='+', type=float, help='you can pass in "1.0 224" or "0.75 224"') parser.add_argument( '--use_memcached', action='store_true', help='whether use memcached to boost speed of fetch crop&mask') # parser.add_argument('--memcached_host', default='127.0.0.1') parser.add_argument("--fold", '-fd', type=int, default=3) parser.add_argument("--split_idx", '-sp', type=int, default=1) parser.add_argument( "--snap_individual", action="store_true", help="whether to snapshot each individual epoch/iteration") parser.add_argument("--proc_num", "-proc", type=int, default=1) parser.add_argument( "--use_sigmoid_cross_entropy", "-sigmoid", action="store_true", help="whether to use sigmoid cross entropy or softmax cross entropy") parser.add_argument( "--is_pretrained", action="store_true", help="whether is to pretrain BP4D later will for DISFA dataset or not") parser.add_argument( "--pretrained_target", '-pt', default="", help="whether pretrain label set will use DISFA or not") parser.add_argument("--fix", '-fix', action="store_true", help="whether to fix first few conv layers or not") parser.add_argument( '--occlude', default='', help= 'whether to use occlude face of upper/left/right/lower/none to test') parser.add_argument("--prefix", '-prefix', default="", help="_beta, for example 3_fold_beta") parser.add_argument('--eval_mode', action='store_true', help='Use test datasets for evaluation metric') parser.add_argument("--img_resolution", type=int, default=512) parser.add_argument( "--FERA", action='store_true', help='whether to use FERA data split train and validate') parser.add_argument( '--FPN', action="store_true", help= "whether to use feature pyramid network for training and prediction") parser.add_argument( '--fake_box', action="store_true", help="whether to use fake average box coordinate to predict") parser.add_argument('--roi_align', action="store_true", help="whether to use roi_align or roi_pooling") parser.add_argument("--train_test", default="trainval", type=str) parser.add_argument("--trail_times", default=20, type=int) parser.add_argument("--each_trail_iteration", default=1000, type=int) args = parser.parse_args() if not os.path.exists(args.pid): os.makedirs(args.pid) pid = str(os.getpid()) pid_file_path = args.pid + os.sep + "{0}_{1}_fold_{2}.pid".format( args.database, args.fold, args.split_idx) # with open(pid_file_path, "w") as file_obj: # file_obj.write(pid) # file_obj.flush() config.IMG_SIZE = (args.img_resolution, args.img_resolution) print('GPU: {}'.format(args.gpu)) if args.is_pretrained: adaptive_AU_database(args.pretrained_target) else: adaptive_AU_database(args.database) np.random.seed(args.seed) # 需要先构造一个list的txt文件:id_trainval_0.txt, 每一行是subject + "/" + emotion_seq + "/" frame mc_manager = None if args.use_memcached: from collections_toolkit.memcached_manager import PyLibmcManager mc_manager = PyLibmcManager(args.memcached_host) if mc_manager is None: raise IOError("no memcached found listen in {}".format( args.memcached_host)) if args.FPN: faster_rcnn = FPN101(len(config.AU_SQUEEZE), pretrained_resnet=args.pretrained_model, use_roialign=args.roi_align, mean_path=args.mean, min_size=args.img_resolution, max_size=args.img_resolution) elif args.feature_model == 'vgg16': faster_rcnn = FasterRCNNVGG16( n_fg_class=len(config.AU_SQUEEZE), pretrained_model=args.pretrained_model, mean_file=args.mean, min_size=args.img_resolution, max_size=args.img_resolution, extract_len=args.extract_len, fix=args.fix) # 可改为/home/nco/face_expr/result/snapshot_model.npz elif args.feature_model == 'vgg19': faster_rcnn = FasterRCNNVGG19(n_fg_class=len(config.AU_SQUEEZE), pretrained_model=args.pretrained_model, mean_file=args.mean, min_size=args.img_resolution, max_size=args.img_resolution, extract_len=args.extract_len, dataset=args.database, fold=args.fold, split_idx=args.split_idx) elif args.feature_model == 'resnet101': faster_rcnn = FasterRCNNResnet101( n_fg_class=len(config.AU_SQUEEZE), pretrained_model=args.pretrained_model, mean_file=args.mean, min_size=args.img_resolution, max_size=args.img_resolution, extract_len=args.extract_len ) # 可改为/home/nco/face_expr/result/snapshot_model.npz elif args.feature_model == "mobilenet_v1": faster_rcnn = FasterRCNN_MobilenetV1( pretrained_model_type=args.pretrained_model_args, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], mean_file=args.mean, n_class=len(config.AU_SQUEEZE)) batch_size = args.batch_size with chainer.no_backprop_mode(), chainer.using_config("train", False): test_data = AUDataset(database=args.database, fold=args.fold, img_resolution=args.img_resolution, split_name=args.train_test, split_index=args.split_idx, mc_manager=mc_manager, train_all_data=False, prefix=args.prefix, pretrained_target=args.pretrained_target, is_FERA=args.FERA) test_data = TransformDataset(test_data, Transform(faster_rcnn, mirror=False)) if args.fake_box: test_data = TransformDataset(test_data, FakeBoxTransform(args.database)) if args.proc_num == 1: test_iter = SerialIterator(test_data, args.batch_size, repeat=False, shuffle=True) else: test_iter = MultiprocessIterator(test_data, batch_size=args.batch_size, n_processes=args.proc_num, repeat=False, shuffle=True, n_prefetch=10, shared_mem=10000000) gpu = int(args.gpu) if "," not in args.gpu else int( args.gpu[:args.gpu.index(",")]) chainer.cuda.get_device_from_id(gpu).use() faster_rcnn.to_gpu(gpu) evaluator = SpeedEvaluator( test_iter, faster_rcnn, lambda batch, device: concat_examples_not_none( batch, device, padding=-99), device=gpu, trail_times=args.trail_times, each_trail_iteration=args.each_trail_iteration, database=args.database) observation = evaluator.evaluate() with open(args.out + os.path.sep + "evaluation_speed_test.json", "w") as file_obj: file_obj.write( json.dumps(observation, indent=4, separators=(',', ': '))) file_obj.flush()
def main(): print("chainer cudnn enabled: {}".format(chainer.cuda.cudnn_enabled)) parser = argparse.ArgumentParser( description='Action Unit R-CNN training example:') parser.add_argument('--pid', '-pp', default='/tmp/AU_R_CNN/') parser.add_argument('--gpu', '-g', default="0", help='GPU ID, multiple GPU split by comma, \ ' 'Note that BPTT updater do not support multi-GPU') parser.add_argument('--lr', '-l', type=float, default=0.001) parser.add_argument('--out', '-o', default='result', help='Output directory') parser.add_argument('--database', default='BP4D', help='Output directory: BP4D/DISFA/BP4D_DISFA') parser.add_argument('--readtype', default='rgb', help='rgb/flow') parser.add_argument('--seed', '-s', type=int, default=0) parser.add_argument('--iteration', '-i', type=int, default=70000) parser.add_argument('--epoch', '-e', type=int, default=20) parser.add_argument('--batch_size', '-bs', type=int, default=20) parser.add_argument('--snapshot', '-snap', type=int, default=1000) parser.add_argument('--mean', default=config.ROOT_PATH + "BP4D/idx/mean_rgb.npy", help='image mean .npy file') parser.add_argument('--feature_model', default="resnet101", help="vgg or resnet101 for train") parser.add_argument('--optimizer', default='RMSprop', help='optimizer: RMSprop/AdaGrad/Adam/SGD/AdaDelta') parser.add_argument('--pretrained_model', default='resnet101', help='imagenet/vggface/resnet101/*.npz') parser.add_argument( '--use_memcached', action='store_true', help='whether use memcached to boost speed of fetch crop&mask') # parser.add_argument('--memcached_host', default='127.0.0.1') parser.add_argument("--fold", '-fd', type=int, default=3) parser.add_argument("--split_idx", '-sp', type=int, default=1) parser.add_argument("--proc_num", "-proc", type=int, default=1) parser.add_argument( "--is_pretrained", action="store_true", help="whether is to pretrain BP4D later will for DISFA dataset or not") parser.add_argument( "--pretrained_target", '-pt', default="", help="whether pretrain label set will use DISFA or not") parser.add_argument('--eval_mode', action='store_true', help='Use test datasets for evaluation metric') parser.add_argument('--test_model', default="", help='test model for evaluation') parser.add_argument( '--occlude', default='', help= 'whether to use occlude face of upper/left/right/lower/none to test') parser.add_argument("--img_resolution", type=int, default=512) args = parser.parse_args() config.IMG_SIZE = (args.img_resolution, args.img_resolution) if not os.path.exists(args.pid): os.makedirs(args.pid) pid = str(os.getpid()) pid_file_path = args.pid + os.path.sep + "{0}_{1}_fold_{2}.pid".format( args.database, args.fold, args.split_idx) with open(pid_file_path, "w") as file_obj: file_obj.write(pid) file_obj.flush() print('GPU: {}'.format(args.gpu)) if args.is_pretrained: adaptive_AU_database(args.pretrained_target) else: adaptive_AU_database(args.database) np.random.seed(args.seed) # 需要先构造一个list的txt文件:id_trainval_0.txt, 每一行是subject + "/" + emotion_seq + "/" frame mc_manager = None if args.use_memcached: from collections_toolkit.memcached_manager import PyLibmcManager mc_manager = PyLibmcManager(args.memcached_host) if mc_manager is None: raise IOError("no memcached found listen in {}".format( args.memcached_host)) resnet101 = ResNet(len(config.AU_SQUEEZE), pretrained_model=args.pretrained_model) model = TrainChain(resnet101) if args.eval_mode: with chainer.no_backprop_mode(), chainer.using_config("train", False): if args.occlude: test_data = ImageDataset( database=args.database, fold=args.fold, split_name='test', split_index=args.split_idx, mc_manager=mc_manager, train_all_data=False, pretrained_target=args.pretrained_target, img_resolution=args.img_resolution) test_data = TransformDataset( test_data, Transform(mean_rgb_path=args.mean, mirror=False)) assert args.occlude in ["upper", "lower", "left", "right"] test_data = TransformDataset(test_data, OccludeTransform(args.occlude)) if args.proc_num == 1: test_iter = SerialIterator(test_data, 1, repeat=False, shuffle=True) else: test_iter = MultiprocessIterator(test_data, batch_size=1, n_processes=args.proc_num, repeat=False, shuffle=True, n_prefetch=10, shared_mem=10000000) single_model_file_name = args.test_model chainer.serializers.load_npz(single_model_file_name, resnet101) gpu = int(args.gpu) chainer.cuda.get_device_from_id(gpu).use() resnet101.to_gpu(gpu) evaluator = AUEvaluator(test_iter, resnet101, lambda batch, device: concat_examples( batch, device, padding=0), args.database, "/home/machen/face_expr", device=gpu, npz_out_path=args.out + os.path.sep + "npz_occlude_{0}_split_{1}.npz".format( args.occlude, args.split_idx)) observation = evaluator.evaluate() with open( args.out + os.path.sep + "evaluation_occlude_{0}_fold_{1}_result_test_mode.json" .format(args.occlude, args.split_idx), "w") as file_obj: file_obj.write( json.dumps(observation, indent=4, separators=(',', ': '))) file_obj.flush() else: test_data = ImageDataset( database=args.database, fold=args.fold, split_name='test', split_index=args.split_idx, mc_manager=mc_manager, train_all_data=False, pretrained_target=args.pretrained_target, img_resolution=args.img_resolution) test_data = TransformDataset( test_data, Transform(mean_rgb_path=args.mean, mirror=False)) if args.proc_num == 1: test_iter = SerialIterator(test_data, 1, repeat=False, shuffle=False) else: test_iter = MultiprocessIterator(test_data, batch_size=1, n_processes=args.proc_num, repeat=False, shuffle=False, n_prefetch=10, shared_mem=10000000) single_model_file_name = args.test_model chainer.serializers.load_npz(single_model_file_name, resnet101) gpu = int(args.gpu) if "," not in args.gpu else int( args.gpu[:args.gpu.index(",")]) chainer.cuda.get_device_from_id(gpu).use() resnet101.to_gpu(gpu) evaluator = AUEvaluator( test_iter, resnet101, lambda batch, device: concat_examples( batch, device, padding=0), args.database, "/home/machen/face_expr", device=gpu, npz_out_path=args.out + os.path.sep + "npz_split_{}.npz".format(args.split_idx)) observation = evaluator.evaluate() with open( args.out + os.path.sep + "evaluation_split_{}_result_train_mode.json".format( args.split_idx), "w") as file_obj: file_obj.write( json.dumps(observation, indent=4, separators=(',', ': '))) file_obj.flush() return train_data = ImageDataset(database=args.database, fold=args.fold, split_name='trainval', split_index=args.split_idx, mc_manager=mc_manager, train_all_data=args.is_pretrained, read_type=args.readtype, pretrained_target=args.pretrained_target, img_resolution=args.img_resolution) train_data = TransformDataset(train_data, Transform(args.mean, mirror=True)) if args.proc_num == 1: train_iter = SerialIterator(train_data, args.batch_size, True, True) else: train_iter = MultiprocessIterator(train_data, batch_size=args.batch_size, n_processes=args.proc_num, repeat=True, shuffle=True, n_prefetch=10, shared_mem=31457280) if "," in args.gpu: for gpu in args.gpu.split(","): chainer.cuda.get_device_from_id(int(gpu)).use() else: chainer.cuda.get_device_from_id(int(args.gpu)).use() optimizer = None if args.optimizer == 'AdaGrad': optimizer = chainer.optimizers.AdaGrad( lr=args.lr ) # 原本为MomentumSGD(lr=args.lr, momentum=0.9) 由于loss变为nan问题,改为AdaGrad elif args.optimizer == 'RMSprop': optimizer = chainer.optimizers.RMSprop(lr=args.lr) elif args.optimizer == 'Adam': print("using Adam") optimizer = chainer.optimizers.Adam(alpha=args.lr) elif args.optimizer == 'SGD': optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9) elif args.optimizer == "AdaDelta": print("using AdaDelta") optimizer = chainer.optimizers.AdaDelta() optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005)) optimizer_name = args.optimizer if not os.path.exists(args.out): os.makedirs(args.out) pretrained_optimizer_file_name = '{0}_{1}_fold_{2}_{3}_{4}_optimizer.npz'.format( args.database, args.fold, args.split_idx, args.feature_model, optimizer_name) pretrained_optimizer_file_name = args.out + os.path.sep + pretrained_optimizer_file_name single_model_file_name = args.out + os.path.sep + '{0}_{1}_fold_{2}_{3}_model.npz'.format( args.database, args.fold, args.split_idx, args.feature_model) if os.path.exists(pretrained_optimizer_file_name): print("loading optimizer snatshot:{}".format( pretrained_optimizer_file_name)) chainer.serializers.load_npz(pretrained_optimizer_file_name, optimizer) if os.path.exists(single_model_file_name): print("loading pretrained snapshot:{}".format(single_model_file_name)) chainer.serializers.load_npz(single_model_file_name, model.backbone) print(" GPU({0}) updater".format(args.gpu)) updater = chainer.training.StandardUpdater( train_iter, optimizer, device=int(args.gpu), converter=lambda batch, device: concat_examples( batch, device, padding=0)) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(chainer.training.extensions.snapshot_object( optimizer, filename=os.path.basename(pretrained_optimizer_file_name)), trigger=(args.snapshot, 'iteration')) trainer.extend(chainer.training.extensions.snapshot_object( model.backbone, filename=os.path.basename(single_model_file_name)), trigger=(args.snapshot, 'iteration')) log_interval = 100, 'iteration' print_interval = 100, 'iteration' plot_interval = 100, 'iteration' if args.optimizer != "Adam" and args.optimizer != "AdaDelta": trainer.extend(chainer.training.extensions.ExponentialShift('lr', 0.1), trigger=(10, 'epoch')) elif args.optimizer == "Adam": # use Adam trainer.extend(chainer.training.extensions.ExponentialShift( "alpha", 0.5, optimizer=optimizer), trigger=(10, 'epoch')) if args.optimizer != "AdaDelta": trainer.extend(chainer.training.extensions.observe_lr(), trigger=log_interval) trainer.extend( chainer.training.extensions.LogReport( trigger=log_interval, log_name="{0}_fold_{1}.log".format(args.fold, args.split_idx))) trainer.extend(chainer.training.extensions.PrintReport([ 'iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/accuracy', ]), trigger=print_interval) trainer.extend( chainer.training.extensions.ProgressBar(update_interval=100)) if chainer.training.extensions.PlotReport.available(): trainer.extend(chainer.training.extensions.PlotReport( ['main/loss', "validation/main/loss"], file_name='loss_{0}_fold_{1}.png'.format(args.fold, args.split_idx), trigger=plot_interval), trigger=plot_interval) trainer.extend(chainer.training.extensions.PlotReport( ['main/accuracy'], file_name='accuracy_{0}_fold_{1}.png'.format( args.fold, args.split_idx), trigger=plot_interval), trigger=plot_interval) trainer.run()
def main(args): # 各種データをユニークな名前で保存するために時刻情報を取得する exec_time = GET.datetimeSHA() # Load dataset train, test, n_out = getDataset(args.in_path) # モデルを決定する actfun = GET.actfun(args.actfun) model = L.Classifier(CNT(n_out, args.n_unit, actfun, args.dropout)) if args.gpu_id >= 0: # Make a specified GPU current chainer.backends.cuda.get_device_from_id(args.gpu_id).use() model.to_gpu() # Copy the model to the GPU chainer.global_config.autotune = True # else: # model.to_intel64() # Setup an optimizer optimizer = GET.optimizer(args.optimizer).setup(model) for func_name in model.predictor.base._children: for param in model.predictor.base[func_name].params(): param.update_rule.hyperparam.alpha *= args.alpha # Setup iterator train_iter = MultiprocessIterator(train, args.batchsize) test_iter = MultiprocessIterator(test, args.batchsize, repeat=False, shuffle=False) # train_iter = chainer.iterators.SerialIterator(train, args.batchsize) # test_iter = chainer.iterators.SerialIterator(test, args.batchsize, # repeat=False, shuffle=False) # Set up a trainer updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu_id) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out_path) # Evaluate the model with the test dataset for each epoch trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu_id)) # Dump a computational graph from 'loss' variable at the first iteration # The "main" refers to the target link of the "main" optimizer. trainer.extend( extensions.dump_graph('main/loss', out_name=exec_time + '_graph.dot')) # Take a snapshot for each specified epoch frequency = args.epoch if args.frequency == -1 else max(1, args.frequency) trainer.extend(extensions.snapshot(filename=exec_time + '_{.updater.epoch}.snapshot'), trigger=(frequency, 'epoch')) # Write a log of evaluation statistics for each epoch trainer.extend(extensions.LogReport(log_name=exec_time + '.log')) # trainer.extend(extensions.observe_lr()) # Save two plot images to the result dir if args.plot and extensions.PlotReport.available(): trainer.extend( PlotReportLog(['main/loss', 'validation/main/loss'], 'epoch', file_name='loss.png')) trainer.extend( extensions.PlotReport( ['main/accuracy', 'validation/main/accuracy'], 'epoch', file_name='acc.png')) # trainer.extend( # PlotReportLog(['lr'], # 'epoch', file_name='lr.png', val_pos=(-80, -60)) # ) # Print selected entries of the log to stdout # Here "main" refers to the target link of the "main" optimizer again, and # "validation" refers to the default name of the Evaluator extension. # Entries other than 'epoch' are reported by the Classifier link, called by # either the updater or the evaluator. trainer.extend( extensions.PrintReport([ 'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', # 'lr', 'elapsed_time' ])) # Print a progress bar to stdout trainer.extend(extensions.ProgressBar()) if args.resume: # Resume from a snapshot chainer.serializers.load_npz(args.resume, trainer) # Set pruning # http://tosaka2.hatenablog.com/entry/2017/11/17/194051 masks = pruning.create_model_mask(model, args.pruning, args.gpu_id) trainer.extend(pruning.pruned(model, masks)) # predict.pyでモデルを決定する際に必要なので記憶しておく model_param = F.args2dict(args) model_param['shape'] = train[0][0].shape model_param['n_out'] = n_out if args.only_check is False: # predict.pyでモデルのパラメータを読み込むjson形式で保存する with open(F.getFilePath(args.out_path, exec_time, '.json'), 'w') as f: json.dump(model_param, f, indent=4, sort_keys=True) # Run the training trainer.run() # 最後にモデルを保存する # スナップショットを使ってもいいが、 # スナップショットはファイルサイズが大きいので chainer.serializers.save_npz( F.getFilePath(args.out_path, exec_time, '.model'), model)
if __name__ == '__main__': nlp = spacy.load('en_core_web_sm', disable=['vectors', 'textcat', 'tagger', 'ner']) ds = TextDataset('dev-v1.1.jsonl').map(json.loads) \ .map(lambda x: [token.text for token in nlp(x['question']) if not token.is_space]) # PyTorch print('PyTorch') loader = DataLoader(ds, batch_size=3, num_workers=4, shuffle=True) it = iter(loader) print(next(it)) del it # Chainer print('Chainer') it = MultiprocessIterator(ds, batch_size=3, n_processes=4, shuffle=True) print(next(it)) it.finalize() # Keras print('Keras') sequence = TextSequence(ds, batch_size=3) enqueuer = OrderedEnqueuer(sequence, use_multiprocessing=True, shuffle=True) enqueuer.start() it = enqueuer.get() print(next(it)) enqueuer.stop()
model.use_preset('evaluate') if args.det_type == 'faster': train_chain = FasterRCNNTrainChain(model) train_transform = FasterRCNNTransform(model) else: train_chain = SSDMultiboxTrainChain(model) train_transform = SSDTransform(model.coder, model.insize, model.mean) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() train = TransformDataset(datasets_train, train_transform) train_iter = MultiprocessIterator(train, args.batchsize, n_processes=4, shared_mem=100000000) test_iter = SerialIterator(dataset_test, args.batchsize, repeat=False, shuffle=False) optimizer = chainer.optimizers.MomentumSGD(lr=args.init_lr) optimizer.setup(train_chain) for param in train_chain.params(): if param.name == 'b': param.update_rule.add_hook(GradientScaling(2)) else: param.update_rule.add_hook(WeightDecay(0.0005))
def main(): parser = argparse.ArgumentParser(description='Chainer example: MNIST') parser.add_argument('--batchsize', '-b', type=int, default=100, help='Number of images in each mini-batch') parser.add_argument('--epoch', '-e', type=int, default=20, help='Number of sweeps over the dataset to train') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--resume', '-r', default='', help='Resume the training from snapshot using model ' 'and state files in the specified directory') parser.add_argument('--unit', '-u', type=int, default=1000, help='Number of units') args = parser.parse_args() print('GPU: {}'.format(args.gpu)) print('# unit: {}'.format(args.unit)) print('# Minibatch-size: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('') # Set up a neural network to train model = L.Classifier(train_mnist.MLP(args.unit, 10)) if args.gpu >= 0: # Make a speciied GPU current chainer.backends.cuda.get_device_from_id(args.gpu).use() model.to_gpu() # Copy the model to the GPU # Setup an optimizer optimizer = chainer.optimizers.Adam() optimizer.setup(model) if args.resume: # Resume from a snapshot serializers.load_npz('{}/mlp.model'.format(args.resume), model) serializers.load_npz('{}/mlp.state'.format(args.resume), optimizer) # Load the MNIST dataset train, test = chainer.datasets.get_mnist() train_count = len(train) test_count = len(test) with MultiprocessIterator(train, args.batchsize) as train_iter, \ MultiprocessIterator(test, args.batchsize, repeat=False, shuffle=False) as test_iter: sum_accuracy = 0 sum_loss = 0 while train_iter.epoch < args.epoch: batch = train_iter.next() x_array, t_array = convert.concat_examples(batch, args.gpu) x = chainer.Variable(x_array) t = chainer.Variable(t_array) optimizer.update(model, x, t) sum_loss += float(model.loss.data) * len(t.data) sum_accuracy += float(model.accuracy.data) * len(t.data) if train_iter.is_new_epoch: print('epoch: {}'.format(train_iter.epoch)) print('train mean loss: {}, accuracy: {}'.format( sum_loss / train_count, sum_accuracy / train_count)) # evaluation sum_accuracy = 0 sum_loss = 0 for batch in test_iter: x_array, t_array = convert.concat_examples(batch, args.gpu) x = chainer.Variable(x_array) t = chainer.Variable(t_array) loss = model(x, t) sum_loss += float(loss.data) * len(t.data) sum_accuracy += float(model.accuracy.data) * len(t.data) test_iter.reset() print('test mean loss: {}, accuracy: {}'.format( sum_loss / test_count, sum_accuracy / test_count)) sum_accuracy = 0 sum_loss = 0 # Save the model and the optimizer print('save the model') serializers.save_npz('{}/mlp.model'.format(args.out), model) print('save the optimizer') serializers.save_npz('{}/mlp.state'.format(args.out), optimizer)
def main(): parser = argparse.ArgumentParser(description="LapSRN") parser.add_argument("--dataset", type=str) parser.add_argument("--outdirname", type=str, default="./models") parser.add_argument("--scale", type=int, default=4) parser.add_argument("--batchsize", type=int, default=64) parser.add_argument("--epoch", type=int, default=100) parser.add_argument("--steps_per_epoch", type=int, default=128) parser.add_argument("--model", default=None) parser.add_argument("--gpu", type=int, default=-1) args = parser.parse_args() print('GPU: {}'.format(args.gpu)) print('# dataset: {}'.format(args.dataset)) print('# outdirname: {}'.format(args.outdirname)) print('# scale: {}'.format(args.scale)) print('# batchsize: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('# steps_per_epoch: {}'.format(args.steps_per_epoch)) print('# model: {}'.format(args.model)) print('') OUTPUT_DIRECTORY = args.outdirname if not os.path.exists(OUTPUT_DIRECTORY): os.makedirs(OUTPUT_DIRECTORY) model = LapSRN() if args.model is not None: print("Loading model...") serializers.load_npz(args.model, model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() xp = cuda.cupy else: xp = np optimizer = Adam() optimizer.setup(model) print("loading dataset...") paths = glob.glob(args.dataset) train_dataset = ImageDataset(scale=args.scale, paths=paths, dtype=xp.float32, cropsize=96) iterator = MultiprocessIterator(train_dataset, batch_size=args.batchsize, repeat=True, shuffle=True) step = 0 epoch = 0 loss = 0 print("training...") for zipped_batch in iterator: lr = chainer.Variable(xp.array([zipped[0] for zipped in zipped_batch])) hr = chainer.Variable(xp.array([zipped[1] for zipped in zipped_batch])) sr = model(lr) loss += l1_charbonnier(sr, hr, model).data optimizer.update(l1_charbonnier, sr, hr, model) if step % args.steps_per_epoch == 0: loss /= args.steps_per_epoch print("Epoch: {}, Loss: {}, PSNR: {}".format( epoch, loss, PSNR(sr.data[0], hr.data[0]))) chainer.serializers.save_npz( os.path.join(OUTPUT_DIRECTORY, "model_{}.npz".format(epoch)), model) epoch += 1 loss = 0 step += 1 if epoch > args.epoch: break print("Done")
# Setup an optimizer if args.opt == 'nesterov': optimizer = chainermn.create_multi_node_optimizer( chainer.optimizers.NesterovAG(), comm) else: optimizer = chainermn.create_multi_node_optimizer( chainer.optimizers.MomentumSGD(), comm) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(float(args.wd))) train = chainermn.scatter_dataset(train, comm, shuffle=True) test = chainermn.scatter_dataset(test, comm) train_iter = MultiprocessIterator(train, args.batchsize // comm.size, n_processes=8) test_iter = MultiprocessIterator(test, args.test_batchsize // comm.size, repeat=False, shuffle=False, n_processes=8) updater = training.StandardUpdater(train_iter, optimizer, device=device) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=output_dir) if args.cosine: trainer.extend( CosineAnnealing('lr', int(args.epoch), len(train) / (args.batchsize // comm.size),
if args.data_aug: name += "_data_aug" print("name: ", name) resize_shape = (512, 512) train, valid = get_coco( resize_shape, args.dice_coef, args.dir, data_aug=args.data_aug ) # type: Tuple[Iterator[np.ndarray], Iterator[np.ndarray]] train_iter = convert_to_keras_batch( #SerialIterator( MultiprocessIterator( train, batch_size=8, n_processes=12, n_prefetch=120, shared_mem=1000 * 1000 * 5)) # type: Iterator[Tuple[np.ndarray, np.ndarray]] valid_iter = convert_to_keras_batch( #SerialIterator( MultiprocessIterator( valid, batch_size=8, #repeat=False, shuffle=False, n_processes=12, n_prefetch=120, shared_mem=1000 * 1000 * 5)) # type: Iterator[Tuple[np.ndarray, np.ndarray]]
from chainer.training.updaters import StandardUpdater from chainercv.links.model.resnet import ResNet50 from models.arcface import ArcFace from paired_image_dataset import PairedImageSet chainer.config.cv_resize_backend = 'cv2' if __name__ == "__main__": photo_path = sorted(Path('photos').glob('*')) sketch_path = sorted(Path('sketches').glob('*')) pair_list = [[str(i), str(j)] for i, j in zip(photo_path, sketch_path)] img_size = (200, 250) dataset = PairedImageSet(pair_list, '', img_size, False, np.float32) iter_train = MultiprocessIterator(dataset, 5, n_processes=2) adam = Adam(alpha=0.002, beta1=0.0, beta2=0.9) resnet = ResNet50(pretrained_model='imagenet') fc_dim = 500 resnet.fc6 = L.Linear(None, fc_dim) # change the number of fc layer to 500 temp = 30 margin = 0.5 arcface = ArcFace(temp, margin, resnet) adam.setup(arcface) updater = StandardUpdater(iter_train, adam) trainer = Trainer(updater, (1000, 'iteration')) trainer.run()
def main(): parser = argparse.ArgumentParser( description='Space Time Action Unit R-CNN training example:') parser.add_argument('--pid', '-pp', default='/tmp/SpaceTime_AU_R_CNN/') parser.add_argument('--gpu', '-g', nargs='+', type=int, help='GPU ID, multiple GPU split by space') parser.add_argument('--lr', '-l', type=float, default=0.001) parser.add_argument('--out', '-o', default='output_two_stream', help='Output directory') parser.add_argument('--database', default='BP4D', help='Output directory: BP4D/DISFA/BP4D_DISFA') parser.add_argument('--iteration', '-i', type=int, default=70000) parser.add_argument('--epoch', '-e', type=int, default=20) parser.add_argument('--batch_size', '-bs', type=int, default=1) parser.add_argument('--snapshot', '-snap', type=int, default=1000) parser.add_argument('--mean_rgb', default=config.ROOT_PATH + "BP4D/idx/mean_rgb.npy", help='image mean .npy file') parser.add_argument('--mean_flow', default=config.ROOT_PATH + "BP4D/idx/mean_flow.npy", help='image mean .npy file') parser.add_argument('--backbone', default="resnet101", help="vgg/resnet101/mobilenet_v1 for train") parser.add_argument('--optimizer', default='SGD', help='optimizer: RMSprop/AdaGrad/Adam/SGD/AdaDelta') parser.add_argument('--pretrained_model_rgb', help='imagenet/mobilenet_v1/resnet101/*.npz') parser.add_argument( '--pretrained_model_flow', help= "path of optical flow pretrained model, can also use the same npz with rgb" ) parser.add_argument('--two_stream_mode', type=TwoStreamMode, choices=list(TwoStreamMode), help='rgb_flow/ optical_flow/ rgb') parser.add_argument( '--use_memcached', action='store_true', help='whether use memcached to boost speed of fetch crop&mask') # parser.add_argument('--memcached_host', default='127.0.0.1') parser.add_argument("--fold", '-fd', type=int, default=3) parser.add_argument("--fix", action="store_true", help="fix parameter of conv2 update when finetune") parser.add_argument("--split_idx", '-sp', type=int, default=1) parser.add_argument("--use_paper_num_label", action="store_true", help="only to use paper reported number of labels" " to train") parser.add_argument( "--roi_align", action="store_true", help="whether to use roi align or roi pooling layer in CNN") parser.add_argument("--T", '-T', type=int, default=10) parser.add_argument("--proc_num", "-proc", type=int, default=1) args = parser.parse_args() os.makedirs(args.pid, exist_ok=True) os.makedirs(args.out, exist_ok=True) pid = str(os.getpid()) pid_file_path = args.pid + os.sep + "{0}_{1}_fold_{2}.pid".format( args.database, args.fold, args.split_idx) with open(pid_file_path, "w") as file_obj: file_obj.write(pid) file_obj.flush() print('GPU: {}'.format(",".join(list(map(str, args.gpu))))) adaptive_AU_database(args.database) mc_manager = None if args.use_memcached: from collections_toolkit.memcached_manager import PyLibmcManager mc_manager = PyLibmcManager(args.memcached_host) if mc_manager is None: raise IOError("no memcached found listen in {}".format( args.memcached_host)) paper_report_label, class_num = squeeze_label_num_report( args.database, args.use_paper_num_label) paper_report_label_idx = list(paper_report_label.keys()) au_rcnn_train_chain_list = [] if args.backbone == 'vgg': au_rcnn = AU_RCNN_VGG16(pretrained_model=args.pretrained_model_rgb, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], use_roi_align=args.roi_align) au_rcnn_train_chain = AU_RCNN_ROI_Extractor(au_rcnn) au_rcnn_train_chain_list.append(au_rcnn_train_chain) elif args.backbone == 'resnet101': if args.two_stream_mode != TwoStreamMode.rgb_flow: assert (args.pretrained_model_rgb == "" and args.pretrained_model_flow != "") or\ (args.pretrained_model_rgb != "" and args.pretrained_model_flow == "") pretrained_model = args.pretrained_model_rgb if args.pretrained_model_rgb else args.pretrained_model_flow au_rcnn = AU_RCNN_Resnet101( pretrained_model=pretrained_model, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], use_roi_align=args.roi_align, use_optical_flow_input=( args.two_stream_mode == TwoStreamMode.optical_flow), temporal_length=args.T) au_rcnn_train_chain = AU_RCNN_ROI_Extractor(au_rcnn) au_rcnn_train_chain_list.append(au_rcnn_train_chain) else: # rgb_flow mode au_rcnn_rgb = AU_RCNN_Resnet101( pretrained_model=args.pretrained_model_rgb, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], use_roi_align=args.roi_align, use_optical_flow_input=False, temporal_length=args.T) au_rcnn_optical_flow = AU_RCNN_Resnet101( pretrained_model=args.pretrained_model_flow, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], use_roi_align=args.roi_align, use_optical_flow_input=True, temporal_length=args.T) au_rcnn_train_chain_rgb = AU_RCNN_ROI_Extractor(au_rcnn_rgb) au_rcnn_train_chain_optical_flow = AU_RCNN_ROI_Extractor( au_rcnn_optical_flow) au_rcnn_train_chain_list.append(au_rcnn_train_chain_rgb) au_rcnn_train_chain_list.append(au_rcnn_train_chain_optical_flow) model = Wrapper(au_rcnn_train_chain_list, class_num, args.database, args.T, two_stream_mode=args.two_stream_mode, gpus=args.gpu) batch_size = args.batch_size img_dataset = AUDataset(database=args.database, L=args.T, fold=args.fold, split_name='trainval', split_index=args.split_idx, mc_manager=mc_manager, two_stream_mode=args.two_stream_mode, train_all_data=False, paper_report_label_idx=paper_report_label_idx) train_dataset = TransformDataset( img_dataset, Transform(L=args.T, mirror=True, mean_rgb_path=args.mean_rgb, mean_flow_path=args.mean_flow)) if args.proc_num == 1: train_iter = SerialIterator(train_dataset, batch_size, repeat=True, shuffle=True) else: train_iter = MultiprocessIterator(train_dataset, batch_size=batch_size, n_processes=args.proc_num, repeat=True, shuffle=True, n_prefetch=3, shared_mem=53457280) if len(args.gpu) > 1: for gpu in args.gpu: chainer.cuda.get_device_from_id(gpu).use() else: chainer.cuda.get_device_from_id(args.gpu[0]).use() model.to_gpu(args.gpu[0]) optimizer = None if args.optimizer == 'AdaGrad': optimizer = chainer.optimizers.AdaGrad( lr=args.lr ) # 原本为MomentumSGD(lr=args.lr, momentum=0.9) 由于loss变为nan问题,改为AdaGrad elif args.optimizer == 'RMSprop': optimizer = chainer.optimizers.RMSprop(lr=args.lr) elif args.optimizer == 'Adam': optimizer = chainer.optimizers.Adam(alpha=args.lr) elif args.optimizer == 'SGD': optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9) elif args.optimizer == "AdaDelta": optimizer = chainer.optimizers.AdaDelta() optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005)) optimizer_name = args.optimizer # BP4D_3_fold_1_resnet101@rnn@no_temporal@use_paper_num_label@roi_align@label_dep_layer@conv_lstm@sampleframe#13_model.npz use_paper_key_str = "use_paper_num_label" if args.use_paper_num_label else "all_avail_label" roi_align_key_str = "roi_align" if args.roi_align else "roi_pooling" single_model_file_name = args.out + os.sep + \ '{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@T#{7}_model.npz'.format(args.database, args.fold, args.split_idx, args.backbone, args.two_stream_mode, use_paper_key_str, roi_align_key_str, args.T) print(single_model_file_name) pretrained_optimizer_file_name = args.out + os.sep + \ '{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@T#{7}_optimizer.npz'.format( args.database, args.fold, args.split_idx, args.backbone, args.two_stream_mode, use_paper_key_str, roi_align_key_str, args.T) print(pretrained_optimizer_file_name) if os.path.exists(pretrained_optimizer_file_name): print("loading optimizer snatshot:{}".format( pretrained_optimizer_file_name)) chainer.serializers.load_npz(pretrained_optimizer_file_name, optimizer) if os.path.exists(single_model_file_name): print("loading pretrained snapshot:{}".format(single_model_file_name)) chainer.serializers.load_npz(single_model_file_name, model) if args.fix: au_rcnn = model.au_rcnn_train_chain.au_rcnn au_rcnn.extractor.conv1.W.update_rule.enabled = False au_rcnn.extractor.bn1.gamma.update_rule.enabled = False au_rcnn.extractor.bn1.beta.update_rule.enabled = False res2_names = ["a", "b1", "b2"] for res2_name in res2_names: if res2_name == "a": getattr(au_rcnn.extractor.res2, res2_name).conv1.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn1.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn1.beta.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).conv2.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).conv3.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).conv4.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn2.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn2.beta.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn3.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn3.beta.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn4.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn4.beta.update_rule.enabled = False elif res2_name.startswith("b"): getattr(au_rcnn.extractor.res2, res2_name).conv1.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn1.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn1.beta.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).conv2.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).conv3.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn2.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn2.beta.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn3.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn3.beta.update_rule.enabled = False updater = chainer.training.StandardUpdater( train_iter, optimizer, device=args.gpu[0], converter=lambda batch, device: concat_examples( batch, device, padding=0)) trainer = training.Trainer(updater, (10, 'iteration'), out=args.out) trainer.extend(chainer.training.extensions.snapshot_object( optimizer, filename=os.path.basename(pretrained_optimizer_file_name)), trigger=(args.snapshot, 'iteration')) trainer.extend(chainer.training.extensions.snapshot_object( model, filename=os.path.basename(single_model_file_name)), trigger=(args.snapshot, 'iteration')) log_interval = 100, 'iteration' print_interval = 100, 'iteration' plot_interval = 10, 'iteration' if args.optimizer != "Adam" and args.optimizer != "AdaDelta": trainer.extend(chainer.training.extensions.ExponentialShift('lr', 0.1), trigger=(10, 'epoch')) elif args.optimizer == "Adam": trainer.extend(chainer.training.extensions.ExponentialShift( "alpha", 0.1, optimizer=optimizer), trigger=(10, 'epoch')) if args.optimizer != "AdaDelta": trainer.extend(chainer.training.extensions.observe_lr(), trigger=log_interval) trainer.extend( chainer.training.extensions.LogReport( trigger=log_interval, log_name="log_{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@T#{7}.log".format( args.database, args.fold, args.split_idx, args.backbone, args.two_stream_mode, use_paper_key_str, roi_align_key_str, args.T))) # trainer.reporter.add_observer("main_par", model.loss_head_module) trainer.extend(chainer.training.extensions.PrintReport([ 'iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/accuracy', ]), trigger=print_interval) trainer.extend( chainer.training.extensions.ProgressBar(update_interval=100)) if chainer.training.extensions.PlotReport.available(): trainer.extend(chainer.training.extensions.PlotReport( ['main/loss'], file_name="loss_{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@T#{7}.png".format( args.database, args.fold, args.split_idx, args.backbone, args.two_stream_mode, use_paper_key_str, roi_align_key_str, args.T), trigger=plot_interval), trigger=plot_interval) trainer.extend(chainer.training.extensions.PlotReport( ['main/accuracy'], file_name="accuracy_{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@T#{7}.png". format(args.database, args.fold, args.split_idx, args.backbone, args.two_stream_mode, use_paper_key_str, roi_align_key_str, args.T), trigger=plot_interval), trigger=plot_interval) # trainer.run() cProfile.runctx("trainer.run()", globals(), locals(), "Profile.prof") s = pstats.Stats("Profile.prof") s.strip_dirs().sort_stats("time").print_stats()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--batchsize', '-b', type=int, default=32, help='Number of images in each mini-batch') parser.add_argument('--epoch', '-e', type=int, default=100, help='Number of sweeps over the dataset to train') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--source', default='mnist') parser.add_argument('--target', default='mnist_m') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--resume', '-r', default='', help='Resume the training from snapshot') parser.add_argument('--seed', type=int, default=0, help='Random seed of z at visualization stage') parser.add_argument('--n_processes', type=int, default=16, help='Interval of displaying log to console') args = parser.parse_args() print('GPU: {}'.format(args.gpu)) print('# Minibatch-size: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('') # Set up a neural network to train gen = Generator( n_hidden=params['gen']['n_hidden'], n_resblock=params['gen']['n_resblock'], n_ch=params['gen']['n_ch'], wscale=params['gaussian_wscale'], res=params['res_image'], bn_eps=params['bn_eps']) dis = Discriminator( n_ch=params['dis']['n_ch'], wscale=params['gaussian_wscale'], bn_eps=params['bn_eps'], dr_prob=params['dis']['dropout_prob'], noise_sigma=params['dis']['noise_sigma'] ) cls = L.Classifier(DigitClassifier(n_class=params['n_class'])) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() gen.to_gpu() dis.to_gpu() cls.to_gpu() p_opt = params['optimize'] # Setup an optimizer def make_optimizer(model): optimizer = chainer.optimizers.Adam(alpha=p_opt['base_lr'], beta1=p_opt['beta1']) optimizer.setup(model) optimizer.add_hook( chainer.optimizer.WeightDecay(p_opt['weight_decay'])) return optimizer opt_gen = make_optimizer(gen) opt_dis = make_optimizer(dis) opt_cls = make_optimizer(cls) def load_dataset(name, dtype='train'): if name == 'mnist': train, _ = chainer.datasets.get_mnist(withlabel=True, ndim=3) dataset = TransformDataset(train, transform=gray2rgb) return TransformDataset(dataset, transform=scale) elif name == 'mnist_m': dataset = get_mnist_m(dtype, withlabel=True) return TransformDataset(dataset, transform=scale) else: raise NotImplementedError source = load_dataset(args.source) # from chainer.datasets import split_dataset # source, _ = split_dataset(source, split_at=1000) target_train = load_dataset(args.target, dtype='train') source_iter = MultiprocessIterator( source, args.batchsize, n_processes=args.n_processes) target_train_iter = MultiprocessIterator( target_train, args.batchsize, n_processes=args.n_processes) # Set up a trainer updater = PixelDAUpdater( models=(gen, dis, cls), iterator={'main': source_iter, 'target': target_train_iter}, optimizer={ 'gen': opt_gen, 'dis': opt_dis, 'cls': opt_cls}, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) snapshot_interval = (1, 'epoch') display_interval = (10, 'iteration') for opt in [opt_gen, opt_cls, opt_dis]: trainer.extend( extensions.ExponentialShift('alpha', p_opt['alpha_decay_rate'], optimizer=opt), trigger=(p_opt['alpha_decay_steps'], 'iteration')) trainer.extend( extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.npz'), trigger=snapshot_interval) trainer.extend(extensions.LogReport(trigger=display_interval)) trainer.extend(extensions.PrintReport([ 'epoch', 'iteration', 'gen/loss', 'dis/loss', 'cls/loss', 'validation/main/accuracy' ]), trigger=display_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) # Save two plot images to the result dir if extensions.PlotReport.available(): trainer.extend( extensions.PlotReport(['gen/loss', 'dis/loss', 'cls/loss'], 'iteration', trigger=(100, 'iteration'), file_name='loss.png')) trainer.extend( extensions.PlotReport(['validation/main/accuracy'], 'epoch', file_name='accuracy.png')) # Dump examples of generated images for every epoch trainer.extend(out_generated_image(source_iter, gen, args.gpu, args.out)) # Evaluate the model with the test dataset for each epoch target_test = load_dataset(args.target, dtype='test') target_test_iter = MultiprocessIterator( target_test, args.batchsize, n_processes=args.n_processes, repeat=False, shuffle=False) trainer.extend( extensions.Evaluator(target_test_iter, cls, device=args.gpu)) # Visualize computational graph for debug # trainer.extend(extensions.dump_graph('gen/loss', out_name='gen.dot')) # trainer.extend(extensions.dump_graph('dis/loss', out_name='dis.dot')) # trainer.extend(extensions.dump_graph('cls/loss', out_name='cls.dot')) if args.resume: # Resume from a snapshot chainer.serializers.load_npz(args.resume, trainer) # Run the training trainer.run()
def main(): parser = argparse.ArgumentParser( description='Space Time Action Unit R-CNN training example:') parser.add_argument('--pid', '-pp', default='/tmp/SpaceTime_AU_R_CNN/') parser.add_argument('--gpu', '-g', nargs='+', type=int, help='GPU ID, multiple GPU split by space') parser.add_argument('--lr', '-l', type=float, default=0.001) parser.add_argument('--out', '-o', default='end_to_end_result', help='Output directory') parser.add_argument('--database', default='BP4D', help='Output directory: BP4D/DISFA/BP4D_DISFA') parser.add_argument('--iteration', '-i', type=int, default=70000) parser.add_argument('--epoch', '-e', type=int, default=20) parser.add_argument('--batch_size', '-bs', type=int, default=1) parser.add_argument('--snapshot', '-snap', type=int, default=1000) parser.add_argument('--need_validate', action='store_true', help='do or not validate during training') parser.add_argument('--mean', default=config.ROOT_PATH + "BP4D/idx/mean_no_enhance.npy", help='image mean .npy file') parser.add_argument('--backbone', default="mobilenet_v1", help="vgg/resnet101/mobilenet_v1 for train") parser.add_argument('--optimizer', default='SGD', help='optimizer: RMSprop/AdaGrad/Adam/SGD/AdaDelta') parser.add_argument('--pretrained_model_rgb', help='imagenet/mobilenet_v1/resnet101/*.npz') parser.add_argument( '--pretrained_model_of', help= "path of optical flow pretrained model (may be single stream OF model)" ) parser.add_argument('--pretrained_model_args', nargs='+', type=float, help='you can pass in "1.0 224" or "0.75 224"') parser.add_argument('--spatial_edge_mode', type=SpatialEdgeMode, choices=list(SpatialEdgeMode), help='1:all_edge, 2:configure_edge, 3:no_edge') parser.add_argument('--spatial_sequence_type', type=SpatialSequenceType, choices=list(SpatialSequenceType), help='1:all_edge, 2:configure_edge, 3:no_edge') parser.add_argument( '--temporal_edge_mode', type=TemporalEdgeMode, choices=list(TemporalEdgeMode), help='1:rnn, 2:attention_block, 3.point-wise feed forward(no temporal)' ) parser.add_argument('--two_stream_mode', type=TwoStreamMode, choices=list(TwoStreamMode), help='spatial/ temporal/ spatial_temporal') parser.add_argument('--conv_rnn_type', type=ConvRNNType, choices=list(ConvRNNType), help='conv_lstm or conv_sru') parser.add_argument("--bi_lstm", action="store_true", help="whether to use bi-lstm as Edge/Node RNN") parser.add_argument( '--use_memcached', action='store_true', help='whether use memcached to boost speed of fetch crop&mask') # parser.add_argument('--memcached_host', default='127.0.0.1') parser.add_argument("--fold", '-fd', type=int, default=3) parser.add_argument("--layers", type=int, default=1) parser.add_argument("--label_win_size", type=int, default=3) parser.add_argument("--fix", action="store_true", help="fix parameter of conv2 update when finetune") parser.add_argument("--x_win_size", type=int, default=1) parser.add_argument("--use_label_dependency", action="store_true", help="use label dependency layer after conv_lstm") parser.add_argument("--dynamic_backbone", action="store_true", help="use dynamic backbone: conv lstm as backbone") parser.add_argument("--ld_rnn_dropout", type=float, default=0.4) parser.add_argument("--split_idx", '-sp', type=int, default=1) parser.add_argument("--use_paper_num_label", action="store_true", help="only to use paper reported number of labels" " to train") parser.add_argument( "--roi_align", action="store_true", help="whether to use roi align or roi pooling layer in CNN") parser.add_argument("--debug", action="store_true", help="debug mode for 1/50 dataset") parser.add_argument("--sample_frame", '-sample', type=int, default=10) parser.add_argument( "--snap_individual", action="store_true", help="whether to snapshot each individual epoch/iteration") parser.add_argument("--proc_num", "-proc", type=int, default=1) parser.add_argument("--fetch_mode", type=int, default=1) parser.add_argument('--eval_mode', action='store_true', help='Use test datasets for evaluation metric') args = parser.parse_args() os.makedirs(args.pid, exist_ok=True) os.makedirs(args.out, exist_ok=True) pid = str(os.getpid()) pid_file_path = args.pid + os.sep + "{0}_{1}_fold_{2}.pid".format( args.database, args.fold, args.split_idx) # with open(pid_file_path, "w") as file_obj: # file_obj.write(pid) # file_obj.flush() print('GPU: {}'.format(",".join(list(map(str, args.gpu))))) adaptive_AU_database(args.database) mc_manager = None if args.use_memcached: from collections_toolkit.memcached_manager import PyLibmcManager mc_manager = PyLibmcManager(args.memcached_host) if mc_manager is None: raise IOError("no memcached found listen in {}".format( args.memcached_host)) paper_report_label, class_num = squeeze_label_num_report( args.database, args.use_paper_num_label) paper_report_label_idx = list(paper_report_label.keys()) use_feature_map_res45 = (args.conv_rnn_type != ConvRNNType.conv_rcnn) and ( args.conv_rnn_type != ConvRNNType.fc_lstm) use_au_rcnn_loss = (args.conv_rnn_type == ConvRNNType.conv_rcnn) au_rcnn_train_chain_list = [] if args.backbone == 'vgg': au_rcnn = AU_RCNN_VGG16(pretrained_model=args.pretrained_model_rgb, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], mean_file=args.mean, use_roi_align=args.roi_align) au_rcnn_train_chain = AU_RCNN_ROI_Extractor(au_rcnn) au_rcnn_train_chain_list.append(au_rcnn_train_chain) elif args.backbone == 'resnet101': if args.two_stream_mode != TwoStreamMode.spatial_temporal: pretrained_model = args.pretrained_model_rgb if args.pretrained_model_rgb else args.pretrained_model_of au_rcnn = AU_RCNN_Resnet101( pretrained_model=pretrained_model, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], mean_file=args.mean, classify_mode=use_au_rcnn_loss, n_class=class_num, use_roi_align=args.roi_align, use_feature_map_res45=use_feature_map_res45, use_feature_map_res5=(args.conv_rnn_type != ConvRNNType.fc_lstm or args.conv_rnn_type == ConvRNNType.sep_conv_lstm), use_optical_flow_input=( args.two_stream_mode == TwoStreamMode.optical_flow), temporal_length=args.sample_frame) au_rcnn_train_chain = AU_RCNN_ROI_Extractor(au_rcnn) au_rcnn_train_chain_list.append(au_rcnn_train_chain) else: au_rcnn_rgb = AU_RCNN_Resnet101( pretrained_model=args.pretrained_model_rgb, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], mean_file=args.mean, classify_mode=use_au_rcnn_loss, n_class=class_num, use_roi_align=args.roi_align, use_feature_map_res45=use_feature_map_res45, use_feature_map_res5=(args.conv_rnn_type != ConvRNNType.fc_lstm or args.conv_rnn_type == ConvRNNType.sep_conv_lstm), use_optical_flow_input=False, temporal_length=args.sample_frame) au_rcnn_optical_flow = AU_RCNN_Resnet101( pretrained_model=args.pretrained_model_of, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], mean_file=args.mean, classify_mode=use_au_rcnn_loss, n_class=class_num, use_roi_align=args.roi_align, use_feature_map_res45=use_feature_map_res45, use_feature_map_res5=(args.conv_rnn_type != ConvRNNType.fc_lstm or args.conv_rnn_type == ConvRNNType.sep_conv_lstm), use_optical_flow_input=True, temporal_length=args.sample_frame) au_rcnn_train_chain_rgb = AU_RCNN_ROI_Extractor(au_rcnn_rgb) au_rcnn_train_chain_optical_flow = AU_RCNN_ROI_Extractor( au_rcnn_optical_flow) au_rcnn_train_chain_list.append(au_rcnn_train_chain_rgb) au_rcnn_train_chain_list.append(au_rcnn_train_chain_optical_flow) elif args.backbone == "mobilenet_v1": au_rcnn = AU_RCNN_MobilenetV1( pretrained_model_type=args.pretrained_model_args, min_size=config.IMG_SIZE[0], max_size=config.IMG_SIZE[1], mean_file=args.mean, classify_mode=use_au_rcnn_loss, n_class=class_num, use_roi_align=args.roi_align) au_rcnn_train_chain = AU_RCNN_ROI_Extractor(au_rcnn) if use_au_rcnn_loss: au_rcnn_train_loss = AU_RCNN_TrainChainLoss() loss_head_module = au_rcnn_train_loss elif args.conv_rnn_type == ConvRNNType.conv_lstm: label_dependency_layer = None if args.use_label_dependency: label_dependency_layer = LabelDependencyRNNLayer( args.database, in_size=2048, class_num=class_num, train_mode=True, label_win_size=args.label_win_size) space_time_conv_lstm = SpaceTimeConv( label_dependency_layer, args.use_label_dependency, class_num, spatial_edge_mode=args.spatial_edge_mode, temporal_edge_mode=args.temporal_edge_mode, conv_rnn_type=args.conv_rnn_type) loss_head_module = space_time_conv_lstm elif args.conv_rnn_type == ConvRNNType.sep_conv_lstm: space_time_sep_conv_lstm = SpaceTimeSepConv( database=args.database, class_num=class_num, spatial_edge_mode=args.spatial_edge_mode, temporal_edge_mode=args.temporal_edge_mode) loss_head_module = space_time_sep_conv_lstm elif args.conv_rnn_type == ConvRNNType.fc_lstm: space_time_fc_lstm = SpaceTimeSepFcLSTM( database=args.database, class_num=class_num, spatial_edge_mode=args.spatial_edge_mode, temporal_edge_mode=args.temporal_edge_mode) loss_head_module = space_time_fc_lstm model = Wrapper(au_rcnn_train_chain_list, loss_head_module, args.database, args.sample_frame, use_feature_map=use_feature_map_res45, two_stream_mode=args.two_stream_mode) batch_size = args.batch_size img_dataset = AUDataset(database=args.database, fold=args.fold, split_name='trainval', split_index=args.split_idx, mc_manager=mc_manager, train_all_data=False) train_video_data = AU_video_dataset( au_image_dataset=img_dataset, sample_frame=args.sample_frame, train_mode=(args.two_stream_mode != TwoStreamMode.optical_flow), paper_report_label_idx=paper_report_label_idx, ) Transform = Transform3D train_video_data = TransformDataset(train_video_data, Transform(au_rcnn, mirror=False)) if args.proc_num == 1: train_iter = SerialIterator(train_video_data, batch_size * args.sample_frame, repeat=True, shuffle=False) else: train_iter = MultiprocessIterator(train_video_data, batch_size=batch_size * args.sample_frame, n_processes=args.proc_num, repeat=True, shuffle=False, n_prefetch=10, shared_mem=10000000) if len(args.gpu) > 1: for gpu in args.gpu: chainer.cuda.get_device_from_id(gpu).use() else: chainer.cuda.get_device_from_id(args.gpu[0]).use() model.to_gpu(args.gpu[0]) optimizer = None if args.optimizer == 'AdaGrad': optimizer = chainer.optimizers.AdaGrad( lr=args.lr ) # 原本为MomentumSGD(lr=args.lr, momentum=0.9) 由于loss变为nan问题,改为AdaGrad elif args.optimizer == 'RMSprop': optimizer = chainer.optimizers.RMSprop(lr=args.lr) elif args.optimizer == 'Adam': optimizer = chainer.optimizers.Adam(alpha=args.lr) elif args.optimizer == 'SGD': optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9) elif args.optimizer == "AdaDelta": optimizer = chainer.optimizers.AdaDelta() optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005)) optimizer_name = args.optimizer key_str = "{0}_fold_{1}".format(args.fold, args.split_idx) file_list = [] file_list.extend(os.listdir(args.out)) snapshot_model_file_name = args.out + os.sep + filter_last_checkpoint_filename( file_list, "model", key_str) # BP4D_3_fold_1_resnet101@rnn@no_temporal@use_paper_num_label@roi_align@label_dep_layer@conv_lstm@sampleframe#13_model.npz use_paper_key_str = "use_paper_num_label" if args.use_paper_num_label else "all_avail_label" roi_align_key_str = "roi_align" if args.roi_align else "roi_pooling" label_dependency_layer_key_str = "label_dep_layer" if args.use_label_dependency else "no_label_dep" single_model_file_name = args.out + os.sep + \ '{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@{7}@{8}@{9}@sampleframe#{10}_model.npz'.format(args.database, args.fold, args.split_idx, args.backbone, args.spatial_edge_mode, args.temporal_edge_mode, use_paper_key_str, roi_align_key_str, label_dependency_layer_key_str, args.conv_rnn_type,args.sample_frame )#, args.label_win_size) print(single_model_file_name) pretrained_optimizer_file_name = args.out + os.sep +\ '{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@{7}@{8}@{9}@sampleframe#{10}_optimizer.npz'.format(args.database, args.fold, args.split_idx, args.backbone, args.spatial_edge_mode, args.temporal_edge_mode, use_paper_key_str, roi_align_key_str, label_dependency_layer_key_str, args.conv_rnn_type, args.sample_frame)# args.label_win_size) print(pretrained_optimizer_file_name) if os.path.exists(pretrained_optimizer_file_name): print("loading optimizer snatshot:{}".format( pretrained_optimizer_file_name)) chainer.serializers.load_npz(pretrained_optimizer_file_name, optimizer) if args.snap_individual: if os.path.exists(snapshot_model_file_name) and os.path.isfile( snapshot_model_file_name): print("loading pretrained snapshot:{}".format( snapshot_model_file_name)) chainer.serializers.load_npz(snapshot_model_file_name, model) else: if os.path.exists(single_model_file_name): print("loading pretrained snapshot:{}".format( single_model_file_name)) chainer.serializers.load_npz(single_model_file_name, model) if args.fix: au_rcnn = model.au_rcnn_train_chain.au_rcnn au_rcnn.extractor.conv1.W.update_rule.enabled = False au_rcnn.extractor.bn1.gamma.update_rule.enabled = False au_rcnn.extractor.bn1.beta.update_rule.enabled = False res2_names = ["a", "b1", "b2"] for res2_name in res2_names: if res2_name == "a": getattr(au_rcnn.extractor.res2, res2_name).conv1.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn1.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn1.beta.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).conv2.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).conv3.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).conv4.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn2.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn2.beta.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn3.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn3.beta.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn4.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn4.beta.update_rule.enabled = False elif res2_name.startswith("b"): getattr(au_rcnn.extractor.res2, res2_name).conv1.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn1.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn1.beta.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).conv2.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).conv3.W.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn2.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn2.beta.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn3.gamma.update_rule.enabled = False getattr(au_rcnn.extractor.res2, res2_name).bn3.beta.update_rule.enabled = False # if (args.spatial_edge_mode in [SpatialEdgeMode.ld_rnn, SpatialEdgeMode.bi_ld_rnn] or args.temporal_edge_mode in \ # [TemporalEdgeMode.ld_rnn, TemporalEdgeMode.bi_ld_rnn]) or (args.conv_rnn_type != ConvRNNType.conv_rcnn): # updater = BPTTUpdater(train_iter, optimizer, converter=lambda batch, device: concat_examples(batch, device, # padding=0), device=args.gpu[0]) if len(args.gpu) > 1: gpu_dict = {"main": args.gpu[0]} # many gpu will use parallel_models = {"parallel": model.au_rcnn_train_chain} for slave_gpu in args.gpu[1:]: gpu_dict[slave_gpu] = int(slave_gpu) updater = PartialParallelUpdater( train_iter, optimizer, args.database, models=parallel_models, devices=gpu_dict, converter=lambda batch, device: concat_examples( batch, device, padding=0)) else: print("only one GPU({0}) updater".format(args.gpu[0])) updater = chainer.training.StandardUpdater( train_iter, optimizer, device=args.gpu[0], converter=lambda batch, device: concat_examples( batch, device, padding=0)) @training.make_extension(trigger=(1, "epoch")) def reset_order(trainer): print("reset dataset order after one epoch") if args.debug: trainer.updater._iterators[ "main"].dataset._dataset.reset_for_debug_mode() else: trainer.updater._iterators[ "main"].dataset._dataset.reset_for_train_mode() trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(reset_order) trainer.extend(chainer.training.extensions.snapshot_object( optimizer, filename=os.path.basename(pretrained_optimizer_file_name)), trigger=(args.snapshot, 'iteration')) if not args.snap_individual: trainer.extend(chainer.training.extensions.snapshot_object( model, filename=os.path.basename(single_model_file_name)), trigger=(args.snapshot, 'iteration')) else: snap_model_file_name = '{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@{7}@{8}@{9}sampleframe#{10}@win#{11}_'.format( args.database, args.fold, args.split_idx, args.backbone, args.spatial_edge_mode, args.temporal_edge_mode, use_paper_key_str, roi_align_key_str, label_dependency_layer_key_str, args.conv_rnn_type, args.sample_frame, args.label_win_size) snap_model_file_name = snap_model_file_name + "{.updater.iteration}.npz" trainer.extend(chainer.training.extensions.snapshot_object( model, filename=snap_model_file_name), trigger=(args.snapshot, 'iteration')) log_interval = 100, 'iteration' print_interval = 10, 'iteration' plot_interval = 10, 'iteration' if args.optimizer != "Adam" and args.optimizer != "AdaDelta": trainer.extend(chainer.training.extensions.ExponentialShift('lr', 0.1), trigger=(10, 'epoch')) elif args.optimizer == "Adam": trainer.extend(chainer.training.extensions.ExponentialShift( "alpha", 0.1, optimizer=optimizer), trigger=(10, 'epoch')) if args.optimizer != "AdaDelta": trainer.extend(chainer.training.extensions.observe_lr(), trigger=log_interval) trainer.extend( chainer.training.extensions.LogReport( trigger=log_interval, log_name="log_{0}_fold_{1}_{2}@{3}@{4}@{5}.log".format( args.fold, args.split_idx, args.backbone, args.spatial_edge_mode, args.temporal_edge_mode, args.conv_rnn_type))) # trainer.reporter.add_observer("main_par", model.loss_head_module) trainer.extend(chainer.training.extensions.PrintReport([ 'iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/accuracy', ]), trigger=print_interval) trainer.extend( chainer.training.extensions.ProgressBar(update_interval=100)) if chainer.training.extensions.PlotReport.available(): trainer.extend(chainer.training.extensions.PlotReport( ['main/loss'], file_name='loss_{0}_fold_{1}_{2}@{3}@{4}@{5}.png'.format( args.fold, args.split_idx, args.backbone, args.spatial_edge_mode, args.temporal_edge_mode, args.conv_rnn_type), trigger=plot_interval), trigger=plot_interval) trainer.extend(chainer.training.extensions.PlotReport( ['main/accuracy'], file_name='accuracy_{0}_fold_{1}_{2}@{3}@{4}@{5}.png'.format( args.fold, args.split_idx, args.backbone, args.spatial_edge_mode, args.temporal_edge_mode, args.conv_rnn_type), trigger=plot_interval), trigger=plot_interval) trainer.run()
def main(): parser = argparse.ArgumentParser( description='train script of Time-axis R-CNN:') parser.add_argument('--pid', '-pp', default='/tmp/SpaceTime_AU_R_CNN/') parser.add_argument('--gpu', '-g', type=int, help='GPU ID') parser.add_argument('--lr', '-l', type=float, default=0.0001) parser.add_argument('--out', '-o', default='output_time_axis_rcnn', help='Output directory') parser.add_argument('--database', default='BP4D', help='Output directory: BP4D/DISFA/BP4D_DISFA') parser.add_argument('--iteration', '-i', type=int, default=70000) parser.add_argument('--optimizer', type=OptimizerType, choices=list(OptimizerType)) parser.add_argument('--epoch', '-e', type=int, default=20) parser.add_argument('--batch_size', '-bs', type=int, default=1) parser.add_argument('--feature_dim', type=int, default=2048) parser.add_argument('--roi_size', type=int, default=7) parser.add_argument('--snapshot', '-snap', type=int, default=5) parser.add_argument("--fold", '-fd', type=int, default=3) parser.add_argument('--two_stream_mode', type=TwoStreamMode, choices=list(TwoStreamMode), help='rgb_flow/ optical_flow/ rgb') parser.add_argument("--faster_backbone", type=FasterBackboneType, choices=list(FasterBackboneType), help='tcn/conv1d') parser.add_argument("--data_dir", type=str, default="/extract_features") parser.add_argument("--conv_layers", type=int, default=10) parser.add_argument("--split_idx", '-sp', type=int, default=1) parser.add_argument("--use_paper_num_label", action="store_true", help="only to use paper reported number of labels" " to train") parser.add_argument("--proc_num", "-proc", type=int, default=1) args = parser.parse_args() args.data_dir = config.ROOT_PATH + "/" + args.data_dir os.makedirs(args.pid, exist_ok=True) os.makedirs(args.out, exist_ok=True) pid = str(os.getpid()) pid_file_path = args.pid + os.path.sep + "{0}_{1}_fold_{2}.pid".format( args.database, args.fold, args.split_idx) with open(pid_file_path, "w") as file_obj: file_obj.write(pid) file_obj.flush() print('GPU: {}'.format(args.gpu)) adaptive_AU_database(args.database) paper_report_label, class_num = squeeze_label_num_report( args.database, args.use_paper_num_label) paper_report_label_idx = list(paper_report_label.keys()) if args.faster_backbone == FasterBackboneType.tcn: Bone = TcnBackbone elif args.faster_backbone == FasterBackboneType.conv1d: Bone = FasterBackbone if args.two_stream_mode == TwoStreamMode.rgb or args.two_stream_mode == TwoStreamMode.optical_flow: faster_extractor_backbone = Bone(args.conv_layers, args.feature_dim, 1024) faster_head_module = FasterHeadModule( args.feature_dim, class_num + 1, args.roi_size ) # note that the class number here must include background initialW = chainer.initializers.Normal(0.001) spn = SegmentProposalNetwork(1024, n_anchors=len(config.ANCHOR_SIZE), initialW=initialW) train_chain = TimeSegmentRCNNTrainChain(faster_extractor_backbone, faster_head_module, spn) model = Wrapper(train_chain, two_stream_mode=args.two_stream_mode) elif args.two_stream_mode == TwoStreamMode.rgb_flow: faster_extractor_backbone = Bone(args.conv_layers, args.feature_dim, 1024) faster_head_module = FasterHeadModule( args.feature_dim, class_num + 1, args.roi_size ) # note that the class number here must include background initialW = chainer.initializers.Normal(0.001) spn = SegmentProposalNetwork(1024, n_anchors=len(config.ANCHOR_SIZE), initialW=initialW) train_chain = TimeSegmentRCNNTrainChain(faster_extractor_backbone, faster_head_module, spn) # faster_extractor_backbone_flow = FasterBackbone(args.database, args.conv_layers, args.feature_dim, 1024) # faster_head_module_flow = FasterHeadModule(1024, class_num + 1, # args.roi_size) # note that the class number here must include background # initialW = chainer.initializers.Normal(0.001) # spn_flow = SegmentProposalNetwork(1024, n_anchors=len(config.ANCHOR_SIZE), initialW=initialW) # train_chain_flow = TimeSegmentRCNNTrainChain(faster_extractor_backbone_flow, faster_head_module_flow, spn_flow) # time_seg_train_chain_list = [train_chain_rgb, train_chain_flow] model = Wrapper(train_chain, two_stream_mode=args.two_stream_mode) if args.gpu >= 0: model.to_gpu(args.gpu) chainer.cuda.get_device(args.gpu).use() optimizer = None if args.optimizer == OptimizerType.AdaGrad: optimizer = chainer.optimizers.AdaGrad( lr=args.lr ) # 原本为MomentumSGD(lr=args.lr, momentum=0.9) 由于loss变为nan问题,改为AdaGrad elif args.optimizer == OptimizerType.RMSprop: optimizer = chainer.optimizers.RMSprop(lr=args.lr) elif args.optimizer == OptimizerType.Adam: optimizer = chainer.optimizers.Adam(alpha=args.lr) elif args.optimizer == OptimizerType.SGD: optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9) elif args.optimizer == OptimizerType.AdaDelta: optimizer = chainer.optimizers.AdaDelta() optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005)) data_dir = args.data_dir + "/{0}_{1}_fold_{2}/train".format( args.database, args.fold, args.split_idx) dataset = NpzFeatureDataset(data_dir, args.database, two_stream_mode=args.two_stream_mode, T=10.0, use_mirror_data=True) dataset = TransformDataset(dataset, Transform(mirror=True)) if args.proc_num == 1: train_iter = SerialIterator(dataset, args.batch_size, repeat=True, shuffle=True) else: train_iter = MultiprocessIterator(dataset, batch_size=args.batch_size, n_processes=args.proc_num, repeat=True, shuffle=True, n_prefetch=10, shared_mem=10000000) # BP4D_3_fold_1_resnet101@rnn@no_temporal@use_paper_num_label@roi_align@label_dep_layer@conv_lstm@sampleframe#13_model.npz use_paper_classnum = "use_paper_num_label" if args.use_paper_num_label else "all_avail_label" model_file_name = args.out + os.path.sep + \ 'time_axis_rcnn_{0}_{1}_fold_{2}@{3}@{4}@{5}@{6}_model.npz'.format(args.database, args.fold, args.split_idx, use_paper_classnum, args.two_stream_mode, args.conv_layers, args.faster_backbone) print(model_file_name) pretrained_optimizer_file_name = args.out + os.path.sep +\ 'time_axis_rcnn_{0}_{1}_fold_{2}@{3}@{4}@{5}@{6}_optimizer.npz'.format(args.database, args.fold, args.split_idx, use_paper_classnum, args.two_stream_mode, args.conv_layers,args.faster_backbone) print(pretrained_optimizer_file_name) if os.path.exists(pretrained_optimizer_file_name): print("loading optimizer snatshot:{}".format( pretrained_optimizer_file_name)) chainer.serializers.load_npz(pretrained_optimizer_file_name, optimizer) if os.path.exists(model_file_name): print("loading pretrained snapshot:{}".format(model_file_name)) chainer.serializers.load_npz(model_file_name, model.time_seg_train_chain) print("only one GPU({0}) updater".format(args.gpu)) updater = chainer.training.StandardUpdater( train_iter, optimizer, device=args.gpu, converter=lambda batch, device: concat_examples_not_string( batch, device, padding=0)) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(chainer.training.extensions.snapshot_object( optimizer, filename=os.path.basename(pretrained_optimizer_file_name)), trigger=(args.snapshot, 'epoch')) trainer.extend(chainer.training.extensions.snapshot_object( model.time_seg_train_chain, filename=os.path.basename(model_file_name)), trigger=(args.snapshot, 'epoch')) log_interval = 100, 'iteration' print_interval = 100, 'iteration' plot_interval = 100, 'iteration' if args.optimizer != "Adam" and args.optimizer != "AdaDelta": trainer.extend(chainer.training.extensions.ExponentialShift('lr', 0.1), trigger=(20, 'epoch')) elif args.optimizer == "Adam": trainer.extend(chainer.training.extensions.ExponentialShift( "alpha", 0.1, optimizer=optimizer), trigger=(10, 'epoch')) if args.optimizer != "AdaDelta": trainer.extend(chainer.training.extensions.observe_lr(), trigger=log_interval) trainer.extend( chainer.training.extensions.LogReport( trigger=log_interval, log_name="log_{0}_{1}_{2}_fold_{3}_{4}.log".format( args.faster_backbone, args.database, args.fold, args.split_idx, use_paper_classnum))) trainer.extend(chainer.training.extensions.PrintReport([ 'iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/roi_loc_loss', 'main/roi_cls_loss', 'main/rpn_loc_loss', 'main/rpn_cls_loss', 'main/accuracy', 'main/rpn_accuracy', ]), trigger=print_interval) trainer.extend( chainer.training.extensions.ProgressBar(update_interval=100)) if chainer.training.extensions.PlotReport.available(): trainer.extend(chainer.training.extensions.PlotReport( ['main/loss'], file_name='loss_{0}_{1}_fold_{2}_{3}.png'.format( args.database, args.fold, args.split_idx, use_paper_classnum), trigger=plot_interval), trigger=plot_interval) trainer.extend(chainer.training.extensions.PlotReport( ['main/accuracy'], file_name='accuracy_{0}_{1}_fold_{2}_{3}.png'.format( args.database, args.fold, args.split_idx, use_paper_classnum), trigger=plot_interval), trigger=plot_interval) trainer.run()
def create_trainer( config: Config, output: Path, ): assert_config(config) if output.exists(): raise Exception(f"output directory {output} already exists.") # model predictor = create_predictor(config.model) if config.train.trained_model is not None: chainer.serializers.load_npz( config.train.trained_model["predictor_path"], predictor) model = Model( loss_config=config.loss, predictor=predictor, local_padding_size=config.dataset.local_padding_size, ) model.to_gpu(config.train.gpu[0]) cuda.get_device_from_id(config.train.gpu[0]).use() # dataset dataset = create_dataset(config.dataset) batchsize_devided = config.train.batchsize // len(config.train.gpu) train_iter = MultiprocessIterator(dataset["train"], config.train.batchsize) test_iter = MultiprocessIterator(dataset["test"], batchsize_devided, repeat=False, shuffle=True) train_test_iter = MultiprocessIterator(dataset["train_test"], batchsize_devided, repeat=False, shuffle=True) if dataset["test_eval"] is not None: test_eval_iter = MultiprocessIterator(dataset["test_eval"], batchsize_devided, repeat=False, shuffle=True) else: test_eval_iter = None # optimizer def create_optimizer(model): cp: Dict[str, Any] = copy(config.train.optimizer) n = cp.pop("name").lower() if n == "adam": optimizer = optimizers.Adam(**cp) elif n == "sgd": optimizer = optimizers.SGD(**cp) else: raise ValueError(n) optimizer.setup(model) if config.train.optimizer_gradient_clipping is not None: optimizer.add_hook( optimizer_hooks.GradientClipping( config.train.optimizer_gradient_clipping)) return optimizer optimizer = create_optimizer(model) if config.train.trained_model is not None: chainer.serializers.load_npz( config.train.trained_model["optimizer_path"], optimizer) # updater if len(config.train.gpu) <= 1: updater = StandardUpdater( iterator=train_iter, optimizer=optimizer, converter=concat_optional, device=config.train.gpu[0], ) else: updater = ParallelUpdater( iterator=train_iter, optimizer=optimizer, converter=concat_optional, devices={ "main" if i == 0 else f"gpu{gpu}": gpu for i, gpu in enumerate(config.train.gpu) }, ) if config.train.trained_model is not None: updater.iteration = optimizer.t # trainer output.mkdir() config.save_as_json((output / "config.json").absolute()) trigger_log = (config.train.log_iteration, "iteration") trigger_snapshot = (config.train.snapshot_iteration, "iteration") trigger_stop = ((config.train.stop_iteration, "iteration") if config.train.stop_iteration is not None else None) trainer = training.Trainer(updater, stop_trigger=trigger_stop, out=output) tb_writer = SummaryWriter(Path(output)) shift_ext = None if config.train.linear_shift is not None: shift_ext = extensions.LinearShift(**config.train.linear_shift) if config.train.step_shift is not None: shift_ext = extensions.StepShift(**config.train.step_shift) if shift_ext is not None: if config.train.trained_model is not None: shift_ext._t = optimizer.t trainer.extend(shift_ext) if config.train.ema_decay is not None: train_predictor = predictor predictor = deepcopy(predictor) ext = ExponentialMovingAverage(target=train_predictor, ema_target=predictor, decay=config.train.ema_decay) trainer.extend(ext, trigger=(1, "iteration")) ext = extensions.Evaluator(test_iter, model, concat_optional, device=config.train.gpu[0]) trainer.extend(ext, name="test", trigger=trigger_log) ext = extensions.Evaluator(train_test_iter, model, concat_optional, device=config.train.gpu[0]) trainer.extend(ext, name="train", trigger=trigger_log) if test_eval_iter is not None: generator = Generator(config=config, model=predictor, max_batch_size=config.train.batchsize) generate_evaluator = GenerateEvaluator( generator=generator, time_length=config.dataset.time_length_evaluate, local_padding_time_length=config.dataset. local_padding_time_length_evaluate, ) ext = extensions.Evaluator( test_eval_iter, generate_evaluator, concat_optional, device=config.train.gpu[0], ) trainer.extend(ext, name="eval", trigger=trigger_snapshot) ext = extensions.snapshot_object(predictor, filename="main_{.updater.iteration}.npz") trainer.extend(ext, trigger=trigger_snapshot) # ext = extensions.snapshot_object( # optimizer, filename="optimizer_{.updater.iteration}.npz" # ) # trainer.extend(ext, trigger=trigger_snapshot) trainer.extend(extensions.FailOnNonNumber(), trigger=trigger_log) trainer.extend(extensions.observe_lr(), trigger=trigger_log) trainer.extend(extensions.LogReport(trigger=trigger_log)) trainer.extend( extensions.PrintReport(["iteration", "main/loss", "test/main/loss"]), trigger=trigger_log, ) trainer.extend(TensorBoardReport(writer=tb_writer), trigger=trigger_log) trainer.extend(extensions.dump_graph(root_name="main/loss")) if trigger_stop is not None: trainer.extend(extensions.ProgressBar(trigger_stop)) return trainer
len(gpu_datasets[0]))[0] gpu_datasets[-1] = adapted_second_split else: gpu_datasets = [train_dataset] if args.use_serial_iterator: train_iterators = [ chainer.iterators.SerialIterator(dataset, args.batch_size) for dataset in gpu_datasets ] validation_iterator = chainer.iterators.SerialIterator( validation_dataset, args.batch_size) else: train_iterators = [ MultiprocessIterator(dataset, args.batch_size, n_processes=args.num_processes) for dataset in gpu_datasets ] validation_iterator = MultiprocessIterator( validation_dataset, args.batch_size, n_processes=args.num_processes, repeat=False) updater = MultiprocessParallelUpdater( train_iterators, optimizer, devices=args.gpus, converter=get_concat_and_pad_examples(args.blank_label))
def main(): args = create_args('train') targs = get_params_from_target(args.target) targs['A'] = args.anchors_per_position targs['T'] = args.max_points_per_voxel targs['K'] = args.max_voxels result_dir = create_result_dir(args.model_name) dump_setting(targs, result_dir) # Prepare devices devices = {} for gid in [int(i) for i in args.gpus.split(',')]: if 'main' not in devices: devices['main'] = gid else: devices['gpu{}'.format(gid)] = gid # Instantiate a model model = CRMapDetector(VoxelNet, args.loss_alpha, args.loss_beta, **targs) # Instantiate a optimizer optimizer = get_optimizer(model, **vars(args)) # Setting up datasets prep = VoxelRPNPreprocessor(**targs) train = TransformDataset( KITTI(args.kitti_path, 'train', train_proportion=args.train_proportion), prep) valid = TransformDataset( KITTI(args.kitti_path, 'val', valid_proportion=args.valid_proportion), prep) print('train: {}, valid: {}'.format(len(train), len(valid))) # Iterator train_iter = MultiprocessIterator(train, args.batchsize) valid_iter = MultiprocessIterator(valid, args.valid_batchsize, repeat=False, shuffle=False) # Updater updater = ParallelUpdater(train_iter, optimizer, devices=devices) trainer = Trainer(updater, (args.epoch, 'epoch'), out=result_dir) # Extentions trainer.extend(extensions.Evaluator(valid_iter, model, device=devices['main']), trigger=(args.valid_freq, 'epoch')) trainer.extend(extensions.snapshot(), trigger=(args.snapshot_iter, 'iteration')) trainer.extend(extensions.LogReport(), trigger=(args.show_log_iter, 'iteration')) trainer.extend(extensions.ProgressBar(update_interval=20)) trainer.extend( extensions.PrintReport([ 'epoch', 'iteration', 'main/conf_loss', 'main/reg_loss', 'validation/main/conf_loss', 'validation/main/reg_loss' ])) # Resume from snapshot if args.resume_from: chainer.serializers.load_npz(args.resume_from, trainer) # Train and save trainer.run() model.save(create_result_file(args.model_name))
def main(): parser = argparse.ArgumentParser(description='I3D R-CNN train:') parser.add_argument('--pid', '-pp', default='/tmp/SpaceTime_AU_R_CNN/') parser.add_argument('--gpu', '-g', nargs='+', type=int, help='GPU ID, multiple GPU split by space') parser.add_argument('--lr', '-l', type=float, default=0.001) parser.add_argument('--out', '-o', default='i3d_result', help='Output directory') parser.add_argument('--database', default='BP4D', help='Output directory: BP4D/DISFA/BP4D_DISFA') parser.add_argument('--iteration', '-i', type=int, default=70000) parser.add_argument('--epoch', '-e', type=int, default=20) parser.add_argument('--batch_size', '-bs', type=int, default=1) parser.add_argument('--snapshot', '-snap', type=int, default=1000) parser.add_argument('--mean', default=config.ROOT_PATH + "BP4D/idx/mean_no_enhance.npy", help='image mean .npy file') parser.add_argument('--backbone', default="mobilenet_v1", help="vgg/resnet101/mobilenet_v1 for train") parser.add_argument('--optimizer', default='SGD', help='optimizer: RMSprop/AdaGrad/Adam/SGD/AdaDelta') parser.add_argument('--pretrained_rgb', help='imagenet/mobilenet_v1/resnet101/*.npz') parser.add_argument( '--pretrained_flow', help= "path of optical flow pretrained model (may be single stream OF model)" ) parser.add_argument('--two_stream_mode', type=TwoStreamMode, choices=list(TwoStreamMode), help='spatial/ temporal/ spatial_temporal') parser.add_argument( '--use_memcached', action='store_true', help='whether use memcached to boost speed of fetch crop&mask') # parser.add_argument('--memcached_host', default='127.0.0.1') parser.add_argument("--fold", '-fd', type=int, default=3) parser.add_argument("--split_idx", '-sp', type=int, default=1) parser.add_argument("--use_paper_num_label", action="store_true", help="only to use paper reported number of labels" " to train") parser.add_argument( "--roi_align", action="store_true", help="whether to use roi align or roi pooling layer in CNN") parser.add_argument("--T", '-T', type=int, default=10, help="sequence length of one video clip") parser.add_argument("--out_channel", type=int, default=2048, help="length of extract ROI feature") parser.add_argument("--proc_num", "-proc", type=int, default=1) args = parser.parse_args() os.makedirs(args.pid, exist_ok=True) os.makedirs(args.out, exist_ok=True) pid = str(os.getpid()) pid_file_path = args.pid + os.sep + "{0}_{1}_fold_{2}.pid".format( args.database, args.fold, args.split_idx) with open(pid_file_path, "w") as file_obj: file_obj.write(pid) file_obj.flush() print('GPU: {}'.format(",".join(list(map(str, args.gpu))))) adaptive_AU_database(args.database) mc_manager = None if args.use_memcached: from collections_toolkit.memcached_manager import PyLibmcManager mc_manager = PyLibmcManager(args.memcached_host) if mc_manager is None: raise IOError("no memcached found listen in {}".format( args.memcached_host)) paper_report_label, class_num = squeeze_label_num_report( args.database, args.use_paper_num_label) paper_report_label_idx = list(paper_report_label.keys()) au_rcnn_train_chain_list = [] if args.backbone == 'i3d': if args.two_stream_mode == TwoStreamMode.rgb: i3d_feature_backbone = I3DFeatureExtractor(modality='rgb') i3d_roi_head = I3DRoIHead(out_channel=args.out_channel, roi_size=7, spatial_scale=1 / 16., dropout_prob=0.) chainer.serializers.load_npz(args.pretrained_flow, i3d_feature_backbone) chainer.serializers.load_npz(args.pretrained_flow, i3d_roi_head) au_rcnn_train_chain_rgb = AU_RCNN_ROI_Extractor( i3d_feature_backbone, i3d_roi_head) au_rcnn_train_chain_list.append(au_rcnn_train_chain_rgb) elif args.two_stream_mode == TwoStreamMode.optical_flow: i3d_feature_backbone_flow = I3DFeatureExtractor(modality='flow') i3d_roi_head = I3DRoIHead(out_channel=args.out_channel, roi_size=7, spatial_scale=1 / 16., dropout_prob=0.) au_rcnn_train_chain_flow = AU_RCNN_ROI_Extractor( i3d_feature_backbone_flow, i3d_roi_head) chainer.serializers.load_npz(args.pretrained_flow, i3d_feature_backbone_flow) chainer.serializers.load_npz(args.pretrained_flow, i3d_roi_head) au_rcnn_train_chain_list.append(au_rcnn_train_chain_flow) elif args.two_stream_mode == TwoStreamMode.rgb_flow: i3d_feature_backbone = I3DFeatureExtractor(modality='rgb') i3d_roi_head_rgb = I3DRoIHead(out_channel=args.out_channel, roi_size=7, spatial_scale=1 / 16., dropout_prob=0.) chainer.serializers.load_npz(args.pretrained_rgb, i3d_feature_backbone) chainer.serializers.load_npz(args.pretrained_rgb, i3d_roi_head_rgb) au_rcnn_train_chain_rgb = AU_RCNN_ROI_Extractor( i3d_feature_backbone, i3d_roi_head_rgb) au_rcnn_train_chain_list.append(au_rcnn_train_chain_rgb) i3d_feature_backbone_flow = I3DFeatureExtractor(modality='flow') i3d_roi_head_flow = I3DRoIHead(out_channel=args.out_channel, roi_size=7, spatial_scale=1 / 16., dropout_prob=0.) au_rcnn_train_chain_flow = AU_RCNN_ROI_Extractor( i3d_feature_backbone_flow, i3d_roi_head_flow) au_rcnn_train_chain_list.append(au_rcnn_train_chain_flow) chainer.serializers.load_npz(args.pretrained_flow, i3d_feature_backbone_flow) chainer.serializers.load_npz(args.pretrained_flow, i3d_roi_head_flow) au_rcnn_train_loss = AU_RCNN_TrainChainLoss() loss_head_module = au_rcnn_train_loss model = Wrapper(au_rcnn_train_chain_list, loss_head_module, args.database, args.T, args.two_stream_mode, args.gpu) batch_size = args.batch_size img_dataset = AUDataset(database=args.database, fold=args.fold, split_name='trainval', split_index=args.split_idx, mc_manager=mc_manager, train_all_data=False) train_video_data = AU_video_dataset( au_image_dataset=img_dataset, sample_frame=args.T, train_mode=True, paper_report_label_idx=paper_report_label_idx) Transform = Transform3D substract_mean = SubStractMean(args.mean) train_video_data = TransformDataset( train_video_data, Transform(substract_mean, mirror=False)) if args.proc_num == 1: train_iter = SerialIterator(train_video_data, batch_size * args.sample_frame, repeat=True, shuffle=False) else: train_iter = MultiprocessIterator(train_video_data, batch_size=batch_size * args.sample_frame, n_processes=args.proc_num, repeat=True, shuffle=False, n_prefetch=10, shared_mem=10000000) for gpu in args.gpu: chainer.cuda.get_device_from_id(gpu).use() optimizer = None if args.optimizer == 'AdaGrad': optimizer = chainer.optimizers.AdaGrad( lr=args.lr ) # 原本为MomentumSGD(lr=args.lr, momentum=0.9) 由于loss变为nan问题,改为AdaGrad elif args.optimizer == 'RMSprop': optimizer = chainer.optimizers.RMSprop(lr=args.lr) elif args.optimizer == 'Adam': optimizer = chainer.optimizers.Adam(alpha=args.lr) elif args.optimizer == 'SGD': optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9) elif args.optimizer == "AdaDelta": optimizer = chainer.optimizers.AdaDelta() optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005)) optimizer_name = args.optimizer key_str = "{0}_fold_{1}".format(args.fold, args.split_idx) file_list = [] file_list.extend(os.listdir(args.out)) # BP4D_3_fold_1_resnet101@rnn@no_temporal@use_paper_num_label@roi_align@label_dep_layer@conv_lstm@sampleframe#13_model.npz use_paper_key_str = "use_paper_num_label" if args.use_paper_num_label else "all_{}_label".format( args.database) roi_align_key_str = "roi_align" if args.roi_align else "roi_pooling" single_model_file_name = args.out + os.sep + \ '{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@T#{7}_model.npz'.format(args.database, args.fold, args.split_idx, args.backbone, args.two_stream_mode, use_paper_key_str, roi_align_key_str, args.T) print(single_model_file_name) pretrained_optimizer_file_name = args.out + os.sep +\ '{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@T#{7}_optimizer.npz'.format(args.database, args.fold, args.split_idx, args.backbone, args.two_stream_mode, use_paper_key_str, roi_align_key_str, args.T) print(pretrained_optimizer_file_name) if os.path.exists(pretrained_optimizer_file_name): print("loading optimizer snatshot:{}".format( pretrained_optimizer_file_name)) chainer.serializers.load_npz(pretrained_optimizer_file_name, optimizer) if os.path.exists(single_model_file_name): print("loading pretrained snapshot:{}".format(single_model_file_name)) chainer.serializers.load_npz(single_model_file_name, model) updater = chainer.training.StandardUpdater( train_iter, optimizer, device=args.gpu[0], converter=lambda batch, device: concat_examples( batch, device, padding=0)) @training.make_extension(trigger=(1, "epoch")) def reset_order(trainer): print("reset dataset order after one epoch") trainer.updater._iterators[ "main"].dataset._dataset.reset_for_train_mode() trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(reset_order) trainer.extend(chainer.training.extensions.snapshot_object( optimizer, filename=os.path.basename(pretrained_optimizer_file_name)), trigger=(args.snapshot, 'iteration')) log_interval = 100, 'iteration' print_interval = 10, 'iteration' plot_interval = 10, 'iteration' if args.optimizer != "Adam" and args.optimizer != "AdaDelta": trainer.extend(chainer.training.extensions.ExponentialShift('lr', 0.1), trigger=(10, 'epoch')) elif args.optimizer == "Adam": trainer.extend(chainer.training.extensions.ExponentialShift( "alpha", 0.1, optimizer=optimizer), trigger=(10, 'epoch')) if args.optimizer != "AdaDelta": trainer.extend(chainer.training.extensions.observe_lr(), trigger=log_interval) trainer.extend( chainer.training.extensions.LogReport( trigger=log_interval, log_name="log_{0}_{1}_fold_{2}_{3}@{4}@{5}@{6}@T#{7}.log".format( args.database, args.fold, args.split_idx, args.backbone, args.two_stream_mode, use_paper_key_str, roi_align_key_str, args.T))) # trainer.reporter.add_observer("main_par", model.loss_head_module) trainer.extend(chainer.training.extensions.PrintReport([ 'iteration', 'epoch', 'elapsed_time', 'lr', 'main/loss', 'main/accuracy', ]), trigger=print_interval) trainer.extend( chainer.training.extensions.ProgressBar(update_interval=100)) if chainer.training.extensions.PlotReport.available(): trainer.extend(chainer.training.extensions.PlotReport( ['main/loss'], file_name='loss_{0}_fold_{1}_{2}@{3}@{4}@{5}.png'.format( args.fold, args.split_idx, args.backbone, args.spatial_edge_mode, args.temporal_edge_mode, args.conv_rnn_type), trigger=plot_interval), trigger=plot_interval) trainer.extend(chainer.training.extensions.PlotReport( ['main/accuracy'], file_name='accuracy_{0}_fold_{1}_{2}@{3}@{4}@{5}.png'.format( args.fold, args.split_idx, args.backbone, args.spatial_edge_mode, args.temporal_edge_mode, args.conv_rnn_type), trigger=plot_interval), trigger=plot_interval) trainer.run()
def compute_all_metrics(args, test_dir, test_index): truth_dataset = dataset.XpDataset(args.truth_dir, test_index, image=False, label=True) pred_datasets = [ dataset.XpDataset(td, test_index, image=False, label=True) for td in test_dir ] truth_iter = MultiprocessIterator(truth_dataset, args.num_parallel, shuffle=False, repeat=False) pred_iters = [ MultiprocessIterator(pd, args.num_parallel, shuffle=False, repeat=False) for pd in pred_datasets ] #truth_iter = SerialIterator(truth_dataset, args.num_parallel, shuffle=False, repeat=False) #pred_iters = [ SerialIterator(pd, args.num_parallel, shuffle=False, repeat=False) for pd in pred_datasets ] #all_metrics = { } batch_results_dict = {} for i, batches in tqdm.tqdm(enumerate(zip(truth_iter, *pred_iters)), total=len(truth_dataset) // args.num_parallel): if args.n_image is not None and args.n_image <= i: break truth_vars = utils.batch_to_vars(batches[0])[0] pred_vars_list = [ utils.batch_to_vars(batch)[0] for batch in batches[1:] ] truth_vars['label'] = xp.concatenate([ xp.expand_dims(xp.asarray(label), axis=0) for label in truth_vars['label'] ], axis=0) # Compute metrics for pred_vars, test_name in zip(pred_vars_list, args.test_names): pred_vars['label'] = xp.concatenate([ xp.expand_dims(xp.asarray(label), axis=0) for label in pred_vars['label'] ], axis=0) values = computeMetrics(truth_vars, pred_vars, args.metrics) batch_results_dict.setdefault(test_name, []).append(values) #all_metrics.setdefault(test_name, dict()) new_axis = list(batch_results_dict.keys()) new_data = [] for test_name, batch_results in batch_results_dict.items(): data_dict = {} for batch_result in batch_results: for key, values in batch_result.items(): data_dict.setdefault(key, []).append(values) new_data.append(data_dict) new_data = [ xr.Dataset({ key: xr.concat(value, dim='case_name') for key, value in dataset_.items() }) for dataset_ in new_data ] return xr.concat(new_data, pd.Index(new_axis, name='test_name'))