Ejemplo n.º 1
0
def main():
	''' pipeline for testing and evaluation '''
	# preset parameters
	save_path = '../data_viper/model_feat/'

	# load data
	# imL = 48
	bs = 100
	datafile_viper = '../data_viper/viper.pkl'
	viper = loadfile(datafile_viper)

	# load model
	modelfile_viper = '../data_viper/model_feat/model.pkl'
	model = loadfile(modelfile_viper)

	# evaluation and testing
	# test_x = viper.test_x.get_value(borrow=True)
	test_x = np.asarray(viper.test_feat)
	test_y = viper.test_y
	n_test = test_x.shape[0]
	test_ypred = model.predict(viper.test_feat)
	test_ypred = np.asarray(test_ypred).flatten()

	# test_ims = test_x.reshape((n_test, imL, imL, -1))

	# assign predicted scores to images
	h, w = viper.imgs[0].shape[:2]
	mh, mw = len(np.unique(viper.yy)), len(np.unique(viper.xx))
	msk0 = np.zeros(mh*mw).astype(np.uint8)
	msks = [msk0.copy() for im in viper.imgs]

	showlist = []
	for i in range(n_test):
		imgid = viper.test_imgids[i]
		patid = viper.test_ctrids[i]
		score = test_ypred[i]
		msks[imgid][patid] = score*255

	# resize predicted salience map to match image size
	msks_rs = [imresize(msk.reshape((mw, mh)).T, size=(h, w))/255. for msk in msks]

	# save salience map for comparison
	test_imids = np.asarray(np.unique(viper.test_imgids))
	salmap_gt = np.asarray(viper.salmsks) #np.asarray([viper.salmsks[imid] for imid in test_imids])
	salmap_pred = np.asarray(msks_rs) #np.asarray([msks_rs[imid]/255. for imid in test_imids])
	savefile(save_path+'salmaps_comparison.pkl', [test_imids, salmap_gt, salmap_pred])

	# quantize to show different test patches
	# kmeans = KMeans(init='k-means++', n_clusters=10, n_init=10)
	# kmeans.fit(test_ypred.reshape(n_test, 1))

	# # save to result folder
	# for i in range(10):
	# 	idx = kmeans.labels_== i
	# 	if any(idx): 
	# 		im = immontage(list(test_ims[idx])) 
	# 		imsave(save_path+'{}.jpg'.format(kmeans.cluster_centers_[i]), im)

	print 'testing finished'
Ejemplo n.º 2
0
def test_SVR():
	datafile_viper = '../data_viper/viper.pkl'
	viper = loadfile(datafile_viper)

	from sklearn.svm import SVR
	model = SVR(C=10, kernel='rbf', shrinking=False, verbose=True)

	model.fit(viper.train_feat, viper.train_y)

	y_pred = model.predict(viper.test_feat)
	print 'testing error {}'.format(abs_error(y_pred, viper.test_y)) 
Ejemplo n.º 3
0
def test_lasso_regression():
	datafile_viper = '../data_viper/viper.pkl'
	viper = loadfile(datafile_viper)

	from sklearn.linear_model import Lasso

	model = Lasso(alpha=1e-3)
	model.fit(viper.train_feat, viper.train_y)

	y_pred = model.predict(viper.test_feat)
	print 'testing error {}'.format(abs_error(y_pred, viper.test_y)) 
Ejemplo n.º 4
0
def test_linear_regression():
	datafile_viper = '../data_viper/viper.pkl'
	viper = loadfile(datafile_viper)

	from sklearn.linear_model import LinearRegression

	model = LinearRegression(normalize=True)
	model.fit(viper.train_feat, viper.train_y)

	y_pred = model.predict(viper.test_feat)
	print 'testing error {}'.format(abs_error(y_pred, viper.test_y)) 
Ejemplo n.º 5
0
def test_knn_regression():

	datafile_viper = '../data_viper/viper.pkl'
	viper = loadfile(datafile_viper)

	from sklearn.neighbors import KNeighborsRegressor
	model = KNeighborsRegressor(n_neighbors=5, weights='uniform', metric='euclidean')
	model.fit(viper.train_feat, viper.train_y)

	n_test = len(viper.test_feat)
	y_pred = np.zeros(n_test)
	for i, feat in zip(np.arange(n_test), viper.test_feat):
		dist, ind = model.kneighbors(feat)
		y_pred[i] = (viper.train_y[ind]*np.exp(-dist**2)).sum()/(np.exp(-dist**2)).sum()
	
	# y_pred = model.predict(viper.test_feat)
	print 'testing error {}'.format(abs_error(y_pred, viper.test_y)) 
Ejemplo n.º 6
0
def main():
	''' pipeline for evaluating salience '''
	# three types: 
	# 1) unsupervised, knnsal
	# 2) groundtruth, gtsal 
	# 3) prediction, predsal

	## load cnn salience with groundtruth
	supsal_path = '../data_viper/model_feat/salmaps_comparison.pkl'
	test_imids, salmap_gt, salmap_pred = loadfile(supsal_path)

	mapsz = salmap_gt[0].shape

	## load knn salience 
	knnsal_path = '../data_viper/salience_all.mat'
	tmp = loadfile(knnsal_path)
	knn_gal = tmp['salience_all_gal'] # view a
	knn_prb = tmp['salience_all_gal'] # view b

	labeled_imidx_path = '../data_viper/labeled_imidx.mat'
	tmp = loadfile(labeled_imidx_path)
	labeled_imidx = tmp['labeled_imidx'].flatten()
	salmap_knn_small = knn_gal[:, :, labeled_imidx].transpose((2, 0, 1))
	salmap_knn_all = [mapresize(im, size=mapsz) for im in salmap_knn_small]

	# get rid of background for better illustration 
	datafile_viper = '../data_viper/viper.pkl'
	viper = loadfile(datafile_viper)
	salmap_knn = []
	for seg, msk in zip(viper.segmsks, salmap_knn_all): 
		idx = seg == 0
		msk[idx] = 0
		salmap_knn.append(msk)
	salmap_knn = np.asarray(salmap_knn)

	# qualitative evaluation
	save_path = '../data_viper/model_feat/'
	for i in test_imids:
		pl.figure(1)
		pl.subplot(1, 4, 1) # show image
		pl.imshow(viper.imgs[i])
		pl.title('image')
		pl.subplot(1, 4, 2) # show groundtruth salience
		pl.imshow(salmap_gt[i]*255., cmap='hot', vmin=0, vmax=255)
		pl.title('groundtruth')
		pl.subplot(1, 4, 3) # show knn salience
		pl.imshow(salmap_knn[i]*255., cmap='hot', vmin=0, vmax=255)
		pl.title('KNN salience')
		pl.xlabel('abserr={0:.2f}'.format(abs_error(salmap_knn[i].flatten(), salmap_gt[i].flatten())))
		pl.subplot(1, 4, 4) # show CNN prediction salience
		pl.imshow(salmap_pred[i]*255., cmap='hot', vmin=0, vmax=255)
		pl.title('CNN salience')
		pl.xlabel('abserr={0:.2f}'.format(abs_error(salmap_pred[i].flatten(), salmap_gt[i].flatten())))
		pl.savefig(save_path + '{0:03d}.jpg'.format(i))
		print save_path +'{0:03d}.jpg'.format(i) + ' saved!'

	# quantitative evaluation
	test_idx = np.unique(test_imids)
	print 'mean abs error - KNN vs Gt: {0:.2f}'.format(abs_error(salmap_knn[test_idx], salmap_gt[test_idx]))
	print 'mean abs error - CNN vs Gt: {0:.2f}'.format(abs_error(salmap_pred[test_idx], salmap_gt[test_idx]))

	# pl.figure(2)	
	# test_idx = np.unique(test_imids)
	# recall_knn, precision_knn = get_roc_curve(salmap_gt[test_idx], salmap_knn[test_idx])
	# pl.plot(recall_knn, precision_knn, 'b', linewidth=2, label='knn vs. gt')
	# recall_cnn, precision_cnn = get_roc_curve(salmap_gt[test_idx], salmap_pred[test_idx])
	# pl.plot(recall_cnn, precision_cnn, 'r', linewidth=2, label='cnn vs. gt')
	# pl.xlabel('recall')
	# pl.ylabel('precision')
	# pl.legend()
	# pl.savefig(save_path+'roc.jpg')
	# print 'ROC curve saved!'

	os.system('xdg-open '+save_path)
Ejemplo n.º 7
0
def main():
	''' pipeline for supervised salience training '''

	if os.path.isdir('../data_viper/'):
		datapath = '../data_viper/'
	else:
		datapath = '../data/'

	save_path = '../data_viper/model_feat/'

	DATA_OPT = 'feat' 		# feature type
	TRAIN_OPT = 'SVR'				# training model option
	TRAIN = True 					# wheather re-train the model

	# prepare training data for supervised salience training 
	#=======================================================
	datafile_viper = datapath + 'viper.pkl'
	if not os.path.isfile(datafile_viper):
		viper = DataMan_viper_small()
		viper.make_data()
		savefile(datafile_viper, viper)
	else:
		viper = loadfile(datafile_viper)
	
	viper = preprocess_data(viper, DATA_OPT)

	# training 
	# ==============
	modelfile = datapath + 'model_feat/model.pkl'

	if TRAIN:
		tic = time.clock()
		model = train_model(viper, TRAIN_OPT)
		toc = time.clock()
		print 'Elapsed training time: {0:.2f} min'.format((toc-tic)/60.)

		savefile(modelfile, model)
		os.system('ls -lh ' + modelfile)		
	else:
		model = loadfile(modelfile)
	
	## validation
	#=========================================
	print 'validating trained model'
	nValid = 5000
	valididx = np.random.permutation(viper.valid_feat.shape[0])[:nValid]
	# valid_ypred = model.predict(viper.valid_feat[valididx])
	valid_ypred = predict(model, viper.valid_feat[valididx], viper.yy[viper.valid_ctrids][valididx], viper.imH)

	#- quantize patches based on testing scores
	kmeans = KMeans(init='k-means++', n_clusters=10, n_init=10, verbose=1)
	kmeans.fit(valid_ypred.reshape(nValid, 1))

	#- crop patches for testing image
	valid_patset = np.asarray(viper.get_patchset('valid'))[valididx]

	#- save to result folder
	os.system('rm '+save_path+'*.jpg')
	for i in range(10):
		idx = kmeans.labels_== i
		if any(idx): 
			pats = immontage(list(valid_patset[idx])) 
			imsave(save_path+'{}.jpg'.format(kmeans.cluster_centers_[i]), pats)
			print 'patchset {} saved'.format(i)

	### testing 
	#===============
	print 'testing'
	# test_ypred = model.predict(viper.test_feat)
	test_ypred = predict(model, viper.test_feat, viper.yy_test[viper.test_ctrids], viper.imH)
	
	## assign predicted scores to images
	h, w = viper.imgs[0].shape[:2]
	mh, mw = len(np.unique(viper.yy_test)), len(np.unique(viper.xx_test))
	msk0 = np.zeros(mh*mw, dtype=np.float32)
	msks = [msk0.copy() for im in viper.imgs]

	showlist = []
	n_test = len(test_ypred)
	for i in range(n_test):
		imgid = viper.test_imgids[i]
		patid = viper.test_ctrids[i]
		score = test_ypred[i]
		msks[imgid][patid] = score

	# resize predicted salience map to match image size
	msks_rs = [mapresize(msk.reshape((mw, mh)).T, size=(h, w)) for msk in msks]
	# msks_rs = msks

	# save salience map for comparison
	test_imids = np.asarray(np.unique(viper.test_imgids))
	salmap_gt = np.asarray(viper.salmsks) #np.asarray([viper.salmsks[imid] for imid in test_imids])
	salmap_pred = np.asarray(msks_rs) #np.asarray([msks_rs[imid]/255. for imid in test_imids])
	savefile(save_path+'salmaps_comparison.pkl', [test_imids, salmap_gt, salmap_pred])
Ejemplo n.º 8
0
def test_knn():

	datafile_viper = '../data_viper/viper.pkl'
	viper = loadfile(datafile_viper)
	viper = downsample_data(viper)
	# from sklearn.neighbors import KNeighborsRegressor
	# model = KNeighborsRegressor(n_neighbors=5, weights='uniform', metric='euclidean')
	# model.fit(viper.train_feat, viper.train_y)
	from sklearn.neighbors import KDTree
	
	# divide into stripes
	nStripe = 10
	y_max = viper.yy.max()
	y_min = viper.yy.min()
	y_len = np.int((y_max - y_min)/10.)
	y_centers = np.round(np.linspace(y_min+y_len, y_max-y_len, nStripe))

	k = 5
	y_ctr = y_centers[k] 

	stripe_idx = np.where((viper.yy[viper.train_ctrids] >= y_ctr-y_len) & (viper.yy[viper.train_ctrids] < y_ctr+y_len))[0]
	
	model = KDTree(viper.train_feat[stripe_idx, :288], metric='euclidean')

	train_patset = viper.get_patchset('train')
	test_patset = viper.get_patchset('test')

	test_ids = np.where((viper.yy[viper.test_ctrids] >= y_ctr-y_len) & (viper.yy[viper.test_ctrids] < y_ctr+y_len))[0]
	np.random.shuffle(test_ids)
	for i in test_ids:

		get_testrect = lambda i: [viper.xx[viper.test_ctrids[i]] - viper.patL/2, 
								viper.yy[viper.test_ctrids[i]] - viper.patL/2,
								viper.patL, viper.patL]

		get_trainrect = lambda i: [viper.xx[viper.train_ctrids[i]] - viper.patL/2, 
								viper.yy[viper.train_ctrids[i]] - viper.patL/2,
								viper.patL, viper.patL]

		gray2color = lambda grayim: np.dstack((grayim, grayim, grayim))

		imlist = []
		patlist = []
		maplist = []
		patlist.append(imresize(test_patset[i], size=(100, 100)))
		imlist.append(drawrect(viper.imgs[viper.test_imgids[i]], get_testrect(i)))
		maplist.append(viper.salmsks[viper.test_imgids[i]])
		dist, ind = model.query(viper.test_feat[i, :288], k=30, return_distance=True)
		print viper.test_y[i]
		hist = np.histogram(viper.train_y[stripe_idx[ind[0]]])
		print hist[0]
		print hist[1]
		print dist
		for id in stripe_idx[ind[0]]:
			patlist.append(imresize(train_patset[id], size=(100, 100)))
			imlist.append(drawrect(viper.imgs[viper.train_imgids[id]], get_trainrect(id)))
			maplist.append(viper.salmsks[viper.train_imgids[id]])
		pats = immontage(patlist)
		imgs = immontage(imlist)
		maps = immontage(maplist)
		imsave('tmp1.jpg', pats)
		imsave('tmp2.jpg', imgs)
		imsave('tmp3.jpg', maps)

		raw_input()

	os.system('xdg-open tmp1.jpg')
Ejemplo n.º 9
0
def main():
	''' pipeline for supervised salience training '''

	if os.path.isdir('../data_viper/'):
		datapath = '../data_viper/'
	else:
		datapath = '../data/'

	# prepare training data for supervised salience training 
	datafile_viper = datapath + 'viper.pkl'
	if not os.path.isfile(datafile_viper):
		viper = DataMan_viper_small()
		viper.make_data()
		savefile(datafile_viper, viper)

	viper = loadfile(datafile_viper)
	viper = change_label(viper)
	viper.train_feat = viper.get_pixeldata('train')
	viper.valid_feat = viper.get_pixeldata('valid')
	viper.test_feat = viper.get_pixeldata('test')

	bs = 100
	imL = 10
	nfilter1 = 16
	filterL = 3

	x = T.tensor4(name='x', dtype=theano.config.floatX)
	y = T.ivector(name='y')

	# layer0 = x.reshape((bs, 3, imL, imL))
	conv1 = ConvLayer(input=x, image_shape=(bs, 3, imL, imL), 
				filter_shape=(nfilter1, 3, filterL, filterL),  
				flatten=True,
				actfun=tanh,
				tag='_convpool1')

	# outL = np.floor((imL-filterL+1.)/recfield).astype(np.int)
	outL = imL-filterL+1

	# nfilter3 = 16
	# filterL3 = 3
	# conv3 = ConvLayer(input=conv2.output(), image_shape=(bs, nfilter2, outL2, outL2), 
	# 			filter_shape=(nfilter3, nfilter2, filterL3, filterL3), 
	# 			flatten=True,
	# 			actfun=tanh,
	# 			tag='_conv3')
	#
	# outL3 = outL2-filterL3+1

	fc2 = FCLayer(input=conv1.output(), n_in=nfilter1*outL*outL, n_out=256, actfun=tanh, tag='_fc2')
	fc3 = FCLayer(input=fc2.output(), n_in=256, n_out=10, actfun=sigmoid, tag='_fc3')
	params_cmb = conv1.params + fc2.params + fc3.params 

	# ypred = fc3.output().flatten()
	ypred = fc3.output()

	model = GeneralModel(input=x, data=viper, output=ypred,
				target=y, params=params_cmb,
				regularizers=0, 
				cost_func=negative_log_likelihood,
				error_func=sqr_error, 
				batch_size=bs)

	sgd = sgd_optimizer(data=viper,  
					model=model,
					batch_size=bs, 
					learning_rate=0.001,
					n_epochs=500)

	sgd.fit_viper()

	filepath = datapath + 'model/model.pkl'
	savefile(filepath, model)
	os.system('ls -lh ' + filepath)