def __call__(self, D, G, input, target): loss_D = 0 loss_G = 0 loss_G_FM = 0 fake = G(input) real_features = D(torch.cat((input, target), dim=1)) fake_features = D(torch.cat((input, fake.detach()), dim=1)) for i in range(self.n_D): real_grid = get_grid(real_features[i][-1], is_real=True).to(self.device, self.dtype) fake_grid = get_grid(fake_features[i][-1], is_real=False).to(self.device, self.dtype) # it doesn't need to be fake_features loss_D += (self.criterion(real_features[i][-1], real_grid) + self.criterion(fake_features[i][-1], fake_grid)) * 0.5 fake_features = D(torch.cat((input, fake), dim=1)) for i in range(self.n_D): real_grid = get_grid(fake_features[i][-1], is_real=True).to(self.device, self.dtype) loss_G += self.criterion(fake_features[i][-1], real_grid) if self.opt.HD: for j in range(len(fake_features[0])): loss_G_FM += self.FMcriterion(fake_features[i][j], real_features[i][j].detach()) loss_G += loss_G_FM * (1.0 / self.opt.n_D) * self.opt.lambda_FM return loss_D, loss_G, target, fake
def part_1(): grid = utils.get_grid(__file__, grid_cls=Grid, value_transformer=PointType, delimiter='', cast=str) while True: grid, changes = apply_adjacency_rules(grid) if not changes: print(len(grid.get_occupied_seats())) return
def part_2_bfs(): grid = utils.get_grid(__file__, delimiter='') # We find all low points like in part 1, but perform a classic flood fill algorithm # via BFS starting from low points, and filling it upwards. # # Each fill from a low point will be guaranteed to consist of a single basin, # since we can assume that every node not maximum height is only part of 1 basin. basins = [] for low_point in get_low_points(grid): queue = collections.deque([low_point]) basin = set([low_point]) visited = set([low_point]) while queue: point = queue.popleft() for neighbor in grid.neighbors(point): if neighbor not in visited: visited.add(neighbor) if grid[neighbor] != 9: basin.add(neighbor) queue.append(neighbor) basins.append(basin) top_3 = sorted(basins, key=len, reverse=True)[:3] print(math.prod(len(basin) for basin in top_3))
def test(epoch): imgs = iter(test_loader).next() imgs = imgs.cuda() pred = model(imgs) I = get_grid(imgs.detach().cpu(), pred.detach().cpu()) I = Image.fromarray(I.numpy()) I.save('./results/{}.jpg'.format(epoch))
def part_2_dag(): grid = utils.get_grid(__file__, delimiter='') # We find all low points like in part 1, but create a directed downflow graph, # where u -> v is a directed edge if there is downwards flow from u to v, and u # is not a node of maximal height. # # For a given low point, it will be a part of a DAG such that the low point # will be the singular leaf node of the DAG. Thus, the corresponding basin # will simply be all nodes in the DAG that can reach the low point as well as # the low point itself. downflow_graph = nx.DiGraph() for point in grid: for neighbor in grid.neighbors(point): if grid[point] != 9 and grid[point] > grid[neighbor]: downflow_graph.add_edge(point, neighbor) basins = [] for low_point in get_low_points(grid): basin = set([low_point]) | nx.ancestors(downflow_graph, low_point) basins.append(basin) top_3 = sorted(basins, key=len, reverse=True)[:3] print(math.prod(len(basin) for basin in top_3))
def __call__(self, D, G, input, target): loss_D = 0 loss_G = 0 loss_G_FM = 0 fake = G(input) real_features = D(torch.cat((input, target), dim=1)) fake_features = D(torch.cat((input, fake.detach()), dim=1)) for i in range(self.opt.n_D): real_grid = get_grid(real_features[i][-1], is_real=True).to(self.device) fake_grid = get_grid(fake_features[i][-1], is_real=False).to( self.device) # it doesn't need to be fake_features loss_D += (self.criterion(real_features[i][-1], real_grid) + self.criterion(fake_features[i][-1], fake_grid)) * 0.5 fake_features = D(torch.cat((input, fake), dim=1)) for i in range(self.opt.n_D): for j in range(len(fake_features[0])): loss_G_FM += self.FMcriterion(fake_features[i][j], real_features[i][j].detach()) real_grid = get_grid(fake_features[i][-1], is_real=True).to(self.device) loss_G += self.criterion(fake_features[i][-1], real_grid) loss_G += loss_G_FM * (1.0 / self.opt.n_D) * self.opt.lambda_FM if self.opt.VGG_loss: loss_G_VGG_FM = 0 weights = [1.0 / 32, 1.0 / 16, 1.0 / 8, 1.0 / 4, 1.0] real_features_VGG, fake_features_VGG = self.VGGNet( target), self.VGGNet(fake) for i in range(len(real_features_VGG)): loss_G_VGG_FM += weights[i] * self.FMcriterion( fake_features_VGG[i], real_features_VGG[i]) loss_G += loss_G_VGG_FM * self.opt.lambda_FM return loss_D, loss_G, target, fake
def part_1(): grid = utils.get_grid(__file__, grid_cls=utils.DiagonalGrid, delimiter='') flash_count = 0 for _ in range(100): flashed = run_step(grid) flash_count += len(flashed) print(flash_count)
def part_2(): slopes = [ (1, 1), (1, 3), (1, 5), (1, 7), (2, 1), ] grid = utils.get_grid(__file__, grid_cls=Grid, delimiter='', cast=str) print(math.prod(get_trees_encountered(grid, slope) for slope in slopes))
def part_2(): grid = utils.get_grid(__file__, grid_cls=utils.DiagonalGrid, delimiter='') step = 0 while True: step += 1 flashed = run_step(grid) if len(flashed) == len(grid): print(step) break
def part_1(): grid = utils.get_grid(__file__, delimiter='', cast=str) step = 0 while True: moves = move_east(grid) moves += move_south(grid) step += 1 if not moves: print(step) break
def forward(self, x, flow): args = self.args # WarpingLayer uses F.grid_sample, which expects normalized grid # we still output unnormalized flow for the convenience of comparing EPEs with FlowNet2 and original code # so here we need to denormalize the flow flow_for_grip = torch.zeros_like(flow) flow_for_grip[:,0,:,:] = flow[:,0,:,:] / ((flow.size(3) - 1.0) / 2.0) flow_for_grip[:,1,:,:] = flow[:,1,:,:] / ((flow.size(2) - 1.0) / 2.0) grid = (get_grid(x).to(args.device) + flow_for_grip).permute(0, 2, 3, 1) x_warp = F.grid_sample(x, grid) return x_warp
def part_2(): grid = utils.get_grid(__file__, delimiter='') # We remove all nodes of maximal height from the original graph. This will partition # the grid into connected components, where the connected components are precisely # the basins. for point, value in grid.items(): if value == 9: grid.graph.remove_node(point) basins = nx.connected_components(grid.graph) top_3 = sorted(basins, key=len, reverse=True)[:3] print(math.prod(len(basin) for basin in top_3))
def nearest_warp(x, flow): grid_b, grid_y, grid_x = get_grid(x) flow = tf.cast(flow, tf.int32) _, h, w, _ = tf.unstack(tf.shape(x)) warped_gy = tf.add(grid_y, flow[:,:,:,1]) # flow_y warped_gy = tf.clip_by_value(warped_gy, 0, h-1) warped_gx = tf.add(grid_x, flow[:,:,:,0]) # flow_x warped_gx = tf.clip_by_value(warped_gx, 0, w-1) warped_indices = tf.stack([grid_b, warped_gy, warped_gx], axis = 3) warped_x = tf.gather_nd(x, warped_indices) return warped_x
def bilinear_warp(x, flow): _, h, w, _ = tf.unstack(tf.shape(x)) grid_b, grid_y, grid_x = get_grid(x) grid_b = tf.cast(grid_b, tf.float32) grid_y = tf.cast(grid_y, tf.float32) grid_x = tf.cast(grid_x, tf.float32) fx, fy = tf.unstack(flow, axis = -1) fx_0 = tf.floor(fx) fx_1 = fx_0+1 fy_0 = tf.floor(fy) fy_1 = fy_0+1 # warping indices h_lim = tf.cast(h-1, tf.float32) w_lim = tf.cast(w-1, tf.float32) gy_0 = tf.clip_by_value(grid_y + fy_0, 0., h_lim) gy_1 = tf.clip_by_value(grid_y + fy_1, 0., h_lim) gx_0 = tf.clip_by_value(grid_x + fx_0, 0., w_lim) gx_1 = tf.clip_by_value(grid_x + fx_1, 0., w_lim) g_00 = tf.cast(tf.stack([grid_b, gy_0, gx_0], axis = 3), tf.int32) g_01 = tf.cast(tf.stack([grid_b, gy_0, gx_1], axis = 3), tf.int32) g_10 = tf.cast(tf.stack([grid_b, gy_1, gx_0], axis = 3), tf.int32) g_11 = tf.cast(tf.stack([grid_b, gy_1, gx_1], axis = 3), tf.int32) # gather contents x_00 = tf.gather_nd(x, g_00) x_01 = tf.gather_nd(x, g_01) x_10 = tf.gather_nd(x, g_10) x_11 = tf.gather_nd(x, g_11) # coefficients c_00 = tf.expand_dims((fy_1 - fy)*(fx_1 - fx), axis = 3) c_01 = tf.expand_dims((fy_1 - fy)*(fx - fx_0), axis = 3) c_10 = tf.expand_dims((fy - fy_0)*(fx_1 - fx), axis = 3) c_11 = tf.expand_dims((fy - fy_0)*(fx - fx_0), axis = 3) return c_00*x_00 + c_01*x_01 + c_10*x_10 + c_11*x_11
def part_2(): grid = utils.get_grid(__file__, input_transformer=expand_map, grid_cls=utils.DirectedGrid, delimiter='') print(get_lowest_risk_path(grid))
def part_1(): grid = utils.get_grid(__file__, delimiter='') print(sum(grid[point] + 1 for point in get_low_points(grid)))
# networks af_plus = get_network('AF_plus') feature_loss = get_network('feature_loss') discrim = get_network('discriminator') gan_loss = get_network('gan_loss') # loss function l1_loss = torch.nn.L1Loss() # adaptive scale space during training sigma = Variable(2.0 * torch.ones(1), requires_grad=True).float() # scale gauss_conv = F.conv2d gauss_update_method = Gaussian_Conv_Update() # grid for bilinear sampling grid = get_grid(cfg.data.image_size, cfg.data.border_size) # optimizer for the network param1 = list(af_plus.parameters()) param2 = [sigma] optim = torch.optim.Adam([{'params':param2, 'lr':0.001, 'weight_decay':0.0},{'params':param1}], lr=cfg.train.learning_rate, weight_decay=cfg.train.weight_decay) # optimizer for the discriminator optim_d = torch.optim.Adam(discrim.parameters(), lr=cfg.train.learning_rate, weight_decay=cfg.train.weight_decay) ep = cfg.train.num_epochs # number of epochs # initialize logging variables train_loss = []
def part_1(): grid = utils.get_grid(__file__, grid_cls=utils.DirectedGrid, delimiter='') print(get_lowest_risk_path(grid))
def part_1(): grid = utils.get_grid(__file__, grid_cls=Grid, delimiter='', cast=str) print(get_trees_encountered(grid, (1, 3)))
def __init__(self): """Construct.""" self.grid = get_grid()