def stn_transform(output, input): imrec = input m = torch.size(output, 0) n = torch.size(output, 1) for i in range(m): for j in range(n): if ((abs(output[i][j][0]) + abs(output[i][j][1]) != 0)): imrec[i + math.floor(output[i][j][0])][ j + math.floor(output[i][j][1])] = input[i][j] return imrec
def tenmat(X, rdim, as_np=True, force_sparse=False): # return the mode-rdim matricization of input, # i.e. the rows of the output are the result of flattening along # mode rdims ndims = X.dim() Xshape = np.array(X.shape) cdims = np.flatnonzero(np.arange(ndims) != rdim) if X.is_sparse: indices = np.array(X.coalesce().indices()) ridx = indices[rdim, :] csize = Xshape[cdims] cidx = np.ravel_multi_index(indices[cdims, :], csize) if as_np: Y = coo_matrix((X.values(), (ridx, cidx))) elif not as_np: new_inds = np.vstack([ridx, cidx]) Y = torch.sparse.FloatTensor( new_inds, X.values(), torch.size([Xshape[rdim], np.prod(csize)])) else: Y = X.permute(rdim, *cdims).reshape(Xshape[rdim], np.prod(np.array(Xshape)[cdims])) if as_np: Y = np.array(Y) if force_sparse: Y = coo_matrix(Y) else: if force_sparse: Y = Y.to_sparse() return Y
def update_active(t): view = t.data.view(-1, remaining_sents, self.params.decoder_rnn_size) new_size = list(t.size()) new_size[-2] = new_size[-2] * len(active_idx) \ // remaining_sents return Variable( view.index_select(1, active_idx).view(*new_size))
def get_size_mult(x): res = 1 """ this is after passing by the max pooling layer this is to pass the array to a flat version """ for dim in x.dim(): res = res * torch.size()[dim]
def forward(self, t_img1, t_img2): t_pyr1 = self.make_laplacian_pyramid(t_img1, self.max_levels) t_pyr2 = self.make_laplacian_pyramid(t_img2, self.max_levels) t_losses = [ torch.norm(a - b, ord=1) / torch.size(a, out_type=torch.float32) for a, b in zip(t_pyr1, t_pyr2) ] t_loss = torch.sum(t_losses) * torch.shape(t_img1, out_type=torch.float32)[0] return t_loss
def __init__(self, input_dim, output_dim, weights=None): super(Layer, self).__init__() if weights is None: self.W = nn.Parameter( torch.randn(input_dim, output_dim) / np.sqrt(input_dim), requires_grad=True, ) else: assert weights.shape == torch.size((input_dim, output_dim)) self.W = nn.Parameter(weights)
def max_pool_3d(params, k): _, indices = torch.topk(params, k, sorted=False) shape = torch.size(indices) r1 = torch.reshape(torch.range(shape[0]), (-1, 1)) r2 = torch.reshape(torch.range(shape[1]), (-1, 1)) r1 = r1.repeat((1, k * shape[1])) r2 = r2.repeat((1, k)) r1 = torch.reshape(r1, (-1, 1)) r2 = torch.reshape(r2, (-1, 1)).repeat(shape[0], 1) indices = torch.cat((r1, r2, torch.reshape(indices, (-1, 1))), 1) return torch.reshape(gater_3d(params, indices), (-1, shape[1], k))
def get_surrogate_objective(s_model, qz_x, z, mask, types, n, rho, device): mu, sigma = s_model(z, mask, device) kld = [] l_r = [] for i in range(types): if mu[i] == -1: continue tmp_mask = torch.sum(mask == i, dim=-1).bool() tmp_mu = mu[i] #k * D tmp_sigma = sigma[i] ri = dist.Normal(tmp_mu, tmp_sigma) z_ri = ri.rsample(torch.size([n])) #n * K * D l_ri = ri.log_prob(z_ri).sum(-1) #n*K l_qi = qz_x.log_prob(z_ri).sum(-1) #n*K l_qi = torch.logsumexp(l_qi).expand_as(l_ri) #n*K kld.append(torch.mean(l_ri - l_qi, dim=1)) l_r.append(torch.mean(l_ri, dim=1)) l_r = torch.logsumexp(torch.stack(l_r), dim=0) #n kld = torch.sum(torch.mean(torch.stack(kld))) #1 obj = kld * rho - torch.sum(l_r) return obj, kld, l_r
def forward( self, observations, graph: Graph, diffusion_graph: Graph, observed, starts, targets, pairwise_node_features, steps=None, ): assert observed.shape[0] == starts.shape[0] == targets.shape[0] n_pred = observed.shape[0] if self.diffusion_graph_transformer is None and self.direction_edge_mpl is None: if graph.edges.shape != torch.size([graph.n_edge, 1]) or ((graph.Out_nodes_counts -1.0).abs() > 1e-5).any(): rw_graphs = graph.update(edges=torch.ones([graph.n_edge, n_pred], device = graph.device)) rw_graphs = rw_graphs.c_weights() else: rw_graphs = graph virtual_coords = None virtual_coords = self.compute_diffusion(diffusion_graph, observations) if self.double_way_diffusion: virtual_coords_reversed = self.compute_diffusion(diffusion_graph.reversed_edges(), observations) virtual_coords = torch.cat([virtual_coords, virtual_coord_reversed]) rw_graphs - self.compute_rw_weights(virtual_coords, observed, pairwise_node_features, targets, graph) target_distributions = self.compute_random_walk(rw_graphs, observations, starts, targets, steps) return target_distributions, virtual_coords, rw_weights
def train(model, start): optimizer = optim.Adam(model.paramaters(), lr=1e-4) criterion = nn.MSELoss() game = Game() dino = Dinosaur(game) game_state = GameEnvironment(dino, game) replay_memory = [] actions = torch.zeros([model.number_of_actions], dtype=torch.cuda.float32) action[0] = 1 image_data, reward, terminal, score, high_score = game_state.get_next_state(action) epsilon = model.initial_epsilon iteration = 0 epsilon decrements = np.linspace(model.initial_epsilon, model.final_epsilon, model.number_of_iterations) while iteration < model.number_of_iterations: output = model(image_data) action = torch.zeros([model.number_of_actions], dtype=torch.float32) action = transfer_to_cuda(action) random_action = random.random() <= epsilon action_index = [torch.randint(model.number_of_actions, torch.size([]), dtype = torch.int) if random_action else torch.argmax(output)][0] action_index = transfer_to_cuda(action_index) # Setting the action to 1 because you gotta jump first to start the game action[action_index] = 1 image_data_1, reward, terminal, score, high_score = game_state.get_next_state(action)
def build_l1_loss_with_mask(x_t, x_o, mask): mask_ratio = 1. - mask.view(-1).sum() / torch.size(mask) l1 = torch.abs(x_t - x_o) return mask_ratio * torch.mean(l1 * mask) + (1. - mask_ratio) * torch.mean( l1 * (1. - mask))
def LSTMCell(input, hidden, w_ih, w_hh, count, b_ih=None, b_hh=None): # if input.is_cuda: # igates = F.linear(input, w_ih) # hgates = F.linear(hidden[0], w_hh) # state = fusedBackend.LSTMFused.apply # return state(igates, hgates, hidden[1]) if b_ih is None else state(igates, hgates, hidden[1], b_ih, b_hh) hx, cx = hidden gates = F.linear(input, w_ih, b_ih) + F.linear(hx, w_hh, b_hh) # if count == 0: # cellmemory(:,:,count) = cellgate if preset == False: ingate, forgetgate, cellgate, outgate, sensitivitygate_1, sensitivitygate_2, sensitivitygate_3 = gates.chunk( 7, 1) ingate = F.sigmoid(ingate) forgetgate = F.sigmoid(forgetgate) sensitivitygate_1 = F.relu(sensitivitygate_1) sensitivitygate_2 = F.sigmoid(sensitivitygate_2) sensitivitygate_3 = F.relu(sensitivitygate_3).round() cellgatetemp = cellgate.unsqueeze_(2) # cellgatetemp.expand(:,:,torch.size(cellmemory,2)) #with sensitivity gates sensitivitygate_1 = sensitivitygate.unsqueeze_(2) # sensitivitygate_1.expand(:,:,torch.size(cellmemory,2)) sensitivitygate_2 = sensitivitygate.unsqueeze_(2) # sensitivitygate_2.expand(:,:,torch.size(cellmemory,2)) sensitivitygate_3 = sensitivitygate.unsqueeze_(2) # sensitivitygate_3.expand(:,:,torch.size(cellmemory,2)) direction = torch.pow( .0001 * sensitivitygate_1, 2) * sensitivitygate_2 * (cellmemory - cellgatetemp) distance = torch.pow(.0001 * sensitivtygate_1, 2) + torch.pow( (cellmemory - cellgate), (2 * sensitivitygate_3)) else: ingate, forgetgate, cellgate, outgate = gates.chunk(4, 1) ingate = F.sigmoid(ingate) forgetgate = F.sigmoid(forgetgate) cellgatetemp = cellgate.unsqueeze_(2) # cellgatetemp.expand(:,:,torch.size(cellmemory,2)) #with preset sensitivities # a = #between 0 and infinity # b = #between 0 and 1 # c = #between 0 and infinity direction = torch.pow(.0001 * a, 2) * b * (cellmemory - cellgatetemp) distance = torch.pow(.0001 * a, 2) + torch.pow( (cellmemory - cellgate), (2 * c)) # direction = (a^2 * b * (x-z)) # distance = (a^2 + (x-z)^(4*c)) # clustergrad = (a^2 * b * (x-z))/(a^2 + (x-z)^(4*c)) clustergrad = torch.sum( (direction / distance), 2) / torch.size(cellmemory, 2) cellgate = F.tanh(cellgate + clustergrad) # cellmemory(:,:,count) = cellgate outgate = F.sigmoid(outgate) cy = (forgetgate * cx) + (ingate * cellgate) hy = outgate * F.tanh(cy) return hy, cy, cellmemory
def input_shape(self) -> torch.Size: return torch.size(self._input_shape)