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'))