From e2208bfc2ed540065bef2e8e12d914d873464da7 Mon Sep 17 00:00:00 2001 From: Daniil Kazantsev Date: Sun, 10 Mar 2019 22:23:22 +0000 Subject: all python code updated --- test/test_CPU_regularisers.py | 18 +- test/test_run_test.py | 558 +++++++++++++++++++++--------------------- 2 files changed, 286 insertions(+), 290 deletions(-) (limited to 'test') diff --git a/test/test_CPU_regularisers.py b/test/test_CPU_regularisers.py index 851569c..5e3f303 100644 --- a/test/test_CPU_regularisers.py +++ b/test/test_CPU_regularisers.py @@ -32,7 +32,7 @@ class TestRegularisers(unittest.TestCase): def test_FGP_TV_CPU(self): Im,input,ref = self.getPars() - fgp_cpu = FGP_TV(input,0.04,1200,1e-5,0,0,0,'cpu'); + fgp_cpu,info = FGP_TV(input,0.02,300,0.0,0,0,'cpu'); rms = rmse(Im, fgp_cpu) @@ -42,7 +42,7 @@ class TestRegularisers(unittest.TestCase): # set parameters Im, input,ref = self.getPars() # call routine - fgp_cpu = ROF_TV(input,0.04,1200,2e-5, 'cpu') + fgp_cpu,info = ROF_TV(input,0.02,1000,0.001,0.0, 'cpu') rms = rmse(Im, fgp_cpu) @@ -53,7 +53,7 @@ class TestRegularisers(unittest.TestCase): # set parameters Im, input,ref = self.getPars() # call routine - sb_cpu = SB_TV(input,0.04,150,1e-5,0,0,'cpu') + sb_cpu,info = SB_TV(input,0.02,150,0.0,0,'cpu') rms = rmse(Im, sb_cpu) @@ -64,9 +64,9 @@ class TestRegularisers(unittest.TestCase): # set parameters Im, input,ref = self.getPars() # call routine - sb_cpu = TGV(input,0.04,1.0,2.0,250,12,'cpu') + tgv_cpu,info = TGV(input,0.02,1.0,2.0,500,12,0.0,'cpu') - rms = rmse(Im, sb_cpu) + rms = rmse(Im, tgv_cpu) # now test that it generates some expected output self.assertAlmostEqual(rms,0.02,delta=0.01) @@ -75,7 +75,7 @@ class TestRegularisers(unittest.TestCase): # set parameters Im, input,ref = self.getPars() # call routine - sb_cpu = LLT_ROF(input,0.04,0.01,1000,1e-4,'cpu') + sb_cpu,info = LLT_ROF(input,0.01,0.008,1000,0.001,0.0,'cpu') rms = rmse(Im, sb_cpu) @@ -86,7 +86,7 @@ class TestRegularisers(unittest.TestCase): # set parameters Im, input,ref = self.getPars() # call routine - sb_cpu = NDF(input, 0.06, 0.04,1000,0.025,1, 'cpu') + sb_cpu,info = NDF(input, 0.02, 0.17,1000,0.01,1,0.0, 'cpu') rms = rmse(Im, sb_cpu) @@ -97,7 +97,7 @@ class TestRegularisers(unittest.TestCase): # set parameters Im, input,ref = self.getPars() # call routine - sb_cpu = Diff4th(input, 3.5,0.02,500,0.001, 'cpu') + sb_cpu,info = Diff4th(input, 0.8,0.02,1000,0.001,0.0, 'cpu') rms = rmse(Im, sb_cpu) @@ -108,7 +108,7 @@ class TestRegularisers(unittest.TestCase): # set parameters Im, input,ref = self.getPars() # call routine - sb_cpu = FGP_dTV(input,ref,0.04,1000,1e-7,0.2,0,0,0, 'cpu') + sb_cpu,info = FGP_dTV(input,ref,0.02,500,0.0,0.2,0,0, 'cpu') rms = rmse(Im, sb_cpu) diff --git a/test/test_run_test.py b/test/test_run_test.py index 5a688c9..1174c5b 100755 --- a/test/test_run_test.py +++ b/test/test_run_test.py @@ -27,14 +27,14 @@ def nrmse(im1, im2): max_val = max(np.max(im1), np.max(im2)) min_val = min(np.min(im1), np.min(im2)) return 1 - (rmse / (max_val - min_val)) - + def rmse(im1, im2): rmse = np.sqrt(np.sum((im1 - im2) ** 2) / float(im1.size)) return rmse ############################################################################### class TestRegularisers(unittest.TestCase): - + def test_ROF_TV_CPU_vs_GPU(self): #print ("tomas debug test function") @@ -42,53 +42,55 @@ class TestRegularisers(unittest.TestCase): filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') - + Im = Im/255 perc = 0.05 u0 = Im + np.random.normal(loc = 0 , - scale = perc * Im , + scale = perc * Im , size = np.shape(Im)) u_ref = Im + np.random.normal(loc = 0 , - scale = 0.01 * Im , + scale = 0.01 * Im , size = np.shape(Im)) - + # map the u0 u0->u0>0 # f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1) u0 = u0.astype('float32') u_ref = u_ref.astype('float32') - + print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") print ("____________ROF-TV bench___________________") print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") - + # set parameters pars = {'algorithm': ROF_TV, \ 'input' : u0,\ - 'regularisation_parameter':0.04,\ - 'number_of_iterations': 2500,\ - 'time_marching_parameter': 0.00002 - } + 'regularisation_parameter':0.02,\ + 'number_of_iterations': 1000,\ + 'time_marching_parameter': 0.001,\ + 'tolerance_constant':0.0} print ("#############ROF TV CPU####################") start_time = timeit.default_timer() - rof_cpu = ROF_TV(pars['input'], - pars['regularisation_parameter'], - pars['number_of_iterations'], - pars['time_marching_parameter'],'cpu') + (rof_cpu, infocpu) = ROF_TV(pars['input'], + pars['regularisation_parameter'], + pars['number_of_iterations'], + pars['time_marching_parameter'], + pars['tolerance_constant'],'cpu') rms = rmse(Im, rof_cpu) pars['rmse'] = rms - + txtstr = printParametersToString(pars) txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time) print (txtstr) print ("##############ROF TV GPU##################") start_time = timeit.default_timer() try: - rof_gpu = ROF_TV(pars['input'], - pars['regularisation_parameter'], - pars['number_of_iterations'], - pars['time_marching_parameter'],'gpu') + (rof_gpu, infogpu) = ROF_TV(pars['input'], + pars['regularisation_parameter'], + pars['number_of_iterations'], + pars['time_marching_parameter'], + pars['tolerance_constant'],'gpu') except ValueError as ve: self.skipTest("Results not comparable. GPU computing error.") @@ -99,78 +101,74 @@ class TestRegularisers(unittest.TestCase): txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time) print (txtstr) print ("--------Compare the results--------") - tolerance = 1e-04 + tolerance = 1e-05 diff_im = np.zeros(np.shape(rof_cpu)) diff_im = abs(rof_cpu - rof_gpu) diff_im[diff_im > tolerance] = 1 self.assertLessEqual(diff_im.sum() , 1) - + def test_FGP_TV_CPU_vs_GPU(self): print(__name__) filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') - + Im = Im/255 perc = 0.05 u0 = Im + np.random.normal(loc = 0 , - scale = perc * Im , + scale = perc * Im , size = np.shape(Im)) u_ref = Im + np.random.normal(loc = 0 , - scale = 0.01 * Im , + scale = 0.01 * Im , size = np.shape(Im)) - + # map the u0 u0->u0>0 # f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1) u0 = u0.astype('float32') u_ref = u_ref.astype('float32') - + print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") print ("____________FGP-TV bench___________________") print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") - - + + # set parameters pars = {'algorithm' : FGP_TV, \ - 'input' : u0,\ - 'regularisation_parameter':0.04, \ - 'number_of_iterations' :1200 ,\ - 'tolerance_constant':0.00001,\ - 'methodTV': 0 ,\ - 'nonneg': 0 ,\ - 'printingOut': 0 - } - + 'input' : u0,\ + 'regularisation_parameter':0.02, \ + 'number_of_iterations' :400 ,\ + 'tolerance_constant':0.0,\ + 'methodTV': 0 ,\ + 'nonneg': 0} + print ("#############FGP TV CPU####################") start_time = timeit.default_timer() - fgp_cpu = FGP_TV(pars['input'], - pars['regularisation_parameter'], - pars['number_of_iterations'], - pars['tolerance_constant'], - pars['methodTV'], - pars['nonneg'], - pars['printingOut'],'cpu') - - + (fgp_cpu,infocpu) = FGP_TV(pars['input'], + pars['regularisation_parameter'], + pars['number_of_iterations'], + pars['tolerance_constant'], + pars['methodTV'], + pars['nonneg'],'cpu') + + rms = rmse(Im, fgp_cpu) pars['rmse'] = rms - + txtstr = printParametersToString(pars) txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time) print (txtstr) - + print ("##############FGP TV GPU##################") start_time = timeit.default_timer() try: - fgp_gpu = FGP_TV(pars['input'], - pars['regularisation_parameter'], - pars['number_of_iterations'], - pars['tolerance_constant'], - pars['methodTV'], - pars['nonneg'], - pars['printingOut'],'gpu') + (fgp_gpu,infogpu) = FGP_TV(pars['input'], + pars['regularisation_parameter'], + pars['number_of_iterations'], + pars['tolerance_constant'], + pars['methodTV'], + pars['nonneg'],'gpu') except ValueError as ve: self.skipTest("Results not comparable. GPU computing error.") @@ -181,7 +179,7 @@ class TestRegularisers(unittest.TestCase): txtstr = printParametersToString(pars) txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time) print (txtstr) - + print ("--------Compare the results--------") tolerance = 1e-05 diff_im = np.zeros(np.shape(fgp_cpu)) @@ -195,65 +193,60 @@ class TestRegularisers(unittest.TestCase): filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') - + Im = Im/255 perc = 0.05 u0 = Im + np.random.normal(loc = 0 , - scale = perc * Im , + scale = perc * Im , size = np.shape(Im)) u_ref = Im + np.random.normal(loc = 0 , - scale = 0.01 * Im , + scale = 0.01 * Im , size = np.shape(Im)) - + # map the u0 u0->u0>0 # f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1) u0 = u0.astype('float32') u_ref = u_ref.astype('float32') - + print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") print ("____________SB-TV bench___________________") print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") - - + + # set parameters pars = {'algorithm' : SB_TV, \ - 'input' : u0,\ - 'regularisation_parameter':0.04, \ - 'number_of_iterations' :150 ,\ - 'tolerance_constant':1e-05,\ - 'methodTV': 0 ,\ - 'printingOut': 0 - } - + 'input' : u0,\ + 'regularisation_parameter':0.02, \ + 'number_of_iterations' :250 ,\ + 'tolerance_constant':0.0,\ + 'methodTV': 0} + print ("#############SB-TV CPU####################") start_time = timeit.default_timer() - sb_cpu = SB_TV(pars['input'], - pars['regularisation_parameter'], - pars['number_of_iterations'], - pars['tolerance_constant'], - pars['methodTV'], - pars['printingOut'],'cpu') - - + (sb_cpu, info_vec_cpu) = SB_TV(pars['input'], + pars['regularisation_parameter'], + pars['number_of_iterations'], + pars['tolerance_constant'], + pars['methodTV'], 'cpu') + + rms = rmse(Im, sb_cpu) pars['rmse'] = rms - + txtstr = printParametersToString(pars) txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time) print (txtstr) - + print ("##############SB TV GPU##################") start_time = timeit.default_timer() try: - - sb_gpu = SB_TV(pars['input'], - pars['regularisation_parameter'], - pars['number_of_iterations'], - pars['tolerance_constant'], - pars['methodTV'], - pars['printingOut'],'gpu') + (sb_gpu, info_vec_gpu) = SB_TV(pars['input'], + pars['regularisation_parameter'], + pars['number_of_iterations'], + pars['tolerance_constant'], + pars['methodTV'], 'gpu') except ValueError as ve: self.skipTest("Results not comparable. GPU computing error.") @@ -276,64 +269,65 @@ class TestRegularisers(unittest.TestCase): filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') - + Im = Im/255 perc = 0.05 u0 = Im + np.random.normal(loc = 0 , - scale = perc * Im , + scale = perc * Im , size = np.shape(Im)) u_ref = Im + np.random.normal(loc = 0 , - scale = 0.01 * Im , + scale = 0.01 * Im , size = np.shape(Im)) - + # map the u0 u0->u0>0 # f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1) u0 = u0.astype('float32') u_ref = u_ref.astype('float32') - + print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") print ("____________TGV bench___________________") print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") - - + + # set parameters pars = {'algorithm' : TGV, \ - 'input' : u0,\ - 'regularisation_parameter':0.04, \ - 'alpha1':1.0,\ - 'alpha0':2.0,\ - 'number_of_iterations' :250 ,\ - 'LipshitzConstant' :12 ,\ - } - + 'input' : u0,\ + 'regularisation_parameter':0.02, \ + 'alpha1':1.0,\ + 'alpha0':2.0,\ + 'number_of_iterations' :1000 ,\ + 'LipshitzConstant' :12 ,\ + 'tolerance_constant':0.0} + print ("#############TGV CPU####################") start_time = timeit.default_timer() - tgv_cpu = TGV(pars['input'], - pars['regularisation_parameter'], - pars['alpha1'], - pars['alpha0'], - pars['number_of_iterations'], - pars['LipshitzConstant'],'cpu') - + (tgv_cpu, info_vec_cpu) = TGV(pars['input'], + pars['regularisation_parameter'], + pars['alpha1'], + pars['alpha0'], + pars['number_of_iterations'], + pars['LipshitzConstant'], + pars['tolerance_constant'],'cpu') + rms = rmse(Im, tgv_cpu) pars['rmse'] = rms - + txtstr = printParametersToString(pars) txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time) print (txtstr) - + print ("##############TGV GPU##################") start_time = timeit.default_timer() try: - tgv_gpu = TGV(pars['input'], - pars['regularisation_parameter'], - pars['alpha1'], - pars['alpha0'], - pars['number_of_iterations'], - pars['LipshitzConstant'],'gpu') - + (tgv_gpu, info_vec_gpu) = TGV(pars['input'], + pars['regularisation_parameter'], + pars['alpha1'], + pars['alpha0'], + pars['number_of_iterations'], + pars['LipshitzConstant'], + pars['tolerance_constant'],'gpu') except ValueError as ve: self.skipTest("Results not comparable. GPU computing error.") @@ -355,60 +349,62 @@ class TestRegularisers(unittest.TestCase): filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') - + Im = Im/255 perc = 0.05 u0 = Im + np.random.normal(loc = 0 , - scale = perc * Im , + scale = perc * Im , size = np.shape(Im)) u_ref = Im + np.random.normal(loc = 0 , - scale = 0.01 * Im , + scale = 0.01 * Im , size = np.shape(Im)) - + # map the u0 u0->u0>0 # f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1) u0 = u0.astype('float32') u_ref = u_ref.astype('float32') - + print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") print ("____________LLT-ROF bench___________________") print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") - - + + # set parameters pars = {'algorithm' : LLT_ROF, \ - 'input' : u0,\ - 'regularisation_parameterROF':0.04, \ - 'regularisation_parameterLLT':0.01, \ - 'number_of_iterations' :1000 ,\ - 'time_marching_parameter' :0.0001 ,\ - } - + 'input' : u0,\ + 'regularisation_parameterROF':0.01, \ + 'regularisation_parameterLLT':0.0085, \ + 'number_of_iterations' : 1000 ,\ + 'time_marching_parameter' :0.0001 ,\ + 'tolerance_constant':0.0} + print ("#############LLT- ROF CPU####################") start_time = timeit.default_timer() - lltrof_cpu = LLT_ROF(pars['input'], - pars['regularisation_parameterROF'], - pars['regularisation_parameterLLT'], - pars['number_of_iterations'], - pars['time_marching_parameter'],'cpu') - + (lltrof_cpu, info_vec_cpu) = LLT_ROF(pars['input'], + pars['regularisation_parameterROF'], + pars['regularisation_parameterLLT'], + pars['number_of_iterations'], + pars['time_marching_parameter'], + pars['tolerance_constant'], 'cpu') + rms = rmse(Im, lltrof_cpu) pars['rmse'] = rms - + txtstr = printParametersToString(pars) txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time) print (txtstr) print ("#############LLT- ROF GPU####################") start_time = timeit.default_timer() try: - lltrof_gpu = LLT_ROF(pars['input'], - pars['regularisation_parameterROF'], - pars['regularisation_parameterLLT'], - pars['number_of_iterations'], - pars['time_marching_parameter'],'gpu') - + (lltrof_gpu, info_vec_gpu) = LLT_ROF(pars['input'], + pars['regularisation_parameterROF'], + pars['regularisation_parameterLLT'], + pars['number_of_iterations'], + pars['time_marching_parameter'], + pars['tolerance_constant'], 'gpu') + except ValueError as ve: self.skipTest("Results not comparable. GPU computing error.") @@ -419,7 +415,7 @@ class TestRegularisers(unittest.TestCase): txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time) print (txtstr) print ("--------Compare the results--------") - tolerance = 1e-04 + tolerance = 1e-05 diff_im = np.zeros(np.shape(lltrof_gpu)) diff_im = abs(lltrof_cpu - lltrof_gpu) diff_im[diff_im > tolerance] = 1 @@ -430,64 +426,66 @@ class TestRegularisers(unittest.TestCase): filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') - + Im = Im/255 perc = 0.05 u0 = Im + np.random.normal(loc = 0 , - scale = perc * Im , + scale = perc * Im , size = np.shape(Im)) u_ref = Im + np.random.normal(loc = 0 , - scale = 0.01 * Im , + scale = 0.01 * Im , size = np.shape(Im)) - + # map the u0 u0->u0>0 # f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1) u0 = u0.astype('float32') u_ref = u_ref.astype('float32') - + print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") print ("_______________NDF bench___________________") print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") - - + + # set parameters pars = {'algorithm' : NDF, \ - 'input' : u0,\ - 'regularisation_parameter':0.06, \ - 'edge_parameter':0.04,\ - 'number_of_iterations' :1000 ,\ - 'time_marching_parameter':0.025,\ - 'penalty_type': 1 - } - + 'input' : u0,\ + 'regularisation_parameter':0.02, \ + 'edge_parameter':0.017,\ + 'number_of_iterations' :1500 ,\ + 'time_marching_parameter':0.01,\ + 'penalty_type':1,\ + 'tolerance_constant':0.0} + print ("#############NDF CPU####################") start_time = timeit.default_timer() - ndf_cpu = NDF(pars['input'], - pars['regularisation_parameter'], - pars['edge_parameter'], - pars['number_of_iterations'], - pars['time_marching_parameter'], - pars['penalty_type'],'cpu') - + (ndf_cpu,info_vec_cpu) = NDF(pars['input'], + pars['regularisation_parameter'], + pars['edge_parameter'], + pars['number_of_iterations'], + pars['time_marching_parameter'], + pars['penalty_type'], + pars['tolerance_constant'],'cpu') + rms = rmse(Im, ndf_cpu) pars['rmse'] = rms - + txtstr = printParametersToString(pars) txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time) print (txtstr) - + print ("##############NDF GPU##################") start_time = timeit.default_timer() try: - ndf_gpu = NDF(pars['input'], - pars['regularisation_parameter'], - pars['edge_parameter'], - pars['number_of_iterations'], - pars['time_marching_parameter'], - pars['penalty_type'],'gpu') - + (ndf_gpu,info_vec_gpu) = NDF(pars['input'], + pars['regularisation_parameter'], + pars['edge_parameter'], + pars['number_of_iterations'], + pars['time_marching_parameter'], + pars['penalty_type'], + pars['tolerance_constant'],'gpu') + except ValueError as ve: self.skipTest("Results not comparable. GPU computing error.") rms = rmse(Im, ndf_gpu) @@ -503,49 +501,50 @@ class TestRegularisers(unittest.TestCase): diff_im[diff_im > tolerance] = 1 self.assertLessEqual(diff_im.sum(), 1) - + def test_Diff4th_CPU_vs_GPU(self): filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') - + Im = Im/255 perc = 0.05 u0 = Im + np.random.normal(loc = 0 , - scale = perc * Im , + scale = perc * Im , size = np.shape(Im)) u_ref = Im + np.random.normal(loc = 0 , - scale = 0.01 * Im , + scale = 0.01 * Im , size = np.shape(Im)) - + # map the u0 u0->u0>0 # f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1) u0 = u0.astype('float32') u_ref = u_ref.astype('float32') - + print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") print ("___Anisotropic Diffusion 4th Order (2D)____") print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") - + # set parameters pars = {'algorithm' : Diff4th, \ 'input' : u0,\ - 'regularisation_parameter':3.5, \ + 'regularisation_parameter':0.8, \ 'edge_parameter':0.02,\ - 'number_of_iterations' :500 ,\ - 'time_marching_parameter':0.001 - } - + 'number_of_iterations' :1000 ,\ + 'time_marching_parameter':0.0001,\ + 'tolerance_constant':0.0} + print ("#############Diff4th CPU####################") start_time = timeit.default_timer() - diff4th_cpu = Diff4th(pars['input'], - pars['regularisation_parameter'], - pars['edge_parameter'], - pars['number_of_iterations'], - pars['time_marching_parameter'],'cpu') - + (diff4th_cpu,info_vec_cpu) = Diff4th(pars['input'], + pars['regularisation_parameter'], + pars['edge_parameter'], + pars['number_of_iterations'], + pars['time_marching_parameter'], + pars['tolerance_constant'],'cpu') + rms = rmse(Im, diff4th_cpu) pars['rmse'] = rms @@ -555,12 +554,13 @@ class TestRegularisers(unittest.TestCase): print ("##############Diff4th GPU##################") start_time = timeit.default_timer() try: - diff4th_gpu = Diff4th(pars['input'], - pars['regularisation_parameter'], - pars['edge_parameter'], - pars['number_of_iterations'], - pars['time_marching_parameter'], 'gpu') - + (diff4th_gpu,info_vec_gpu) = Diff4th(pars['input'], + pars['regularisation_parameter'], + pars['edge_parameter'], + pars['number_of_iterations'], + pars['time_marching_parameter'], + pars['tolerance_constant'],'gpu') + except ValueError as ve: self.skipTest("Results not comparable. GPU computing error.") rms = rmse(Im, diff4th_gpu) @@ -580,72 +580,68 @@ class TestRegularisers(unittest.TestCase): filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') - + Im = Im/255 perc = 0.05 u0 = Im + np.random.normal(loc = 0 , - scale = perc * Im , + scale = perc * Im , size = np.shape(Im)) u_ref = Im + np.random.normal(loc = 0 , - scale = 0.01 * Im , + scale = 0.01 * Im , size = np.shape(Im)) - + # map the u0 u0->u0>0 # f = np.frompyfunc(lambda x: 0 if x < 0 else x, 1,1) u0 = u0.astype('float32') u_ref = u_ref.astype('float32') - + print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") print ("____________FGP-dTV bench___________________") print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") - + # set parameters pars = {'algorithm' : FGP_dTV, \ - 'input' : u0,\ - 'refdata' : u_ref,\ - 'regularisation_parameter':0.04, \ - 'number_of_iterations' :1000 ,\ - 'tolerance_constant':1e-07,\ - 'eta_const':0.2,\ - 'methodTV': 0 ,\ - 'nonneg': 0 ,\ - 'printingOut': 0 - } - + 'input' : u0,\ + 'refdata' : u_ref,\ + 'regularisation_parameter':0.02, \ + 'number_of_iterations' :500 ,\ + 'tolerance_constant':0.0,\ + 'eta_const':0.2,\ + 'methodTV': 0 ,\ + 'nonneg': 0} + print ("#############FGP dTV CPU####################") start_time = timeit.default_timer() - fgp_dtv_cpu = FGP_dTV(pars['input'], - pars['refdata'], - pars['regularisation_parameter'], - pars['number_of_iterations'], - pars['tolerance_constant'], - pars['eta_const'], - pars['methodTV'], - pars['nonneg'], - pars['printingOut'],'cpu') - - + (fgp_dtv_cpu,info_vec_cpu) = FGP_dTV(pars['input'], + pars['refdata'], + pars['regularisation_parameter'], + pars['number_of_iterations'], + pars['tolerance_constant'], + pars['eta_const'], + pars['methodTV'], + pars['nonneg'],'cpu') + + rms = rmse(Im, fgp_dtv_cpu) pars['rmse'] = rms - + txtstr = printParametersToString(pars) txtstr += "%s = %.3fs" % ('elapsed time',timeit.default_timer() - start_time) print (txtstr) print ("##############FGP dTV GPU##################") start_time = timeit.default_timer() try: - fgp_dtv_gpu = FGP_dTV(pars['input'], - pars['refdata'], - pars['regularisation_parameter'], - pars['number_of_iterations'], - pars['tolerance_constant'], - pars['eta_const'], - pars['methodTV'], - pars['nonneg'], - pars['printingOut'],'gpu') + (fgp_dtv_gpu,info_vec_gpu) = FGP_dTV(pars['input'], + pars['refdata'], + pars['regularisation_parameter'], + pars['number_of_iterations'], + pars['tolerance_constant'], + pars['eta_const'], + pars['methodTV'], + pars['nonneg'],'gpu') except ValueError as ve: self.skipTest("Results not comparable. GPU computing error.") rms = rmse(Im, fgp_dtv_gpu) @@ -660,23 +656,23 @@ class TestRegularisers(unittest.TestCase): diff_im = abs(fgp_dtv_cpu - fgp_dtv_gpu) diff_im[diff_im > tolerance] = 1 self.assertLessEqual(diff_im.sum(), 1) - +""" def test_cpu_ROF_TV(self): #filename = os.path.join(".." , ".." , ".." , "data" ,"testLena.npy") - + filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') Im = Im/255 - - """ + + # read noiseless image - Im = plt.imread(filename) - Im = np.asarray(Im, dtype='float32') - """ + #Im = plt.imread(filename) + #Im = np.asarray(Im, dtype='float32') + tolerance = 1e-05 rms_rof_exp = 8.313131464999238e-05 #expected value for ROF model @@ -695,27 +691,27 @@ class TestRegularisers(unittest.TestCase): pars_rof_tv['number_of_iterations'], pars_rof_tv['time_marching_parameter'],'cpu') rms_rof = rmse(Im, rof_cpu) - + # now compare obtained rms with the expected value self.assertLess(abs(rms_rof-rms_rof_exp) , tolerance) def test_cpu_FGP_TV(self): #filename = os.path.join(".." , ".." , ".." , "data" ,"testLena.npy") - + filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') Im = Im/255 - """ + # read noiseless image - Im = plt.imread(filename) - Im = np.asarray(Im, dtype='float32') - """ + # Im = plt.imread(filename) + # Im = np.asarray(Im, dtype='float32') + tolerance = 1e-05 rms_fgp_exp = 0.019152347 #expected value for FGP model - + pars_fgp_tv = {'algorithm' : FGP_TV, \ 'input' : Im,\ 'regularisation_parameter':0.04, \ @@ -723,18 +719,18 @@ class TestRegularisers(unittest.TestCase): 'tolerance_constant':1e-06,\ 'methodTV': 0 ,\ 'nonneg': 0 ,\ - 'printingOut': 0 + 'printingOut': 0 } print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") print ("_________testing FGP-TV (2D, CPU)__________") print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") - fgp_cpu = FGP_TV(pars_fgp_tv['input'], + fgp_cpu = FGP_TV(pars_fgp_tv['input'], pars_fgp_tv['regularisation_parameter'], pars_fgp_tv['number_of_iterations'], - pars_fgp_tv['tolerance_constant'], + pars_fgp_tv['tolerance_constant'], pars_fgp_tv['methodTV'], pars_fgp_tv['nonneg'], - pars_fgp_tv['printingOut'],'cpu') + pars_fgp_tv['printingOut'],'cpu') rms_fgp = rmse(Im, fgp_cpu) # now compare obtained rms with the expected value self.assertLess(abs(rms_fgp-rms_fgp_exp) , tolerance) @@ -748,10 +744,10 @@ class TestRegularisers(unittest.TestCase): Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') Im = Im/255 - + tolerance = 1e-05 rms_rof_exp = 8.313131464999238e-05 #expected value for ROF model - + # set parameters for ROF-TV pars_rof_tv = {'algorithm': ROF_TV, \ 'input' : Im,\ @@ -773,20 +769,20 @@ class TestRegularisers(unittest.TestCase): rms_rof = rmse(Im, rof_gpu) # now compare obtained rms with the expected value self.assertLess(abs(rms_rof-rms_rof_exp) , tolerance) - + def test_gpu_FGP(self): #filename = os.path.join(".." , ".." , ".." , "data" ,"testLena.npy") filename = os.path.join("test","lena_gray_512.tif") plt = TiffReader() # read image - Im = plt.imread(filename) + Im = plt.imread(filename) Im = np.asarray(Im, dtype='float32') Im = Im/255 tolerance = 1e-05 - + rms_fgp_exp = 0.019152347 #expected value for FGP model - + # set parameters for FGP-TV pars_fgp_tv = {'algorithm' : FGP_TV, \ 'input' : Im,\ @@ -795,19 +791,19 @@ class TestRegularisers(unittest.TestCase): 'tolerance_constant':1e-06,\ 'methodTV': 0 ,\ 'nonneg': 0 ,\ - 'printingOut': 0 + 'printingOut': 0 } print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") print ("_________testing FGP-TV (2D, GPU)__________") print ("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%") try: - fgp_gpu = FGP_TV(pars_fgp_tv['input'], + fgp_gpu = FGP_TV(pars_fgp_tv['input'], pars_fgp_tv['regularisation_parameter'], pars_fgp_tv['number_of_iterations'], - pars_fgp_tv['tolerance_constant'], + pars_fgp_tv['tolerance_constant'], pars_fgp_tv['methodTV'], pars_fgp_tv['nonneg'], - pars_fgp_tv['printingOut'],'gpu') + pars_fgp_tv['printingOut'],'gpu') except ValueError as ve: self.skipTest("Results not comparable. GPU computing error.") rms_fgp = rmse(Im, fgp_gpu) @@ -815,7 +811,7 @@ class TestRegularisers(unittest.TestCase): self.assertLess(abs(rms_fgp-rms_fgp_exp) , tolerance) - +""" if __name__ == '__main__': unittest.main() -- cgit v1.2.3