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.01,0.01], beta=[0.001,1,1,1,1]): 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 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, path): """ Extract Image Feature Function :param path: vgg19 filepath :return:None """ self.function = caffe.CaffeFunction(path)
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="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 load(self, path): body, ext = os.path.splitext(path) if os.path.exists(path): print 'Loading', path self.func = pickle.load(open(path, 'rb')) else: print 'Loading', body+'.caffemodel' self.func = caffe.CaffeFunction(body+'.caffemodel') if self.func != None: print 'Saving', body+'.pkl' pickle.dump(self.func, open(body+'.pkl', 'wb')) return self.func != None
def ready(): global categories global mean_image global func # print('Loading Contour label file...') categories = np.loadtxt(LABEL_PATH, str, delimiter='\n') # print('Loading Contour mean file...') mean_image = np.load(MEAN_PATH) # print('Mean shape:', mean_image.shape) # print('Loading Contour model file...') func = caffe.CaffeFunction(MODEL_PATH) return
def load_param(path, obj, ignore_layers=None): src = None # load .pkl if exists if os.path.isfile(change_ext(path, '.pkl')): with open(change_ext(path, '.pkl'), 'rb') as f: src = pickle.load(f) # load caffemodel and save pkl (if .pkl file doesn't exist) else: src = caffe.CaffeFunction(change_ext(path, '.caffemodel')) pickle.dump(src, open(change_ext(path, '.pkl'), 'wb')) copy_model(src, obj, ignore_layers)
def main(): parser = argparse.ArgumentParser( description='Convert caffemodel to chainermodel') parser.add_argument('model', help='Path to caffemodel') parser.add_argument('--out', '-o', default='chainermodel', help='Output directory') args = parser.parse_args() try: os.makedirs(args.out) except OSError: pass caffemodel = caffe.CaffeFunction(args.model) modelname = extractFilename(args.model) pickle.dump(caffemodel, open(os.path.join(args.out, modelname + '.pkl'), 'wb'), -1)
L_style = (Fu.mean_squared_error(conv1_1G,conv1_1A)/(4*64*64*50176*50176) + Fu.mean_squared_error(conv2_1G,conv2_1A)/(4*128**128*12544*12544) + Fu.mean_squared_error(conv3_1G,conv3_1A)/(4*256*256*3136*3136) + Fu.mean_squared_error(conv4_1G,conv4_1A)/(4*512*512*784*784)\ )/4 # this is equal weighting of E_l loss = a_p_ratio*L_content + L_style return loss #main p=readimage(content_image)#read content image a=readimage(style_image)#read style image print "Loading caffe model.It takes time...." func = caffe.CaffeFunction('VGG_ILSVRC_19_layers.caffemodel') if gpu_id >= 0: func.to_gpu() print "....fhinish loading!" x_data=xp.random.randn(1,3,224,224).astype(np.float32) x = Variable(x_data) #x = readimage('imge230.png') # if you want to start from a exsiting image #optimize x(=image) with adam alpha=1 beta1=0.9 beta2=0.999
shape = (fixed_w * w / h, fixed_h) 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) prob = F.softmax(y) labels = open('labels.txt').read().split('\n') maxid = np.argmax(prob.data[0]) print labels[maxid], prob.data[0, maxid]
import pickle import cv2 import numpy as np from chainer import Variable from chainer.functions import caffe from chainer import cuda if len(sys.argv) < 3: print("usage: %s imagedir outputfile" % sys.argv[0]) quit() inputpath = sys.argv[1] outputfile = sys.argv[2] # Caffeのモデル読み込み(時間がかかる) print("loading model ... ", end="", file=sys.stderr) model = caffe.CaffeFunction("bvlc_reference_caffenet.caffemodel") model.to_gpu() print("done", file=sys.stderr) # 平均画像の読み込み mean = np.load("ilsvrc_2012_mean.npy") # 3x255x255 の画像 def load_images(inputpath, mean): imglist = [] filenames = [] for root, dirs, files in os.walk(inputpath): for fn in sorted(files): filenames.append(fn) bn, ext = os.path.splitext(fn)
help='caffe model file path') parser.add_argument('--label', '-l', type=str, default='labels.txt', help='label file path') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU device index. negative value indicates CPU') args = parser.parse_args() device = args.gpu categories = np.loadtxt(args.label, str, delimiter='\n') caffe_model = caffe.CaffeFunction(args.model) if device >= 0: caffe_model.to_gpu(device) if os.path.isdir(args.image_path): image_files = os.listdir(args.image_path) image_paths = map(lambda f: os.path.join(args.image_path, f), image_files) image_paths = filter(os.path.isfile, image_paths) else: image_paths = [args.image_path] for image_path in image_paths: try: x = load_image(image_path, device) y = predict(caffe_model, x)
)/4 # this is equal weighting of E_l # ratio = 0.001 #alpha/beta loss = ratio * L_content + L_style return loss #main cuda.init(3) # is GPU ID!! p = readimage('satoshi_fb.png') #read a content image a = readimage('style.png') #read a style image #download a pretraind caffe model from here: https://gist.github.com/ksimonyan/3785162f95cd2d5fee77#file-readme-md func = caffe.CaffeFunction( 'VGG_ILSVRC_19_layers.caffemodel') #it takes some time. func.to_gpu() x_data = np.random.randn(1, 3, 224, 224).astype(np.float32) x = Variable(cuda.to_gpu(x_data)) x = readimage('imge230.png') # if you want to start from a exsiting image savedir = "satoshi_fb_adam" #optimize x(=image) with adam #note we use numpy for optimization alpha = 1 beta1 = 0.9 beta2 = 0.999
import cPickle as pickle from chainer.functions import caffe import sys model_path = sys.argv[1] pkl_path = sys.argv[2] model = caffe.CaffeFunction(model_path) with open(pkl_path, 'wb') as f: pickle.dump(model, f, pickle.HIGHEST_PROTOCOL)
if args.gpu >= 0: cuda.get_device(args.gpu).use() xp = cuda.cupy if args.gpu >= 0 else np xp.random.seed(123) # load a new model to be fine-tuned if os.path.exists('model/vgg19.pkl'): print('Loading Caffe model file: {}'.format('model/vgg19.pkl')) with open('model/vgg19.pkl', 'rb') as f: vgg = pickle.load(f) else: print('Loading Caffe model file: {}'.format( 'model/VGG_ILSVRC_19_layers.caffemodel')) vgg = caffe.CaffeFunction('model/VGG_ILSVRC_19_layers.caffemodel') pickle.dump(vgg, open('model/vgg19.pkl', 'wb')) if args.gpu >= 0: vgg.to_gpu() X, Y = load_data() # x = np.zeros((len(X), 4096), dtype=np.float32) x = [] for i in xrange(0, len(X)): pixels = X[i] array = xp.asarray(pixels) x_data = xp.ascontiguousarray(array) if args.gpu >= 0: x_data = cuda.to_gpu(x_data)
#!/usr/bin/env python # -*- coding:utf-8 -*- """ Convert caffemodel file to npz format for saving time in traning preparation """ from chainer.functions import caffe from chainer import serializers ALEXNET_CAFFEMODEL = 'data/bvlc_alexnet.caffemodel' ALEXNET_NPZ = 'data/bvlc_alexnet.npz' if __name__ == '__main__': alexnet = caffe.CaffeFunction(ALEXNET_CAFFEMODEL) serializers.save_npz(ALEXNET_NPZ, alexnet)
from chainer.functions import caffe import chainer.serializers as s import cPickle as pickle from animeface import AnimeFaceDataset import chainer.serializers as s import os import cv2 as cv import sys import numpy as np from PIL import Image import chainer from chainer import cuda import chainer.functions as F from CNN_2 import CNN from chainer.functions import caffe import chainer.serializers as s import cPickle as pickle alex = caffe.CaffeFunction("bvlc_alexnet.caffemodel") pickle.dump(alex, open('alex', 'wb')) print 'Converting caffe model to chainer model was completed!' cnn = CNN(data=np.zeros(5), target=np.zeros(5), gpu=-1, n_outputs=0) #cnn.train_and_test(n_epoch=20,batchsize=100) cnn.dump_model('_chainer_fc6')
im = im - MEAN_VALUES return rawim.transpose(2, 0, 1).astype(np.float32) #main # Prepare dataset file_place = '../data/MSCOCO/annotations/captions_train2014.json' train_image_id2feature = get_image_ids(file_place) file_place = '../data/MSCOCO/annotations/captions_val2014.json' val_image_id2feature = get_image_ids(file_place) #Caffeモデルをロード print "loading caffe models" func = caffe.CaffeFunction('../data/bvlc_googlenet.caffemodel') if gpu_id >= 0: func.to_gpu() print "done" print 'feature_exractor' file_base = '../data/MSCOCO/train2014/COCO_train2014_' for i, image_id in enumerate(train_image_id2feature.keys()): if i % 5000 == 0: print i try: image = image_read_np(file_base + str("{0:012d}".format(image_id) + '.jpg')) except Exception as e:
k = 0 for i in range(imsize[1] / 175): for j in range(imsize[0] / 175): k += 1 image_c = image.crop( [175 * i, 175 * j, 175 * (i + 1), 175 * (j + 1)]) image_c.save('%d%d.png' % (i, j)) imshow(np.asarray(image_c)) plt.show() cnn_dog('%d%d.png' % (i, j), k, categories_dog, func, verbose=True) ############################################################################### # initialization of the caffe model categories = np.loadtxt("labels_dog.txt", str, delimiter="\t") categories_dog = [i for i in range(len(categories)) if 'dog' in categories[i]][:-2] model = 'bvlc_googlenet.caffemodel' gpu = -1 print('Loading Caffe model file %s...' % model, file=sys.stderr) try: func except NameError: func = caffe.CaffeFunction(model) print('Loaded', file=sys.stderr)
def load_caffemodel(caffemodel): print("load model... %s" % caffemodel) model = caffe.CaffeFunction(caffemodel) return lambda layer_name: Conv(getattr(model, layer_name))
import sys import os import scipy as sp import numpy as np import chainer from chainer import Function, gradient_check, Variable, optimizers, serializers, utils from chainer import Link, Chain, ChainList import chainer.functions as F import chainer.links as L from chainer.functions import caffe import cv2 import pickle print('loading caffemodel') model = caffe.CaffeFunction('../manga6_92000.caffemodel') print('making pickle') pickle.dump(model, open('../model.pkl', 'wb')) print('symbolic link') # titles = ["MeteoSanStrikeDesu","SaladDays_vol18","HinagikuKenzan","HarukaRefrain", "Belmondo", "LoveHina_vol14", "GOOD_KISS_Ver2", "YamatoNoHane", "Arisa", "AisazuNihaIrarenai"] titles = ['Belmondo'] os.chdir('./WebGUI/image') # トーン除去前のデータ # os.remove('Belmondo') for title in titles: os.symlink('../../../' + title, './' + title)
def load(self, path): self.func = caffe.CaffeFunction(path)
def main(img_name, out_img_name): oriImg = cv.imread(img_name) # B,G,R order param, model = config_reader() multiplier = [ x * model['boxsize'] / oriImg.shape[0] for x in param['scale_search'] ] #multiplier = multiplier[:1] #net = caffe.Net(model['deployFile'], model['caffemodel'], caffe.TEST) net = caffe.CaffeFunction(model['caffemodel']) heatmap_avg = np.zeros((oriImg.shape[0], oriImg.shape[1], 19)) paf_avg = np.zeros((oriImg.shape[0], oriImg.shape[1], 38)) for m in range(len(multiplier)): scale = multiplier[m] imageToTest = cv.resize(oriImg, (0, 0), fx=scale, fy=scale, interpolation=cv.INTER_CUBIC) imageToTest_padded, pad = util.padRightDownCorner( imageToTest, model['stride'], model['padValue']) print imageToTest_padded.shape #net.blobs['data'].reshape(*(1, 3, imageToTest_padded.shape[0], imageToTest_padded.shape[1])) #net.blobs['data'].data[...] = np.transpose(np.float32(imageToTest_padded[:,:,:,np.newaxis]), (3,2,0,1))/256 - 0.5; netInput = ary2input(imageToTest_padded) start_time = time.time() #output_blobs = net.forward() netOutput = net(inputs={'data': netInput}, outputs=['Mconv7_stage6_L1', 'Mconv7_stage6_L2']) print('At scale %d, The CNN took %.2f ms.' % (m, 1000 * (time.time() - start_time))) # extract outputs, resize, and remove padding #heatmap = np.transpose(np.squeeze(net.blobs[output_blobs.keys()[1]].data), (1,2,0)) # output 1 is heatmaps heatmap = np.transpose(np.squeeze(netOutput[1].data), (1, 2, 0)) # output 1 is heatmaps heatmap = cv.resize(heatmap, (0, 0), fx=model['stride'], fy=model['stride'], interpolation=cv.INTER_CUBIC) heatmap = heatmap[:imageToTest_padded.shape[0] - pad[2], :imageToTest_padded.shape[1] - pad[3], :] heatmap = cv.resize(heatmap, (oriImg.shape[1], oriImg.shape[0]), interpolation=cv.INTER_CUBIC) #paf = np.transpose(np.squeeze(net.blobs[output_blobs.keys()[0]].data), (1,2,0)) # output 0 is PAFs paf = np.transpose(np.squeeze(netOutput[0].data), (1, 2, 0)) # output 0 is PAFs paf = cv.resize(paf, (0, 0), fx=model['stride'], fy=model['stride'], interpolation=cv.INTER_CUBIC) paf = paf[:imageToTest_padded.shape[0] - pad[2], :imageToTest_padded.shape[1] - pad[3], :] paf = cv.resize(paf, (oriImg.shape[1], oriImg.shape[0]), interpolation=cv.INTER_CUBIC) heatmap_avg = heatmap_avg + heatmap / len(multiplier) paf_avg = paf_avg + paf / len(multiplier) U = paf_avg[:, :, 16] * -1 V = paf_avg[:, :, 17] X, Y = np.meshgrid(np.arange(U.shape[1]), np.arange(U.shape[0])) M = np.zeros(U.shape, dtype='bool') M[U**2 + V**2 < 0.5 * 0.5] = True U = ma.masked_array(U, mask=M) V = ma.masked_array(V, mask=M) import scipy print heatmap_avg.shape from scipy.ndimage.filters import gaussian_filter all_peaks = [] peak_counter = 0 start_time = time.time() for part in range(19 - 1): x_list = [] y_list = [] map_ori = heatmap_avg[:, :, part] map = gaussian_filter(map_ori, sigma=3) map_left = np.zeros(map.shape) map_left[1:, :] = map[:-1, :] map_right = np.zeros(map.shape) map_right[:-1, :] = map[1:, :] map_up = np.zeros(map.shape) map_up[:, 1:] = map[:, :-1] map_down = np.zeros(map.shape) map_down[:, :-1] = map[:, 1:] peaks_binary = np.logical_and.reduce( (map >= map_left, map >= map_right, map >= map_up, map >= map_down, map > param['thre1'])) peaks = zip(np.nonzero(peaks_binary)[1], np.nonzero(peaks_binary)[0]) # note reverse peaks_with_score = [x + (map_ori[x[1], x[0]], ) for x in peaks] id = range(peak_counter, peak_counter + len(peaks)) peaks_with_score_and_id = [ peaks_with_score[i] + (id[i], ) for i in range(len(id)) ] all_peaks.append(peaks_with_score_and_id) peak_counter += len(peaks) # find connection in the specified sequence, center 29 is in the position 15 limbSeq = [[2,3], [2,6], [3,4], [4,5], [6,7], [7,8], [2,9], [9,10], \ [10,11], [2,12], [12,13], [13,14], [2,1], [1,15], [15,17], \ [1,16], [16,18], [3,17], [6,18]] # the middle joints heatmap correpondence mapIdx = [[31,32], [39,40], [33,34], [35,36], [41,42], [43,44], [19,20], [21,22], \ [23,24], [25,26], [27,28], [29,30], [47,48], [49,50], [53,54], [51,52], \ [55,56], [37,38], [45,46]] connection_all = [] special_k = [] mid_num = 10 for k in range(len(mapIdx)): score_mid = paf_avg[:, :, [x - 19 for x in mapIdx[k]]] candA = all_peaks[limbSeq[k][0] - 1] candB = all_peaks[limbSeq[k][1] - 1] nA = len(candA) nB = len(candB) indexA, indexB = limbSeq[k] if (nA != 0 and nB != 0): connection_candidate = [] for i in range(nA): for j in range(nB): vec = np.subtract(candB[j][:2], candA[i][:2]) norm = math.sqrt(vec[0] * vec[0] + vec[1] * vec[1]) vec = np.divide(vec, norm) startend = zip(np.linspace(candA[i][0], candB[j][0], num=mid_num), \ np.linspace(candA[i][1], candB[j][1], num=mid_num)) vec_x = np.array([score_mid[int(round(startend[I][1])), int(round(startend[I][0])), 0] \ for I in range(len(startend))]) vec_y = np.array([score_mid[int(round(startend[I][1])), int(round(startend[I][0])), 1] \ for I in range(len(startend))]) score_midpts = np.multiply(vec_x, vec[0]) + np.multiply( vec_y, vec[1]) score_with_dist_prior = sum( score_midpts) / len(score_midpts) + min( 0.5 * oriImg.shape[0] / norm - 1, 0) criterion1 = len( np.nonzero(score_midpts > param['thre2']) [0]) > 0.8 * len(score_midpts) criterion2 = score_with_dist_prior > 0 if criterion1 and criterion2: connection_candidate.append([ i, j, score_with_dist_prior, score_with_dist_prior + candA[i][2] + candB[j][2] ]) connection_candidate = sorted(connection_candidate, key=lambda x: x[2], reverse=True) connection = np.zeros((0, 5)) for c in range(len(connection_candidate)): i, j, s = connection_candidate[c][0:3] if (i not in connection[:, 3] and j not in connection[:, 4]): connection = np.vstack( [connection, [candA[i][3], candB[j][3], s, i, j]]) if (len(connection) >= min(nA, nB)): break connection_all.append(connection) else: special_k.append(k) connection_all.append([]) # last number in each row is the total parts number of that person # the second last number in each row is the score of the overall configuration subset = -1 * np.ones((0, 20)) candidate = np.array([item for sublist in all_peaks for item in sublist]) for k in range(len(mapIdx)): if k not in special_k: partAs = connection_all[k][:, 0] partBs = connection_all[k][:, 1] indexA, indexB = np.array(limbSeq[k]) - 1 for i in range(len(connection_all[k])): #= 1:size(temp,1) found = 0 subset_idx = [-1, -1] for j in range(len(subset)): #1:size(subset,1): if subset[j][indexA] == partAs[i] or subset[j][ indexB] == partBs[i]: subset_idx[found] = j found += 1 if found == 1: j = subset_idx[0] if (subset[j][indexB] != partBs[i]): subset[j][indexB] = partBs[i] subset[j][-1] += 1 subset[j][-2] += candidate[partBs[i].astype(int), 2] + connection_all[k][i][2] elif found == 2: # if found 2 and disjoint, merge them j1, j2 = subset_idx print "found = 2" membership = ((subset[j1] >= 0).astype(int) + (subset[j2] >= 0).astype(int))[:-2] if len(np.nonzero(membership == 2)[0]) == 0: #merge subset[j1][:-2] += (subset[j2][:-2] + 1) subset[j1][-2:] += subset[j2][-2:] subset[j1][-2] += connection_all[k][i][2] subset = np.delete(subset, j2, 0) else: # as like found == 1 subset[j1][indexB] = partBs[i] subset[j1][-1] += 1 subset[j1][-2] += candidate[ partBs[i].astype(int), 2] + connection_all[k][i][2] # if find no partA in the subset, create a new subset elif not found and k < 17: row = -1 * np.ones(20) row[indexA] = partAs[i] row[indexB] = partBs[i] row[-1] = 2 row[-2] = sum( candidate[connection_all[k][i, :2].astype(int), 2]) + connection_all[k][i][2] subset = np.vstack([subset, row]) # delete some rows of subset which has few parts occur deleteIdx = [] for i in range(len(subset)): if subset[i][-1] < 4 or subset[i][-2] / subset[i][-1] < 0.4: deleteIdx.append(i) subset = np.delete(subset, deleteIdx, axis=0) print('Body Estimation took %.2f ms.' % (1000 * (time.time() - start_time))) # visualize colors = [[255, 0, 0], [255, 85, 0], [255, 170, 0], [255, 255, 0], [170, 255, 0], [85, 255, 0], [0, 255, 0], \ [0, 255, 85], [0, 255, 170], [0, 255, 255], [0, 170, 255], [0, 85, 255], [0, 0, 255], [85, 0, 255], \ [170, 0, 255], [255, 0, 255], [255, 0, 170], [255, 0, 85]] cmap = matplotlib.cm.get_cmap('hsv') canvas = cv.imread(img_name) # B,G,R order for i in range(18): rgba = np.array(cmap(1 - i / 18. - 1. / 36)) rgba[0:3] *= 255 for j in range(len(all_peaks[i])): cv.circle(canvas, all_peaks[i][j][0:2], 4, colors[i], thickness=-1) # visualize 2 stickwidth = 4 for i in range(17): for n in range(len(subset)): index = subset[n][np.array(limbSeq[i]) - 1] if -1 in index: continue cur_canvas = canvas.copy() Y = candidate[index.astype(int), 0] X = candidate[index.astype(int), 1] mX = np.mean(X) mY = np.mean(Y) length = ((X[0] - X[1])**2 + (Y[0] - Y[1])**2)**0.5 angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1])) polygon = cv.ellipse2Poly( (int(mY), int(mX)), (int(length / 2), stickwidth), int(angle), 0, 360, 1) cv.fillConvexPoly(cur_canvas, polygon, colors[i]) canvas = cv.addWeighted(canvas, 0.4, cur_canvas, 0.6, 0) cv.imwrite(out_img_name, canvas)
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
cuda.check_cuda_available() xp = cuda.cupy if args.gpu >= 0 else np caffe_model = args.model chainer_model_path = \ re.sub('\.caffemodel$', '.chainermodel.pkl', caffe_model) chainer_model = None if not os.path.isfile(chainer_model_path): if not os.path.isfile(caffe_model): print('{} is not found.'.format(caffe_model)) exit(1) else: print('Converting the caffemodel.') print('It takes a while, ', end='') print('but this process is not required from the next time.') func = caffe.CaffeFunction(caffe_model) pickle.dump(func, open(chainer_model_path, mode='wb+')) else: func = pickle.load(open(chainer_model_path, mode='rb')) if args.gpu >= 0: cuda.get_device(args.gpu).use() func.to_gpu() in_size = 224 mean_image = np.load(args.mean) cropwidth = 256 - in_size start = cropwidth // 2 stop = start + in_size mean_image = mean_image[:, start:stop, start:stop].copy()