def _retrieve(name_npz, name_caffemodel, model):
root = download.get_dataset_directory('pfnet/chainer/models/')
path = os.path.join(root, name_npz)
path_caffemodel = os.path.join(root, name_caffemodel)
return download.cache_or_load_file(
path, lambda path: _make_npz(path, path_caffemodel, model),
lambda path: npz.load_npz(path, model))
def _retrieve_word_vocabulary():
def creator(path):
words = _load_words(_train_url)
vocab = {}
index = 0
with open(path, 'w') as f:
for word in words:
if word not in vocab:
vocab[word] = index
index += 1
f.write(word + '\n')
return vocab
def loader(path):
vocab = {}
with open(path) as f:
for i, word in enumerate(f):
vocab[word.strip()] = i
return vocab
root = download.get_dataset_directory('txt')
path = os.path.join(root, 'vocab.txt')
print root
return download.cache_or_load_file(path, creator, loader)
def _retrieve(n_layers, name_npz, name_caffemodel, model):
root = download.get_dataset_directory('pfnet/chainer/models/')
path = os.path.join(root, name_npz)
path_caffemodel = os.path.join(root, name_caffemodel)
return download.cache_or_load_file(
path, lambda path: _make_npz(path, path_caffemodel, model, n_layers),
lambda path: npz.load_npz(path, model))
def _retrieve_emnist(name, archives):
# the path to store the cached file to
root = download.get_dataset_directory('pfnet/chainer/emnist')
path = os.path.join(root, name)
return download.cache_or_load_file(path,
lambda path: _make_npz(path, archives),
numpy.load)
def get_facade():
root = download.get_dataset_directory('study_chainer/facade')
npz_path = os.path.join(root, 'base.npz')
url = 'http://cmp.felk.cvut.cz/~tylecr1/facade/CMP_facade_DB_base.zip'
def creator(path):
archive_path = download.cached_download(url)
images = []
labels = []
with zipfile.ZipFile(archive_path, 'r') as archive:
for i in range(1, 378 + 1):
image_name = 'base/cmp_b{:04d}.jpg'.format(i)
label_name = 'base/cmp_b{:04d}.png'.format(i)
image = Image.open(io.BytesIO(archive.read(image_name)))
image = np.asarray(image)
images.append(image)
label = Image.open(io.BytesIO(archive.read(label_name)))
label = np.asarray(label)
labels.append(label)
np.savez_compressed(path, images=images, labels=labels)
return {'images': images, 'labels': labels}
raw = download.cache_or_load_file(npz_path, creator, np.load)
return raw['images'], raw['labels']
def _retrieve_cifar_100():
root = download.get_dataset_directory('pfnet/chainer/cifar')
path = os.path.join(root, 'cifar-100.npz')
url = 'https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz'
def creator(path):
def load(archive, file_name):
d = _pickle_load(archive.extractfile(file_name))
x = d['data'].reshape((-1, 3072))
y = numpy.array(d['fine_labels'], dtype=numpy.uint8)
return x, y
archive_path = download.cached_download(url)
with tarfile.open(archive_path, 'r:gz') as archive:
train_x, train_y = load(archive, 'cifar-100-python/train')
test_x, test_y = load(archive, 'cifar-100-python/test')
numpy.savez_compressed(path,
train_x=train_x,
train_y=train_y,
test_x=test_x,
test_y=test_y)
return {
'train_x': train_x,
'train_y': train_y,
'test_x': test_x,
'test_y': test_y
}
return download.cache_or_load_file(path, creator, numpy.load)
def get_kaggle():
root = 'pfnet/chainer/pubchem'
cache_root = download.get_dataset_directory(root)
fname = 'pubchem.h5'
cache_path = os.path.join(cache_root, fname)
dataset = download.cache_or_load_file(cache_path, creator, loader)
N = len(dataset)
return D.split_dataset_random(dataset, int(N * 0.75))
def _get_cifar(name, withlabel, ndim, scale):
root = download.get_dataset_directory(os.path.join('pfnet', 'chainer',
'cifar'))
npz_path = os.path.join(root, '{}.npz'.format(name))
url = 'https://www.cs.toronto.edu/~kriz/{}-python.tar.gz'.format(name)
def creator(path):
archive_path = download.cached_download(url)
if name == 'cifar-10':
train_x = numpy.empty((5, 10000, 3072), dtype=numpy.uint8)
train_y = numpy.empty((5, 10000), dtype=numpy.uint8)
test_y = numpy.empty(10000, dtype=numpy.uint8)
dir_name = '{}-batches-py'.format(name)
with tarfile.open(archive_path, 'r:gz') as archive:
# training set
for i in range(5):
file_name = '{}/data_batch_{}'.format(dir_name, i + 1)
d = _pickle_load(archive.extractfile(file_name))
train_x[i] = d['data']
train_y[i] = d['labels']
# test set
file_name = '{}/test_batch'.format(dir_name)
d = _pickle_load(archive.extractfile(file_name))
test_x = d['data']
test_y[...] = d['labels'] # copy to array
train_x = train_x.reshape(50000, 3072)
train_y = train_y.reshape(50000)
else:
# name == 'cifar-100'
def load(archive, file_name):
d = _pickle_load(archive.extractfile(file_name))
x = d['data'].reshape((-1, 3072))
y = numpy.array(d['fine_labels'], dtype=numpy.uint8)
return x, y
with tarfile.open(archive_path, 'r:gz') as archive:
train_x, train_y = load(archive, 'cifar-100-python/train')
test_x, test_y = load(archive, 'cifar-100-python/test')
numpy.savez_compressed(path, train_x=train_x, train_y=train_y,
test_x=test_x, test_y=test_y)
return {'train_x': train_x, 'train_y': train_y,
'test_x': test_x, 'test_y': test_y}
raw = download.cache_or_load_file(npz_path, creator, numpy.load)
train = _preprocess_cifar(raw['train_x'], raw['train_y'], withlabel,
ndim, scale)
test = _preprocess_cifar(raw['test_x'], raw['test_y'], withlabel, ndim,
scale)
return train, test
def get_kaggle(debug=False):
root = 'pfnet/chainer/pubchem'
cache_root = download.get_dataset_directory(root)
fname = 'pubchem_debug.h5' if debug else 'pubchem.h5'
cache_path = os.path.join(cache_root, fname)
def creator(path):
return _creator(path, debug)
dataset = download.cache_or_load_file(cache_path, creator, kaggle.loader)
N = len(dataset)
return D.split_dataset_random(dataset, int(N * 0.8))
def _retrieve_ptb_words(name, url):
def creator(path):
vocab = _retrieve_word_vocabulary()
words = _load_words(url)
x = numpy.empty(len(words), dtype=numpy.int32)
for i, word in enumerate(words):
x[i] = vocab[word]
numpy.savez_compressed(path, x=x)
return {'x': x}
root = download.get_dataset_directory('pfnet/chainer/ptb')
path = os.path.join(root, name)
loaded = download.cache_or_load_file(path, creator, numpy.load)
return loaded['x']
def _retrieve_ptb_words(name, url):
def creator(path):
vocab = _retrieve_word_vocabulary()
words = _load_words(url)
x = numpy.empty(len(words), dtype=numpy.int32)
for i, word in enumerate(words):
x[i] = vocab[word]
numpy.savez_compressed(path, x=x)
return {'x': x}
root = download.get_dataset_directory('pfnet/chainer/ptb')
path = os.path.join(root, name)
loaded = download.cache_or_load_file(path, creator, numpy.load)
return loaded['x']
def get_wiki_dataset(url, max=-1, th=5):
"""
Gets sequence dataset of wikipedia dump. Retrieved from here: https://dumps.wikimedia.org/backup-index.html
Will download the dataset, extract the content using WikiExtractor(https://github.com/attardi/wikiextractor-2) to extract content from dump
Next it will tokenize text and build a sequence array: a list of integers that represent word sequences and a vocabulary
where the index of each element will be the integer used in the sequence of that word in the seq array
Dataset is not shuffled and order of sentences will be respected on an article basis, "." will be replaces by <eos> tokens
:param: url link to the dump on wikipedia
:param: Limit number of tokens in s
:return: seq, voc
"""
def creator(path):
dump_path = download.cached_download(url)
tmp_dir = tempfile.mkdtemp()
# WikiExtractor needs .bz2 extension to function well
dump_sym = os.path.join(tmp_dir, 'dump.bz2')
os.symlink(dump_path, dump_sym)
print "Extracting dump..."
extract_dir = os.path.join(tmp_dir,'extracts')
extract_dump(dump_sym, extract_dir, quiet=True)
print "Building vocabulary and sequence array.."
seq,voc = _build_dataset(extract_dir, path,max,th)
# clean up temp file:
print "Removing dump"
shutil.rmtree(extract_dir)
return seq, voc
def loader(path):
with open(path) as io:
data = np.load(io)
return data['seq'],data['voc']
root = download.get_dataset_directory('svoss/chainer/wiki')
path = os.path.join(root, hashlib.md5(url).hexdigest()+("_%d-%d" % (max,th))+".npz")
return download.cache_or_load_file(path, creator, loader)
def _retrieve_cifar(name):
root = download.get_dataset_directory('pfnet/chainer/cifar')
path = os.path.join(root, '{}.npz'.format(name))
url = 'https://www.cs.toronto.edu/~kriz/{}-python.tar.gz'.format(name)
def creator(path):
archive_path = download.cached_download(url)
train_x = numpy.empty((5, 10000, 3072), dtype=numpy.uint8)
train_y = numpy.empty((5, 10000), dtype=numpy.uint8)
test_y = numpy.empty(10000, dtype=numpy.uint8)
dir_name = '{}-batches-py'.format(name)
with tarfile.open(archive_path, 'r:gz') as archive:
# training set
for i in range(5):
file_name = '{}/data_batch_{}'.format(dir_name, i + 1)
d = _pickle_load(archive.extractfile(file_name))
train_x[i] = d['data']
train_y[i] = d['labels']
# test set
file_name = '{}/test_batch'.format(dir_name)
d = _pickle_load(archive.extractfile(file_name))
test_x = d['data']
test_y[...] = d['labels'] # copy to array
train_x = train_x.reshape(50000, 3072)
train_y = train_y.reshape(50000)
numpy.savez_compressed(path,
train_x=train_x,
train_y=train_y,
test_x=test_x,
test_y=test_y)
return {
'train_x': train_x,
'train_y': train_y,
'test_x': test_x,
'test_y': test_y
}
return download.cache_or_load_file(path, creator, numpy.load)
def _get_tox21(config_name, preprocessor, with_label=True):
basename = config_name
global config
c = config[config_name]
url = c['url']
sdffile = c['filename']
cache_root = download.get_dataset_directory(root)
cache_path = os.path.join(cache_root, basename + ".sdf")
def creator(path):
return _creator(path, sdffile, url)
mol_supplier = download.cache_or_load_file(cache_path, creator,
Chem.SDMolSupplier)
descriptors, labels = preprocessor(mol_supplier, label_names)
if with_label:
return tuple_dataset.TupleDataset(descriptors, labels)
else:
return descriptors
def _retrieve_cifar(name):
root = download.get_dataset_directory('pfnet/chainer/cifar')
path = os.path.join(root, '{}.npz'.format(name))
url = 'https://www.cs.toronto.edu/~kriz/{}-python.tar.gz'.format(name)
def creator(path):
archive_path = download.cached_download(url)
train_x = numpy.empty((5, 10000, 3072), dtype=numpy.uint8)
train_y = numpy.empty((5, 10000), dtype=numpy.uint8)
test_y = numpy.empty(10000, dtype=numpy.uint8)
dir_name = '{}-batches-py'.format(name)
with tarfile.open(archive_path, 'r:gz') as archive:
# training set
for i in range(5):
file_name = '{}/data_batch_{}'.format(dir_name, i + 1)
d = pickle.load(archive.extractfile(file_name))
train_x[i] = d['data']
train_y[i] = d['labels']
# test set
file_name = '{}/test_batch'.format(dir_name)
d = pickle.load(archive.extractfile(file_name))
test_x = d['data']
test_y[...] = d['labels'] # copy to array
train_x = train_x.reshape(50000, 3072)
train_y = train_y.reshape(50000)
numpy.savez_compressed(path, train_x=train_x, train_y=train_y,
test_x=test_x, test_y=test_y)
return {'train_x': train_x, 'train_y': train_y,
'test_x': test_x, 'test_y': test_y}
return download.cache_or_load_file(path, creator, numpy.load)
def _retrieve_cifar_100():
root = download.get_dataset_directory('pfnet/chainer/cifar')
path = os.path.join(root, 'cifar-100.npz')
url = 'https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz'
def creator(path):
def load(archive, file_name):
d = _pickle_load(archive.extractfile(file_name))
x = d['data'].reshape((-1, 3072))
y = numpy.array(d['fine_labels'], dtype=numpy.uint8)
return x, y
archive_path = download.cached_download(url)
with tarfile.open(archive_path, 'r:gz') as archive:
train_x, train_y = load(archive, 'cifar-100-python/train')
test_x, test_y = load(archive, 'cifar-100-python/test')
numpy.savez_compressed(path, train_x=train_x, train_y=train_y,
test_x=test_x, test_y=test_y)
return {'train_x': train_x, 'train_y': train_y,
'test_x': test_x, 'test_y': test_y}
return download.cache_or_load_file(path, creator, numpy.load)
def _retrieve_word_vocabulary():
def creator(path):
words = _load_words(_train_url)
vocab = {}
index = 0
with open(path, 'w') as f:
for word in words:
if word not in vocab:
vocab[word] = index
index += 1
f.write(word + '\n')
return vocab
def loader(path):
vocab = {}
with open(path) as f:
for i, word in enumerate(f):
vocab[word.strip()] = i
return vocab
root = download.get_dataset_directory('pfnet/chainer/ptb')
path = os.path.join(root, 'vocab.txt')
return download.cache_or_load_file(path, creator, loader)
def _retrieve_fashion_mnist(name, urls):
root = download.get_dataset_directory('pfnet/chainer/fashion-mnist')
path = os.path.join(root, name)
return download.cache_or_load_file(path, lambda path: make_npz(path, urls),
numpy.load)
def _retrieve_svhn(name, url):
root = download.get_dataset_directory('pfnet/chainer/svhn')
path = os.path.join(root, name)
return download.cache_or_load_file(path, lambda path: _make_npz(path, url),
numpy.load)
def main():
parser = argparse.ArgumentParser(
description=
'Fully Convolutional Dual Center Pose Proposal Network for Pose Estimation'
)
parser.add_argument('--batchsize',
'-b',
type=int,
default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=200,
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='results/dual_cp',
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')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
parser.add_argument('--frequency',
'-f',
type=int,
default=-1,
help='Frequency of taking a snapshot')
parser.add_argument('--train_resnet',
type=bool,
default=True,
help='train resnet')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
n_class = 9
train_path = os.path.join(os.getcwd(), root,
'train_data/OcclusionChallengeICCV2015')
caffe_model = 'ResNet-50-model.caffemodel'
distance_sanity = 0.05
chainer.using_config('cudnn_deterministic', True)
model = DualCPNetClassifier(DualCenterProposalNetworkRes50FCN(
n_class=n_class,
output_scale=1.0,
pretrained_model=not args.train_resnet),
mothod="RANSAC",
distance_sanity=distance_sanity)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
model.to_gpu() # Copy the model to the GPU
# Setup an optimizer
optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9)
optimizer.setup(model)
# load train data
train = DualCPNetDataset(train_path,
range(0, 1200)[0::2],
img_height=192,
img_width=256,
random=True,
random_crop=True)
# load test data
test = DualCPNetDataset(train_path,
range(0, 1200)[1::2],
img_height=192,
img_width=256)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
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
evaluator = extensions.Evaluator(test_iter, model, device=args.gpu)
evaluator.default_name = 'val'
trainer.extend(evaluator)
# 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'],
# 'epoch', file_name='loss.png'))
# trainer.extend(
# extensions.PlotReport(
# ['main/accuracy'],
# 'epoch', file_name='accuracy.png'))
trainer.extend(
extensions.PrintReport([
'epoch', 'main/l_cls', 'main/l_cp', 'main/l_ocp', 'main/cls_acc',
'main/cp_acc', 'main/ocp_acc', 'val/main/l_cls', 'val/main/l_cp',
'val/main/l_ocp', 'val/main/cls_acc', 'val/main/cp_acc',
'val/main/ocp_acc', '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)
else:
npz_name = 'DualCenterProposalNetworkRes50FCN_occulusion_challenge.npz'
caffemodel_name = 'ResNet-50-model.caffemodel'
path = os.path.join(root, 'trained_data/', npz_name)
path_caffemodel = os.path.join(root, 'trained_data/', caffemodel_name)
print 'npz model path : ' + path
print 'caffe model path : ' + path_caffemodel
download.cache_or_load_file(
path, lambda path: _make_chainermodel_npz(path, path_caffemodel,
model, n_class),
lambda path: serializers.load_npz(path, model))
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(
description=
'Fully Convolutional Dual Center Pose Proposal Network for Pose Estimation'
)
parser.add_argument('--batchsize',
'-b',
type=int,
default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=200,
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='results/dual_cp',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot')
parser.add_argument('--frequency',
'-f',
type=int,
default=-1,
help='Frequency of taking a snapshot')
parser.add_argument('--train_resnet',
type=bool,
default=False,
help='train resnet')
parser.add_argument('--train-resnet',
dest='train_resnet',
action='store_true')
parser.set_defaults(train_resnet=False)
parser.add_argument('--no-accuracy',
dest='compute_acc',
action='store_false')
parser.set_defaults(compute_acc=True)
parser.add_argument('--no-pose-accuracy',
dest='compute_pose_acc',
action='store_false')
parser.set_defaults(compute_pose_acc=True)
args = parser.parse_args()
compute_class_accuracy = args.compute_acc
compute_pose_accuracy = args.compute_pose_acc and args.compute_acc
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('# compute class accuracy: {}'.format(compute_class_accuracy))
print('# compute pose accuracy: {}'.format(compute_pose_accuracy))
print('')
im_size = (640, 480)
objs = np.arange(3) + 1
n_class = len(objs) + 1
train_path = os.path.join(os.getcwd(), root,
'train_data/JSK_Objects/train')
bg_path = os.path.join(os.getcwd(), root, 'train_data/MS_COCO/train2017')
# bg_path = os.path.join(os.getcwd(), root, 'train_data/VOCdevkit/VOC2012/JPEGImages')
caffe_model = 'ResNet-50-model.caffemodel'
distance_sanity = 0.05
output_scale = 0.6
eps = 0.05
interval = 15
chainer.using_config('cudnn_deterministic', True)
model = DualCPNetClassifier(DualCenterProposalNetworkRes50_predict7(
n_class=n_class, pretrained_model=not args.train_resnet),
basepath=train_path,
im_size=im_size,
distance_sanity=distance_sanity,
compute_class_accuracy=compute_class_accuracy,
compute_pose_accuracy=compute_pose_accuracy,
output_scale=output_scale)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
model.to_gpu() # Copy the model to the GPU
# Setup an optimizer
optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001))
# load train data
train = JSKPoseEstimationAutoContextDataset(train_path,
objs,
bg_path,
interval=interval,
iteration_per_epoch=1000,
mode='test',
resize_rate=0.5,
metric_filter=output_scale +
eps)
# load test data
# test = JSKPoseEstimationAutoContextDataset(train_path, objs, bg_path,
# interval=interval,
# mode='train',
# resize_rate=0.5,
# metric_filter=output_scale + eps)
test = JSKPoseEstimationDataset(train_path,
objs,
mode='train',
interval=interval,
resize_rate=0.5,
metric_filter=output_scale + eps)
print "number of train data : ", train.__len__()
print "number of test data : ", test.__len__()
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize)
# test_iter = chainer.iterators.MultiprocessIterator(test, args.batchsize,
# repeat=False, shuffle=False)
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
evaluator = extensions.Evaluator(test_iter, model, device=args.gpu)
evaluator.default_name = 'val'
trainer.extend(evaluator)
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot and snapshot object for each specified epoch
frequency = args.epoch if args.frequency == -1 else max(1, args.frequency)
trainer.extend(extensions.snapshot(), trigger=(frequency, 'epoch'))
trainer.extend(extensions.snapshot_object(
model.predictor, filename='model_iteration-{.updater.iteration}'),
trigger=(frequency, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport([
'epoch', 'main/l_cls', 'main/l_cp', 'main/l_ocp', 'main/cls_acc',
'main/ocp_acc', 'main/rot_acc', 'val/main/l_cls', 'val/main/l_cp',
'val/main/l_ocp', 'val/main/cls_acc', 'val/main/ocp_acc',
'val/main/rot_acc', '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)
else:
npz_name = 'DualCenterProposalNetworkRes50_jsk_class{}.npz'
caffemodel_name = 'ResNet-50-model.caffemodel'
path = os.path.join(root, 'trained_data/', npz_name.format(n_class))
path_caffemodel = os.path.join(root, 'trained_data/', caffemodel_name)
print 'npz model path : ' + path
print 'caffe model path : ' + path_caffemodel
download.cache_or_load_file(
path, lambda path: _make_chainermodel_npz(path, path_caffemodel,
model, n_class),
lambda path: serializers.load_npz(path, model))
# Run the training
trainer.run()
def _retrieve(name, url, model):
root = download.get_dataset_directory('pfnet/chainer/models/')
path = os.path.join(root, name)
return download.cache_or_load_file(
path, lambda path: _make_npz(path, url, model),
lambda path: npz.load_npz(path, model))
def _retrieve_svhn(name, url):
root = download.get_dataset_directory('pfnet/chainer/svhn')
path = os.path.join(root, name)
return download.cache_or_load_file(
path, lambda path: _make_npz(path, url), numpy.load)
def _retrieve_fmnist(name, urls):
root = download.get_dataset_directory('fmnist/fmnist')
path = os.path.join(root, name)
return download.cache_or_load_file(path,
lambda path: _make_npz(path, urls),
numpy.load)
def _retrieve_mnist(name, data_paths):
root = download.get_dataset_directory('./temp_dir')
path = os.path.join(root, name)
return download.cache_or_load_file(
path, lambda path: make_npz(path, data_paths), numpy.load)
def main():
parser = argparse.ArgumentParser(description='Fully Convolutional Depth Invariant Network')
parser.add_argument('--batchsize', '-b', type=int, default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch', '-e', type=int, default=200,
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='di_net_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')
parser.add_argument('--snapshot_interval', type=int, default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval', type=int, default=100,
help='Interval of displaying log to console')
parser.add_argument('--frequency', '-f', type=int, default=-1,
help='Frequency of taking a snapshot')
parser.add_argument('--train_resnet', type=bool, default=False,
help='train resnet')
parser.add_argument('--ver2', type=bool, default=True,
help='di net version 2')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
n_class = 20
# n_class = 36
n_view = 37
train_path = os.path.join(os.getcwd(), root, 'train_data/willow_models')
caffe_model = 'ResNet-50-model.caffemodel'
chainer.using_config('cudnn_deterministic', True)
if args.ver2:
model = L.Classifier(
DepthInvariantNetworkRes50FCNVer2(n_class=n_class,
pretrained_model= not args.train_resnet))
else:
model = L.Classifier(
DepthInvariantNetworkRes50FCN(n_class=n_class,
pretrained_model= not args.train_resnet))
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
model.to_gpu() # Copy the model to the GPU
# Setup an optimizer
optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9)
optimizer.setup(model)
# load train data
train = DepthInvariantNetDataset(train_path, range(1,n_class), range(0, n_view - 2),
random_resize=True, resize_train=True,
force_resize=True)
# load test data
test = DepthInvariantNetDataset(train_path, range(1,n_class), range(n_view - 2, n_view),
img_size=(256, 192), random=False, random_flip=False)
test_resized = DepthInvariantNetDataset(train_path, range(1,n_class),
range(n_view - 2, n_view),
img_size=(256, 192), random=False,
random_flip=False, random_resize=True,
force_resize=True)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
test_resized_iter = chainer.iterators.SerialIterator(test_resized, args.batchsize,
repeat=False, shuffle=False)
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
evaluator = extensions.Evaluator(test_iter, model, device=args.gpu)
evaluator.default_name = 'val'
trainer.extend(evaluator)
evaluator_resized = extensions.Evaluator(test_resized_iter, model, device=args.gpu)
evaluator_resized.default_name = 'resized_val'
trainer.extend(evaluator_resized)
# 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'],
# 'epoch', file_name='loss.png'))
# trainer.extend(
# extensions.PlotReport(
# ['main/accuracy'],
# 'epoch', file_name='accuracy.png'))
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'main/accuracy',
'val/main/loss','val/main/accuracy',
'resized_val/main/loss','resized_val/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)
else:
if args.ver2:
npz_name = 'DepthInvariantNetworkRes50FCNVer2.npz'
else:
npz_name = 'DepthInvariantNetworkRes50FCN.npz'
caffemodel_name = 'ResNet-50-model.caffemodel'
path = os.path.join(root, 'trained_data/', npz_name)
path_caffemodel = os.path.join(root, 'trained_data/', caffemodel_name)
print 'npz model path : ' + path
print 'caffe model path : ' + path_caffemodel
download.cache_or_load_file(
path,
lambda path: _make_chainermodel_npz(path, path_caffemodel,
model, n_class, v2=args.ver2),
lambda path: serializers.load_npz(path, model))
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(
description=
'Fully Convolutional Dual Center Pose Proposal Network for Pose Estimation'
)
parser.add_argument('--batchsize',
type=int,
default=1,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=200,
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='results/dual_cp_ver2_auto_gen',
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')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot')
parser.add_argument('--display_interval',
type=int,
default=100,
help='Interval of displaying log to console')
parser.add_argument('--frequency',
'-f',
type=int,
default=-1,
help='Frequency of taking a snapshot')
parser.add_argument(
'--background',
'-bg',
default='../../train_data/VOCdevkit/VOC2012/JPEGImages',
help='Path to background dataset')
parser.add_argument('--train_resnet',
type=bool,
default=False,
help='train resnet')
parser.add_argument('--train-resnet',
dest='train_resnet',
action='store_true')
parser.set_defaults(train_resnet=False)
parser.add_argument('--no-accuracy',
dest='compute_acc',
action='store_false')
parser.set_defaults(compute_acc=True)
parser.add_argument('--no-pose-accuracy',
dest='compute_pose_acc',
action='store_false')
parser.set_defaults(compute_pose_acc=True)
args = parser.parse_args()
background_path = args.background
compute_class_accuracy = args.compute_acc
compute_pose_accuracy = args.compute_pose_acc and args.compute_acc
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('# compute class accuracy: {}'.format(compute_class_accuracy))
print('# compute pose accuracy: {}'.format(compute_pose_accuracy))
print('')
n_class = 9
train_path = os.path.join(os.getcwd(), root,
'train_data/OcclusionChallengeICCV2015')
caffe_model = 'ResNet-50-model.caffemodel'
distance_sanity = 0.05
output_scale = 0.12
eps = 0.05
chainer.using_config('cudnn_deterministic', True)
model = DualCPNetClassifier(DualCenterProposalNetworkRes50_predict7(
n_class=n_class, pretrained_model=not args.train_resnet),
basepath=train_path,
im_size=(640, 480),
distance_sanity=distance_sanity,
compute_class_accuracy=compute_class_accuracy,
compute_pose_accuracy=compute_pose_accuracy,
output_scale=output_scale)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
model.to_gpu() # Copy the model to the GPU
# Setup an optimizer
optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9)
optimizer.setup(model)
train_range = range(1000)
# train_range = range(len(glob.glob(os.path.join(args.background, '*.jpg'))))
print "number of training data is {}".format(len(train_range))
# load train data
train = DualCPNetAutoGenerateDataset(train_path,
background_path,
train_range,
gaussian_noise=False,
gamma_augmentation=True,
avaraging=True,
salt_pepper_noise=False,
contrast=False,
random_iteration=True,
metric_filter=output_scale + eps)
# load test data
test_range = np.arange(1213)[0::6]
test = DualCPNetDataset(train_path,
test_range,
img_height=480,
img_width=640,
metric_filter=output_scale + eps)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
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
evaluator = extensions.Evaluator(test_iter, model, device=args.gpu)
evaluator.default_name = 'val'
trainer.extend(evaluator)
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot and snapshot object for each specified epoch
frequency = args.epoch if args.frequency == -1 else max(1, args.frequency)
trainer.extend(extensions.snapshot(), trigger=(frequency, 'epoch'))
trainer.extend(extensions.snapshot_object(
model.predictor, filename='model_iteration-{.updater.iteration}'),
trigger=(frequency, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport([
'epoch', 'main/l_cls', 'main/l_cp', 'main/l_ocp', 'main/cls_acc',
'main/ocp_acc', 'main/rot_acc', 'main/5cm5deg', 'val/main/l_cls',
'val/main/l_cp', 'val/main/l_ocp', 'val/main/cls_acc',
'val/main/ocp_acc', 'val/main/rot_acc', 'val/main/5cm5deg',
'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)
else:
npz_name = 'DualCenterProposalNetworkRes50ver2_occulusion_challenge.npz'
caffemodel_name = 'ResNet-50-model.caffemodel'
path = os.path.join(root, 'trained_data/', npz_name)
path_caffemodel = os.path.join(root, 'trained_data/', caffemodel_name)
print 'npz model path : ' + path
print 'caffe model path : ' + path_caffemodel
download.cache_or_load_file(
path, lambda path: _make_chainermodel_npz(path, path_caffemodel,
model, n_class),
lambda path: serializers.load_npz(path, model))
# Run the training
trainer.run()
def _retrieve_fashion_mnist(name, urls):
root = download.get_dataset_directory('pfnet/chainer/fashion-mnist')
path = os.path.join(root, name)
return download.cache_or_load_file(
path, lambda path: make_npz(path, urls), numpy.load)
def _get_cifar(name, withlabel, ndim, scale):
root = download.get_dataset_directory(
os.path.join('pfnet', 'chainer', 'cifar'))
npz_path = os.path.join(root, '{}.npz'.format(name))
url = 'https://www.cs.toronto.edu/~kriz/{}-python.tar.gz'.format(name)
def creator(path):
archive_path = download.cached_download(url)
if name == 'cifar-10':
train_x = numpy.empty((5, 10000, 3072), dtype=numpy.uint8)
train_y = numpy.empty((5, 10000), dtype=numpy.uint8)
test_y = numpy.empty(10000, dtype=numpy.uint8)
dir_name = '{}-batches-py'.format(name)
with tarfile.open(archive_path, 'r:gz') as archive:
# training set
for i in range(5):
file_name = '{}/data_batch_{}'.format(dir_name, i + 1)
d = _pickle_load(archive.extractfile(file_name))
train_x[i] = d['data']
train_y[i] = d['labels']
# test set
file_name = '{}/test_batch'.format(dir_name)
d = _pickle_load(archive.extractfile(file_name))
test_x = d['data']
test_y[...] = d['labels'] # copy to array
train_x = train_x.reshape(50000, 3072)
train_y = train_y.reshape(50000)
else:
# name == 'cifar-100'
def load(archive, file_name):
d = _pickle_load(archive.extractfile(file_name))
x = d['data'].reshape((-1, 3072))
y = numpy.array(d['fine_labels'], dtype=numpy.uint8)
return x, y
with tarfile.open(archive_path, 'r:gz') as archive:
train_x, train_y = load(archive, 'cifar-100-python/train')
test_x, test_y = load(archive, 'cifar-100-python/test')
numpy.savez_compressed(path,
train_x=train_x,
train_y=train_y,
test_x=test_x,
test_y=test_y)
return {
'train_x': train_x,
'train_y': train_y,
'test_x': test_x,
'test_y': test_y
}
raw = download.cache_or_load_file(npz_path, creator, numpy.load)
train = _preprocess_cifar(raw['train_x'], raw['train_y'], withlabel, ndim,
scale)
test = _preprocess_cifar(raw['test_x'], raw['test_y'], withlabel, ndim,
scale)
return train, test
