def eval_epoch(data_loader, model, writer, epoch):
metrics = {
"loss": Mean(),
}
for images in tqdm(data_loader, desc="epoch {} evaluation".format(epoch)):
images_1, targets, images_3 = [image.to(DEVICE) for image in images]
preds, etc = model(images_1, images_3)
loss = compute_loss(input=preds, target=targets)
metrics["loss"].update(loss.data.cpu().numpy())
writer.add_scalar("loss",
metrics["loss"].compute_and_reset(),
global_step=epoch)
writer.add_image("target",
utils.make_grid(denormalize(targets)),
global_step=epoch)
writer.add_image("pred",
utils.make_grid(denormalize(preds)),
global_step=epoch)
with torch.no_grad():
video = make_video(model, images_1, images_3)
writer.add_video("video/interp", video, fps=5, global_step=epoch)
for k in etc:
if k.startswith("flow"):
writer.add_image(k,
utils.make_grid(flow_to_rgb(etc[k])),
global_step=epoch)
else:
writer.add_image(k, utils.make_grid(etc[k]), global_step=epoch)
writer.flush()
def on_epoch_end(self, epoch, logs):
# Initialize GRADCam Class
cam = GradCAM(self.model, self.layer_name)
count = 0
foldername = self.save_dir + '/epoch{}'.format(epoch)
if not os.path.exists(foldername):
os.makedirs(foldername)
for data in self.activation_data:
image = data[0]
image = np.expand_dims(image, 0)
pred = model.predict(image)
classIDx = np.argmax(pred[0])
# Compute Heatmap
heatmap = cam.compute_heatmap(image, classIDx)
image = image.reshape(image.shape[1:])
image = image * 255
image = image.astype(np.uint8)
# Overlay heatmap on original image
heatmap = cv2.resize(heatmap, (image.shape[1], image.shape[0]))
plt.imshow(np.squeeze(image))
plt.imshow(heatmap, alpha=.6, cmap='inferno')
plt.axis('off')
plt.savefig(self.save_dir +
'/epoch{}/out{}.png'.format(epoch, count),
bbox_inches='tight',
transparent=True,
pad_inches=0)
plt.clf()
count += 1
make_grid(foldername)
def test_make_grid():
'Makes 2D grid from list using F or C order'
mk_array = lambda ar: np.array(ar, np.int32)
def ar_eq_(ar1, ar2):
'Asssert equality of two arrays'
for pair in zip(ar1.flatten(), ar2.flatten()):
eq_(*pair)
pairs = ((([0, 3], [1, 4], [2, 5]),
make_grid(3, 2, top0=True, lst=range(6),
order='F')), (([1, 3], [0, 2]),
make_grid(2,
2,
top0=False,
lst=range(4),
order='F')),
(([0, 1], [2,
3]), make_grid(2,
2,
top0=True,
lst=range(4),
order='C')))
for ar, grid in pairs:
ar_eq_(mk_array(ar), grid)
def main():
logging.basicConfig(level=logging.INFO)
args = build_parser().parse_args()
logging.info(args_to_string(args))
fix_seed(args.seed)
data_loader = torch.utils.data.DataLoader(
Dataset(args.dataset_path),
batch_size=args.batch_size,
shuffle=True,
num_workers=os.cpu_count(),
drop_last=True,
)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
encoder = Encoder(args.model_size, args.latent_size)
decoder = Decoder(args.model_size, args.latent_size)
encoder.to(device)
decoder.to(device)
opt = torch.optim.Adam(list(encoder.parameters()) +
list(decoder.parameters()),
lr=args.learning_rate)
noise_dist = torch.distributions.Normal(0, 1)
writer = SummaryWriter(args.experiment_path)
metrics = {"loss": Mean()}
for epoch in range(args.epochs):
encoder.train()
decoder.train()
for real, _ in tqdm(data_loader,
desc="epoch {} training".format(epoch)):
real = real.to(device)
mean, log_var = encoder(real)
latent = noise_dist.sample(
(args.batch_size, args.latent_size)).to(device)
latent = mean + latent * torch.exp(log_var / 2)
fake = decoder(latent)
# TODO: loss (reconstruction, summing, mean)
mse = F.mse_loss(input=fake, target=real)
kld = -0.5 * (1 + log_var - mean**2 - log_var.exp()).sum(-1)
loss = mse.mean() + kld.mean()
metrics["loss"].update(loss.data.cpu().numpy())
opt.zero_grad()
loss.mean().backward()
opt.step()
writer.add_scalar("loss",
metrics["loss"].compute_and_reset(),
global_step=epoch)
writer.add_image("real",
utils.make_grid((real + 1) / 2),
global_step=epoch)
writer.add_image("fake",
utils.make_grid((fake + 1) / 2),
global_step=epoch)
def pathfinder(algorithm, name, win, win_rows, win_width, line_height):
pygame.display.set_caption(name)
grid = utils.make_grid(win_rows, line_height)
start = None
end = None
run = True
started = False
while run:
utils.draw(win, grid, win_rows, win_width, line_height=line_height)
for event in pygame.event.get():
if utils.is_quit(event):
run = False
if started:
continue
if pygame.mouse.get_pressed()[0]:
pos = pygame.mouse.get_pos()
row, col = utils.get_clicked_pos(pos, win_rows, win_width,
line_height)
if row >= 0 and col >= 0:
spot = grid[row][col]
if not start and spot != end:
start = spot
start.make_start()
elif not end and spot != start:
end = spot
end.make_end()
elif spot != end and spot != start:
spot.make_barrier()
elif pygame.mouse.get_pressed()[2]:
pos = pygame.mouse.get_pos()
row, col = utils.get_clicked_pos(pos, win_rows, win_width,
line_height)
if row >= 0 and col >= 0:
spot = grid[row][col]
spot.reset()
if spot == start:
start = None
elif spot == end:
end = None
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and start and end:
for row in grid:
for spot in row:
spot.update_neighbors(grid)
algorithm(
lambda: utils.draw(win, grid, win_rows, win_width,
line_height), grid, start, end)
if event.key == pygame.K_c:
start = None
end = None
grid = utils.make_grid(win_rows, line_height)
def make_sprite(label_img, save_path):
import math
nrow = int(math.floor(math.sqrt(label_img.shape[0])))
xx = utils.make_grid(np.zeros((1, 3, 32, 32)), padding=0)
if xx.shape[2] == 33: # https://github.com/pytorch/vision/issues/206
sprite = utils.make_grid(label_img, nrow=nrow, padding=0)
sprite = sprite[:, 1:, 1:]
utils.save_image(sprite, os.path.join(save_path, 'sprite.png'))
else:
utils.save_image(label_img,
os.path.join(save_path, 'sprite.png'),
nrow=nrow,
padding=0)
def generate_data_walk(self, real, number):
self.model.eval()
if not os.path.exists('interpolated_images/'):
os.makedirs('interpolated_images/')
print('interpolating')
# Interpolate between the noise(z1, z2) with number_int steps between
number_int = 10
img1 = real[0]
img2 = real[1]
images = []
alpha_step = 1.0 / float(number_int + 1)
print(alpha_step)
alpha = 0
for i in range(1, number_int + 1):
img = img1 * alpha + img2 * (1.0 - alpha)
alpha += alpha_step
im = img.mul(0.5).add(0.5) #denormalize
images.append(im.view(3, 32, 32).data.cpu())
grid = utils.make_grid(images, nrow=number_int)
utils.save_image(grid,
'interpolated_images/data_interpolated_{}.png'.format(
str(number).zfill(3)),
nrow=8)
print(
"Saved data interpolated images to interpolated_images/interpolated_{}."
.format(str(number).zfill(3)))
def generate_latent_walk_disentangled(self, number):
self.model.eval()
if not os.path.exists('interpolated_images/'):
os.makedirs('interpolated_images/')
z = torch.randn(1, 100)
for i in range(10, 90):
z1 = torch.clone(z).cuda()
images = []
lower_lim = -1.0
step_size = 0.2
for j in range(10):
z1[0, i] = lower_lim + step_size
lower_lim += step_size
fake_im = self.model.generator(z1)
fake_im = fake_im.mul(0.5).add(0.5) #denormalize
images.append(fake_im.view(3, 32, 32).data.cpu())
grid = utils.make_grid(images, nrow=10)
utils.save_image(
grid,
'interpolated_images/varying_dim-{}_{}_epoch{}.png'.format(
str(i), str(j),
str(number).zfill(3)))
print(
"Saved disentangled interpolated images to interpolated_images/interpolated_{}."
.format(str(number).zfill(3)))
def fit(self, X, num_epoch=50, seed=0, f_resolution=10, init='random'):
N, D = X.shape
if init != 'random':
Z = init.copy()
else:
width = (max(self.clipping) - min(self.clipping))
mid = sum(self.clipping) / 2
low, high = mid - self.scale * width, mid + self.scale * width
np.random.seed(seed)
Z = np.random.uniform(low=low, high=high, size=(N, self.L))
X, Z = jnp.array(X), jnp.array(Z)
history = dict(E=np.zeros((num_epoch, )),
Y=np.zeros((num_epoch, N, D)),
f=np.zeros((num_epoch, f_resolution**self.L, D)),
Z=np.zeros((num_epoch, N, self.L)))
for epoch in tqdm(range(num_epoch)):
Y = estimate_f(Z, Z, X, self.sigma)
Z = estimate_z(X, Z, self.sigma, self.eta, self.clipping)
Z_new = make_grid(f_resolution, (Z.min(), Z.max()))
Z_new = jnp.array(Z_new)
Y_new = estimate_f(Z_new, Z, X, self.sigma)
history['E'][epoch] = np.sum((Y - X)**2) / N
history['Y'][epoch] = np.array(Y)
history['Z'][epoch] = np.array(Z)
history['f'][epoch] = np.array(Y_new)
return history
def get_keyboard(self):
ntf = self.next_to_fill()
try:
return self.basic_keyboards[ntf](self)
except KeyError:
pass
try:
hint = self.hints[ntf](self)
except KeyError:
return None
if self.more:
hint = territories - hint
keyboard = make_grid(sorted(hint, key=str.casefold))
keyboard.append(["More..."])
if ntf == "TERR" and self.terrs:
if not self.terr_remove:
keyboard.append(["Remove"])
else:
keyboard.append(["Add"])
keyboard.append(["Done"])
keyboard.append(["Back"])
return RKM(keyboard)
def fit(self, X, num_epoch=50, seed=0, f_resolution=10, init='random'):
N, D = X.shape
if init != 'random':
Z = init.copy()
else:
np.random.seed(seed)
Z = np.random.normal(scale=self.scale, size=(N, self.L))
history = dict(E=np.zeros((num_epoch, )),
Y=np.zeros((num_epoch, N, D)),
f=np.zeros((num_epoch, f_resolution**self.L, D)),
Z=np.zeros((num_epoch, N, self.L)))
for epoch in tqdm(range(num_epoch)):
Y, R = self.estimate_f(X, Z)
Z = self.estimate_e(X, Y, Z, R)
Z_new = make_grid(f_resolution,
bounds=(np.min(Z), np.max(Z)),
dim=self.L)
f, _ = self.estimate_f(X, Z_new, Z)
history['Y'][epoch] = Y
history['f'][epoch] = f
history['Z'][epoch] = Z
history['E'][epoch] = np.sum(
(Y - X)**2) / N + self.λ * np.sum(Z**2)
return history
def show_retreats_prompt(self, bot, game, player):
try:
t = next(t1 for t1, k, t2 in player.retreat_choices if t2 is None)
except StopIteration:
message = "The following retreats will be attempted:\n\n"
for t1, k, t2 in player.retreat_choices:
message += "{}-{}\n".format(t1, t2)
message += "\nIs this correct"
keyboard = [
["Yes", "No"],
]
bot.send_message(player.id, message, reply_markup=RKM(keyboard))
return
keyboard = make_grid(sorted(player.retreats[t], key=str.casefold))
keyboard.append(["Disband"])
if next(t2 for t1, k, t2 in player.retreat_choices) is not None:
keyboard.append(["Back"])
bot.send_message(player.id,
"Where should {} retreat to?".format(t),
reply_markup=RKM(keyboard))
def fit(self, X, num_epoch=50, seed=0, f_resolution=10, init='random'):
N, D = X.shape
if init != 'random':
Z = init.copy()
else:
width = (max(self.clipping) - min(self.clipping))
mid = sum(self.clipping) / 2
low, high = mid - self.scale*width, mid + self.scale* width
np.random.seed(seed)
Z = np.random.uniform(low=low, high=high, size=(N, self.L))
history = dict(
E=np.zeros((num_epoch,)),
Y=np.zeros((num_epoch, N, D)),
f=np.zeros((num_epoch, f_resolution**self.L, D)),
Z=np.zeros((num_epoch, N, self.L)))
for epoch in tqdm(range(num_epoch)):
Y, R = self.estimate_f(X, Z)
Z = self.estimate_e(X, Y, Z, R)
Z_new = make_grid(f_resolution,
bounds=(np.min(Z), np.max(Z)),
dim=self.L)
f, _ = self.estimate_f(X, Z_new, Z)
history['Y'][epoch] = Y
history['f'][epoch] = f
history['Z'][epoch] = Z
history['E'][epoch] = np.sum((Y - X)**2) / N
return history
def generate_latent_walk(self, number):
self.model.eval()
if not os.path.exists('interpolated_images/'):
os.makedirs('interpolated_images/')
print('interpolating')
# Interpolate between the noise(z1, z2) with number_int steps between
number_int = 10
z_intp = torch.FloatTensor(1, 100)
z1 = torch.randn(1, 100)
z2 = torch.randn(1, 100)
z_intp = z_intp.cuda()
z1 = z1.cuda()
z2 = z2.cuda()
z_intp = Variable(z_intp)
images = []
alpha_step = 1.0 / float(number_int + 1)
print(alpha_step)
alpha = 0
for i in range(1, number_int + 1):
z_intp.data = z1 * alpha + z2 * (1.0 - alpha)
alpha += alpha_step
fake_im = self.model.generator(z_intp)
fake_im = fake_im.mul(0.5).add(0.5) #denormalize
images.append(fake_im.view(3, 32, 32).data.cpu())
grid = utils.make_grid(images, nrow=number_int)
utils.save_image(
grid, 'interpolated_images/interpolated_{}.png'.format(
str(number).zfill(3)))
print(
"Saved latent interpolated images to interpolated_images/interpolated_{}."
.format(str(number).zfill(3)))
def test_ind_to_ij():
'''Consistency of make_grid (which maps list to 2D grid) and ind_to_ij
which maps list index to ij position on grid'''
height, width = 3,2
grid = make_grid(height,width,lst=range(height*width),order='F')
for ind in range(height*width):
ij = tuple( ind_to_ij(height,width,ind,'F') )
eq_( grid[ij], ind )
def test_ind_to_ij():
'''Consistency of make_grid (which maps list to 2D grid) and ind_to_ij
which maps list index to ij position on grid'''
height, width = 3, 2
grid = make_grid(height, width, lst=range(height * width), order='F')
for ind in range(height * width):
ij = tuple(ind_to_ij(height, width, ind, 'F'))
eq_(grid[ij], ind)
def make_image(trainer):
fake = G(inputv, test=True)
fake = chainer.cuda.to_cpu(fake.data)
img = make_grid(fake)
img = np.asarray(np.transpose(np.clip((img + 1) * 127.5, 0, 255),
(1, 2, 0)),
dtype=np.uint8)
imsave(os.path.join(dst, name.format(trainer.updater.iteration)), img)
def log(phase):
writer.add_scalar(f'{phase}_loss', loss.item(), global_step)
if i % args.display_freq == 0:
recon = torch.cat((x[0], x_[0]), dim=2)
latent = make_grid(z[0].unsqueeze(1), 4, 4)
if args.display:
view_in.render(recon)
view_z.render(latent)
writer.add_image(f'{phase}_recon', recon, global_step)
writer.add_image(f'{phase}_latent', latent.squeeze(0), global_step)
def test_make_grid():
'Makes 2D grid from list using F or C order'
mk_array = lambda ar: np.array(ar,np.int32)
def ar_eq_(ar1,ar2):
'Asssert equality of two arrays'
for pair in zip( ar1.flatten(), ar2.flatten() ):
eq_(*pair)
pairs = ( ( ([0,3],[1,4],[2,5]),
make_grid(3,2, top0=True, lst = range(6), order='F') ),
( ([1,3],[0,2]),
make_grid( 2, 2,top0=False, lst = range(4), order='F') ),
( ([0,1],[2,3]),
make_grid( 2, 2, top0=True, lst = range(4), order='C') ) )
for ar,grid in pairs:
ar_eq_( mk_array(ar), grid)
def sample(self, padding=2):
dpi = 100
try:
fake_X = self.generator(self.fixed_z, self.sample_y).detach().cpu()
images = make_grid(fake_X,
samples_per_class=self.samples_per_class,
num_classes=self.num_classes,
padding=padding,
im_size=self.sample_im_size)
if (self.current_epoch % self.checkpoint_every) == 0:
y_labels = [
'AK', 'BCC', 'BKL', 'DF', 'MEL', 'NV', 'SCC', 'VASC'
]
y_ptr = self.sample_im_size // 2
y_locs = []
while y_ptr < images.shape[0]:
y_locs.append(y_ptr)
y_ptr += (self.sample_im_size + padding)
assert len(y_labels) == len(y_locs)
fig, ax = plt.subplots(figsize=(images.shape[1] / dpi,
images.shape[0] / dpi),
dpi=dpi)
ax.imshow(images, interpolation='nearest')
ax.set_xticks([])
plt.yticks(ticks=y_locs, labels=y_labels)
plt.savefig(self.checkpoint_path +
'samples/{}.png'.format(self.current_epoch),
bbox_inches='tight',
dpi=dpi)
# CLOSE THE FIGURE.
plt.close(fig)
#if (self.current_epoch % self.show_every) == 0:
# plt.show()
except AttributeError:
n_samples = self.num_classes * self.samples_per_class
sample_y = np.repeat(np.arange(self.num_classes),
self.samples_per_class)
self.sample_y = torch.LongTensor(sample_y).to(self.device)
self.fixed_z = torch.FloatTensor(size=(n_samples,
self.z_dim)).normal_(
0., 1.).to(self.device)
self.sample()
def make_image(trainer):
with chainer.using_config("Train", False):
with chainer.no_backprop_mode():
fake = G(inputv)
fake = chainer.cuda.to_cpu(fake.data)
img = make_grid(fake)
img = np.asarray(np.transpose(
np.clip((img + 1) * 127.5, 0, 255), (1, 2, 0)),
dtype=np.uint8)
imsave(
os.path.join(dst, name.format(trainer.updater.iteration)),
img)
def _make_images_board(self, model):
model.eval()
num_imgs = 64
fuseTrans = self.cfg.fuseTrans
batch = next(iter(self.data_loaders[1]))
input_images, renderTrans, depthGT, maskGT = utils.unpack_batch_novel(batch, self.cfg.device)
with torch.set_grad_enabled(False):
XYZ, maskLogit = model(input_images)
# ------ build transformer ------
XYZid, ML = transform.fuse3D(
self.cfg, XYZ, maskLogit, fuseTrans) # [B,3,VHW],[B,1,VHW]
newDepth, newMaskLogit, collision = transform.render2D(
self.cfg, XYZid, ML, renderTrans) # [B,N,1,H,W]
return {'RGB': utils.make_grid( input_images[:num_imgs]),
'depth': utils.make_grid(
((1-newDepth)*(collision==1).float())[:num_imgs, 0, 0:1, :, :]),
'depthGT': utils.make_grid(
1-depthGT[:num_imgs, 0, 0:1, :, :]),
'mask': utils.make_grid(
torch.sigmoid(maskLogit[:num_imgs, 0:1,:, :])),
'mask_rendered': utils.make_grid(
torch.sigmoid(newMaskLogit[:num_imgs, 0, 0:1, :, :])),
'maskGT': utils.make_grid(
maskGT[:num_imgs, 0, 0:1, :, :]),
}
def _make_images_board(self, model):
model.eval()
num_imgs = 64
batch = next(iter(self.data_loaders[1]))
input_images, depthGT, maskGT = utils.unpack_batch_fixed(
batch, self.cfg.device)
with torch.set_grad_enabled(False):
XYZ, maskLogit = model(input_images)
XY = XYZ[:, :self.cfg.outViewN * 2, :, :]
depth = XYZ[:, self.cfg.outViewN * 2:self.cfg.outViewN * 3, :, :]
mask = (maskLogit > 0).float()
return {
'RGB':
utils.make_grid(input_images[:num_imgs]),
'depth':
utils.make_grid(1 - depth[:num_imgs, 0:1, :, :]),
'depth_mask':
utils.make_grid(((1 - depth) * mask)[:num_imgs, 0:1, :, :]),
'depthGT':
utils.make_grid(1 - depthGT[:num_imgs, 0:1, :, :]),
'mask':
utils.make_grid(torch.sigmoid(maskLogit[:num_imgs, 0:1, :, :])),
'maskGT':
utils.make_grid(maskGT[:num_imgs, 0:1, :, :]),
}
def _make_images_board(self, model):
model.eval()
num_imgs = 64
fuseTrans = self.cfg.fuseTrans
batch = next(iter(self.data_loaders[1]))
input_images, renderTrans, depthGT, maskGT = utils.unpack_batch_novel(
batch, self.cfg.device)
with torch.set_grad_enabled(False):
XYZ, maskLogit = model(input_images)
# ------ build transformer ------
XYZid, ML = transform.fuse3D(self.cfg, XYZ, maskLogit,
fuseTrans) # [B,3,VHW],[B,1,VHW]
newDepth, newMaskLogit, collision = transform.render2D(
self.cfg, XYZid, ML, renderTrans) # [B,N,1,H,W]
return {
'RGB':
utils.make_grid(input_images[:num_imgs]),
'depth':
utils.make_grid(
((1 - newDepth) * (collision == 1).float())[:num_imgs, 0,
0:1, :, :]),
'depthGT':
utils.make_grid(1 - depthGT[:num_imgs, 0, 0:1, :, :]),
'mask':
utils.make_grid(torch.sigmoid(maskLogit[:num_imgs, 0:1, :, :])),
'mask_rendered':
utils.make_grid(
torch.sigmoid(newMaskLogit[:num_imgs, 0, 0:1, :, :])),
'maskGT':
utils.make_grid(maskGT[:num_imgs, 0, 0:1, :, :]),
}
def show_build_prompt(self, bot, game, player):
try:
t, k, c = player.units_choices[-1]
except IndexError:
t, k, c = True, True, True
if not k:
message = "What kind of unit do you want to build?"
keyboard = [["Army", "Fleet"], ["Back"]]
elif not c and t in split_coasts and k == "F":
message = "On which coast?"
keyboard = [["North", "South"], ["Back"]]
elif not player.units_delta or player.units_done:
if not player.units_choices:
message = "No new units will be built."
elif len(player.units_choices) == 1:
message = ("This new unit will be built:\n\n" +
self.format_build(player.units_choices))
else:
message = ("These new units will be built:\n\n" +
self.format_build(player.units_choices))
message += "\nAre you sure?"
keyboard = [["Yes", "No"]]
else:
keyboard = make_grid(
sorted(player.units_options -
{t
for t, k, c in player.units_choices},
key=str.casefold))
keyboard.append(["Done"])
if not player.units_choices:
message = "Where do you want to build?"
else:
message = ("Currently building:\n\n" +
self.format_build(player.units_choices) +
"\nWhat else?")
keyboard.append(["Back"])
bot.send_message(player.id, message, reply_markup=RKM(keyboard))
def make_video(model, images_1, images_3):
interp_video = []
interp_video.append(torch.zeros_like(images_1))
interp_video.append(denormalize(images_1))
for t in np.arange(0.1, 1.0, 0.1):
preds, etc = model(images_1, images_3, t=t)
interp_video.append(denormalize(preds))
interp_video.append(denormalize(images_3))
interp_video.append(torch.zeros_like(images_3))
interp_video = [utils.make_grid(images) for images in interp_video]
interp_video = torch.stack(interp_video, 0).unsqueeze(0)
return interp_video
def show_disband_prompt(self, bot, game, player):
if not player.units_delta:
message = ("These units will be disbanded: {}\n"
"Are you sure?".format(", ".join(player.units_choices)))
keyboard = [["Yes", "No"]]
else:
keyboard = make_grid(
sorted(player.units_options.difference(player.units_choices),
key=str.casefold))
if not player.units_choices:
message = "Which unit should be disbanded{}?".format(
" first" if len(player.units_options) > 1 else "")
else:
message = "Disbanding {}. Who else?".format(", ".join(
player.units_choices))
keyboard.append(["Back"])
bot.send_message(player.id, message, reply_markup=RKM(keyboard))
def _make_images_board(self, model):
model.eval()
num_imgs = 64
fuseTrans = self.cfg.fuseTrans
batch = next(iter(self.data_loaders[1]))
input_images, renderTrans, depthGT, maskGT = utils.unpack_batch_novel(batch, self.cfg.device)
with torch.set_grad_enabled(False):
XYZ, maskLogit = model(input_images)
##################################
tmp_1 = torch.cat([maskLogit[:,0:1,:,:],maskLogit[:,2:3,:,:],maskLogit[:,4:5,:,:],
maskLogit[:,6:7,:,:],maskLogit[:,7:8,:,:],maskLogit[:,9:10,:,:],
maskLogit[:,11:12,:,:],maskLogit[:,13:14,:,:]],1)
#print(tmp_1.size())
tmp_2 = torch.cat([maskLogit[:,1:2,:,:],maskLogit[:,3:4,:,:],maskLogit[:,5:6,:,:],
maskLogit[:,7:8,:,:],maskLogit[:,9:10,:,:],maskLogit[:,11:12,:,:],
maskLogit[:,13:14,:,:],maskLogit[:,15:16,:,:]],1)
#mask = (maskLogit > 0).byte()
maskLogit = (maskLogit[:,8:16,:,:] > 0).byte()
maskLogit = maskLogit.float()
#mask = (tmp_2 > 0).byte()
# print(mask.size())
###################################
# ------ build transformer ------
XYZid, ML = transform.fuse3D(
self.cfg, XYZ, maskLogit, fuseTrans) # [B,3,VHW],[B,1,VHW]
newDepth, newMaskLogit, collision = transform.render2D(
self.cfg, XYZid, ML, renderTrans) # [B,N,1,H,W]
return {'RGB': utils.make_grid( input_images[:num_imgs]),
'depth': utils.make_grid(
((1-newDepth)*(collision==1).float())[:num_imgs, 0, 0:1, :, :]),
'depthGT': utils.make_grid(
1-depthGT[:num_imgs, 0, 0:1, :, :]),
'mask': utils.make_grid(
torch.sigmoid(maskLogit[:num_imgs, 0:1,:, :])),
'mask_rendered': utils.make_grid(
torch.sigmoid(newMaskLogit[:num_imgs, 0, 0:1, :, :])),
'maskGT': utils.make_grid(
maskGT[:num_imgs, 0, 0:1, :, :]),
}
def _make_images_board(self, model):
model.eval()
num_imgs = 64
batch = next(iter(self.data_loaders[1]))
input_images, depthGT, maskGT = utils.unpack_batch_fixed(batch, self.cfg.device)
with torch.set_grad_enabled(False):
XYZ, maskLogit = model(input_images)
XY = XYZ[:, :self.cfg.outViewN * 2, :, :]
depth = XYZ[:, self.cfg.outViewN * 2:self.cfg.outViewN * 3, :, :]
mask = (maskLogit > 0).float()
return {'RGB': utils.make_grid(input_images[:num_imgs]),
'depth': utils.make_grid(1-depth[:num_imgs, 0:1, :, :]),
'depth_mask': utils.make_grid(
((1-depth)*mask)[:num_imgs, 0:1, :, :]),
'depthGT': utils.make_grid(
1-depthGT[:num_imgs, 0:1, :, :]),
'mask': utils.make_grid(
torch.sigmoid(maskLogit[:num_imgs, 0:1,:, :])),
'maskGT': utils.make_grid(maskGT[:num_imgs, 0:1, :, :]),
}
def main(win, width):
ROWS = 10
grid = make_grid(ROWS, width)
start = None
end = None
target = None
boxes = []
targets = []
# default algorithm
algorithms = itertools.cycle([astar, bfs])
algorithm = next(algorithms)
print(f'Current Algorithm {algorithm.__name__}')
run = True
while run:
draw(win, grid, ROWS, width)
for event in pygame.event.get():
# quitting the window
if event.type == pygame.QUIT:
run = False
# keyboard events
if event.type == pygame.KEYDOWN:
# the algorithm
if event.key == pygame.K_SPACE and start and len(boxes):
# automated process
while len(targets) > 0 and len(boxes) > 0:
# clearing the grid except for start, boxes and barriers
start, grid = clear_grid(grid, all=False)
for row in grid:
for spot in row:
spot.update_neighbors(grid)
path, end = algorithm(
lambda: draw(win, grid, ROWS, width), grid, start,
end, boxes, targets, 'box')
# if the algorithm found a path
if path:
print('got the path')
# clear the opened and colosed spots
start, grid = clear_grid(grid,
all=False,
path=False)
end.make_thebox()
# Walking the robot
start, boxes, targets = walking_robot(
lambda: draw(win, grid, ROWS, width),
start,
path,
end,
boxes,
targets,
task='pickup')
# re-coloring the targets
for t in targets:
t.make_target()
for b in boxes:
b.make_end()
# switch to searching for target locations
path, end = algorithm(
lambda: draw(win, grid, ROWS, width), grid,
start, end, boxes, targets, 'target')
if path:
print('got the targets path')
# clear the opened and colosed spots
start, grid = clear_grid(grid,
all=False,
path=False)
end.make_thebox()
# Walking the robot
start, boxes, targets = walking_robot(
lambda: draw(win, grid, ROWS, width),
start,
path,
end,
boxes,
targets,
task='putdown')
# re-coloring the targets
print(
f'Number of targets after the movement: {len(targets)}'
)
for t in targets:
t.make_target()
for b in boxes:
b.make_end()
else:
print('Stuck')
break
else:
print('Stuck')
break
# Changing algorithm
if event.key == pygame.K_LCTRL:
algorithm = next(algorithms)
print(f'Current Algorithm {algorithm.__name__}')
# clearing the grid except for start, boxes and barriers
time.sleep(0.4)
start, grid = clear_grid(grid, all=False)
# clearing the grid
if event.key == pygame.K_c:
start, grid = clear_grid(grid)
boxes.clear()
targets.clear()
# Adding A Robot
if event.key == pygame.K_r:
# if pygame.mouse.get_pressed()[0]: # left mouse click
pos = pygame.mouse.get_pos()
row, col = get_clicked_pos(pos, ROWS, width)
spot = grid[row][col]
if not start and spot not in boxes and spot not in targets:
start = spot
start.make_start()
# Adding boxes
if event.key == pygame.K_b:
# if pygame.mouse.get_pressed()[0]: # left mouse click
pos = pygame.mouse.get_pos()
row, col = get_clicked_pos(pos, ROWS, width)
spot = grid[row][col]
if spot != start and spot != end and spot not in boxes and spot not in targets:
end = spot
end.make_end()
boxes.append(end)
print(f'Number of Boxes: {len(boxes)}')
# Adding Targets
if event.key == pygame.K_t:
pos = pygame.mouse.get_pos()
row, col = get_clicked_pos(pos, ROWS, width)
spot = grid[row][col]
if spot != start and spot != end and spot not in boxes and spot not in targets:
target = spot
target.make_target()
targets.append(target)
print(f'Number of Targets {len(targets)}')
# Adding Barriers
if event.key == pygame.K_p:
pos = pygame.mouse.get_pos()
row, col = get_clicked_pos(pos, ROWS, width)
spot = grid[row][col]
if spot != start and spot not in boxes and spot not in targets:
spot.make_barrier()
# clearning spots
if pygame.mouse.get_pressed()[2]: # right mouse click
pos = pygame.mouse.get_pos()
row, col = get_clicked_pos(pos, ROWS, width)
spot = grid[row][col]
spot.reset()
if spot == start:
start = None
elif spot in boxes:
boxes.remove(spot)
end = None
elif spot in targets:
targets.remove(spot)
target = None
print(f'Number of Boxes : {len(boxes)}')
print(f'Number of Targets: {len(targets)}')
# quit the window if it exits the while loop
pygame.quit()
"west": True,
}
if stretch["west"]:
maxdx = stretchfactorx * dx
nstrx = int(Lstretchx / dx)
dxvec[:nstrx] = maxdx - (maxdx - dx) / nstrx * np.arange(nstrx)
assert dxvec[0] == maxdx
assert dxvec[nstrx] == dx
x = np.insert(np.cumsum(dxvec), 0, 0)
y = np.insert(np.cumsum(dyvec), 0, 0)
print("Making grid...")
grid = utils.process_cdl_output("./grd_spherical.nc", nx, ny, nz, spherical)
grid = utils.make_grid(grid, x, y)
# sponges
Lsponge = 7e3
sponges = {
"east": False,
"west": True,
"north": False,
"south": False,
}
nspx = int(Lsponge / dx)
nspy = int(Lsponge / dy)
visc_factor = xr.zeros_like(grid.visc_factor)
if sponges["west"]:
def main():
toTensor = transforms.Compose([transforms.ToTensor()])
toPILImg = transforms.ToPILImage()
# Build model
print('Loading model ...\n')
net = FeaturesBlockDualNet(channels=1)
device_ids = [0]
model = nn.DataParallel(net, device_ids=device_ids).cuda()
model.load_state_dict(
torch.load(os.path.join(
opt.logdir, 'FBDN_nl25_30.6378.pth'))) # Input model's path files.
model.eval()
# load data info
print('Loading data info ...\n')
files_source = glob.glob(os.path.join('data', opt.test_data, '*.png'))
files_source.sort()
# process data
psnr_test = 0
for f in files_source:
# image
Img = cv2.imread(f)
Img = normalize(np.float32(Img[:, :, 0]))
Img = np.expand_dims(Img, 0)
Img = np.expand_dims(Img, 1)
ISource = torch.Tensor(Img)
# noise
noise = torch.FloatTensor(ISource.size()).normal_(mean=0,
std=opt.test_noiseL /
255.)
# noisy image
INoisy = ISource + noise
ISource, INoisy = Variable(ISource.cuda()), Variable(INoisy.cuda())
with torch.no_grad(): # this can save much memory
Out = torch.clamp(model(INoisy), 0., 1.)
## if you are using older version of PyTorch, torch.no_grad() may not be supported
# ISource, INoisy = Variable(ISource.cuda(),volatile=True), Variable(INoisy.cuda(),volatile=True)
# Out = torch.clamp(INoisy-model(INoisy), 0., 1.)
psnr = batch_PSNR(Out, ISource, 1.)
psnr_test += psnr
print("%s PSNR %f" % (f, psnr))
# Tensor to Image.
clean_img = utils.make_grid(ISource.data,
nrow=8,
normalize=True,
scale_each=True)
denoising_img = utils.make_grid(Out.data,
nrow=8,
normalize=True,
scale_each=True)
# Image Plot.
fig = plt.figure()
rows = 1
cols = 2
ax1 = fig.add_subplot(rows, cols, 1)
ax1.imshow(np.transpose(clean_img.cpu(), (1, 2, 0)), cmap="gray")
ax1.set_title('clean image')
ax2 = fig.add_subplot(rows, cols, 2)
ax2.imshow(np.transpose(denoising_img.cpu(), (1, 2, 0)), cmap="gray")
ax2.set_title('denoising image')
plt.show()
result_img = torch.clamp(denoising_img * 255, 0, 255)
result_img = np.uint8(result_img.cpu())
imwrite('./fig_result/denoising/' + f,
np.transpose(result_img, (1, 2, 0)))
psnr_test /= len(files_source)
print("\nPSNR on test data %f" % psnr_test)
def main_loop():
window = pygame.display.set_mode((WIDTH, WIDTH))
pygame.display.set_caption('A* Pathfinding Algorithm Visualisation')
rows = 50
width = WIDTH
grid = utils.make_grid(rows, width)
start_spot = None
end_spot = None
run_loop = True
while run_loop:
utils.draw(window, grid, rows, width)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run_loop = False
if pygame.mouse.get_pressed()[0]: #left mouse button = draw
pos = pygame.mouse.get_pos()
row, col = utils.get_click_pos(pos, rows, width)
spot = grid[row][col]
if not start_spot and spot != end_spot:
start_spot = spot
start_spot.make_start()
elif not end_spot and spot != start_spot:
end_spot = spot
end_spot.make_end()
elif spot != start_spot and spot != end_spot:
spot.make_wall()
elif pygame.mouse.get_pressed()[2]: #right mouse button - erase
pos = pygame.mouse.get_pos()
row, col = utils.get_click_pos(pos, rows, width)
spot = grid[row][col]
spot.reset()
if spot == start_spot:
start_spot = None
elif spot == end_spot:
end_spot = None
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and start_spot and end_spot:
for row in grid:
for spot in row:
spot.update_neighbors(grid)
utils.pathfinding_algorithm(lambda: utils.draw(window, grid, rows, width), grid, start_spot, end_spot)
if event.key == pygame.K_c:
start_spot = None
end_spot = None
grid = utils.make_grid(rows, width)
pygame.quit()
def main(win, width, ROWS=30):
global chosenAlgo
# initial values are created
ROWS = slider.getValue()
if ROWS > 25 and ROWS % 2 == 0 and ROWS != 40:
ROWS += 1
grid = make_grid(ROWS, width)
start = None
end = None
run = True
if chosenAlgo == "Github":
choseAlgo = "A*M"
# this while run is here to make the pygame window run untill you close it
while run:
events = pygame.event.get()
draw(win, grid, ROWS, width)
pygame.display.update()
# the event listening is all made here
for event in pygame.event.get():
# the quit event that reroutes you back to the main_menu function
# NOTE THIS FUNCTION IS CALLED FROM WITHIN THE MAIN_MENU FUNCTION THAT IS WHY THIS WORKS
if event.type == pygame.QUIT:
run = False
# event call for LMB, it draws either a start or an end or a block
if pygame.mouse.get_pressed()[0]:
try:
pos = pygame.mouse.get_pos()
row, col = get_clicked_pos(pos, ROWS, width)
node = grid[row][col]
if not start and node != end:
start = node
start.make_start()
elif not end and node != start:
end = node
end.make_end()
elif node != end and node != start:
node.make_blocked()
except:
continue
# event call for MMB, it clears the path found in the prev run
elif pygame.mouse.get_pressed()[1]:
for row in grid:
for node in row:
if node.is_path():
node.reset()
# event call RMB, deleting any block clicked on
elif pygame.mouse.get_pressed()[2]:
pos = pygame.mouse.get_pos()
row, col = get_clicked_pos(pos, ROWS, width)
node = grid[row][col]
node.reset()
if node == start:
start = None
elif node == end:
end = None
# event listener for KEYBOARD press
if event.type == pygame.KEYDOWN:
# if SPACE is pressed than run the A* algorithm
if event.key == pygame.K_SPACE and start and end:
for row in grid:
for node in row:
if node.is_closed() or node.is_open(
) or node.is_path():
node.reset()
for row in grid:
for node in row:
node.update_neighbors(grid)
if chosenAlgo == "A*" or chosenAlgo == "A*M":
aStar_algorithm(lambda: draw(win, grid, ROWS, width),
grid, start, end)
if chosenAlgo == "BFS":
bfs(lambda: draw(win, grid, ROWS, width), grid, start,
end)
elif chosenAlgo == "Dijkstra" or chosenAlgo == "DijkstraM":
Dijkstra_algorithm(
lambda: draw(win, grid, ROWS, width), grid, start,
end)
# if c in pressed than clear the current grid
if event.key == pygame.K_c:
start = None
end = None
grid = make_grid(ROWS, width)
if event.key == pygame.K_g:
generate_walls(lambda: draw(win, grid, ROWS, width), grid,
len(grid), start, end)
