def video_latent(nets, args, x_src, y_list, z_list, psi, fname): x_src.stop_gradient = True latent_dim = z_list[0].size(1) s_list = [] for i, y_trg in enumerate(y_list): z_many = porch.randn(10000, latent_dim) y_many = porch.LongTensor(10000).fill_(y_trg[0]) s_many = nets.mapping_network(z_many, y_many) s_avg = porch.mean(s_many, dim=0, keepdim=True) s_avg = s_avg.repeat(x_src.size(0), 1) for z_trg in z_list: s_trg = nets.mapping_network(z_trg, y_trg) s_trg = porch.lerp(s_avg, s_trg, psi) s_list.append(s_trg) s_prev = None video = [] # fetch reference images for idx_ref, s_next in enumerate(tqdm(s_list, 'video_latent', len(s_list))): if s_prev is None: s_prev = s_next continue if idx_ref % len(z_list) == 0: s_prev = s_next continue frames = interpolate(nets, args, x_src, s_prev, s_next).cpu() video.append(frames) s_prev = s_next for _ in range(10): video.append(frames[-1:]) video = tensor2ndarray255(porch.cat(video)) save_video(fname, video)
def _preprocess(self, edge_list_path, node_label_path): with open(edge_list_path) as f: edge_list = [] node2id = defaultdict(int) for line in f: x, y = list(map(int, line.split())) # Reindex if x not in node2id: node2id[x] = len(node2id) if y not in node2id: node2id[y] = len(node2id) edge_list.append([node2id[x], node2id[y]]) edge_list.append([node2id[y], node2id[x]]) num_nodes = len(node2id) with open(node_label_path) as f: nodes = [] labels = [] label2id = defaultdict(int) for line in f: x, label = list(map(int, line.split())) if label not in label2id: label2id[label] = len(label2id) nodes.append(node2id[x]) if "hindex" in self.name: labels.append(label) else: labels.append(label2id[label]) if "hindex" in self.name: median = np.median(labels) labels = [int(label > median) for label in labels] assert num_nodes == len(set(nodes)) y = torch.zeros(num_nodes, len(label2id)) y[nodes, labels] = 1 return torch.LongTensor(edge_list).t(), y, node2id
def _preprocess(self, root, name): dict_path = os.path.join(root, name + ".dict") graph_path = os.path.join(root, name + ".graph") with open(graph_path) as f: edge_list = [] node2id = defaultdict(int) f.readline() for line in f: x, y, t = list(map(int, line.split())) # Reindex if x not in node2id: node2id[x] = len(node2id) if y not in node2id: node2id[y] = len(node2id) # repeat t times for _ in range(t): # to undirected edge_list.append([node2id[x], node2id[y]]) edge_list.append([node2id[y], node2id[x]]) name_dict = dict() with open(dict_path) as f: for line in f: name, str_x = line.split("\t") x = int(str_x) if x not in node2id: node2id[x] = len(node2id) name_dict[name] = node2id[x] num_nodes = len(node2id) return torch.LongTensor(edge_list).t(), name_dict, node2id
def forward(self, x, y): out = self.main(x) out = porch.Tensor(out) out = out.view(out.size(0), -1) # (batch, num_domains) idx = porch.LongTensor(np.arange(y.shape[0])) # out = out[idx, y] # (batch) s = porch.take( out, list(zip(range(y.shape[0]), y.numpy().astype(int).tolist()))) return s
def preprocess(x): """Preprocess 98-dimensional heatmaps.""" N, C, H, W = x.size() x = truncate(x) x = normalize(x) sw = H // 256 operations = Munch(chin=OPPAIR(0, 3), eyebrows=OPPAIR(-7 * sw, 2), nostrils=OPPAIR(8 * sw, 4), lipupper=OPPAIR(-8 * sw, 4), liplower=OPPAIR(8 * sw, 4), lipinner=OPPAIR(-2 * sw, 3)) for part, ops in operations.items(): start, end = index_map[part] x[:, start:end] = resize(shift(x[:, start:end], ops.shift), ops.resize) zero_out = porch.cat([ porch.arange(0, index_map.chin.start), porch.arange(index_map.chin.end, 33), porch.LongTensor([ index_map.eyebrowsedges.start, index_map.eyebrowsedges.end, index_map.lipedges.start, index_map.lipedges.end ]) ]) x[:, zero_out] = 0 start, end = index_map.nose x[:, start + 1:end] = shift(x[:, start + 1:end], 4 * sw) x[:, start:end] = resize(x[:, start:end], 1) start, end = index_map.eyes x[:, start:end] = resize(x[:, start:end], 1) x[:, start:end] = resize(shift(x[:, start:end], -8), 3) + \ shift(x[:, start:end], -24) # Second-level mask x2 = deepcopy(x) x2[:, index_map.chin.start:index_map.chin.end] = 0 # start:end was 0:33 x2[:, index_map.lipedges.start:index_map.lipinner. end] = 0 # start:end was 76:96 x2[:, index_map.eyebrows.start:index_map.eyebrows. end] = 0 # start:end was 33:51 x = porch.sum(x, dim=1, keepdim=True) # (N, 1, H, W) x2 = porch.sum(x2, dim=1, keepdim=True) # mask without faceline and mouth x[x != x] = 0 # set nan to zero x2[x != x] = 0 # set nan to zero return x.clamp_(0, 1), x2.clamp_(0, 1)
def translate_using_latent(nets, args, x_src, y_trg_list, z_trg_list, psi, filename): x_src.stop_gradient = True N, C, H, W = x_src.size() latent_dim = z_trg_list[0].size(1) x_concat = [x_src] masks = nets.fan.get_heatmap(x_src) if args.w_hpf > 0 else None for i, y_trg in enumerate(y_trg_list): z_many = porch.randn(10000, latent_dim) y_many = porch.LongTensor(10000).fill_(y_trg[0]) s_many = nets.mapping_network(z_many, y_many) s_avg = porch.mean(s_many, dim=0, keepdim=True) s_avg = s_avg.repeat(N, 1) for z_trg in z_trg_list: s_trg = nets.mapping_network(z_trg, y_trg) s_trg = porch.lerp(s_avg, s_trg, psi) x_fake = nets.generator(x_src, s_trg, masks=masks) x_concat += [x_fake] x_concat = porch.cat(x_concat, dim=0) save_image(x_concat, N, filename)
out_model_fn = "../expr/checkpoints/afhq/100000_nets_ema.ckpt/mapping_network.pdparams" mapping_network_ema.load_state_dict(porch.load(out_model_fn)) else: mapping_network_ema = core.model.MappingNetwork( 16, 64, 2) # copy.deepcopy(mapping_network) out_model_fn = "../expr/checkpoints/celeba_hq/100000_nets_ema.ckpt/mapping_network.pdparams" mapping_network_ema.load_state_dict(porch.load(out_model_fn)) d_optimizer = fluid.optimizer.AdamOptimizer( learning_rate=lr, parameter_list=mapping_network_ema.parameters()) from tqdm import tqdm mapping_network_ema.train() z_train_p = porch.Tensor(z_train) y_train_p = porch.LongTensor(y_train) m_out_train_p = porch.Tensor(m_out_train) best_loss = 100000000 for ii in range(100000000000): st = np.random.randint(0, z_train_p.shape[0] - batch_size) out = mapping_network_ema(z_train_p[st:st + batch_size], y_train_p[st:st + batch_size]) d_avg_cost = fluid.layers.mse_loss( out, m_out_train_p[st:st + batch_size] ) #+fluid.layers.mse_loss(out1,m_out_train_1p)+fluid.layers.mse_loss(out2,m_out_train_2p) d_avg_cost.backward() d_optimizer.minimize(d_avg_cost) mapping_network_ema.clear_gradients() if ii % 99 == 0: print("d_avg_cost", d_avg_cost.numpy())
import pickle import paddorch import numpy as np a = paddorch.FloatTensor(np.array([ 0.9, 0.1])) pickle.dump(a,open("tensor.pkl",'wb')) b=pickle.load(open("tensor.pkl",'rb')) print(b) a = paddorch.LongTensor(np.array([ 9, 1])) pickle.dump(a,open("tensor.pkl",'wb')) b=pickle.load(open("tensor.pkl",'rb')) print(b)
if graph_file.is_file() and graph_file.name in todo ] # graphs = [yuxiao_kdd17_graph_to_dgl(graph_file) for graph_file in graph_dir.iterdir() if graph_file.is_file() \ # and graph_file.name.find("soc-Friendster-SNAP.txt.lpm.lscc") == -1 \ # and graph_file.name.find("soc-Facebook-NetRep.txt.lpm.lscc") == -1 \ # and graph_file.suffix == '.lscc'] # graphs = [] # for name in ["cs", "physics"]: # g = Coauthor(name)[0] # g.remove_nodes((g.in_degrees() == 0).nonzero().squeeze()) # g.readonly() # graphs.append(g) # for name in ["computers", "photo"]: # g = AmazonCoBuy(name)[0] # g.remove_nodes((g.in_degrees() == 0).nonzero().squeeze()) # g.readonly() # graphs.append(g) graphs.sort(key=lambda g: g.number_of_nodes(), reverse=True) graph_sizes = torch.LongTensor([g.number_of_nodes() for g in graphs]) for i, g in enumerate(graphs): g.ndata.clear() g.edata.clear() # model = ProNE(args.embed_dim, step=5, mu=0.2, theta=0.5) # emb = model.train(g.to_networkx()).astype(np.float32) # g.ndata['prone'] = torch.from_numpy(emb) print(i, g, graph_sizes[i]) logger.info("save graphs to %s", args.save_file) save_graphs( filename=args.save_file, g_list=graphs, labels={"graph_sizes": graph_sizes} )
def batcher_dev(batch): graph_q, label = zip(*batch) graph_q = dgl.batch(graph_q) return graph_q, torch.LongTensor(label)
import torch N_dim = 200 N_dim2 = N_dim torch.manual_seed(0) a = torch.randn(N_dim2, N_dim).to_sparse().requires_grad_(False) a_dense = a.to_dense().numpy() b = torch.randn(N_dim, N_dim2, requires_grad=True) torch_y = torch.sparse.mm(a, b) print(torch_y) import paddorch import paddle import numpy as np a = paddorch.sparse.FloatTensor( paddorch.LongTensor(a._indices().detach().numpy()), paddorch.FloatTensor(a._values().detach().numpy()), (N_dim2, N_dim)) b = paddorch.from_numpy(b.detach().numpy()) b_param = paddorch.nn.Parameter(b) b.stop_gradient = False a.values.stop_gradient = False y = paddorch.sparse.mm(a, b) print("max diff", np.max(np.abs(torch_y.detach().numpy() - y.numpy()))) c = a.to_dense() import time before = time.time() for _ in range(6): y = paddorch.sparse.mm(a, b) # y = paddorch.mm(c, b )
y = torch.sparse.mm(a, b) b=torch.cat([b,y],dim=1) y.sum().backward() after=time.time() print("time:",after-before) # print("max grad",torch.max(a.grad)) if device=="cuda": import sys sys.exit() with fluid.dygraph.guard(place=place): a=paddorch.sparse.FloatTensor(paddorch.LongTensor(np.stack([I,J]) ), paddorch.FloatTensor(V ) ,(N_dim2, N_dim)) b=paddorch.from_numpy(b_np ) b_param=paddorch.nn.Parameter(b) b.stop_gradient=False a.values.stop_gradient=False import time before=time.time() for _ in range(6): y = paddorch.sparse.mm(a, b ) b=paddorch.cat([b,y],dim=1) break y.sum().backward()
def preprocess(x): """Preprocess 98-dimensional heatmaps.""" N, C, H, W = x.shape x = truncate(x) x = normalize(x) sw = H // 256 operations = Munch(chin=OPPAIR(0, 3), eyebrows=OPPAIR(-7 * sw, 2), nostrils=OPPAIR(8 * sw, 4), lipupper=OPPAIR(-8 * sw, 4), liplower=OPPAIR(8 * sw, 4), lipinner=OPPAIR(-2 * sw, 3)) for part, ops in operations.items(): start, end = index_map[part] torch.copy(resize(shift(x[:, start:end], ops.shift), ops.resize), x[:, start:end]) # = zero_out = torch.cat([ torch.arange(0, index_map.chin.start), torch.arange(index_map.chin.end, 33), torch.LongTensor([ index_map.eyebrowsedges.start, index_map.eyebrowsedges.end, index_map.lipedges.start, index_map.lipedges.end ]) ]) x.fill_(val=0, dim=1, indices=zero_out.numpy()) # x_numpy=x.numpy() # x_numpy[:, zero_out.numpy()] = 0 # x.set_value(x_numpy) # torch.copy(target) # x[:, zero_out] = 0 start, end = index_map.nose torch.copy(shift(x[:, start + 1:end], 4 * sw), x[:, start + 1:end]) torch.copy(resize(x[:, start:end], 1), x[:, start:end]) # x[:, start+1:end] = shift(x[:, start+1:end], 4*sw) # x[:, start:end] = resize(x[:, start:end], 1) start, end = index_map.eyes torch.copy(resize(x[:, start:end], 1), x[:, start:end]) torch.copy(resize(shift(x[:, start:end], -8), 3) + \ shift(x[:, start:end], -24), x[:, start:end] ) # x[:, start:end] = resize(x[:, start:end], 1) # x[:, start:end] = resize(shift(x[:, start:end], -8), 3) + \ # shift(x[:, start:end], -24) # Second-level mask x2 = x.clone() #deepcopy(x) x2.fill_(0, 1, list(range(index_map.chin.start, index_map.chin.end))) x2.fill_(0, 1, list(range(index_map.lipedges.start, index_map.lipedges.end))) x2.fill_(0, 1, list(range(index_map.eyebrows.start, index_map.eyebrows.end))) # x2[:, index_map.chin.start:index_map.chin.end] = 0 # start:end was 0:33 # x2[:, index_map.lipedges.start:index_map.lipinner.end] = 0 # start:end was 76:96 # x2[:, index_map.eyebrows.start:index_map.eyebrows.end] = 0 # start:end was 33:51 x = torch.sum(x, dim=1, keepdim=True) # (N, 1, H, W) x2 = torch.sum(x2, dim=1, keepdim=True) # mask without faceline and mouth x_numpy = x.numpy zero_indices = np.where(x_numpy != x_numpy)[0] x.fill_(0, 0, zero_indices) x2.fill_(0, 0, zero_indices) # x[x != x] = 0 # set nan to zero # x2[x != x] = 0 # set nan to zero return x.clamp_(0, 1), x2.clamp_(0, 1)
import paddorch from paddorch import index_copy_inplace_nograd memory = paddorch.zeros((4, 3)) k = paddorch.arange(0, 6).view(2, 3) out_ids = paddorch.LongTensor([1, 3]) index_copy_inplace_nograd(memory, 0, out_ids, k) print("paddorch", memory) import torch memory = torch.zeros((4, 3)) k = torch.arange(0, 6).view(2, 3).float() out_ids = torch.LongTensor([1, 3]) memory.index_copy_(0, out_ids, k) print("pytorch", memory)