def extract_patches_train(img_test_normalized, patch_size): # Extract training patches manual stride = patch_size height, width, channel = img_test_normalized.shape #print(height, width) num_patches_h = height // stride num_patches_w = width // stride #print(num_patches_h, num_patches_w) new_shape = (num_patches_h * num_patches_w, patch_size, patch_size, channel) new_img = np.zeros(new_shape) print(new_img.shape) cont = 0 # rows for h in range(num_patches_h): # columns for w in range(num_patches_w): new_img[cont] = img_test_normalized[h * stride:(h + 1) * stride, w * stride:(w + 1) * stride] cont += 1 #print(cont) return new_img
def extract_patches_test(binary_img_test_ref, patch_size): # Extract training patches stride = patch_size height, width = binary_img_test_ref.shape #print(height, width) num_patches_h = int(height / stride) num_patches_w = int(width / stride) #print(num_patches_h, num_patches_w) new_shape = (num_patches_h * num_patches_w, patch_size, patch_size) new_img_ref = np.zeros(new_shape) print(new_img_ref.shape) cont = 0 # rows for h in range(num_patches_h): #columns for w in range(num_patches_w): new_img_ref[cont] = binary_img_test_ref[h * stride:(h + 1) * stride, w * stride:(w + 1) * stride] cont += 1 #print(cont) return new_img_ref
def pred_recostruction(patch_size, pred_labels, binary_img_test_ref, img_type=1): # Patches Reconstruction if img_type == 1: stride = patch_size height, width = binary_img_test_ref.shape num_patches_h = height // stride num_patches_w = width // stride #print(num_patches_h, num_patches_w) new_shape = (height, width) img_reconstructed = np.zeros(new_shape) cont = 0 # rows for h in range(num_patches_h): # columns for w in range(num_patches_w): img_reconstructed[h * stride:(h + 1) * stride, w * stride:(w + 1) * stride] = pred_labels[cont] cont += 1 print('Reconstruction Done!') if img_type == 2: stride = patch_size height, width = binary_img_test_ref.shape num_patches_h = height // stride num_patches_w = width // stride new_shape = (height, width, 3) img_reconstructed = np.zeros(new_shape) cont = 0 # rows for h in range(num_patches_h): # columns for w in range(num_patches_w): img_reconstructed[h * stride:(h + 1) * stride, w * stride:(w + 1) * stride, :] = pred_labels[cont] cont += 1 print('Reconstruction Done!') return img_reconstructed
def pmus_passive(fs, rr): """ Passive profile, i.e, no respiratory effort (no spontaneous breathing) :param fs: sample frequency :param rr: respiratory rate :return: pmus profile """ pmus = np.zeros(1, int(np.floor(60.0 / rr * fs) + 1)) return pmus
def pmus_trapezoidal(fs, rr, ttrap, inspeak, exppeak): """ Trapezoidal profile :param fs: sample frequency :param rr: respiratory rate :param ttrap: time array defining trapezoidal profile :param inspeak: negative peak pressure :param exppeak: positive peak pressure :return: pmus profile """ pmus = np.zeros(1, int(np.floor(60.0 / rr * fs) + 1)) return pmus
def convert_preds2rgb(img_reconstructed, label_dict): reversed_label_dict = {value: key for (key, value) in label_dict.items()} print(reversed_label_dict) height, width = img_reconstructed.shape img_reconstructed_rgb = np.zeros((height, width, 3)) for h in range(height): for w in range(width): pixel_class = img_reconstructed[h, w] img_reconstructed_rgb[h, w, :] = ast.literal_eval( reversed_label_dict[pixel_class]) print('Conversion to RGB Done!') return img_reconstructed_rgb.astype(np.uint8)
def zero_grads_for_batch(): gW3 = np.zeros(W3_shape) gW2 = np.zeros(W2_shape) gW1 = np.zeros(W1_shape) gb1 = np.zeros(b1_shape[0]) gb2 = np.zeros(b2_shape[0]) gb3 = np.zeros(b3_shape[0]) return [gW3, gW2, gW1, gb1, gb2, gb3]
# Mask with tiles tile_number = np.ones((340, 480)) mask_c_1 = np.concatenate((tile_number, 2 * tile_number, 3 * tile_number), axis=1) mask_c_2 = np.concatenate((4 * tile_number, 5 * tile_number, 6 * tile_number), axis=1) mask_c_3 = np.concatenate((7 * tile_number, 8 * tile_number, 9 * tile_number), axis=1) mask_c_4 = np.concatenate( (10 * tile_number, 11 * tile_number, 12 * tile_number), axis=1) mask_c_5 = np.concatenate( (13 * tile_number, 14 * tile_number, 15 * tile_number), axis=1) mask_tiles = np.concatenate((mask_c_1, mask_c_2, mask_c_3, mask_c_4, mask_c_5), axis=0) mask_tr_val = np.zeros((mask_tiles.shape)) tr1 = 1 tr2 = 6 tr3 = 7 tr4 = 13 val1 = 5 val2 = 12 mask_tr_val[mask_tiles == tr1] = 1 mask_tr_val[mask_tiles == tr2] = 1 mask_tr_val[mask_tiles == tr3] = 1 mask_tr_val[mask_tiles == tr4] = 1 mask_tr_val[mask_tiles == val1] = 2 mask_tr_val[mask_tiles == val2] = 2 total_no_def = 0
def solve_model(header_params,params,header_features,features,debugmsg): #Extracts each parameter fs = params[header_params.index('Fs')] rvent = params[header_params.index('Rvent')] c = params[header_params.index('C')] rins = params[header_params.index('Rins')] rexp = rins # params[4] peep = params[header_params.index('PEEP')] sp = params[header_params.index('SP')] trigger_type = features[header_features.index('Triggertype')] trigger_arg = params[header_params.index('Triggerarg')] rise_type = features[header_features.index('Risetype')] rise_time = params[header_params.index('Risetime')] cycle_off = params[header_params.index('Cycleoff')] rr = params[header_params.index('RR')] pmus_type = features[header_features.index('Pmustype')] pp = params[header_params.index('Pp')] tp = params[header_params.index('Tp')] tf = params[header_params.index('Tf')] noise = params[header_params.index('Noise')] e2 = params[header_params.index('E2')] model = features[header_features.index('Model')] expected_len = int(np.floor(180.0 / np.min(RR) * np.max(Fs)) + 1) #Assings pmus profile pmus = pmus_profile(fs, rr, pmus_type, pp, tp, tf) pmus = pmus + peep #adjusts PEEP pmus = np.concatenate((np.array([0]), pmus)) #sets the first value to zero #Unit conversion from cmH2O.s/L to cmH2O.s/mL rins = rins / 1000.0 rexp = rexp / 1000.0 rvent = rvent / 1000.0 #Generates time, flow, volume, insex and paw waveforms time = np.arange(0, np.floor(60.0 / rr * fs) + 1, 1) / fs time = np.concatenate((np.array([0]), time)) flow = np.zeros(len(time)) volume = np.zeros(len(time)) insex = np.zeros(len(time)) paw = np.zeros(len(time)) + peep #adjusts PEEP len_time = len(time) #Peak flow detection peak_flow = flow[0] detect_peak_flow = False #Support detection detect_support = False time_support = -1 #Expiration detection detect_exp = False time_exp = -1 if trigger_type == 'flow': # units conversion from L/min to mL/s trigger_arg = trigger_arg / 60.0 * 1000.0 for i in range(1, len(time)): # period until the respiratory effort beginning if (((trigger_type == 'flow' and flow[i] < trigger_arg) or (trigger_type == 'pressure' and paw[i] > trigger_arg + peep) or (trigger_type == 'delay' and time[i] < trigger_arg)) and (not detect_support) and (not detect_exp)): paw[i] = peep y0 = volume[i - 1] tspan = [time[i - 1], time[i]] args = (paw[i], pmus[i], model, c, e2, rins) sol = odeint(flow_model, y0, tspan, args=args) volume[i] = sol[-1] flow[i] = flow_model(volume[i], time[i], paw[i], pmus[i], model, c, e2, rins) if debugmsg: print('volume[i]= {:.2f}, flow[i]= {:.2f}, paw[i]= {:.2f}, waiting'.format(volume[i], flow[i], paw[i])) if (((trigger_type == 'flow' and flow[i] >= trigger_arg) or (trigger_type == 'pressure' and paw[i] <= trigger_arg + peep) or (trigger_type == 'delay' and time[i] >= trigger_arg))): detect_support = True time_support = time[i+1] continue # detection of inspiratory effort # ventilator starts to support the patient elif (detect_support and (not detect_exp)): if rise_type == 'step': paw[i] = sp + peep elif rise_type == 'exp': rise_type = rise_type if np.random.random() > 0.01 else 'linear' if paw[i] < sp + peep: paw[i] = (1.0 - np.exp(-(time[i] - time_support) / rise_time )) * sp + peep if paw[i] >= sp + peep: paw[i] = sp + peep elif rise_type == 'linear': rise_type = rise_type if np.random.random() > 0.01 else 'exp' if paw[i] < sp + peep: paw[i] = (time[i] - time_support) / rise_time * sp + peep if paw[i] >= sp + peep: paw[i] = sp + peep y0 = volume[i - 1] tspan = [time[i - 1], time[i]] args = (paw[i], pmus[i], model, c, e2, rins) sol = odeint(flow_model, y0, tspan, args=args) volume[i] = sol[-1] flow[i] = flow_model(volume[i], time[i], paw[i], pmus[i], model, c, e2, rins) if debugmsg: print('volume[i]= {:.2f}, flow[i]= {:.2f}, paw[i]= {:.2f}, supporting'.format(volume[i], flow[i], paw[i])) if flow[i] >= flow[i - 1]: peak_flow = flow[i] detect_peak_flow = False elif flow[i] < flow[i - 1]: detect_peak_flow = True if (flow[i] <= cycle_off * peak_flow) and detect_peak_flow and i<len_time: detect_exp = True time_exp = i+1 try: paw[i + 1] = paw[i] except IndexError: pass elif detect_exp: if rise_type == 'step': paw[i] = peep elif rise_type == 'exp': if paw[i - 1] > peep: paw[i] = sp * (np.exp(-(time[i] - time[time_exp-1]) / rise_time )) + peep if paw[i - 1] <= peep: paw[i] = peep elif rise_type == 'linear': rise_type = rise_type if np.random.random() > 0.01 else 'exp' if paw[i - 1] > peep: paw[i] = sp * (1 - (time[i] - time[time_exp-1]) / rise_time) + peep if paw[i - 1] <= peep: paw[i] = peep y0 = volume[i - 1] tspan = [time[i - 1], time[i]] args = (paw[i], pmus[i], model, c, e2, rexp + rvent) sol = odeint(flow_model, y0, tspan, args=args) volume[i] = sol[-1] flow[i] = flow_model(volume[i], time[i], paw[i], pmus[i], model, c, e2, rexp + rvent) if debugmsg: print('volume[i]= {:.2f}, flow[i]= {:.2f}, paw[i]= {:.2f}, exhaling'.format(volume[i], flow[i], paw[i])) #Generates InsEx trace if time_exp > -1: insex = np.concatenate((np.ones(time_exp), np.zeros(len(time) - time_exp))) #Drops the first element flow = flow[1:] / 1000.0 * 60.0 # converts back to L/min volume = volume[1:] paw = paw[1:] pmus = pmus[1:] - peep #reajust peep again insex = insex[1:] flow,volume,pmus,insex,paw = generate_cycle(expected_len,flow,volume,pmus,insex,paw,peep=peep) # paw = generate_cycle(expected_len,paw,peep=peep)[0] flow,volume,paw,pmus,insex = generate_noise(noise,flow,volume,paw,pmus,insex) # plt.plot(flow) # plt.plot(volume) # plt.plot(paw) # plt.plot(pmus) # plt.show() return flow, volume, paw, pmus, insex, rins,rexp, c
def train_model(args, net, x_train_paths, y_train_paths, x_val_paths, y_val_paths, batch_size, epochs, x_shape_batch, y_shape_batch, patience=10, delta=0.001, metrics_names=None): # patches_train = x_train_paths print('Start training...') print('=' * 60) print(f'Training on {len(x_train_paths)} images') print(f'Validating on {len(x_val_paths)} images') print('=' * 60) print(f'Total Epochs: {epochs}') # Initialize tensorboard metrics train_summary_writer = tf.summary.create_file_writer( os.path.join(args.results_path, 'logs', 'train')) val_summary_writer = tf.summary.create_file_writer( os.path.join(args.results_path, 'logs', 'val')) # Initialize as maximum possible number min_loss = float('inf') cont = 0 x_train_b = np.zeros(x_shape_batch, dtype=np.float32) y_train_h_b_seg = np.zeros(y_shape_batch, dtype=np.float32) x_val_b = np.zeros(x_shape_batch, dtype=np.float32) y_val_h_b_seg = np.zeros(y_shape_batch, dtype=np.float32) if args.multitasking: # Bounds y_train_h_b_bound = np.zeros(y_shape_batch, dtype=np.float32) y_val_h_b_bound = np.zeros(y_shape_batch, dtype=np.float32) # Dists y_train_h_b_dist = np.zeros(y_shape_batch, dtype=np.float32) y_val_h_b_dist = np.zeros(y_shape_batch, dtype=np.float32) # Colors y_train_h_b_color = np.zeros( (y_shape_batch[0], y_shape_batch[1], y_shape_batch[2], 3), dtype=np.float32) y_val_h_b_color = np.zeros( (y_shape_batch[0], y_shape_batch[1], y_shape_batch[2], 3), dtype=np.float32) # print(net.metrics_names) print(net.output_names) for epoch in range(epochs): # metrics_len = len(net.metrics_names) metrics_len = len(metrics_names) loss_tr = np.zeros((1, metrics_len)) loss_val = np.zeros((1, metrics_len)) # Computing the number of batchs on training n_batchs_tr = len(x_train_paths) // batch_size # Random shuffle the data if not args.multitasking: (x_train_paths_rand, y_train_paths_rand_seg) = shuffle(x_train_paths, y_train_paths[0]) else: (x_train_paths_rand, y_train_paths_rand_seg, y_train_paths_rand_bound, y_train_paths_rand_dist, y_train_paths_rand_color) \ = shuffle(x_train_paths, y_train_paths[0], y_train_paths[1], y_train_paths[2], y_train_paths[3]) # Training the network per batch for batch in tqdm(range(n_batchs_tr), desc="Train"): x_train_paths_b = x_train_paths_rand[batch * batch_size:(batch + 1) * batch_size] y_train_paths_b_seg = y_train_paths_rand_seg[batch * batch_size:(batch + 1) * batch_size] # if args.multitasking: # y_train_paths_b_bound = y_train_paths_rand_bound[batch * batch_size:(batch + 1) * batch_size] # y_train_paths_b_dist = y_train_paths_rand_dist[batch * batch_size:(batch + 1) * batch_size] # y_train_paths_b_color = y_train_paths_rand_color[batch * batch_size:(batch + 1) * batch_size] for b in range(batch_size): x_train_b[b] = np.load(x_train_paths_b[b]) y_train_h_b_seg[b] = np.load(y_train_paths_b_seg[b]).astype( np.float32) # if args.multitasking: # y_train_h_b_bound[b] = np.load(y_train_paths_b_bound[b]) # y_train_h_b_dist[b] = np.load(y_train_paths_b_dist[b]) # y_train_h_b_color[b] = np.load(y_train_paths_b_color[b]) if not args.multitasking: loss_tr = loss_tr + net.train_on_batch(x_train_b, y_train_h_b_seg) else: # Get paths per batch on multitasking labels y_train_paths_b_bound = y_train_paths_rand_bound[batch * batch_size: (batch + 1) * batch_size] y_train_paths_b_dist = y_train_paths_rand_dist[batch * batch_size: (batch + 1) * batch_size] y_train_paths_b_color = y_train_paths_rand_color[batch * batch_size: (batch + 1) * batch_size] # Load multitasking labels for b in range(batch_size): y_train_h_b_bound[b] = np.load( y_train_paths_b_bound[b]).astype(np.float32) y_train_h_b_dist[b] = np.load( y_train_paths_b_dist[b]).astype(np.float32) y_train_h_b_color[b] = np.load( y_train_paths_b_color[b]).astype(np.float32) y_train_b = {"seg": y_train_h_b_seg} y_train_b['bound'] = y_train_h_b_bound y_train_b['dist'] = y_train_h_b_dist y_train_b['color'] = y_train_h_b_color loss_tr = loss_tr + net.train_on_batch( x=x_train_b, y=y_train_b, return_dict=False) # Training loss; Divide by the number of batches # print(loss_tr) loss_tr = loss_tr / n_batchs_tr # Computing the number of batchs on validation n_batchs_val = len(x_val_paths) // batch_size # Evaluating the model in the validation set for batch in tqdm(range(n_batchs_val), desc="Validation"): x_val_paths_b = x_val_paths[batch * batch_size:(batch + 1) * batch_size] y_val_paths_b_seg = y_val_paths[0][batch * batch_size:(batch + 1) * batch_size] for b in range(batch_size): x_val_b[b] = np.load(x_val_paths_b[b]) y_val_h_b_seg[b] = np.load(y_val_paths_b_seg[b]).astype( np.float32) if not args.multitasking: loss_val = loss_val + net.test_on_batch(x_val_b, y_val_h_b_seg) else: # Get paths per batch on multitasking labels y_val_paths_b_bound = y_val_paths[1][batch * batch_size:(batch + 1) * batch_size] y_val_paths_b_dist = y_val_paths[2][batch * batch_size:(batch + 1) * batch_size] y_val_paths_b_color = y_val_paths[3][batch * batch_size:(batch + 1) * batch_size] # Load multitasking labels for b in range(batch_size): y_val_h_b_bound[b] = np.load( y_val_paths_b_bound[b]).astype(np.float32) y_val_h_b_dist[b] = np.load(y_val_paths_b_dist[b]).astype( np.float32) y_val_h_b_color[b] = np.load( y_val_paths_b_color[b]).astype(np.float32) # Dict template: y_val_b = {"segmentation": y_val_h_b_seg, # "boundary": y_val_h_b_bound, "distance": y_val_h_b_dist, # "color": y_val_h_b_color} y_val_b = {"seg": y_val_h_b_seg} y_val_b['bound'] = y_val_h_b_bound y_val_b['dist'] = y_val_h_b_dist y_val_b['color'] = y_val_h_b_color loss_val = loss_val + net.test_on_batch(x=x_val_b, y=y_val_b) loss_val = loss_val / n_batchs_val # train_metrics = dict(zip(net.metrics_names, loss_tr.tolist()[0])) # val_metrics = dict(zip(net.metrics_names, loss_val.tolist()[0])) train_metrics = dict(zip(metrics_names, loss_tr.tolist()[0])) val_metrics = dict(zip(metrics_names, loss_val.tolist()[0])) if not args.multitasking: # print(f'loss_val shape: {loss_val.shape}') train_loss = train_metrics['loss'] train_acc = train_metrics['accuracy'] val_loss = val_metrics['loss'] val_acc = val_metrics['accuracy'] mcc = compute_mcc(val_metrics['true_positives'], val_metrics['true_negatives'], val_metrics['false_positives'], val_metrics['false_negatives']) print(f"Epoch: {epoch} " + f"Training loss: {train_loss :.5f} " + f"Train acc.: {100*train_acc:.5f}% " + f"Validation loss: {val_loss :.5f} " + f"Validation acc.: {100*val_acc:.5f}%") add_tensorboard_scalars(train_summary_writer, val_summary_writer, epoch, 'Total', train_loss, val_loss, train_acc, val_acc, val_mcc=mcc) else: mcc = compute_mcc(val_metrics['seg_true_positives'], val_metrics['seg_true_negatives'], val_metrics['seg_false_positives'], val_metrics['seg_false_negatives']) metrics_table = PrettyTable() metrics_table.title = f'Epoch: {epoch}' metrics_table.field_names = [ 'Task', 'Loss', 'Val Loss', 'Acc %', 'Val Acc %' ] metrics_table.add_row([ 'Seg', round(train_metrics['seg_loss'], 5), round(val_metrics['seg_loss'], 5), round(100 * train_metrics['seg_accuracy'], 5), round(100 * val_metrics['seg_accuracy'], 5) ]) add_tensorboard_scalars(train_summary_writer, val_summary_writer, epoch, 'Segmentation', train_metrics['seg_loss'], val_metrics['seg_loss'], train_metrics['seg_accuracy'], val_metrics['seg_accuracy'], val_mcc=mcc) metrics_table.add_row([ 'Bound', round(train_metrics['bound_loss'], 5), round(val_metrics['bound_loss'], 5), 0, 0 ]) add_tensorboard_scalars(train_summary_writer, val_summary_writer, epoch, 'Boundary', train_metrics['bound_loss'], val_metrics['bound_loss']) metrics_table.add_row([ 'Dist', round(train_metrics['dist_loss'], 5), round(val_metrics['dist_loss'], 5), 0, 0 ]) add_tensorboard_scalars(train_summary_writer, val_summary_writer, epoch, 'Distance', train_metrics['dist_loss'], val_metrics['dist_loss']) metrics_table.add_row([ 'Color', round(train_metrics['color_loss'], 5), round(val_metrics['color_loss'], 5), 0, 0 ]) add_tensorboard_scalars(train_summary_writer, val_summary_writer, epoch, 'Color', train_metrics['color_loss'], val_metrics['color_loss']) metrics_table.add_row([ 'Total', round(train_metrics['loss'], 5), round(val_metrics['loss'], 5), 0, 0 ]) add_tensorboard_scalars(train_summary_writer, val_summary_writer, epoch, 'Total', train_metrics['loss'], val_metrics['loss']) val_loss = val_metrics['loss'] print(metrics_table) # Early stop # Save the model when loss is minimum # Stop the training if the loss don't decreases after patience epochs if val_loss >= min_loss + delta: cont += 1 print(f'EarlyStopping counter: {cont} out of {patience}') if cont >= patience: print("Early Stopping! \t Training Stopped") # print("Saving model...") # net.save(os.path.join(args.checkpoint, 'model_early_stopping.h5')) return net else: cont = 0 min_loss = val_loss print("Saving best model...") net.save(os.path.join(args.results_path, 'best_model.h5'))
header_features, feature = get_random_features(features, num_test_cases) print(f'Number of respiratory cycles to be simulated: {num_test_cases}') fs = max(Fs) rr = min(RR) print(f'Creating waveforms for fs={fs} / rr={rr}') num_points = int(np.floor(180.0 / rr * fs) + 1) print("Test cases:", num_test_cases) print("Number points: ", num_points) # Target waveforms flow = np.zeros((num_points, num_test_cases)) volume = np.zeros((num_points, num_test_cases)) paw = np.zeros((num_points, num_test_cases)) pmus = np.zeros((num_points, num_test_cases)) ins = np.zeros((num_points, num_test_cases)) resistances_ins = np.zeros((1, num_test_cases)) resistances_exp = np.zeros((1, num_test_cases)) capacitances = np.zeros((1, num_test_cases)) t = time.time() for i in range(num_test_cases): if i % 500 == 0: print('%d/%d' % (i, num_test_cases)) (flow[:, i], volume[:, i], paw[:, i], pmus[:, i], ins[:, i], rins, rexp, c) = solve_model(header_params, param[i], header_features, feature[i], '')
capacitances = capacitances.T print("transposed") num_examples = flow.shape[0] num_samples = flow.shape[1] (min_flow, max_flow, flow) = normalize_data(flow) (min_volume, max_volume, volume) = normalize_data(volume) (min_paw, max_paw, paw) = normalize_data(paw) (min_resistance, max_resistance, resistances) = normalize_data(resistances) (min_capacitance, max_capacitance, capacitances) = normalize_data(capacitances) print("normalized data") input_data = np.zeros((num_examples, num_samples, 3)) input_data[:, :, 0] = flow input_data[:, :, 1] = volume input_data[:, :, 2] = paw output_data = np.concatenate((resistances, capacitances), axis=1) indices = np.arange(num_examples) print("input created") input_train, input_test, output_train, output_test, indices_train, indices_test = \ train_test_split(input_data, output_data, indices, test_size=0.3, shuffle=False) input_validation, input_test, output_validation, output_test, indices_validation, indices_test = \ train_test_split(input_test, output_test, indices_test, test_size=0.5, shuffle=False)
# gc.collect() # print(gc.get_count()) # Mask with tiles # Divide tiles in 5 rows and 3 columns. Total = 15 tiles tile_number = np.ones((1220,2200)) mask_c_1 = np.concatenate((tile_number, 2*tile_number, 3*tile_number), axis=1) mask_c_2 = np.concatenate((4*tile_number, 5*tile_number, 6*tile_number), axis=1) mask_c_3 = np.concatenate((7*tile_number, 8*tile_number, 9*tile_number), axis=1) mask_c_4 = np.concatenate((10*tile_number, 11*tile_number, 12*tile_number), axis=1) mask_c_5 = np.concatenate((13*tile_number, 14*tile_number, 15*tile_number), axis=1) mask_tiles = np.concatenate((mask_c_1, mask_c_2, mask_c_3 , mask_c_4, mask_c_5), axis=0) #%% Test model # Creation of mask with test tiles mask_ts_ = np.zeros((mask_tiles.shape)) ts1 = 1 ts2 = 2 ts3 = 3 ts4 = 4 ts5 = 6 ts6 = 9 ts7 = 12 ts8 = 14 ts9 = 15 mask_ts_[mask_tiles == ts1] = 1 mask_ts_[mask_tiles == ts2] = 1 mask_ts_[mask_tiles == ts3] = 1 mask_ts_[mask_tiles == ts4] = 1 mask_ts_[mask_tiles == ts5] = 1 mask_ts_[mask_tiles == ts6] = 1