def _cdf(self, x, gamma): cte = np.sqrt( np.pi) * gamma_function(gamma - 0.5) / gamma_function(gamma) a = hyp2f1(0.5, gamma, 1.5, -x**2) return 0.5 + x * (a / cte)
def compute_matrix_element(gamma): betai = gamma**2 / 2.0 betaf = np.sqrt(1.0 + gamma**4 / 4.0) integral = np.pi * quad(func, 0, np.infty)[0] first_sqrt = (1.0 / (2.0**betai * gamma_function(betai + 1)))**0.5 second_sqrt = (1.0 / (2.0**betaf * gamma_function(betaf + 1)))**0.5 return R * gamma**2 / 2.0 / np.pi * first_sqrt * second_sqrt * integral
def _logpdf3d(self, x, loc, U, log_pdet, gamma,dim): # U is inverse Cholesky, so only one product U*x instead of sqrt(x*U*U.T*x) quaddist = np.square(np.dot(x - loc,U)).sum(axis=-1) a = 1.5*np.log(np.pi) b = np.log(gamma_function(0.5*(gamma-3.))) c = np.log(gamma_function(0.5*gamma)) log_cte = a + b -c log_d = -0.5*gamma*np.log1p(quaddist) - log_cte - 3.*log_pdet return log_d
def levy(self): temp = np.power( ((gamma_function(1 + self.lamda) * np.sin(np.pi * (self.lamda / 2))) / (gamma_function((1 + self.lamda) / 2) * self.lamda * np.power(2, ((self.lamda - 1) / 2)))), 1 / self.lamda) u = np.random.normal(0, temp) v = np.random.normal(0, 1) r = u / (np.power(abs(v), (1 / self.lamda))) return r # random walk value
def _cdf3d(self, x, rc, gamma): # use only to generate random variates a = x**2 + rc**2 hg = gamma_function(0.5*gamma) hg3 = gamma_function(0.5*(gamma-3.)) hyp = hyp2f1(-0.5,0.5*gamma,0.5,-(x/rc)**2) b = -(rc**gamma)*a*(rc**2 + (gamma-1.)*(x**2)) c = (rc**4)*(a**(0.5*gamma))*hyp up = 4.*(a**(-0.5*gamma))*hg*( b + c) down = (gamma-3.)*(gamma-1.)*np.sqrt(np.pi)*(rc**3)*x*hg3 result = up/down return result
def kernelKNN(self, xi, xj): """ kNN kernel """ dim = len(xi) if self.volume is None: self.volume = np.pi**(dim // 2) / gamma_function(dim // 2 + 1) dist = np.linalg.norm(xi - xj, 2) density_at_mean = self.knnK / (self.Num_points * self.volume) * dist return density_at_mean
def weibull_fit(x): '''Fit Weibull parameters using PWM. Return (shape, location, scale). See section 2.2.3.1 of [1] and [2]. ''' M0 = M(0, x) M1 = M(1, x) M2 = M(2, x) M3 = M(3, x) delta = (4 * (M0 * (3 * M2 - M3 - M1) - M1**2) / (M0 - 8 * M1 + 12 * M2 - 4 * M3)) gamma = log(2) / log((2 * M1 - M0) / (2 * (5 * M1 - M0 - 6 * M2 + 2 * M3))) beta = (M0 - delta) / gamma_function(1 + 1 / gamma) return gamma, delta, beta
def normal_inv_gamma(alpha, beta, delta, gamma, mu, sigma): """Return the probability density function for the normal inverse gamma density at (mu, sigma) Args: alpha: shape of variance beta: scale of variance delta: mean of mu gamma: precision of mu mu: normal mean sigma: normal standard deviation Returns: a probability density function """ # You will find scipy.special.gamma useful mantissa_part = (np.sqrt(gamma) / sigma * np.sqrt(2 * np.pi)) * ( beta**alpha / gamma_function(alpha)) * (1 / sigma**2)**(alpha + 1) exponent_part = -1 * (2 * beta + gamma * ((delta - mu)**2)) / 2 * sigma**2 pdf = mantissa_part * np.exp(exponent_part) return pdf
def weibull_fit(x): '''Fit Weibull parameters using PWM. Return (shape, location, scale). See section 2.2.3.1 of [1] and [2]. ''' M0 = M(0, x) M1 = M(1, x) M2 = M(2, x) M3 = M(3, x) delta = (4 * (M0 * (3 * M2 - M3 - M1) - M1**2) / (M0 - 8*M1 + 12*M2 - 4*M3)) gamma = log(2) / log((2*M1 - M0) / (2 * (5*M1 - M0 - 6*M2 + 2*M3))) beta = (M0 - delta) / gamma_function(1 + 1/gamma) return gamma, delta, beta
def gaussian_square(n, t, fwhm): """We obtain a normalized function of the form 2⋅n ⎛t⎞ -⎜─⎟ ⎝τ⎠ ──────── 2 ℯ with the given (amplitude square) fwhm. """ if str(n) == "oo": return heaviside_pi(t / fwhm) / np.sqrt(fwhm) elif n < 1: raise ValueError else: tau = fwhm * np.log(2)**(-1 / (2.0 * n)) / 2 X = t / tau norm = np.sqrt(2 * tau * gamma_function(1 + 1 / (2.0 * n))) return np.exp(-X**(2 * n) / 2) / norm
def normal_inv_gamma(alpha, beta, delta, gamma, mu, sigma): """Return the probability density function for the normal inverse gamma density at (mu, sigma) Args: alpha: shape of variance beta: scale of variance delta: mean of mu gamma: precision of mu mu: normal mean sigma: normal standard deviation Returns: a probability density function """ # You will find scipy.special.gamma useful t1 = np.sqrt(gamma) / (sigma * np.sqrt(2 * np.pi)) t2 = beta**alpha / gamma_function(alpha) t3 = (1 / (sigma**2))**(alpha + 1) t4 = np.exp(-(2 * beta + gamma * ((delta - mu)**2)) / (2 * (sigma**2))) return t1 * t2 * t3 * t4
def _variance_power_folded_norm(a, sigma=1): # Calculates E[X^2] where X ~ power normal distribution (a) return (2**(a+0.5) * sigma**(2*a) * gamma_function(a + 0.5)) / np.sqrt(2*np.pi)
def _pdf(self, x, gamma): cte = np.sqrt( np.pi) * gamma_function(gamma - 0.5) / gamma_function(gamma) nx = (1. + x**2)**(-gamma) return nx / cte
def dirichlet_pdf_log(self, x, alpha): return np.sum(np.log(np.power(x, alpha - 1))) - np.sum( np.log(gamma_function(alpha))) + np.log( gamma_function(np.sum(alpha)))
def _pdf(self,x,gamma): cte = np.sqrt(np.pi)*gamma_function(0.5*(gamma-1.))/gamma_function(gamma/2.) nx = (1. + x**2)**(-0.5*gamma) return nx/cte
def mean_power_folded_norm(a, sigma=1): # Calculates the mean of a power folded normal distribution return (2**((a+1)/2) * sigma**a * gamma_function((a+1)/2)) / np.sqrt(2*np.pi)
def _gamma_pdf(x, alpha=1.0, beta=1.0): # Simple wrapper for the scipy gamma function top = beta**alpha * x**(alpha - 1) * np.exp(-beta * x) return top / gamma_function(alpha)
(2 * np.square(sigma[i]))) for i in range(len(p)) ], 1), 1) accuracy_loss = -1 * tf.reduce_mean(f) # calculate entropy estimation mutual_squared_distances = tf.reduce_sum( tf.square(tf.expand_dims(y, 0) - tf.expand_dims(y, 1)), 2, name='mutual_squared_distances') nearest_distances = tf.sqrt( -1 * tf.nn.top_k(-1 * mutual_squared_distances, k=2)[0][:, 1] + 1e-7, name='nearest_distances') entropy_estimate = tf.identity( tf.reduce_mean(tf.log(nearest_distances + 1e-7)) + tf.digamma(tf.cast(train_batch_size, tf.float32)) + np.euler_gamma + (0.5) * np.log(np.pi) - np.log(gamma_function(1 + 1 / 2)), name='entropy_estimate') diversity_loss = -1 * entropy_estimate # this is the l2 regularization gauge_fixing = tf.reduce_mean(tf.reduce_sum(tf.square(y - 0.0), 1), name='gauge_fixing') loss = accuracy_loss + lamda * diversity_loss + gamma * gauge_fixing learning_rate_ = tf.Variable(learning_rate, dtype=tf.float32, trainable=False, name='learning_rate') update_learning_rate = tf.assign(learning_rate_, learning_rate_ * learning_rate_rate,
def mf(x): V1 = p0 * beta * ( x / M0)**alpha * np.exp(-(x / M0)**beta) / gamma_function(alpha / beta) V2 = pg * (x / Mg)**gamma * np.exp(-(x / Mg)) return V1 + V2