def load_embeddings(embedding_index, embed_dim, senvocab, aspvocab): sentence_embed = torch.zeros(len(senvocab), embed_dim) i = 0 for word in senvocab.keys(): if (word not in embedding_index): if (word != 'PAD'): sentence_embed[i, :] = uniform.Uniform(-0.25, 0.25).sample( torch.Size([embed_dim])) else: sentence_embed[i, :] = embedding_index[word] i += 1 aspect_embed = torch.zeros(len(aspvocab), embed_dim) i = 0 for word in aspvocab.keys(): if (word not in embedding_index): if (word != 'PAD'): aspect_embed[i, :] = uniform.Uniform(-0.25, 0.25).sample( torch.Size([embed_dim])) else: aspect_embed[i, :] = embedding_index[word] i += 1 return sentence_embed, aspect_embed
def GetCR(n, m, alpha, type_CR): ''' :param n: The number of splings :param m: The number of initializations :param alpha: The accuracy parameter :param type_CR: string to determine what CI mthod to use / one of 'normal', 'bootstrap' :return: boolean whether gt is in CI or not ''' # Generate data data = get_data(int(n)) #parameter to be optimized theta = torch.tensor( [[uniform.Uniform(0., .6).sample(), uniform.Uniform(0., .5).sample()]], requires_grad=True) theta, _, _ = theta_n_M_CG_FR(data=data, n_runs=m, func=LogLikelihood, max_iterations=2000, learningrate=0.01, print_info=False) if type_CR == 'LogLike': # Getting Quantities that underly the CIs theta_hat = theta.clone().data.numpy() '''Scores, Hessian = get_derivatives_torch(func=LogLikelihood, param=theta, data=data, print_dims=False) ci, length, shape = normal_CI(alpha, Scores, Hessian, theta_hat)''' ci_bool = LogLikeRatio_CR(data, alpha, theta_hat, theta_gt, func=LogLikelihood) elif type_CR == 'Score': # Getting Quantities that underly the CIs theta_hat = theta.clone().data.numpy() ci_bool = Score_CR(data, alpha, theta_gt, func=LogLikelihood) elif type_CR == 'Wald': # Getting Quantities that underly the CIs theta_hat = theta.clone().data.numpy() Scores, Hessian = get_derivatives_torch(func=LogLikelihood, param=theta, data=data, print_info=False) ci_bool = Wald_CR(data, alpha, theta_hat, theta_gt, Scores, Hessian) else: print('Unknown type of CI!') sys.exit() return ci_bool
def __init__(self, num_boxes, dim): super(Boxes, self).__init__() min_distribution = uniform.Uniform(1e-4, 1e-2) box_mins = min_distribution.sample((num_boxes, dim)) delta_distribution = uniform.Uniform(-0.1, -0.01) box_deltas = delta_distribution.sample((num_boxes, dim)) boxes = torch.stack([box_mins, box_deltas], dim=1) self.boxes = nn.Parameter(boxes)
def theta_n_M(data, n_runs, func, max_iterations=1000, learningrate=0.01, print_info=True): ''' This function performs gradient ascent on the function func, which is governed by the arguments param. Here this procedure is done with n_runs = M initializations. The GA limit with the highest Likelihood value is returned, i.e. theta_n_M Arguments: - func: a pytorch autograd compatible function; function defining the logprobs that build the log-likelihood function (e.g. \ref{func: LogLikelihood}) - data: torch tensor of dim $k\times n $ (c.f. section \ref{sec: Data Generation}); these govern / parametrise func - max_iterations}: scalar (int); (maximum) number of iterations to be performed during gradient ascent - learningrate: scalar; learning rate / step size of the algorithm - print_info: Boolean; whether info about GA runs is to be printed or not Outputs: - theta_hat: numpy arry of dim $1\times d$; The estiamtor theta_n_M that is supposed to be the MLE - loglikelihood_value: value of the found maximum - optim_trajectory: list of instances of param during optimization ''' # Initializing Loss as minus infinity to make sure first run achieves higher likelihood max_likelihood = -1 * np.inf # trajectory_dict is a cache to save the gradient ascent trajectory of all gradient ascent runs trajectory_dict = {} # Running Gradient Ascent multiple (M=n_runs) times for run in range(n_runs): print(f'-------------------Run: {run}-------------\n\n') # Create/ Initialize variable ' TODO: make initialization more flexible theta = torch.tensor([[uniform.Uniform(0., .6).sample(), uniform.Uniform(0., 5.).sample()]], requires_grad=True) # Run complete Gradient ascent theta, L, trajectory = gradient_ascent_torch(func=func, param=theta, data=data, max_iterations=max_iterations, learningrate=learningrate, run_id=run, print_info=print_info) # Save optimization trajectory trajectory_dict.update({run: trajectory}) # Updating Quantities if new max is found # compare likelihood value to previous runs if L > max_likelihood: # This takes forever if n is large. As it is torch implementation I don't see a way to get this faster print(f'New Maximum found! old:{max_likelihood} -> new:{L}') # Update highest likelihood and theta estimate max_likelihood = L theta_hat = theta.clone().data.numpy() # Calculating Derivatives at found theta_hat # get derivatives theta_hat = torch.tensor(theta_hat, requires_grad = True) return theta_hat, trajectory_dict
def __init__(self, dist: str, config: Mapping): """ Generate a set of random rotation and translation error based on a specified distribution :param dist: 'uniform' or 'normal', distributions where the random samples are picked from :param config: type=dict, keys=['R', 'T'], which give the configuration of the distribution, default values are given in the code """ self.error = None if dist == 'uniform': self.dist = 'uniform' R_range = config.get( 'R', np.deg2rad(2)) # rotation error upto 2 degrees by default T_range = config.get( 'T', 0.2) # translation error upto 20 cm by default LOG.warning('Rotation error range (degrees): [-%.2f, %.2f]' % (np.rad2deg(R_range), np.rad2deg(R_range))) LOG.warning('Translation error range (meters): [-%.3f, %.3f]' % (T_range, T_range)) self.R_dist = uniform.Uniform(-R_range, R_range) self.T_dist = uniform.Uniform(-T_range, T_range) # statistics self.R_mean, self.T_mean = 0, 0 # (a+b)/2 self.R_std = 2 * R_range / np.sqrt(12) # (b-a)/sqrt(12) self.T_std = 2 * T_range / np.sqrt(12) elif dist == 'normal': self.dist = 'normal' R_params = config.get( 'R', (np.deg2rad(2), np.deg2rad(0.1) )) # rotation error at 2 degrees as mean, 0.1 degree for std. T_params = config.get( 'T', (0.2, 0.01)) # translation error at 20cm as mean, 1cm for std. LOG.warning('Rotation error mean (degrees): -%.2f, std: %.2f' % (np.rad2deg(R_params[0]), np.rad2deg(R_params[1]))) LOG.warning('Translation error mean (meters): -%.3f, std: %.3f' % (T_params[0], T_params[1])) self.R_dist = normal.Normal(*R_params) self.T_dist = normal.Normal(*T_params) # statistics self.R_mean, self.R_std = R_params self.T_mean, self.T_std = T_params else: LOG.error('Unknown distribution given: %s' % dist) return
def NewtonMethod(func, data, lr, it, conv, print_info=False): theta = torch.tensor( [[uniform.Uniform(0., .6).sample(), uniform.Uniform(0., 5.).sample()]], requires_grad=True) with torch.no_grad(): optim_trajectory = [theta.clone().data.numpy()] err = 10000 for i in range(it): loglikelihoods = func(theta, data) loglikelihood_value = torch.mean(loglikelihoods) loglikelihood_value.backward() gradient = theta.grad #transpose for the multiplication grt = torch.transpose(gradient, 0, 1) # find inverse of hessian func_forHessian = lambda args: torch.mean(func(args, data)) Hessian = torch.autograd.functional.hessian(func_forHessian, theta).squeeze() print(Hessian) HessianInverse = torch.inverse(Hessian) #search direction equivalent to the greadiand update in descent sd = torch.mm(HessianInverse, grt) #transpose back to 1*dim sdt = torch.transpose(sd, 0, 1) with torch.no_grad(): theta.add_(lr * sdt) theta.grad.zero_() optim_trajectory.append(theta.clone().data.numpy()) if print_info: if i % 1 == 0: now = datetime.datetime.now() print( f' Iteration: {i} \t| Log-Likelihood:{loglikelihood_value} \t| theta: {theta} \t|Error:{err} | Time needed: {datetime.datetime.now()-now} ' ) err = np.linalg.norm(optim_trajectory[-1] - optim_trajectory[-2]) if err < conv: break return theta, loglikelihood_value, optim_trajectory
def __init__(self, latent, noise='uniform', path='.', batch_size=512): ''' Initializes the Transporter, including creating the model. latent: (np array) Latent space distribution to map to. Must be an array of one dimensional vectors. noise: (str) Noise distribution to map from. Must be either 'uniform', 'normal', or 'gaussian' path: (str) Path to store any images/weights of the model batch_size: (int) Batch Size ''' self.latent = torch.Tensor(latent) self.dim = len(latent[0]) if noise.lower() == 'uniform': self.noise = uniform.Uniform(-1, 1) elif noise.lower() == 'normal' or noise.lower() == 'gaussian': self.noise = normal.Normal(0, 1) else: raise Exception("{} has not been implemented yet".format(noise)) self.path = path self.batch_size = batch_size self.create_model()
def GetCI(n, m, alpha, type_CI): start = time.time() data = get_data(int(n)).cuda() theta = torch.tensor([[uniform.Uniform(-2, 2).sample()]], requires_grad=True).cuda() theta, _ = gradient_ascent_torch(func=LogLikelihood, param=theta, data=data, max_iterations=5000, learningrate=0.01) if type_CI == 'normal': theta_hat = theta.cpu().clone().data.detach().numpy() Scores, Hessian = get_derivatives_torch(func=LogLikelihood, param=theta, data=data) ci, length, shape = normal_CI(alpha, Scores.cpu(), Hessian.cpu(), theta_hat) end = time.time() print(f'GetCI {end-start}') return ci, length, shape
def log_p(self, zs, θ): """ Calculate conditional probabilities for a run of the simulator Arguments: zs: List[torch.Tensor], latent variables θ: torch.Tensor, parameters Returns: ps: torch.Tensor, where ps[i] = p(z_i|θ, zs[:i]) """ ps = [0 for _ in range(len(zs)-1)] # === PROB. DENSITY CALCULATION FOR ps[0] === # torch Uniform distribution for initial positions of population uni_dist = torchUni.Uniform(0, self.city_size) ps[0] = torch.tensor(1) # computes ps[0] as product of pdfs of independent locations of each person for i in range(self.pop): ps[0] = ps[0] + uni_dist.log_prob(zs[0][5*i]) # initial pos x-coord ps[0] = ps[0] + uni_dist.log_prob(zs[0][5*i+1]) # initial pos y-coord # then multiply by probability of person[i] being chosen as patient zero ps[0] = ps[0] + math.log(1.0/float(self.pop)) for i in range(1, len(zs)-1): ps[i] = self.p_latent_step(zs[i], zs[i-1], θ) return sum(ps)
def __init__(self, n_levels, n_children, n_dims, low=-1000, high=1000, mean=0): if isinstance(low, Number): low = torch.ones(n_dims) * low if isinstance(high, Number): high = torch.ones(n_dims) * high self.n_levels = n_levels self.cluster_means = uniform.Uniform(low + mean, high + mean).sample( (n_children, )) self.concepts = [] for i, cluster_mean in enumerate(self.cluster_means): pref = '\t' * (3 - n_levels) if n_levels > 0: print(pref + 'New cluster centered on {}'.format(cluster_mean)) self.concepts.append( HierarchicalConceptPool(n_levels - 1, n_children, n_dims, low=low / 10, high=high / 10, mean=cluster_mean)) else: print(pref + 'New concept centered on {}'.format(cluster_mean)) self.concepts.append(Concept(cluster_mean, np.eye(n_dims), i))
def __init__(self, n_dims, n_concepts, low=-1, high=1): low = torch.ones(n_dims) * low high = torch.ones(n_dims) * high means = uniform.Uniform(low, high).sample((n_concepts, )) self.concepts = [ Concept(m, torch.eye(n_dims), i) for i, m in enumerate(means) ]
def __call__(self, X): distribution = uniform.Uniform(torch.Tensor([self.lb]), torch.Tensor([self.ub])) multiplier = distribution.sample(torch.Size([self.batch_size])) return multiplier[:, None, None, None].numpy() * X
def _build_tree(self, n_levels, n_children, n_dims, low, high, mean, parent_node): if isinstance(low, Number): low = torch.ones(n_dims) * low if isinstance(high, Number): high = torch.ones(n_dims) * high cluster_means = uniform.Uniform(low + mean, high + mean).sample( (n_children, )) pref = '\t' * (self.n_levels - n_levels) for i, cluster_mean in enumerate(cluster_means): logger.debug(pref + 'New cluster centered on {}'.format(cluster_mean)) node_name = '{}{}'.format(parent_node, i) self.tree.add_edge(parent_node, node_name) if n_levels > 0: self._build_tree(n_levels - 1, n_children, n_dims, low=low / 10, high=high / 10, mean=cluster_mean, parent_node=node_name) self.tree.add_node(node_name, cluster_mean=cluster_mean) else: concept = Concept(cluster_mean, np.eye(n_dims), node_name) self.tree.add_node(node_name, concept=concept)
def __init__(self, hidden_size, scoring_hsize=None): super(BaseCell, self).__init__() self.hidden_size = hidden_size self.binary_function_name_list = ['add', 'mul'] self.binary_function_list = [lambda x,y: x+y, lambda x,y: x*y] self.unary_function_name_list = ['sigmoid', 'tanh', 'oneMinus', 'identity', 'relu'] self.unary_function_list = [torch.sigmoid, torch.tanh, lambda x: 1-x, lambda x: x, torch.relu] self.m = 1 # Num of output vectors self.N = 9 # Num of generated nodes in one cell self.l = 4 # Num of parameter matrices (L_i, R_i, b_i) # Initalize L R weights from the uniform distribution and b to be zero weight_distribution = uniform.Uniform(-1/np.sqrt(hidden_size), 1/np.sqrt(hidden_size)) self.L_list = nn.ParameterList([nn.Parameter(weight_distribution.sample([hidden_size, hidden_size])) for _ in range(self.l)]) self.R_list = nn.ParameterList([nn.Parameter(weight_distribution.sample([hidden_size, hidden_size])) for _ in range(self.l)]) self.b_list = nn.ParameterList([nn.Parameter(torch.zeros(1, hidden_size)) for _ in range(self.l)]) # Set L3, R3, b3 to the identity transformation # self.L_list[3] = nn.Parameter(torch.eye(hidden_size)) self.R_list[3] = nn.Parameter(torch.eye(hidden_size)) self.b_list[3] = nn.Parameter(torch.zeros(1, hidden_size)) # TODO: more complicated scoring if scoring_hsize is not None: self.scoring = nn.Sequential( nn.Linear(hidden_size, scoring_hsize), nn.ReLU(), nn.Linear(scoring_hsize, 1)) else: self.scoring = nn.Linear(hidden_size, 1, bias=False) # softmax function self.softmax_func = torch.nn.Softmax(dim=2)
def unique_random_uniform(samples_shape, minval=0, maxval=1, dtype=tor.FloatTensor): """ Generates only unique random variables. May be smaller than num_samples >>> s = tor.manual_seed(1) >>> u = unique_random_uniform((5000,), maxval=25000000, dtype=tor.LongTensor) >>> print(u) tensor([ 5696, 7039, 24671, ..., 24995458, 24996430, 24998348]) >>> len(u) 5000 """ inds = Variable(tor.ones(samples_shape).type(dtype) * -1) reps = Variable(tor.LongTensor((0, ))) while inds[-1] < 0: uni = uniform.Uniform(minval, maxval) reps_np = np.array(reps, dtype=np.int64) inds = tor.cat( (inds[:reps_np[-1]], uni.sample( (samples_shape[-1] - reps_np[-1], )).type_as(inds)), dim=-1) inds, reps = tor.unique(inds, return_inverse=True) inds, _ = tor.sort(inds, dim=-1) inds = pad_up_to(inds, samples_shape, -1) return inds
def __init__(self,n,p,sig,o=0.0,bias=True): super(CUDAvoir,self).__init__() self.n = torch.tensor(n) self.p = torch.tensor(p) self.sig = torch.tensor(sig) self.v = torch.zeros(self.n) ## Recurrent Layer State Vector self.w = torch.zeros(self.n,self.n) ## Recurrent Layer Weight Matrix self.ol = nn.Linear(self.n, 1, bias=False) ## Linear Output Layer self.o = torch.tensor([o]) ## Initalize Output Neuron self.fb = nn.Linear(1, self.n, bias=False) ## Linear Feedback Layer if bias: ## Recurrent Layer Bias self.b = torch.FloatTensor(n).uniform_(0,1) else: self.b = torch.zeros(self.n) ## Populate Recurrent Layer Weight Matrix norm = normal.Normal(loc=0,scale=self.sig) uni = uniform.Uniform(0,1) for i in range(self.n): for j in range(self.n): uni_draw = uni.sample() if uni_draw < self.p: self.w[i,j] = norm.sample()
def _build_tree(self, n_levels, n_children, n_dims, low, high, scale_fact, cov_scale, mean, parent_name): if isinstance(low, Number): low = torch.ones(n_dims) * low if isinstance(high, Number): high = torch.ones(n_dims) * high cluster_means = uniform.Uniform(low + mean, high + mean).sample((n_children[0],)) pref = '\t' * (self.n_levels - n_levels) concepts = [] for i, cluster_mean in enumerate(cluster_means): logger.debug(pref + 'New cluster centered on {}'.format(cluster_mean)) concept_name = '{}{}'.format(parent_name, i) if n_levels > 1: lower_concepts = self._build_tree(n_levels - 1, n_children[1:], n_dims, low=low * scale_fact, high=high * scale_fact, scale_fact=scale_fact, cov_scale=cov_scale, mean=cluster_mean, parent_name=concept_name) concept = ComposedConcept(lower_concepts, cluster_mean=cluster_mean, id=concept_name) self.tree.add_node(concept) for c in lower_concepts: self.tree.add_edge(concept, c) self.all_nodes.add(concept) else: concept = AtomicConcept(cluster_mean, torch.eye(n_dims) * cov_scale, concept_name) self.tree.add_node(concept) self.all_nodes.add(concept) self.leaf_nodes.add(concept) concepts.append(concept) return concepts
def optimize(xL, xH, infer_args, program): beta = 10.0 # starting beta value ki = 0.95 # beta multiplier each iteration epsb = 0.05 # lower beta cutoff intmin = 0 intmax = 100 distribution = uniform.Uniform(torch.Tensor([intmin]), torch.Tensor([intmax])) inferred_paramL = torch.tensor(len(infer_args)) inferred_paramH = torch.tensor(len(infer_args)) # whether we have an input that satisfies program assertions satisfies = False while not satisfies: inferred_paramL = distribution.sample(inferred_paramL.size()) inferred_paramH = distribution.sample(inferred_paramH.size()) while not (inferred_paramL < inferred_paramH).all(): inferred_paramL = distribution.sample(inferred_paramL.size()) inferred_paramH = distribution.sample(inferred_paramH.size()) inferred_paramL.requires_grad = True inferred_paramH.requires_grad = True #with torch.no_grad(): # inferred_paramL.fill_(-5.0) # inferred_paramH.fill_(5.0) interval = None optimizer = optim.SGD([inferred_paramL, inferred_paramH], lr=0.01) while beta >= epsb: optim_state = OptimizerState(beta=beta, lambda_const=1 / 2, smooth=True) for i in range(500): def closure(): optimizer.zero_grad() optim_state.loss = torch.tensor([0.0], requires_grad=True) inferred_xL = torch.cat((xL, inferred_paramL), 0) inferred_xH = torch.cat((xH, inferred_paramH), 0) interval = AbsInterval(inferred_xL, inferred_xH, 1.0) #print("in: %s" % (str(interval))) y = program.propagate(interval, optim_state) loss = optim_state.loss loss.backward() print("b: %f, Loss: %s,\n in: %s, \n out: %s" % (beta, str(loss.item()), str(interval), str(y))) return loss optimizer.step(closure) #with torch.no_grad(): # xL -= learning_rate * xL.grad # xH -= learning_rate * xH.grad beta = beta * ki sat_state = OptimizerState(beta=beta, lambda_const=1 / 2, smooth=False) if program.satisfied_by(interval, sat_state): satisfies = True return inferred_paramL, inferred_paramH
def get_params_stoch(self, r, fc, out_mu, noise_trans): hidden_r = fc(r) batch_size = r.shape[0] epsilon = uniform.Uniform(low=0, high=1).sample( sample_shape=torch.Size([batch_size, self.hidden_dim])) epsilon_trans = epsilon + noise_trans(epsilon) hidden_noise = torch.cat((hidden_r, epsilon_trans), dim=1) mu = out_mu(hidden_noise) return mu
def __init__(self, n_actions, min_action=None, max_action=None): super(UniformPolicy, self).__init__() self.n_actions = n_actions min_action = torch.Tensor( min_action) if min_action is not None else -torch.ones(n_actions) max_action = torch.Tensor( max_action) if max_action is not None else torch.ones(n_actions) assert min_action.shape == max_action.shape and max_action.shape == torch.Size( [n_actions]) self.distr = uniform.Uniform(min_action, max_action)
def __init__(self, device, x_dim, z_dim, attr_dim, **kwargs): ''' Trainer class. Args: device: CPU/GPU x_dim: Dimension of image feature vector z_dim: Dimension of noise vector attr_dim: Dimension of attribute vector kwargs ''' self.device = device self.x_dim = x_dim self.z_dim = z_dim self.attr_dim = attr_dim self.n_critic = kwargs.get('n_critic', 5) self.lmbda = kwargs.get('lmbda', 10.0) self.beta = kwargs.get('beta', 0.01) self.bs = kwargs.get('batch_size', 32) self.gzsl = kwargs.get('gzsl', False) self.n_train = kwargs.get('n_train') self.n_test = kwargs.get('n_test') if self.gzsl: self.n_test = self.n_train + self.n_test self.eps_dist = uniform.Uniform(0, 1) self.Z_dist = normal.Normal(0, 1) self.eps_shape = torch.Size([self.bs, 1]) self.z_shape = torch.Size([self.bs, self.z_dim]) self.net_G = Generator(self.z_dim, self.attr_dim).to(self.device) self.optim_G = optim.Adam(self.net_G.parameters(), lr=1e-4) self.net_D = Discriminator(self.x_dim, self.attr_dim).to(self.device) self.optim_D = optim.Adam(self.net_D.parameters(), lr=1e-4) # classifier for judging the output of generator self.classifier = MLPClassifier(self.x_dim, self.attr_dim, self.n_train).to(self.device) self.optim_cls = optim.Adam(self.classifier.parameters(), lr=1e-4) # Final classifier trained on augmented data for GZSL self.final_classifier = MLPClassifier(self.x_dim, self.attr_dim, self.n_test).to(self.device) self.optim_final_cls = optim.Adam(self.final_classifier.parameters(), lr=1e-4) self.criterion_cls = nn.CrossEntropyLoss() self.model_save_dir = "saved_models" if not os.path.exists(self.model_save_dir): os.mkdir(self.model_save_dir)
def set_noise_dist(self, limit): """Determines the shape and magnitude of the noise.""" a = -limit b = limit if self.noise_distribution == "uniform": self.distribution = uniform.Uniform(torch.Tensor([a]), torch.Tensor([b])) elif self.noise_distribution == "normal": self.distribution = normal.Normal(torch.Tensor([0]), torch.Tensor([b])) else: print("Unknown precision type") exit()
def sample(self, num_samples): """ Parameters ---------- num_samples: tuple. (num_samples,) """ taus_uniform = uniform.Uniform(0., 1.).sample(num_samples) wang_tau = self.normal.cdf(value=self.normal.icdf(value=taus_uniform) + self.eta) return wang_tau
def load_embedding_matrix(embedding, words, embedding_size): """Add new words in the embedding matrix and return it""" embedding_matrix = torch.zeros(len(words), embedding_size) for i, word in enumerate(words): # Note: PAD embedded as sequence of zeros if word not in embedding: if word != 'PAD': embedding_matrix[i] = uniform.Uniform(-0.25, 0.25).sample( torch.Size([embedding_size])) else: embedding_matrix[i] = embedding[word] return embedding_matrix
def set_noise_dist(self): """Determines the shape and magnitude of the noise.""" a = -self.search_radius b = self.search_radius if self.noise_distribution == "uniform": self.distribution = uniform.Uniform(torch.Tensor([a]), torch.Tensor([b])) elif self.noise_distribution == "normal": self.distribution = normal.Normal(torch.Tensor([0.]), torch.Tensor([b])) else: print("Unknown distribution type") exit()
def set_noise_dist(self): """Determines the shape and magnitude of the noise.""" a = self.sr_min b = self.sr_max c = (b-a)/2. assert a != b # Sanity check if self.noise_shape == "uniform": self.distribution = uniform.Uniform(torch.Tensor([a]), torch.Tensor([b])) elif self.noise_shape == "normal": self.distribution = normal.Normal(torch.Tensor([c]), torch.Tensor([b])) else: print("Unknown distribution type") exit()
def sample(self, num_samples): """ Parameters ---------- num_samples: tuple. (num_samples,) """ taus_uniform = uniform.Uniform(0., 1.).sample(num_samples) tau_eta = taus_uniform**self.eta one_tau_eta = (1 - taus_uniform)**self.eta cpw_tau = tau_eta / ((tau_eta + one_tau_eta)**(1. / self.eta)) return cpw_tau
def sample(self, num_samples): """ Parameters ---------- num_samples: tuple. (num_samples,) """ taus_uniform = uniform.Uniform(0., 1.).sample(num_samples) if self.eta > 0: return taus_uniform**self.exponent else: return 1 - (1 - taus_uniform)**self.exponent
def load_embedmatrix(embed_index,vocab,embeddim): embedding_matrix = torch.zeros(len(vocab),embeddim) i = 0 for word in vocab.keys(): if(word not in embed_index): if(word!='<PAD>'): embedding_matrix[i,:] = uniform.Uniform(-0.25,0.25).sample(torch.Size([embeddim])) else: embedding_matrix[i,:] = embed_index[word] i+=1 return embedding_matrix
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', mean_fac=1, var_fac=.5): super(DoGConv, self).__init__() torch.autograd.set_detect_anomaly(True) # My initialization of the parameters is really hacky and not really useful, but it's only used once, # so I did not optimize it # First we sample the parameters for the Difference of Gaussian Filters uni = uniform.Uniform(torch.tensor([-1.0]), torch.tensor([1.0])) # For the variance we use the Cholesky decomposition in order to enforce pos. def. print('Initializing') self.means = nn.Parameter(mean_fac * uni.sample( (out_channels, in_channels, 2, 1, 2))[..., 0]) var_chol = var_fac * uni.sample( (out_channels, in_channels, 2, 2, 2))[..., 0] var_chol[var_chol == 0] += 1E-1 self.var_chol = nn.Parameter(torch.tril(var_chol)) self.ratios = nn.Parameter(((1 + 1E-8 + (1 - 2E-8) * uni.sample(( out_channels, in_channels, ))) / 2)[..., 0]) self.last_filters = None if bias: self.bias = nn.Parameter(uni.sample((out_channels, ))[..., 0]) else: self.bias = None self.kernel_size = kernel_size self.in_channels = in_channels self.out_channels = out_channels self.stride = stride self.padding = padding self.dilation = dilation self.groups = groups self.padding_mode = padding_mode resol = np.linspace(-1, 1, self.kernel_size) pos = torch.tensor(np.stack(np.meshgrid(resol, resol), axis=2), dtype=torch.float32) self.register_buffer('flat_pos', pos.reshape((1, self.kernel_size**2, 2)))