update

app.py

@@ -45,7 +45,7 @@ Once all template channels are filled, you will be directed to **Mapping Result*
 ### Mapping Result
 After completing the previous steps, your channels will be aligned with the template channels required by our models.
 - In case there are still some channels that haven't been mapped, we will automatically batch and optimally assign them to the template. This ensures that even channels not initially mapped will still be included in the final result.
-- Once the mapping process is completed, a JSON file containing the mapping result will be generated. This file is necessary only if you plan to run the models using the <a href="">source code</a>; otherwise, you can ignore it.
+- Once the mapping process is completed, a JSON file containing the mapping result will be generated. This file is necessary only if you plan to run the models using the <a href="https://github.com/CNElab-Plus/ArtifactRemovalTransformer">source code</a>; otherwise, you can ignore it.
 
 ## 2. Decode data
 After clicking on ``Run`` button, we will process your EEG data based on the mapping result. If necessary, your data will be divided into batches and run the models on each batch sequentially, ensuring that all channels are properly processed.
@@ -278,11 +278,11 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 				with gr.Column():
 					in_samplerate = gr.Textbox(label="Sampling rate (Hz)")
 					in_modelname = gr.Dropdown(choices=[
-										("ART", "EEGART"),
+										("ART", "ART"),
 										("IC-U-Net", "ICUNet"),
-										("IC-U-Net++", "UNetpp"),
-										("IC-U-Net-Attn", "AttUnet")],
-										value="EEGART",
+										("IC-U-Net++", "ICUNet++"),
+										("IC-U-Net-Attn", "ICUnet_attn")],
+										value="ART",
 										label="Model")
 					run_btn = gr.Button("Run", interactive=False)
 					cancel_btn = gr.Button("Cancel", visible=False)
@@ -304,7 +304,7 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 			gr.Markdown()
 	
 	def create_dir(req: gr.Request):
-		os.mkdir(gradio_temp_dir+'/'+req.session_hash)
+		os.mkdir(gradio_temp_dir+'/'+req.session_hash+'/')
 		return gradio_temp_dir+'/'+req.session_hash+'/'
 	demo.load(create_dir, inputs=[], outputs=session_dir)
 	
@@ -326,8 +326,8 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 		stage1_dir = uuid.uuid4().hex + '_stage1/'
 		os.mkdir(rootpath + stage1_dir)
 		
-		basename = os.path.basename(str(in_loc))
-		outputname = os.path.splitext(basename)[0] + '_mapping_result.json'
+		inputname = os.path.basename(str(in_loc))
+		outputname = inputname[:-4] + '_mapping_result.json'
 		
 		stage1_info = {
 			"filePath" : rootpath + stage1_dir,
@@ -349,7 +349,7 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 	    	},
 	    	"unassignedInput" : None,
 	    	"emptyTemplate" : None,
-	    	"batchNum" : None,
+	    	"batch" : None,
 	    	"mappingResult" : [
 	    	{
 				"index" : None,
@@ -436,7 +436,7 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 				md = """
 				### Mapping Result
 				The mapping process has been finished.  
-				Download the file below if you plan to run the models using the <a href="">source code</a>.
+				Download the file below if you plan to run the models using the <a href="https://github.com/CNElab-Plus/ArtifactRemovalTransformer">source code</a>.
 				"""
 				# finalize and save the mapping result
 				outputname = stage1_info["fileNames"]["outputData"]
@@ -523,7 +523,7 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 				md = """
 				### Mapping Result
 				The mapping process has been finished.  
-				Download the file below if you plan to run the models using the <a href="">source code</a>.
+				Download the file below if you plan to run the models using the <a href="https://github.com/CNElab-Plus/ArtifactRemovalTransformer">source code</a>.
 				"""
 				outputname = stage1_info["fileNames"]["outputData"]
 				stage1_info, channel_info = app_utils.mapping_result(stage1_info, channel_info, outputname)
@@ -560,7 +560,7 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 				md = """
 				### Mapping Result
 				The mapping process has been finished.  
-				Download the file below if you plan to run the models using the <a href="">source code</a>.
+				Download the file below if you plan to run the models using the <a href="https://github.com/CNElab-Plus/ArtifactRemovalTransformer">source code</a>.
 				"""
 				outputname = stage1_info["fileNames"]["outputData"]
 				stage1_info, channel_info = app_utils.mapping_result(stage1_info, channel_info, outputname)
@@ -628,7 +628,7 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 			md = """
 			### Mapping Result
 			The mapping process has been finished.  
-			Download the file below if you plan to run the models using the <a href="">source code</a>.
+			Download the file below if you plan to run the models using the <a href="https://github.com/CNElab-Plus/ArtifactRemovalTransformer">source code</a>.
 			"""
 			outputname = stage1_info["fileNames"]["outputData"]
 			stage1_info, channel_info = app_utils.mapping_result(stage1_info, channel_info, outputname)
@@ -814,8 +814,8 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 		stage2_dir = uuid.uuid4().hex + '_stage2/'
 		os.mkdir(rootpath + stage2_dir)
 		
-		basename = os.path.basename(str(in_data))
-		outputname = modelname + '_'+os.path.splitext(basename)[0] + '.csv'
+		inputname = os.path.basename(str(in_data))
+		outputname = modelname + '_'+inputname[:-4] + '.csv'
 		
 		stage2_info = {
 			"filePath" : rootpath + stage2_dir,
@@ -832,31 +832,27 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 				batch_md : gr.Markdown("", visible=True),
 				out_data_file : gr.File(value=None, visible=False)}
 	
-	def run_stage2(stage1_info, stage2_info, samplerate, modelname):
+	def run_model(stage1_info, stage2_info, samplerate, modelname):
 		if stage2_info["errorFlag"] == True:
 			stage2_info["errorFlag"] = False
 			yield {stage2_json : stage2_info}
 		
 		else:
+			filepath = stage2_info["filePath"]
 			inputname = stage2_info["fileNames"]["inputData"]
 			outputname = stage2_info["fileNames"]["outputData"]
-			basename = os.path.basename(str(outputname))
-			basename = os.path.splitext(basename)[0]
+			mapping_result = stage1_info["mappingResult"]
 			break_flag = False
 			
-			for i in range(stage1_info["batchNum"]):
-				yield {batch_md : gr.Markdown('Running model({}/{})...'.format(i+1, stage1_info["batchNum"]))}
+			for i in range(stage1_info["batch"]):
+				yield {batch_md : gr.Markdown('Running model({}/{})...'.format(i+1, stage1_info["batch"]))}
 				try:
-					app_utils.run_model(modelname = modelname,
-										filepath = stage2_info["filePath"],
-										inputname = inputname,
-										m_filename = 'mapped_{:02d}.csv'.format(i+1),
-										d_filename = '{}_{:02d}.csv'.format(basename, i+1),
-										outputname = outputname,
-										samplerate = int(samplerate),
-										batch_cnt = i,
-										old_idx = stage1_info["mappingResult"][i]["index"],
-										orig_flags = stage1_info["mappingResult"][i]["isOriginalData"])
+					# step1: Data preprocessing
+					preprocess_data, channel_num = utils.preprocessing(filepath, inputname, int(samplerate), mapping_result[i])
+					# step2: Signal reconstruction
+					reconstructed_data = utils.reconstruct(modelname, preprocess_data, filepath, i)
+					# step3: Data postprocessing
+					utils.postprocessing(reconstructed_data, int(samplerate), outputname, mapping_result[i], i, channel_num)
 				except FileNotFoundError:
 					print('stop!!')
 					break_flag = True
@@ -877,7 +873,7 @@ with gr.Blocks(js=js, delete_cache=(3600, 3600)) as demo:
 		inputs = [session_dir, stage2_json, in_data_file, in_samplerate, in_modelname],
 		outputs = [stage2_json, run_btn, cancel_btn, batch_md, out_data_file]
 	).success(
-		fn = run_stage2,
+		fn = run_model,
 		inputs = [stage1_json, stage2_json, in_samplerate, in_modelname],
 		outputs = [stage2_json, run_btn, cancel_btn, batch_md, out_data_file]
 	)

app_utils.py

@@ -54,7 +54,7 @@ def match_name(stage1_info):
 	tpl_names = tpl_montage.ch_names
 	in_names = in_montage.ch_names
 	old_idx = [[None]]*30 # store the indices of the in_channels in the order of tpl_channels
-	orig_flags = [False]*30
+	is_orig_data = [False]*30
 	
 	alias_dict = {
 		'T3': 'T7',
@@ -70,7 +70,7 @@ def match_name(stage1_info):
 			
 		if name in in_dict:
 			old_idx[i] = [in_dict[name]["index"]]
-			orig_flags[i] = True
+			is_orig_data[i] = True
 			tpl_dict[name]["matched"] = True
 			in_dict[name]["assigned"] = True
 	
@@ -83,7 +83,7 @@ def match_name(stage1_info):
 	    "mappingResult" : [
 		{
 			"index" : old_idx,
-			"isOriginalData" : orig_flags
+			"isOriginalData" : is_orig_data
 		}
 	    ]
 	})
@@ -270,14 +270,14 @@ def optimal_mapping(channel_info):
 	
 	# store the mapping result
 	old_idx = [[None]]*30
-	orig_flags = [False]*30
+	is_orig_data = [False]*30
 	for i, j in zip(row_idx, col_idx):
 		if j < len(unass_in_names): # filter out dummy channels
 			tpl_name = tpl_names[i]
 			in_name = unass_in_names[j]
 			
 			old_idx[i] = [in_dict[in_name]["index"]]
-			orig_flags[i] = True
+			is_orig_data[i] = True
 			tpl_dict[tpl_name]["matched"] = True
 			in_dict[in_name]["assigned"] = True
 	
@@ -288,23 +288,23 @@ def optimal_mapping(channel_info):
 	
 	result = {
 		"index" : old_idx,
-		"isOriginalData" : orig_flags
+		"isOriginalData" : is_orig_data
 	}
 	channel_info["inputDict"] = in_dict
 	return result, channel_info
 
 def mapping_result(stage1_info, channel_info, filename):
 	unassigned_num = len(stage1_info["unassignedInput"])
-	batch_num = math.ceil(unassigned_num/30) + 1
+	batch = math.ceil(unassigned_num/30) + 1
 	
 	# map the remaining in_channels
 	results = stage1_info["mappingResult"]
-	for i in range(1, batch_num):
+	for i in range(1, batch):
 		# optimally select 30 in_channels to map to the tpl_channels based on proximity
 		result, channel_info = optimal_mapping(channel_info)
 		results += [result]
 	'''
-	for i in range(batch_num):
+	for i in range(batch):
 		results[i]["name"] = {}
 		for j, indices in enumerate(results[i]["index"]):
 			names = [channel_info["inputNames"][idx] for idx in indices] if indices!=[None] else ["zero"]
@@ -313,7 +313,7 @@ def mapping_result(stage1_info, channel_info, filename):
 	data = {
 		#"templateNames" : channel_info["templateNames"],
 		#"inputNames" : channel_info["inputNames"],
-		"batchNum" : batch_num,
+		"batch" : batch,
 		"mappingResult" : results
 	}
 	options = jsbeautifier.default_options()
@@ -323,59 +323,8 @@ def mapping_result(stage1_info, channel_info, filename):
 		jsonfile.write(json_data)
 	
 	stage1_info.update({
-		"batchNum" : batch_num,
+		"batch" : batch,
 		"mappingResult" : results
 	})
 	return stage1_info, channel_info
 
-
-def reorder_data(old_idx, orig_flags, inputname, filename):
-	# read the input data
-	raw_data = utils.read_train_data(inputname)
-	#print(raw_data.shape)
-	new_data = np.zeros((30, raw_data.shape[1]))
-	
-	zero_arr = np.zeros((1, raw_data.shape[1]))
-	for i, (indices, flag) in enumerate(zip(old_idx, orig_flags)):
-		if flag == True:
-			new_data[i, :] = raw_data[indices[0], :]
-		elif indices == [None]:
-			new_data[i, :] = zero_arr
-		else:
-			tmp_data = [raw_data[idx, :] for idx in indices]
-			new_data[i, :] = np.mean(tmp_data, axis=0)
-	
-	utils.save_data(new_data, filename)
-	return raw_data.shape
-
-def restore_order(batch_cnt, raw_data_shape, old_idx, orig_flags, filename, outputname):
-	# read the denoised data
-	d_data = utils.read_train_data(filename)
-	if batch_cnt == 0:
-		new_data = np.zeros((raw_data_shape[0], d_data.shape[1]))
-		#print(new_data.shape)
-	else:
-		new_data = utils.read_train_data(outputname)
-	
-	for i, (indices, flag) in enumerate(zip(old_idx, orig_flags)):
-		if flag == True:
-			new_data[indices[0], :] = d_data[i, :]
-	
-	utils.save_data(new_data, outputname)
-	return
-
-def run_model(modelname, filepath, inputname, m_filename, d_filename, outputname, samplerate, batch_cnt, old_idx, orig_flags):
-	# establish temp folder
-	os.mkdir(filepath+'temp_data/')
-	
-	# step1: Reorder data
-	data_shape = reorder_data(old_idx, orig_flags, inputname, filepath+'temp_data/'+m_filename)
-	# step2: Data preprocessing
-	total_file_num = utils.preprocessing(filepath+'temp_data/', m_filename, samplerate)
-	# step3: Signal reconstruction
-	utils.reconstruct(modelname, total_file_num, filepath+'temp_data/', d_filename, samplerate)
-	# step4: Restore original order
-	restore_order(batch_cnt, data_shape, old_idx, orig_flags, filepath+'temp_data/'+d_filename, outputname)
-	
-	utils.dataDelete(filepath+'temp_data/')
-

model/__pycache__/UNet_attention.cpython-310.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:85dda6aba36abfc30a358e00499a45a17a2c9b2f16647b8adf91b6d0e6882517
+oid sha256:c22a35e64a5b9c7ebb09e866206e4e2ebea59bc1c8253ac2795bb0b64c84df16
 size 13043

model/__pycache__/tf_data.cpython-310.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a0fd072d1c6a351ce360a08e0d267605b1e294b2ee828fe9e04d967eb0546768
+oid sha256:1a57237e3737f55f90c3ee13409cc90034d55ef94610c1fbcdd4768956757341
 size 5981

model/__pycache__/tf_model.cpython-310.pyc

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dbfd285f27e373a49cf4cca80978bb68a566ec349b220663e232868fce11b464
+oid sha256:d12b18b8c5cd4950c70c754e10f70272dd438c980c25a5b712bb1881ece86480
 size 12231

utils.py

@@ -15,38 +15,12 @@ from scipy.signal import decimate, resample_poly, firwin, lfilter
 
 
 os.environ["CUDA_VISIBLE_DEVICES"]="0"
+device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
 
-def resample(signal, fs):
-    # downsample the signal to a sample rate of 256 Hz
-    if fs>256:
-        fs_down = 256 # Desired sample rate
-        q = int(fs / fs_down) # Downsampling factor
-        signal_new = []
-        for ch in signal:
-            x_down = decimate(ch, q)
-            signal_new.append(x_down)
-
-    # upsample the signal to a sample rate of 256 Hz
-    elif fs<256:
-        fs_up = 256  # Desired sample rate
-        p = int(fs_up / fs)  # Upsampling factor 
-        signal_new = []
-        for ch in signal:
-            x_up = resample_poly(ch, p, 1)
-            signal_new.append(x_up)
-
-    else:
-        signal_new = signal
-
-    signal_new = np.array(signal_new).astype(np.float64)
-
-    return signal_new
-
-def resample_(signal, current_fs, target_fs):
-    fs = current_fs
+def resample(signal, fs, tgt_fs):
     # downsample the signal to the target sample rate
-    if fs>target_fs:
-        fs_down = target_fs # Desired sample rate
+    if fs>tgt_fs:
+        fs_down = tgt_fs # Desired sample rate
         q = int(fs / fs_down) # Downsampling factor
         signal_new = []
         for ch in signal:
@@ -54,8 +28,8 @@ def resample_(signal, current_fs, target_fs):
             signal_new.append(x_down)
 
     # upsample the signal to the target sample rate
-    elif fs<target_fs:
-        fs_up = target_fs  # Desired sample rate
+    elif fs<tgt_fs:
+        fs_up = tgt_fs  # Desired sample rate
         p = int(fs_up / fs)  # Upsampling factor 
         signal_new = []
         for ch in signal:
@@ -104,7 +78,7 @@ def cut_data(filepath, raw_data):
     return total
 
 
-def glue_data(file_name, total, output):
+def glue_data(file_name, total):
     gluedata = 0
     for i in range(total):
         file_name1 = file_name + 'output{}.csv'.format(str(i))
@@ -123,13 +97,6 @@ def glue_data(file_name, total, output):
             raw_data[:, 1] = smooth
             gluedata = np.append(gluedata, raw_data, axis=1)
     #print(gluedata.shape)
-    '''
-    filename2 = output
-    with open(filename2, 'w', newline='') as csvfile:
-        writer = csv.writer(csvfile)
-        writer.writerows(gluedata)
-        #print("GLUE DONE!" + filename2)
-    '''
     return gluedata
 
 
@@ -142,8 +109,7 @@ def dataDelete(path):
     try:
         shutil.rmtree(path)
     except OSError as e:
-        pass
-        #print(e)
+        print('dataDelete:', e)
     else:
         pass
         #print("The directory is deleted successfully")
@@ -153,64 +119,78 @@ def decode_data(data, std_num, mode=5):
     
     if mode == "ICUNet":
         # 1. read name
-        model = cumbersome_model2.UNet1(n_channels=30, n_classes=30)
+        model = cumbersome_model2.UNet1(n_channels=30, n_classes=30).to(device)
         resumeLoc = './model/ICUNet/modelsave' + '/checkpoint.pth.tar'
         # 2. load model
-        checkpoint = torch.load(resumeLoc, map_location='cpu')
+        checkpoint = torch.load(resumeLoc, map_location=device)
         model.load_state_dict(checkpoint['state_dict'], False)
         model.eval()
         # 3. decode strategy
         with torch.no_grad():
             data = data[np.newaxis, :, :]
-            data = torch.Tensor(data)
+            data = torch.Tensor(data).to(device)
             decode = model(data)
 
       
-    elif mode == "UNetpp" or mode == "AttUnet":
+    elif mode == "ICUNet++" or mode == "ICUnet_attn":
         # 1. read name
-        if mode == "UNetpp":
-            model = UNet_family.NestedUNet3(num_classes=30)
-        elif mode == "AttUnet":
-            model = UNet_attention.UNetpp3_Transformer(num_classes=30)
-        resumeLoc = './model/'+ mode + '/modelsave' + '/checkpoint.pth.tar'
+        if mode == "ICUNet++":
+            model = UNet_family.NestedUNet3(num_classes=30).to(device)
+        elif mode == "ICUnet_attn":
+            model = UNet_attention.UNetpp3_Transformer(num_classes=30).to(device)
+        resumeLoc = './model/' + mode + '/modelsave' + '/checkpoint.pth.tar'
         # 2. load model
-        checkpoint = torch.load(resumeLoc, map_location='cpu')
+        checkpoint = torch.load(resumeLoc, map_location=device)
         model.load_state_dict(checkpoint['state_dict'], False)
         model.eval()
         # 3. decode strategy
         with torch.no_grad():
             data = data[np.newaxis, :, :]
-            data = torch.Tensor(data)
+            data = torch.Tensor(data).to(device)
             decode1, decode2, decode = model(data)
             
 
-    elif mode == "EEGART":
+    elif mode == "ART":
         # 1. read name
         resumeLoc = './model/' + mode + '/modelsave/checkpoint.pth.tar'
         # 2. load model
-        checkpoint = torch.load(resumeLoc, map_location='cpu')
-        model = tf_model.make_model(30, 30, N=2)
+        checkpoint = torch.load(resumeLoc, map_location=device)
+        model = tf_model.make_model(30, 30, N=2).to(device)
         model.load_state_dict(checkpoint['state_dict'])
         model.eval()
         # 3. decode strategy
         with torch.no_grad():
-            data = torch.FloatTensor(data)
+            data = torch.FloatTensor(data).to(device)
             data = data.unsqueeze(0)
             src = data
-            tgt = data
+            tgt = data # you can modify to randomize data
             batch = tf_data.Batch(src, tgt, 0)
             out = model.forward(batch.src, batch.src[:,:,1:], batch.src_mask, batch.trg_mask)
             decode = model.generator(out)
             decode = decode.permute(0, 2, 1)
-            #add_tensor = torch.zeros(1, 30, 1)
-            #decode = torch.cat((decode, add_tensor), dim=2)
+            add_tensor = torch.zeros(1, 30, 1).to(device)
+            decode = torch.cat((decode, add_tensor), dim=2)
 
     # 4. numpy
     #print(decode.shape)
     decode = np.array(decode.cpu()).astype(np.float64)
     return decode
 
-def preprocessing(filepath, filename, samplerate):
+
+def reorder_data(raw_data, mapping_result):
+    new_data = np.zeros((30, raw_data.shape[1]))
+    zero_arr = np.zeros((1, raw_data.shape[1]))
+    for i, (indices, flag) in enumerate(zip(mapping_result["index"], mapping_result["isOriginalData"])):
+        if flag == True:
+            new_data[i, :] = raw_data[indices[0], :]
+        elif indices[0] == None:
+            new_data[i, :] = zero_arr
+        else:
+            data = [raw_data[idx, :] for idx in indices]
+            new_data[i, :] = np.mean(data, axis=0)
+    return new_data
+
+def preprocessing(filepath, inputfile, samplerate, mapping_result):
     # establish temp folder
     try:
         os.mkdir(filepath+"temp2/")
@@ -220,10 +200,13 @@ def preprocessing(filepath, filename, samplerate):
         print(e)
     
     # read data
-    signal = read_train_data(filepath+filename)
+    signal = read_train_data(inputfile)
+    channel_num = signal.shape[0]
+    # reorder data
+    signal = reorder_data(signal, mapping_result)
     #print(signal.shape)
     # resample
-    signal = resample(signal, samplerate) #signal = resample_(signal, samplerate, 256)
+    signal = resample(signal, samplerate, 256)
     #print(signal.shape)
     # FIR_filter
     signal = FIR_filter(signal, 1, 50)
@@ -231,11 +214,27 @@ def preprocessing(filepath, filename, samplerate):
     # cutting data
     total_file_num = cut_data(filepath, signal)
 
-    return total_file_num
+    return total_file_num, channel_num
+
+def restore_order(data, all_data, mapping_result):
+    for i, (indices, flag) in enumerate(zip(mapping_result["index"], mapping_result["isOriginalData"])):
+        if flag == True:
+            all_data[indices[0], :] = data[i, :]
+    return all_data
+
+def postprocessing(data, samplerate, outputfile, mapping_result, batch_cnt, channel_num):
+    
+    # resample to original sampling rate
+    data = resample(data, 256, samplerate)
+    # restore original order
+    all_data = np.zeros((channel_num, data.shape[1])) if batch_cnt==0 else read_train_data(outputfile)
+    all_data = restore_order(data, all_data, mapping_result)
+    # save data
+    save_data(all_data, outputfile)
 
 
 # model = tf.keras.models.load_model('./denoise_model/')
-def reconstruct(model_name, total, filepath, outputfile, samplerate):
+def reconstruct(model_name, total, filepath, batch_cnt):
     # -------------------decode_data---------------------------
     second1 = time.time()
     for i in range(total):
@@ -255,16 +254,11 @@ def reconstruct(model_name, total, filepath, outputfile, samplerate):
         save_data(d_data, outputname)
 
     # --------------------glue_data----------------------------
-    signal = glue_data(filepath+"temp2/", total, filepath+outputfile)
-    #print(signal.shape)
+    data = glue_data(filepath+"temp2/", total)
     # -------------------delete_data---------------------------
     dataDelete(filepath+"temp2/")
-    # --------------------resample-----------------------------
-    signal = resample_(signal, 256, samplerate)
-    #print(signal.shape)
-    # --------------------save_data----------------------------
-    save_data(signal, filepath+outputfile)
     second2 = time.time()
-
-    print("Using", model_name,"model to reconstruct", outputfile, " has been success in", second2 - second1, "sec(s)")
-
+    
+    print(f"Using {model_name} model to reconstruct batch-{batch_cnt+1} has been success in {second2 - second1} sec(s)")
+    return data
+