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]