def main():
model_path = download_model('alexnet')
func = caffe.CaffeFunction(model_path)
alex = Alex()
copy_model(func, alex)
# alex.to_gpu()
classifier = Classifier(alex)
optimizer = optimizers.MomentumSGD(lr=0.0005)
optimizer.setup(classifier)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001))
print("alex init done.")
train_data = ImageData('data/clf_train_images_1',
'data/clf_train_master.tsv')
test_data = ImageData('data/clf_test_images_1', 'data/clf_test.tsv')
print("data load done.")
classifier, optimizer = train_val(train_data, classifier, optimizer)
print("train done.")
p = predict(test_data, classifier)
print("predict done.")
pd.DataFrame(p.argmax(axis=1)).to_csv('sample_submit.csv', header=None)
def __init__(self, gpu, model, model_type, out_dim):
self.gpu = gpu
self.model = 'bvlc_alexnet.caffemodel'
self.model_type = 'alexnet'
self.batchsize = 1
self.out_dim = out_dim
if self.gpu >= 0:
cuda.check_cuda_available()
print('Loading Caffe model file %s...' % self.model, file=sys.stderr)
self.func = caffe.CaffeFunction(self.model)
print('Loaded', file=sys.stderr)
if self.gpu >= 0:
cuda.get_device(self.gpu).use()
self.func.to_gpu()
if self.model_type == 'alexnet':
self.in_size = 227
mean_image = np.load('ilsvrc_2012_mean.npy')
del self.func.layers[15:23]
self.outname = 'pool5'
#del self.func.layers[13:23]
#self.outname = 'conv5'
cropwidth = 256 - self.in_size
start = cropwidth // 2
stop = start + self.in_size
self.mean_image = mean_image[:, start:stop, start:stop].copy()
def load(self, path):
root, ext = os.path.splitext(path)
if ext == '.pkl':
with open(path, 'rb') as f:
self.func = pickle.load(f)
else:
self.func = caffe.CaffeFunction(path)
def __init__(self, gpu, model, model_type, out_dim):
self.gpu = gpu
self.model = model
self.model_type = model_type
self.batchsize = 1
self.out_dim = out_dim
if self.gpu >= 0:
cuda.check_cuda_available()
app_logger.info('Loading Caffe model file {}...'.format(self.model))
self.func = caffe.CaffeFunction(self.model)
app_logger.info('Loaded')
if self.gpu >= 0:
cuda.get_device(self.gpu).use()
self.func.to_gpu()
if self.model_type == MODEL_TYPE:
self.in_size = 227
mean_image = np.load(DEFAULT_MEAN_IMAGE)
del self.func.layers[15:23]
self.outname = 'pool5'
# del self.func.layers[13:23]
# self.outname = 'conv5'
cropwidth = 256 - self.in_size
start = cropwidth // 2
stop = start + self.in_size
self.mean_image = mean_image[:, start:stop, start:stop].copy()
def _download_pretrained_model(model_type, dest_path):
from chainer.links import caffe
if os.path.exists(dest_path):
raise OSError('destination already exists: %s' % dest_path)
basename, ext = os.path.splitext(models[model_type])
url = base_url + basename + '.caffemodel'
caffe_model_path = chainer.dataset.cached_download(url)
if not os.path.exists(caffe_model_path):
raise OSError('caffe model does not exist: %s' % caffe_model_path)
print('Converting to chainer model')
caffe_model = caffe.CaffeFunction(caffe_model_path)
chainer_model = HandNet(pretrained_model=None)
for link in chainer_model.links():
if not isinstance(link, chainer.Link) or not link.name:
continue
if eval('chainer_model.{0}.b.shape == caffe_model["{0}"].b.shape'.format(link.name)) and\
eval('chainer_model.{0}.W.shape == caffe_model["{0}"].W.shape'.format(link.name)):
exec('chainer_model.{0}.W.data = caffe_model["{0}"].W.data'.format(link.name))
exec('chainer_model.{0}.b.data = caffe_model["{0}"].b.data'.format(link.name))
print('Copied layer {0}'.format(link.name))
else:
print('Failed to copy layer {0}'.format(link.name))
chainer.serializers.save_npz(dest_path, chainer_model)
return True
def __init__(self,
fn="nin_imagenet.caffemodel",
alpha=[0, 0, 1, 1],
beta=[1, 1, 1, 1]):
print("load model... %s" % fn)
self.model = caffe.CaffeFunction(fn)
self.alpha = alpha
self.beta = beta
def __init__(self,
fn="VGG_ILSVRC_16_layers.caffemodel",
alpha=[0, 0, 1, 1],
beta=[1, 1, 1, 1]):
print("load model... %s" % fn)
self.model = caffe.CaffeFunction(fn)
self.alpha = alpha
self.beta = beta
def __init__(self,
fn="illust2vec_tag_ver200.caffemodel",
alpha=[0, 0, 0, 1, 10, 100],
beta=[0.1, 1, 1, 10, 100, 1000]):
print("load model... %s" % fn)
self.model = caffe.CaffeFunction(fn)
self.alpha = alpha
self.beta = beta
# self.pool_func = F.max_pooling_2d
self.pool_func = F.average_pooling_2d
def __init__(self,
fn="bvlc_googlenet.caffemodel",
alpha=[0, 0, 0, 0, 1, 10],
beta=[0.00005, 5, 50, 50, 5000, 500000]):
print("load model... %s" % fn)
self.model = caffe.CaffeFunction(fn)
self.alpha = alpha
self.beta = beta
# self.pool_func = F.max_pooling_2d
self.pool_func = F.average_pooling_2d
def copy_vgg_params(model):
print('Copying params of pretrained model...')
layer_names = [
"conv1_1", "conv1_2", "conv2_1", "conv2_2", "conv3_1",
"conv3_2", "conv3_3", "conv3_4", "conv4_1", "conv4_2",
]
pre_model = caffe.CaffeFunction('models/VGG_ILSVRC_19_layers.caffemodel')
for layer_name in layer_names:
exec("model.%s.W.data = pre_model['%s'].W.data" % (layer_name, layer_name))
exec("model.%s.b.data = pre_model['%s'].b.data" % (layer_name, layer_name))
print('Done.')
def get_coco_pretrained_model():
data_dir = download.get_dataset_directory(root)
pretraind_model_dir = os.path.join(data_dir, 'model')
makedirs(pretraind_model_dir)
pretrained_model_filename = os.path.join(pretraind_model_dir,
'coco_posenet.npz')
pretrained_model_url = 'http://posefs1.perception.cs.cmu.edu/OpenPose/'\
'models/pose/coco/pose_iter_440000.caffemodel'
download_file_path = utils.cached_download(pretrained_model_url)
if os.path.exists(pretrained_model_filename):
return pretrained_model_filename
model = OpenPoseNet(len(JointType) + 1, len(coco_joint_pairs) * 2)
caffe_model = caffe.CaffeFunction(download_file_path)
layer_names = [
"conv1_1", "conv1_2", "conv2_1", "conv2_2", "conv3_1", "conv3_2",
"conv3_3", "conv3_4", "conv4_1", "conv4_2", "conv4_3_CPM",
"conv4_4_CPM", "conv5_1_CPM_L1", "conv5_2_CPM_L1", "conv5_3_CPM_L1",
"conv5_4_CPM_L1", "conv5_1_CPM_L2", "conv5_2_CPM_L2", "conv5_3_CPM_L2",
"conv5_4_CPM_L2", "conv5_5_CPM_L2", "Mconv1_stage2_L1",
"Mconv2_stage2_L1", "Mconv3_stage2_L1", "Mconv4_stage2_L1",
"Mconv5_stage2_L1", "Mconv6_stage2_L1", "Mconv7_stage2_L1",
"Mconv1_stage2_L2", "Mconv2_stage2_L2", "Mconv3_stage2_L2",
"Mconv4_stage2_L2", "Mconv5_stage2_L2", "Mconv6_stage2_L2",
"Mconv7_stage2_L2", "Mconv1_stage3_L1", "Mconv2_stage3_L1",
"Mconv3_stage3_L1", "Mconv4_stage3_L1", "Mconv5_stage3_L1",
"Mconv6_stage3_L1", "Mconv7_stage3_L1", "Mconv1_stage3_L2",
"Mconv2_stage3_L2", "Mconv3_stage3_L2", "Mconv4_stage3_L2",
"Mconv5_stage3_L2", "Mconv6_stage3_L2", "Mconv7_stage3_L2",
"Mconv1_stage4_L1", "Mconv2_stage4_L1", "Mconv3_stage4_L1",
"Mconv4_stage4_L1", "Mconv5_stage4_L1", "Mconv6_stage4_L1",
"Mconv7_stage4_L1", "Mconv1_stage4_L2", "Mconv2_stage4_L2",
"Mconv3_stage4_L2", "Mconv4_stage4_L2", "Mconv5_stage4_L2",
"Mconv6_stage4_L2", "Mconv7_stage4_L2", "Mconv1_stage5_L1",
"Mconv2_stage5_L1", "Mconv3_stage5_L1", "Mconv4_stage5_L1",
"Mconv5_stage5_L1", "Mconv6_stage5_L1", "Mconv7_stage5_L1",
"Mconv1_stage5_L2", "Mconv2_stage5_L2", "Mconv3_stage5_L2",
"Mconv4_stage5_L2", "Mconv5_stage5_L2", "Mconv6_stage5_L2",
"Mconv7_stage5_L2", "Mconv1_stage6_L1", "Mconv2_stage6_L1",
"Mconv3_stage6_L1", "Mconv4_stage6_L1", "Mconv5_stage6_L1",
"Mconv6_stage6_L1", "Mconv7_stage6_L1", "Mconv1_stage6_L2",
"Mconv2_stage6_L2", "Mconv3_stage6_L2", "Mconv4_stage6_L2",
"Mconv5_stage6_L2", "Mconv6_stage6_L2", "Mconv7_stage6_L2"
]
# copy layer params
for layer_name in layer_names:
model[layer_name].copyparams(caffe_model[layer_name])
chainer.serializers.save_npz(pretrained_model_filename, model)
return pretrained_model_filename
def test_py3_available(self):
ws = pkg_resources.WorkingSet()
try:
ws.require('protobuf<3.0.0')
ver = 2
except pkg_resources.VersionConflict:
ver = 3
if ver >= 3:
self.assertTrue(links.caffe.caffe_function.available)
else:
self.assertFalse(links.caffe.caffe_function.available)
with self.assertRaises(RuntimeError):
caffe.CaffeFunction('')
def main():
parser = argparse.ArgumentParser(
description='Load caffe model for chainer')
parser.add_argument('--caffe_model_path',
default='models/VGG_ILSVRC_19_layers.caffemodel',
help='Path for caffe model')
args = parser.parse_args()
print('Load caffe model from {} ...'.format(args.caffe_model_path))
caffe_model = caffe.CaffeFunction(args.caffe_model_path)
print('Load caffe model, DONE')
save_path = '{}.pkl'.format(os.path.splitext(args.caffe_model_path)[0])
print('\nSave to {} ...'.format(save_path))
with open(save_path, 'wb') as f:
pickle.dump(caffe_model, f)
def main():
parser = argparse.ArgumentParser(description='Load caffe model for chainer')
parser.add_argument('--caffe_model_path', default='models/realismCNN_all_iter3.caffemodel', help='Path for caffe model')
parser.add_argument('--chainer_model_path', default='models/realismCNN_all_iter3.npz', help='Path for saving chainer model')
args = parser.parse_args()
print('Load caffe model from {} ...'.format(args.caffe_model_path))
caffe_model = caffe.CaffeFunction(args.caffe_model_path)
print('Load caffe model, DONE')
print('\nTurn CNN into FCN, start ...\n')
chainer_model = RealismCNN()
chainer_model(Variable(np.zeros((1, 3, 227, 227), dtype=np.float32), volatile='on'))
chainer_model = cnn2fcn(caffe_model, chainer_model)
print('\nTurn CNN into FCN, DONE. Save to {} ...'.format(args.chainer_model_path))
serializers.save_npz(args.chainer_model_path, chainer_model)
def LoadCaffeModel(path):
print "Loading %s"%path
root, ext = os.path.splitext(path)
cashnpath = 'cash/'+hashlib.sha224(root).hexdigest()+".pkl"
if path in __Model_cache:
print "Cache hit"
func = __Model_cache[path]
if os.path.exists(cashnpath):
func = pickle.load(open(cashnpath,'rb'))
else:
print "Converting from %s"%path
func = caffe.CaffeFunction('misc/'+path)
pickle.dump(func, open(cashnpath, 'wb'))
__Model_cache[path]=func
if Deel.gpu>=0:
func = func.to_gpu(Deel.gpu)
return func
def __init__(self,
nclass=10,
arch='VGG16',
pooling='avg',
p=5,
a=0.25,
svmpath=None,
l2normalize=False):
super(VGG, self).__init__()
if arch == 'VGG16':
VGGNet = VGG16_conv.VGGNet
srcpath = '/data/unagi0/mukuta/VGG/pretrained/VGG_ILSVRC_16_layers.caffemodel'
srcchainer = '/data/unagi0/mukuta/VGG/pretrained/VGG_ILSVRC_16_layers_cbp_conv.chainer'
elif arch == 'VGG19':
VGGNet = VGG19_conv.VGGNet
srcpath = '/data/unagi0/mukuta/VGG/pretrained/VGG_ILSVRC_19_layers.caffemodel'
srcchainer = '/data/unagi0/mukuta/VGG/pretrained/VGG_ILSVRC_19_layers_cbp_conv.chainer'
else:
print('error in arch')
self.add_link('conv', VGGNet())
if not (os.path.exists(srcchainer)):
from chainer.links import caffe
srcmodel = caffe.CaffeFunction(srcpath)
copy_model(srcmodel, self.conv)
chainer.serializers.save_npz(srcchainer, self.conv)
else:
chainer.serializers.load_npz(srcchainer, self.conv)
if pooling == 'avg':
self.add_link('fc', FC_avg(nclass, l2normalize))
elif pooling == 'spp':
self.add_link('fc', FC_spp(nclass, p, l2normalize))
elif pooling == 'kweight':
self.add_link('fc', FC_kweight(nclass, p, a, l2normalize))
else:
print('error in pooling')
if svmpath:
svm = np.load(svmpath)
self.fc.fc.W.data = svm['coef_'].astype(np.float32)
self.fc.fc.b.data = np.squeeze(svm['intercept_']).astype(
np.float32)
self.train = True
def __init__(self,
model='bvlc_googlenet.caffemodel',
mean='ilsvrc_2012_mean.npy',
labels='labels.txt',
in_size=224):
super(GoogLeNet, self).__init__('GoogLeNet', in_size)
root, ext = os.path.splitext(model)
cashnpath = 'cash/' + hashlib.sha224(root).hexdigest() + ".pkl"
if os.path.exists(cashnpath):
self.func = pickle.load(open(cashnpath, 'rb'))
else:
self.func = caffe.CaffeFunction('misc/' + model)
pickle.dump(self.func, open(cashnpath, 'wb'))
ImageNet.mean_image = np.ndarray((3, 256, 256), dtype=np.float32)
ImageNet.mean_image[0] = 104
ImageNet.mean_image[1] = 117
ImageNet.mean_image[2] = 123
ImageNet.in_size = in_size
self.labels = np.loadtxt("misc/" + labels, str, delimiter="\t")
def init_func(self):
self.func = caffe.CaffeFunction(self.model_file.name)
def test_py3_init_error(self):
with self.assertRaises(RuntimeError):
caffe.CaffeFunction('')
def main():
parser = argparse.ArgumentParser(description='Fast neural style transfer')
parser.add_argument('--gpu',
type=int,
default=0,
help='GPU ID (negative value indicates CPU)')
parser.add_argument(
'--filter_num',
type=int,
default=32,
help="# of filters in ImageTransformer's 1st conv layer")
parser.add_argument('--output_channel',
type=int,
default=3,
help='# of output image channels')
parser.add_argument('--tanh_constant',
type=float,
default=150,
help='Constant for output of ImageTransformer')
parser.add_argument('--instance_normalization',
type=str2bool,
default=True,
help='Use InstanceNormalization if True')
parser.add_argument('--model_path',
default='models/VGG_ILSVRC_19_layers.caffemodel',
help='Path for pretrained model(caffe model)')
parser.add_argument('--lr',
type=float,
default=1e-3,
help='Learning rate for Adam')
parser.add_argument('--n_iterations',
type=int,
default=40000,
help='# of iterations for training')
parser.add_argument('--batch_size',
type=int,
default=4,
help='Number of images in each mini-batch')
parser.add_argument('--n_thread',
type=int,
default=10,
help='# of workers for loading data')
parser.add_argument('--load_size',
type=int,
default=256,
help='Scale image to load_size')
parser.add_argument('--out',
default='fast_style_result',
help='Directory to output the result')
## Different layers & model
parser.add_argument('--content_layers',
type=str2list,
default='relu4_2',
help='Layers for content_loss, sperated by ;')
parser.add_argument('--content_weight',
type=float,
default=1,
help='Weight for content loss')
parser.add_argument('--style_layers',
type=str2list,
default='relu1_1;relu2_1;relu3_1;relu4_1;relu5_1',
help='Layers for style_loss, sperated by ;')
parser.add_argument('--style_weight',
type=float,
default=5,
help='Weight for style loss')
parser.add_argument('--tv_weight',
type=float,
default=1e-6,
help='Weight for tv loss')
parser.add_argument('--style_image_path',
default='images/Starry_Night.jpg',
help='Style src image')
parser.add_argument('--style_load_size',
type=int,
default=256,
help='Scale style image to load_size')
parser.add_argument('--data_root', help='Path for dataset root folder')
parser.add_argument('--train_folder',
default='train2014',
help='Folder for storing train images')
parser.add_argument('--val_folder',
default='val2014',
help='Folder for storing val images')
parser.add_argument('--train_list',
default='train.txt',
help='File storing train image list ')
parser.add_argument('--val_list',
default='val.txt',
help='File storing val images list')
parser.add_argument('--resume',
default='',
help='Resume the training from snapshot')
parser.add_argument('--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot (iterations)')
parser.add_argument('--print_interval',
type=int,
default=50,
help='Interval of printing log to console (iteration)')
parser.add_argument('--plot_interval',
type=int,
default=100,
help='Interval of plot (iteration)')
args = parser.parse_args()
print('Input arguments:')
for key, value in vars(args).items():
print('\t{}: {}'.format(key, value))
print('')
# Set up ImageTransformer & VGG
print('Create & Init models ...')
G = ImageTransformer(args.filter_num, args.output_channel,
args.tanh_constant, args.instance_normalization)
D = chainer_caffe.CaffeFunction(args.model_path)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
G.to_gpu() # Copy the model to the GPU
D.to_gpu()
print('Init models done ...\n')
# Setup an optimizer
optimizer = make_optimizer(G, args.lr)
########################################################################################################################
# Setup dataset & iterator
trainset = SuperImageDataset(os.path.join(args.data_root, args.train_list),
root=os.path.join(args.data_root,
args.train_folder),
load_size=args.load_size)
valset = SuperImageDataset(os.path.join(args.data_root, args.val_list),
root=os.path.join(args.data_root,
args.val_folder))
print('Trainset contains {} image files'.format(len(trainset)))
print('Valset contains {} image files'.format(len(valset)))
print('')
train_iter = chainer.iterators.MultiprocessIterator(
trainset,
args.batch_size,
n_processes=args.n_thread,
n_prefetch=args.n_thread)
val_iter = chainer.iterators.MultiprocessIterator(
trainset,
args.batch_size,
n_processes=args.n_thread,
n_prefetch=args.n_thread)
########################################################################################################################
# Set up a trainer
updater = StyleUpdater(models=(G, D),
args=args,
iterator=train_iter,
optimizer=optimizer,
device=args.gpu)
trainer = training.Trainer(updater, (args.n_iterations, 'iteration'),
out=args.out)
# Snapshot
snapshot_interval = (args.snapshot_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(
G, 'transformer_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval)
# Display
print_interval = (args.print_interval, 'iteration')
trainer.extend(extensions.LogReport(trigger=print_interval))
trainer.extend(extensions.PrintReport([
'iteration', 'main/loss', 'main/content_loss', 'main/style_loss',
'main/tv_loss'
]),
trigger=print_interval)
trainer.extend(extensions.ProgressBar(update_interval=args.print_interval))
trainer.extend(
extensions.dump_graph('main/loss', out_name='TrainGraph.dot'))
# Plot
plot_interval = (args.plot_interval, 'iteration')
trainer.extend(extensions.PlotReport(['main/loss'],
'iteration',
file_name='loss.png',
trigger=plot_interval),
trigger=plot_interval)
trainer.extend(extensions.PlotReport(['main/content_loss'],
'iteration',
file_name='content_loss.png',
trigger=plot_interval),
trigger=plot_interval)
trainer.extend(extensions.PlotReport(['main/style_loss'],
'iteration',
file_name='style_loss.png',
trigger=plot_interval),
trigger=plot_interval)
trainer.extend(extensions.PlotReport(['main/tv_loss'],
'iteration',
file_name='tv_loss.png',
trigger=plot_interval),
trigger=plot_interval)
# Eval
trainer.extend(display_image(G, valset, os.path.join(args.out, 'val'),
args.gpu),
trigger=plot_interval)
if args.resume:
# Resume from a snapshot
print('Resume from {} ... \n'.format(args.resume))
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
print('Training start ...\n')
trainer.run()
"Mconv5_stage6_L1",
"Mconv6_stage6_L1",
"Mconv7_stage6_L1",
"Mconv1_stage6_L2",
"Mconv2_stage6_L2",
"Mconv3_stage6_L2",
"Mconv4_stage6_L2",
"Mconv5_stage6_L2",
"Mconv6_stage6_L2",
"Mconv7_stage6_L2",
]
parser = argparse.ArgumentParser(
description="Convert caffemodel into chainermodel")
parser.add_argument("weights_file", help="weights file path")
args = parser.parse_args()
print("Loading PoseNet...")
chainer_model = CocoPoseNet()
print("Loading caffemodel file...")
caffe_model = caffe.CaffeFunction(args.weights_file)
for layer_name in layer_names:
copy_conv_layer_weights(chainer_model, caffe_model, layer_name)
chainer_file = "coco_posenet.npz"
print("Saving weights file into '%s'..." % (chainer_file))
serializers.save_npz(chainer_file, chainer_model)
print("Done.")
x.to_gpu()
yhat = classifier.predictor(x)
yhat = F.softmax(yhat)
yhat.to_cpu()
predictions[num_samples - len(data):num_samples, :] = yhat.data
return predictions
alex = Alex()
model = ResNet152Layers()
#model_path = download_model('data', 'alexnet') # モデルパラメータのダウンロード
model_path = download_model('data', 'resnet') # モデルパラメータのダウンロード
print(model_path)
func = caffe.CaffeFunction(model_path)
#copy_model(func, alex) # モデルパラメータのコピー
copy_model(func, model) # モデルパラメータのコピー
#alex.to_gpu() # gpuを使う場合
exit()
classifier = Classifier(alex)
print('exit!')
exit()
optimizer = optimizers.MomentumSGD(
lr=0.0005) # パラメータの学習方法は慣性項付きの確率的勾配法で, 学習率は0.0005に設定.
optimizer.setup(classifier)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001)) # l2正則化
#train_data = ImageData('clf_train_images', 'clf_train_master.tsv') # 学習データの読み込み
type=int,
default=227,
help='Input image width')
parser.add_argument('-H',
'--in-height',
type=int,
default=227,
help='Input image height')
parser.add_argument('-D',
'--in-depth',
type=int,
default=3,
help='Input image depth in bytes')
args = parser.parse_args()
print('Loading network...')
net = caffe.CaffeFunction(args.caffemodel)
retriever = chainer_trt.ModelRetriever(args.dest, verbose=args.verbose)
retriever.preprocess_caffemodel(net)
print('Calling forward pass...')
x = numpy.random.rand(1, args.in_depth, args.in_height, args.in_width)
x = x.astype(numpy.float32) * 255.0 # batch==1
with chainer.using_config('train', False):
with chainer_trt.RetainHook():
y, = net(inputs={'data': x}, outputs=args.output_layers)
y = chainer.functions.softmax(y)
retriever(y)
retriever.save()
if args.gpu >= 0:
cuda.check_cuda_available()
xp = cuda.cupy if args.gpu >= 0 else np
assert args.batchsize > 0
dataset = []
with open(args.dataset) as list_file:
for line in list_file:
pair = line.strip().split()
path = os.path.join(args.basepath, pair[0])
dataset.append((path, np.int32(pair[1])))
assert len(dataset) % args.batchsize == 0
print('Loading Caffe model file %s...' % args.model, file=sys.stderr)
func = caffe.CaffeFunction(args.model)
print('Loaded', file=sys.stderr)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
func.to_gpu()
if args.model_type == 'alexnet' or args.model_type == 'caffenet':
in_size = 227
mean_image = np.load(args.mean)
def forward(x, t):
y, = func(inputs={'data': x}, outputs=['fc8'], train=False)
return F.softmax_cross_entropy(y, t), F.accuracy(y, t)
elif args.model_type == 'googlenet':
in_size = 224
# Constant mean over spatial pixels
def load_caffe_model(model_name, output_folder_path='model', copy_model=None):
'''
Load caffe model and save as chainer model.
Args:
model_name (str): Model name
Choose from alexnet, caffenet, googlenet, resnet.
output_path (str): Output path
'''
def __download_model(model_name):
model = {
'alexnet': {
'url':
'http://dl.caffe.berkeleyvision.org/bvlc_alexnet.caffemodel',
'name': 'bvlc_alexnet.caffemodel'
},
'caffenet': {
'url':
'http://dl.caffe.berkeleyvision.org/bvlc_reference_caffenet.caffemodel',
'name': 'bvlc_reference_caffenet.caffemodel'
},
'googlenet': {
'url':
'http://dl.caffe.berkeleyvision.org/bvlc_googlenet.caffemodel',
'name': 'bvlc_googlenet.caffemodel'
},
'resnet50': {
'url': None,
'name': 'ResNet-50-model.caffemodel'
}
}
if not model_name in model:
raise RuntimeError(
'Choose from alexnet, caffenet, googlenet and resnet.')
url = model[model_name]['url']
name = model[model_name]['name']
if not os.path.isdir(os.path.join(output_folder_path, model_name)):
os.mkdir(os.path.join(output_folder_path, model_name))
output_path = os.path.join(output_folder_path, model_name, name)
if not os.path.isfile(output_path) and url is not None:
six.moves.urllib.request.urlretrieve(url, output_path)
else:
logging.info('Already model file exist.')
return output_path
logging.info('Downloading caffe model...')
file_path = __download_model(model_name)
logging.info('Done.')
logging.info('Converting to chainer model...')
model = caffe.CaffeFunction(file_path)
logging.info('Done.')
if output_folder_path:
logging.info('Saving chainer model...')
output_path = os.path.join(output_folder_path, model_name,
'import.npz')
chainer.serializers.save_npz(output_path, model)
logging.info('Done.')
if output_folder_path and copy_model is not None:
logging.info('Saving chainer model...')
__copy_model(model, copy_model)
output_path = os.path.join(output_folder_path, model_name,
'import2.npz')
chainer.serializers.save_npz(output_path, copy_model)
logging.info('Done.')
return model
def convert_alex_caffemodel(caffemodel_path, chainermodel_path):
chainermodel = Alex()
caffemodel = caffe.CaffeFunction(caffemodel_path)
convert_to_chainermodel(caffemodel, chainermodel)
chainer.serializers.save_hdf5(chainermodel_path, chainermodel)
exec("chainer_model.%s.W.data = caffe_model['%s'].W.data" %
(layer_name, layer_name))
exec("chainer_model.%s.b.data = caffe_model['%s'].b.data" %
(layer_name, layer_name))
print("Succeed to copy layer %s" % (layer_name))
else:
print("Failed to copy layer %s!" % (layer_name))
parser = argparse.ArgumentParser(
description="Convert caffemodel into chainermodel")
parser.add_argument(
"arch", help="model architecture: ['posenet', 'facenet', 'handnet']")
parser.add_argument("caffe_file", help="caffe weights file path")
parser.add_argument("chainer_file",
help="file path to save chainer weights file")
args = parser.parse_args()
print("Loading PoseNet...")
chainer_model = models[args.arch]()
print("Loading caffemodel file...")
caffe_model = caffe.CaffeFunction(args.caffe_file)
for layer_name in layer_names[args.arch]:
copy_conv_layer_weights(chainer_model, caffe_model, layer_name)
print("Saving weights file into '%s'..." % (args.chainer_file))
serializers.save_npz(args.chainer_file, chainer_model)
print("Done.")
import chainer
from chainer import cuda
import chainer.functions as F
from chainer.links import caffe
print('Downloading NIN model file for NumPy...')
url = 'https://dl.dropboxusercontent.com/u/206140/'
name = 'nin_imagenet.caffemodel'
import urllib2
fh = urllib2.urlopen(url + name)
with open('/tmp/' + name, 'wb') as output:
output.write(fh.read())
xp = np
func = caffe.CaffeFunction('/tmp/' + name)
def handler(event, context):
# do sklearn stuff here
mean_image = np.ndarray((1, 3, 256, 256), dtype=np.float32)
mean_image[:, 0, :, :] = 104
mean_image[:, 1, :, :] = 117
mean_image[:, 2, :, :] = 123
y, = func(inputs={'data': mean_image}, outputs=['pool4'], train=False)
ret = json.dumps(len(y.data.tolist()))
return {'yay': ret}
t0 = time.time()
print(handler({}, {}))
def init_func(self):
self.func = caffe.CaffeFunction(self.temp_file_path)
else:
shape = (fixed_w, fixed_h * h / w)
left = (shape[0] - fixed_w) / 2
top = (shape[1] - fixed_h) / 2
right = left + fixed_w
bottom = top + fixed_h
image = image.resize(shape)
image = image.crop((left, top, right, bottom))
x_data = np.asarray(image).astype(np.float32)
x_data = x_data.transpose(2, 0, 1)
x_data = x_data[::-1, :, :]
mean_image = np.zeros(3 * 224 * 224).reshape(3, 224, 224).astype(np.float32)
mean_image[0] = 103.0
mean_image[1] = 117.0
mean_image[2] = 123.0
x_data -= mean_image
x_data = np.array([x_data])
x = chainer.Variable(x_data)
func = caffe.CaffeFunction('bvlc_googlenet.caffemodel')
# y, = func(inputs={'data': x}, outputs=['loss3/classifier'], train=False)
y, = func(inputs={'data': x}, outputs=['loss3/classifier'])
prob = F.softmax(y)
labels = open('labels.txt').read().split('\n')
maxid = np.argmax(prob.data[0])
print labels[maxid], prob.data[0, maxid]
