def run_benchmark(self, iter, mode="Valid"): if mode == "Valid": time_interval = c.RAINY_VALID stride = 20 else: time_interval = c.RAINY_TEST stride = 1 test_iter = Iterator(time_interval=time_interval, sample_mode="sequent", seq_len=c.IN_SEQ + c.OUT_SEQ, stride=1) evaluator = Evaluator(iter) i = 1 while not test_iter.use_up: data, date_clip, *_ = test_iter.sample(batch_size=c.BATCH_SIZE) in_data = np.zeros(shape=(c.BATCH_SIZE, c.IN_SEQ, c.H, c.W, c.IN_CHANEL)) gt_data = np.zeros(shape=(c.BATCH_SIZE, c.OUT_SEQ, c.H, c.W, 1)) if type(data) == type([]): break in_data[...] = data[:, :c.IN_SEQ, ...] if c.IN_CHANEL == 3: gt_data[...] = data[:, c.IN_SEQ:c.IN_SEQ + c.OUT_SEQ, :, :, 1:-1] elif c.IN_CHANEL == 1: gt_data[...] = data[:, c.IN_SEQ:c.IN_SEQ + c.OUT_SEQ, ...] else: raise NotImplementedError # in_date = date_clip[0][:c.IN_SEQ] if c.NORMALIZE: in_data = normalize_frames(in_data) gt_data = normalize_frames(gt_data) mse, mae, gdl, pred = self.model.valid_step(in_data, gt_data) evaluator.evaluate(gt_data, pred) logging.info(f"Iter {iter} {i}: \n\t mse:{mse} \n\t mae:{mae} \n\t gdl:{gdl}") i += 1 if i % stride == 0: if c.IN_CHANEL == 3: in_data = in_data[:, :, :, :, 1:-1] for b in range(c.BATCH_SIZE): predict_date = date_clip[b][c.IN_SEQ] logging.info(f"Save {predict_date} results") if mode == "Valid": save_path = os.path.join(c.SAVE_VALID, str(iter), predict_date.strftime("%Y%m%d%H%M")) else: save_path = os.path.join(c.SAVE_TEST, str(iter), predict_date.strftime("%Y%m%d%H%M")) path = os.path.join(save_path, "in") save_png(in_data[b], path) path = os.path.join(save_path, "pred") save_png(pred[b], path) path = os.path.join(save_path, "out") save_png(gt_data[b], path) evaluator.done()
def testPrediction(epoch): if epoch % 5 == 0: for i in range(0, len(x), int(len(y) / 5)): if epoch == 0: utils.save_png( x[i] * 255, runPath + '/samples/i' + f'{i:04}' + '.0.rgb.png') utils.save_png( y[i] * 255, runPath + '/samples/i' + f'{i:04}' + '.1.mask.png') prediction = utils.predict(model, x[i]) * 255 utils.save_png( prediction.reshape(resolution, resolution, 3), runPath + '/samples/i' + f'{i:04}' + '.e' + f'{epoch:05}' + '.png')
if mode == "Valid": save_path = os.path.join(cfg.SAVE_VALID, str(iter), predict_date.strftime("%Y%m%d%H%M")) display_path = os.path.join( cfg.SAVE_DISPLAY, str(iter), predict_date.strftime("%Y%m%d%H%M")) save_in_data = in_data[0] save_out_data = gt_data[0] else: display_path = os.path.join( cfg.SAVE_DISPLAY, str(iter), predict_date.strftime("%Y%m%d%H%M")) save_path = os.path.join(cfg.SAVE_TEST, str(iter), predict_date.strftime("%Y%m%d%H%M")) save_in_data = np.zeros((cfg.DISPLAY_IN_SEQ, 900, 900, 1)) save_out_data = np.zeros((cfg.OUT_SEQ, 900, 900, 1)) save_pred_data = np.zeros((cfg.PREDICT_LENGTH, 900, 900, 1)) save_in_data[:, 90:-90, :, :] = in_data[0] save_out_data[:, 90:-90, :, :] = gt_data[0] from utils import save_png from supervisor.color_map import multi_process_transfer path = os.path.join(save_path, "in") save_png(save_in_data, path) if mode != 'Valid': multi_process_transfer(path, display_path + '/in') # multi_process_transfer(path, display_path + 'pred') path = os.path.join(save_path, "out") save_png(save_out_data, path) if mode != 'Valid': multi_process_transfer(path, display_path + '/out')
from matplotlib import style import numpy as np fig = plt.figure() ax = fig.add_subplot(111) style.use('ggplot') phantom = np.fromfile( "../../../jaw_512x512x512_uint16.raw", dtype=np.uint16).reshape((512,512,512)) # because original data is ordered in unusual way phantom[:] = np.rot90(phantom) central_slice = np.rot90(phantom[140,:,100:411], 2) plt.imshow(central_slice, cmap="gray", vmax=3) import matplotlib.patches as patches ax.add_patch(patches.Rectangle((135,260), 40, 40, fill=False, edgecolor="red")) ax.add_patch(patches.Rectangle((153,236), 3, 40, facecolor="green", edgecolor="green")) plt.axis('off') plt.grid(False) plt.colorbar() #plt.show() from utils import save_png save_png(__file__, fig, bbox_inches='tight')
import matplotlib.pyplot as plt from matplotlib import style import numpy as np fig, ax = plt.subplots() style.use('ggplot') phantom = np.fromfile( "../figures/jaw/jaw-rect_sl110_512x512_float32.raw", dtype=np.float32).reshape((512,512)) central_slice = phantom[:,100:411] plt.imshow(central_slice, cmap="gray", vmax=3) import matplotlib.patches as patches #ax.add_patch(patches.Rectangle((135,260), 40, 40, fill=False, edgecolor="red")) ax.add_patch(patches.Rectangle((153,384), 3, 32, facecolor="green", edgecolor="green")) plt.axis('off') plt.grid(False) plt.colorbar() #plt.show() from utils import save_png save_png(__file__, fig, subdir="jaw", bbox_inches='tight')
def train(dataset_dir, log_dir, load_path=None): # init Tacotron2 model = Tacotron2() # init loss fn criterion = Tacotron2Loss() # init optimizer optimizer = torch.optim.Adam(model.parameters(), lr=0.05) epoch = 0 max_epoch = 100 iteration = 1 save_iters = 100 if load_path is not None: model, optimizer, iteration = load_model(load_path, model, optimizer) # init lr scheduler lr_lambda = lambda step: 4000**0.5 * min((step + 1) * 4000**-1.5, (step + 1)**-0.5) if load_path is not None: scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lr_lambda, last_epoch=iteration) else: scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda=lr_lambda) # prepare data loader dataset = SpeechDataset(dataset_dir) collate_fn = SpeechCollate() batch_size = 2 dataloader = DataLoader(dataset, num_workers=0, shuffle=True, batch_size=batch_size, drop_last=True, collate_fn=collate_fn) # change train mode model.train() while epoch < max_epoch: total_loss = 0 for batch in dataloader: stime = time() mel_padded, output_lengths, text_padded, input_lengths = batch mel_predict = model((text_padded.long(), input_lengths.long(), mel_padded.float(), output_lengths.long())) loss, loss_item = criterion(mel_predict, mel_padded) total_loss += loss_item model.zero_grad() loss.backward() optimizer.step() scheduler.step() dur_time = time() - stime lr = optimizer.param_groups[0]['lr'] print( 'epoch : {}, iteration : {}, loss : {:.8f}, time : {:.1f}s/it (lr : {})' .format(epoch + 1, iteration, loss_item, dur_time, lr)) if iteration % save_iters == 0: save_model(log_dir, model, optimizer, iteration) mel_output = mel_predict[0].detach().numpy().astype(np.float32) mel_target = mel_padded[0].detach().numpy().astype(np.float32) png_path = os.path.join(log_dir, 'mel_{}.png'.format(iteration)) save_png((mel_output, mel_target), png_path) iteration += 1 epoch += 1
def run_benchmark(self, iter, mode="Valid"): if mode == "Valid": time_interval = c.RAINY_VALID else: time_interval = c.RAINY_TEST test_iter = Iterator(time_interval=time_interval, sample_mode="sequent", seq_len=c.IN_SEQ + c.OUT_SEQ, stride=10, mode=mode) i = 1 while not test_iter.use_up: data, date_clip, *_ = test_iter.sample(batch_size=c.BATCH_SIZE) data = np.array(data) if data.shape[0] == 0: break print(data.shape) if mode == 'Valid': in_data = np.zeros(shape=(c.BATCH_SIZE, c.IN_SEQ, c.H_TRAIN, c.W_TRAIN, c.IN_CHANEL)) gt_data = np.zeros(shape=(c.BATCH_SIZE, c.OUT_SEQ, c.H_TRAIN, c.W_TRAIN, c.IN_CHANEL)) in_data[:, :, :, :, :] = data[:, :c.IN_SEQ, :, :, :] gt_data[:, :, :, :, :] = data[:, c.IN_SEQ:c.IN_SEQ + c.OUT_SEQ, :, :, :] else: in_data = np.zeros(shape=(c.BATCH_SIZE, c.DISPLAY_IN_SEQ, c.H_TEST, c.W_TEST, c.IN_CHANEL)) gt_data = np.zeros(shape=(c.BATCH_SIZE, c.OUT_SEQ, c.H_TEST, c.W_TEST, c.IN_CHANEL)) in_data[:, :, :, :, :] = data[:, :c.DISPLAY_IN_SEQ, :, :, :] gt_data[:, :, :, :, :] = data[:, c. DISPLAY_IN_SEQ:c.DISPLAY_IN_SEQ + c.OUT_SEQ, :, :, :] if type(data) == type([]): break if c.NORMALIZE: in_data = normalize_frames(in_data) gt_data = normalize_frames(gt_data) if mode == 'Valid': mse, mae, gdl, pred = self.model.valid_step(in_data, gt_data) logging.info( f"Iter {iter} {i}: \n\t mse:{mse} \n\t mae:{mae} \n\t gdl:{gdl}" ) else: pred = self.model.pred_step(in_data[:, 5:10]) i += 1 for b in range(c.BATCH_SIZE): predict_date = date_clip[b] logging.info(f"Save {predict_date} results") if mode == "Valid": save_path = os.path.join( c.SAVE_VALID, str(iter), predict_date.strftime("%Y%m%d%H%M")) display_path = os.path.join( c.SAVE_DISPLAY, str(iter), predict_date.strftime("%Y%m%d%H%M")) save_in_data = in_data[b] save_out_data = gt_data[b] save_pred_data = pred[b] else: display_path = os.path.join( c.SAVE_DISPLAY, str(iter), predict_date.strftime("%Y%m%d%H%M")) save_path = os.path.join( c.SAVE_TEST, str(iter), predict_date.strftime("%Y%m%d%H%M")) save_in_data = np.zeros((c.DISPLAY_IN_SEQ, 900, 900, 1)) save_out_data = np.zeros((c.OUT_SEQ, 900, 900, 1)) save_pred_data = np.zeros((c.PREDICT_LENGTH, 900, 900, 1)) save_in_data[:, 90:-90, :, :] = in_data[b] save_out_data[:, 90:-90, :, :] = gt_data[b] save_pred_data[:, 90:-90, :, :] = pred[b] path = os.path.join(save_path, "in") save_png(save_in_data, path) if mode != 'Valid': multi_process_transfer(path, display_path + '/in') path = os.path.join(save_path, "pred") save_png(save_pred_data, path) if mode != 'Valid': os.system(r'./post_processing/postprocessing' + ' ' + save_path) pred_display_dir = os.path.join(display_path, 'pred') multi_process_transfer(path, pred_display_dir) # multi_process_transfer(path, display_path + 'pred') path = os.path.join(save_path, "out") save_png(save_out_data, path) if mode != 'Valid': multi_process_transfer(path, display_path + '/out')
def run_benchmark(self, iter, mode="Test"): if mode == "Valid": time_interval = c.RAINY_VALID stride = 5 else: time_interval = c.RAINY_TEST stride = 1 test_iter = Iterator(time_interval=time_interval, sample_mode="sequent", seq_len=self._in_seq + self._out_seq, stride=1) evaluator = Evaluator(iter, length=self._out_seq, mode=mode) i = 1 while not test_iter.use_up: data, date_clip, *_ = test_iter.sample(batch_size=self._batch) in_data = np.zeros(shape=(self._batch, self._in_seq, self._h, self._w, c.IN_CHANEL)) gt_data = np.zeros(shape=(self._batch, self._out_seq, self._h, self._w, 1)) if type(data) == type([]): break in_data[...] = data[:, :self._in_seq, :, :, :] if c.IN_CHANEL == 3: gt_data[...] = data[:, self._in_seq:self._in_seq + self._out_seq, :, :, :] elif c.IN_CHANEL == 1: gt_data[...] = data[:, self._in_seq:self._in_seq + self._out_seq, :, :, :] else: raise NotImplementedError # in_date = date_clip[0][:c.IN_SEQ] if c.NORMALIZE: in_data = normalize_frames(in_data) gt_data = normalize_frames(gt_data) in_data = crop_img(in_data) gt_data = crop_img(gt_data) mse, mae, gdl, pred = self.g_model.valid_step(in_data, gt_data) evaluator.evaluate(gt_data, pred) self.logger.info( f"Iter {iter} {i}: \n\t mse:{mse} \n\t mae:{mae} \n\t gdl:{gdl}" ) i += 1 if i % stride == 0: if c.IN_CHANEL == 3: in_data = in_data[:, :, :, :, 1:-1] for b in range(self._batch): predict_date = date_clip[b][self._in_seq - 1] self.logger.info(f"Save {predict_date} results") if mode == "Valid": save_path = os.path.join( c.SAVE_VALID, str(iter), predict_date.strftime("%Y%m%d%H%M")) else: save_path = os.path.join( c.SAVE_TEST, str(iter), predict_date.strftime("%Y%m%d%H%M")) path = os.path.join(save_path, "in") save_png(in_data[b], path) path = os.path.join(save_path, "pred") save_png(pred[b], path) path = os.path.join(save_path, "out") save_png(gt_data[b], path) evaluator.done() self.notifier.eval(iter, evaluator.result_path)
def run_benchmark(self, iter, mode="Valid"): if mode == "Valid": time_interval = c.RAINY_VALID else: time_interval = c.RAINY_TEST test_iter = Iterator(time_interval=time_interval, sample_mode="sequent", seq_len=c.IN_SEQ + c.OUT_SEQ, stride=20, mode=mode) i = 1 while not test_iter.use_up: data, date_clip, *_ = test_iter.sample(batch_size=c.BATCH_SIZE) if mode == 'Valid': in_data = np.zeros(shape=(c.BATCH_SIZE, c.IN_SEQ, c.H_TRAIN, c.W_TRAIN, c.IN_CHANEL)) gt_data = np.zeros(shape=(c.BATCH_SIZE, c.OUT_SEQ, c.H_TRAIN, c.W_TRAIN, c.IN_CHANEL)) else: in_data = np.zeros(shape=(c.BATCH_SIZE, c.IN_SEQ, c.H_TEST, c.W_TEST, c.IN_CHANEL)) gt_data = np.zeros(shape=(c.BATCH_SIZE, c.OUT_SEQ, c.H_TEST, c.W_TEST, c.IN_CHANEL)) if type(data) == type([]): break in_data[:, :, :, :, :] = data[:, :c.IN_SEQ, :, :, :] gt_data[:, :, :, :, :] = data[:, c.IN_SEQ:c.IN_SEQ + c.OUT_SEQ, :, :, :] if c.NORMALIZE: in_data = normalize_frames(in_data) gt_data = normalize_frames(gt_data) if mode == 'Valid': mse, mae, gdl, pred = self.model.valid_step(in_data, gt_data) logging.info( f"Iter {iter} {i}: \n\t mse:{mse} \n\t mae:{mae} \n\t gdl:{gdl}" ) else: pred = self.model.pred_step(in_data) i += 1 for b in range(c.BATCH_SIZE): predict_date = date_clip[b] logging.info(f"Save {predict_date} results") if mode == "Valid": save_path = os.path.join( c.SAVE_VALID, str(iter), predict_date.strftime("%Y%m%d%H%M")) else: save_path = os.path.join( c.SAVE_TEST, str(iter), predict_date.strftime("%Y%m%d%H%M")) path = os.path.join(save_path, "in") save_png(in_data[0], path) path = os.path.join(save_path, "pred") save_png(pred[0], path) path = os.path.join(save_path, "out") save_png(gt_data[0], path)
import matplotlib.pyplot as plt from matplotlib import style import numpy as np fig = plt.figure() style.use('ggplot') img = np.fromfile("../figures/johann/johann_fr37_pc.raw", dtype=np.uint16).reshape((992,672)) img[:] = np.flipud(img) plt.imshow(img, cmap="gray", interpolation="none", vmax=10000) plt.colorbar() plt.grid(False) plt.axis('off') #plt.show() from utils import save_png save_png( "johann_fr37_raw", fig, subdir="johann", bbox_inches='tight' )