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'
)
