def get_likelihood(test_statistics, dhisto, dtypes, lib, params): ''' get likelihood object :type test_statistics: a string :param test_statistics: test statistics method chi2 / modchi2 / barlow / poisson :type dhisto: a dictionary :param dhisto: data histogram {'H':H, 'H2':H2} :type dtypes: a list / numpy array :param dtypes: list of dtypes involved :type lib: a Library object :param lib: library object to get baseline events :type params: a dictionary :param params: minimizer start values by user :return LH: a Likelihood class LH: likelihood object ''' LH = Likelihood(dhisto, test_statistics, verbose=verbose) ## special info for barlow LLH if 'barlow' in test_statistics: events = collect_events(lib, dtypes) unhistos, norms = get_barlow_params(events, params) LH.set_barlow(unhistos, norms) return LH
def __init__(self, epsilon, tsplits, n, loci_20, loci_11, loci_02): ''' Build a model with n intervals per epochs, epochs separated by tsplits.''' self.no_epochs = len(tsplits) self.no_intervals = n ts = list(linspace(epsilon, tsplits[0], num=n)) for i in xrange(1, len(tsplits)): ts.extend(linspace(tsplits[i - 1] + epsilon, tsplits[i], num=n)) self.lik = Likelihood(ts, loci_20, loci_11, loci_02)
def __init__(self, data, paramranges): self.posterior = None self.data = data self.Lik = Likelihood(data) # self.lnL = self.Lik.lnL self.lnL = self.Lik.rosenbrock2d self.paramranges = paramranges
def __init__(self,data,paramranges,n_live): self.data = data self.Lik = Likelihood(data) self.lnL = self.Lik.gauss2d self.paramranges = paramranges self.ndims = self.paramranges.ndim self.n_live = n_live
def __init__(self, epsilon, tsplits, n, loci_20, loci_11, loci_02): ''' Build a model with n intervals per epochs, epochs separated by tsplits.''' self.no_epochs = len(tsplits) self.no_intervals = n ts = list(linspace(epsilon, tsplits[0], num=n)) for i in xrange(1,len(tsplits)): ts.extend(linspace(tsplits[i-1]+epsilon, tsplits[i], num=n)) self.lik = Likelihood(ts, loci_20, loci_11, loci_02)
def __init__(self,data,paramranges): self.posterior = None self.data = data self.Lik = Likelihood(data) # self.lnL = self.Lik.lnL self.lnL = self.Lik.gauss2d # self.lnL = self.Lik.pseudoplanck # self.lnL = self.Lik.rosenbrock2d self.paramranges = paramranges self.ndims = paramranges.shape[0] # if previous file exists, delete it if os.path.isfile('samples.txt'): os.remove('samples.txt') print('Removed samples.txt from previous run')
class FourParamIM(object): def __init__(self, ts, loci_20, loci_11, loci_02): self.ts = ts self.lik = Likelihood(ts, loci_20, loci_11, loci_02) def log_likelihood(self, c1, c2, m12, m21): '''Compute the log likelihood for the four parameter model.''' c1s = [c1] * len(self.ts) c2s = [c2] * len(self.ts) m12s = [m12] * len(self.ts) m21s = [m21] * len(self.ts) return self.lik.log_likelihood(c1s, c2s, m12s, m21s) def __call__(self, c1, c2, m12, m21): return self.log_likelihood(c1, c2, m12, m21) def mle_parameters(self, c1, c2, m12, m21): ''' Estimate MLE parameters. Provided parameters are used as start values.''' def function(x): c1, c2, m12, m21 = x return -self.log_likelihood(c1, c2, m12, m21) return fmin(function, [c1, c2, m12, m21])
class FourParamIM(object): def __init__(self, ts, loci_20, loci_11, loci_02): self.ts = ts self.lik = Likelihood(ts, loci_20, loci_11, loci_02) def log_likelihood(self, c1, c2, m12, m21): '''Compute the log likelihood for the four parameter model.''' c1s = [c1] * len(self.ts) c2s = [c2] * len(self.ts) m12s = [m12] * len(self.ts) m21s = [m21] * len(self.ts) return self.lik.log_likelihood(c1s, c2s, m12s, m21s) def __call__(self, c1, c2, m12, m21): return self.log_likelihood(c1, c2, m12, m21) def mle_parameters(self, c1, c2, m12, m21): ''' Estimate MLE parameters. Provided parameters are used as start values.''' def function(x): c1, c2, m12, m21 = x return -self.log_likelihood(c1, c2, m12, m21) return fmin(function, [c1,c2,m12,m21])
class EpochsIM(object): def __init__(self, epsilon, tsplits, n, loci_20, loci_11, loci_02): ''' Build a model with n intervals per epochs, epochs separated by tsplits.''' self.no_epochs = len(tsplits) self.no_intervals = n ts = list(linspace(epsilon, tsplits[0], num=n)) for i in xrange(1,len(tsplits)): ts.extend(linspace(tsplits[i-1]+epsilon, tsplits[i], num=n)) self.lik = Likelihood(ts, loci_20, loci_11, loci_02) def log_likelihood(self, c1s, c2s, m12s, m21s): '''Compute the log likelihood for the four parameter model.''' assert len(c1s) == self.no_epochs assert len(c2s) == self.no_epochs assert len(m12s) == self.no_epochs assert len(m21s) == self.no_epochs def rep(lst, n): result = [] for elm in lst: result.extend([elm] * n) return result IM_c1s = rep(c1s, self.no_intervals) IM_c2s = rep(c2s, self.no_intervals) IM_m12s = rep(m12s, self.no_intervals) IM_m21s = rep(m21s, self.no_intervals) return self.lik.log_likelihood(IM_c1s, IM_c2s, IM_m12s, IM_m21s) def __call__(self, c1s, c2s, m12s, m21s): return self.log_likelihood(c1s, c2s, m12s, m21s) def _wrap_params(self, c1s, c2s, m12s, m21s): return c1s + c2s + m12s + m21s def _unwrap_params(self, x): c1s = x[:self.no_epochs] c2s = x[self.no_epochs:2*self.no_epochs] m12s = x[2*self.no_epochs:3*self.no_epochs] m21s = x[3*self.no_epochs:] return c1s, c2s, m12s, m21s def mle_parameters(self, c1s, c2s, m12s, m21s): ''' Estimate MLE parameters. Provided parameters are used as start values.''' def function(x): if min(x) < 0: return float('Inf') c1, c2, m12, m21 = self._unwrap_params(x) return -self.log_likelihood(c1, c2, m12, m21) def callback(x): c1s,c2s,m12s,m21s = self._unwrap_params(x) print 'c1s:', c1s print 'c2s:', c2s print 'm12s:', m12s print 'm21s:', m21s print return self._unwrap_params(fmin(function, self._wrap_params(c1s,c2s,m12s,m21s), maxiter=1000, callback=callback))
def __init__(self, ts, loci_20, loci_11, loci_02): self.ts = ts self.lik = Likelihood(ts, loci_20, loci_11, loci_02)
# 24 x 1 vector of positions corresponding to seg. sites positions = np.loadtxt("example_data/positions.txt", dtype=int) times = [10, 20, 30, 40, 50] r = 1e-4 N = 2000 # True selected position is 568 liks = [] print("## Pass 1. Testing") for i, pos in enumerate(positions): dta = data[:, (i, ), :] if np.min(dta[-1]) < 0.02: # Skip sites which are are lost continue ih = init_haps[:, (i, )] lik = Likelihood(data[:, (i, ), :], init_haps[:, (i, )], times, [pos], pos, None) fit = lik.maxlik(N=N, log10r=math.log10(r), h=0.5, bounds=(-.15, .15)) s_hat = fit.x ml = -fit.fun ml0 = lik.likelihood(N, r, 0.5, 0.0) lr = 2 * (ml - ml0) if lr < 0: print(dta, ) print("Site: %d\tLoglik ratio: %g" % (pos, lr)) liks.append((pos, lr)) print("## Pass 2. Estimation") maxpos = sorted(liks, key=lambda tup: -tup[1])[0][0] print("Site with highest LR: %d" % maxpos) print("Estimating a 5-locus model at this site...") mpi = tuple(positions).index(maxpos)
import dynesty from dynesty import plotting as dyplot from likelihood import Likelihood data = np.load('data.npy') # Define the dimensionality of our problem. ndim = 2 # Define our 3-D correlated multivariate normal log-likelihood. # C = np.identity(ndim) # C[C==0] = 0.95 # Cinv = np.linalg.inv(C) # lnorm = -0.5 * (np.log(2 * np.pi) * ndim + # np.log(np.linalg.det(C))) L = Likelihood(data) # def loglike(x): # return -0.5 * np.dot(x, np.dot(Cinv, x)) + lnorm # Define our uniform prior via the prior transform. def ptform(u): return 10. * u # Sample from our distribution. sampler = dynesty.NestedSampler(L.lnL, ptform, ndim, bound='single', nlive=500) sampler.run_nested(dlogz=0.1) res = sampler.results # Plot results.
import numpy as np from likelihood import Likelihood data = np.load('data.npy') L = Likelihood(data) print( L.pseudoplanck([ 3.20090859e-01, 2.21224104e-02, 6.69496793e-01, 2.09219606e-09, 9.63266374e-01, 5.24779614e-02, 8.12628423e-01 ])) # print( L.rosenbrock2d([1,1]) ) # print( L.rosenbrock2d([1,2]) ) # print( L.rosenbrock2d([2,1]) ) # print(L.lnL([5,3])) # print(L.lnL([5,2])) # print(L.lnL([15,13])) # print(L.lnL([3,3])) # integrate it over entire parameter space # x = np.linspace(0,10,1000) # y = np.linspace(0,10,1000) # grid = np.zeros((1000,1000)) # for i,xi in enumerate(x): # print( i ) # for j,yj in enumerate(y): # grid[i,j] = L.lnL([xi,yj]) # grid = np.exp(grid) # ix = np.zeros(1000)
import numpy as np import sys sys.path.insert(0, "./modules") from data import ToyInverseProblem, ToyGPData, InverseProblem from means import ZeroMean from covariances import MaternCov from gaussianprocesses import GaussianProcess, ConditionedGaussianProcess from gpvisual import GPVisual from likelihood import Likelihood # Set up Inverse Problem ip = ToyInverseProblem(10) li = Likelihood(ip) gpdata = ToyGPData(10) gpdata = InverseProblem(gpdata.locations, li.function, gpdata.variance) mean_fct = ZeroMean() cov_fct = MaternCov() gp = GaussianProcess(mean_fct, cov_fct) cond_gp = ConditionedGaussianProcess(gp, gpdata) import matplotlib.pyplot as plt gpvis = GPVisual(cond_gp) gpvis.addplot_deviation() gpvis.addplot_mean() gpvis.addplot_observations() plt.show()
def calculate_clusters(data_file_name, init_method="kmeans", max_iterations=10, max_internal_iterations=10, use_gpu=False, config: tf.ConfigProto = tf.ConfigProto()): start = time.time() iterations = 0 internal_iterations = 0 loglikelihood_history = [] with tf.device("/gpu:0" if use_gpu else "/cpu:0"): data = GraphData.load_graph_data(data_file_name) if init_method == "random": initial_clusters = find_random_initial_clustering(data) else: initial_clusters = find_initial_clustering(data, config) tau = Tau(data, initial_clusters) multinomial = Multinomial(data, tau) markov_chain = MarkovChain(data, tau) likelihood = Likelihood(data, tau, multinomial, markov_chain) tau.init(data, multinomial.density, markov_chain.stationary, markov_chain.trans) generate_time_end = time.time() likelihood_result = None trans_result = None with tf.Session(config=config) as session: # init session.run(tf.global_variables_initializer()) tau.update_taum(session) multinomial.update_density(session) previous_log = -1e30 for i in range(max_iterations): iterations += 1 previous_log_internal = -1e30 for z in range(max_internal_iterations): internal_iterations += 1 tau.update_tau(session) new_log = likelihood.calculate(session) if abs(previous_log_internal - new_log) < 1e-7: break loglikelihood_history.append(new_log) previous_log_internal = new_log trans_result = markov_chain.update_trans(session) markov_chain.update_stationary(session) multinomial.update_density(session) new_log = likelihood.calculate(session) likelihood_result = new_log loglikelihood_history.append(likelihood_result) if previous_log > new_log: break previous_log = new_log memory_gpu = 0 if use_gpu: memory_gpu = session.run( tf.contrib.memory_stats.MaxBytesInUse()) / 1024 / 1024 end = time.time() membership = __find_element_membership(data, tau) memory_cpu = psutil.Process().memory_info().rss / 1024 / 1024 results = Results(likelihood_result, trans_result, membership, initial_clusters) measurements = Measurements(generate_time_end - start, end - generate_time_end, memory_cpu, memory_gpu, iterations, internal_iterations, loglikelihood_history, data.N) return results, measurements
class EpochsIM(object): def __init__(self, epsilon, tsplits, n, loci_20, loci_11, loci_02): ''' Build a model with n intervals per epochs, epochs separated by tsplits.''' self.no_epochs = len(tsplits) self.no_intervals = n ts = list(linspace(epsilon, tsplits[0], num=n)) for i in xrange(1, len(tsplits)): ts.extend(linspace(tsplits[i - 1] + epsilon, tsplits[i], num=n)) self.lik = Likelihood(ts, loci_20, loci_11, loci_02) def log_likelihood(self, c1s, c2s, m12s, m21s): '''Compute the log likelihood for the four parameter model.''' assert len(c1s) == self.no_epochs assert len(c2s) == self.no_epochs assert len(m12s) == self.no_epochs assert len(m21s) == self.no_epochs def rep(lst, n): result = [] for elm in lst: result.extend([elm] * n) return result IM_c1s = rep(c1s, self.no_intervals) IM_c2s = rep(c2s, self.no_intervals) IM_m12s = rep(m12s, self.no_intervals) IM_m21s = rep(m21s, self.no_intervals) return self.lik.log_likelihood(IM_c1s, IM_c2s, IM_m12s, IM_m21s) def __call__(self, c1s, c2s, m12s, m21s): return self.log_likelihood(c1s, c2s, m12s, m21s) def _wrap_params(self, c1s, c2s, m12s, m21s): return c1s + c2s + m12s + m21s def _unwrap_params(self, x): c1s = x[:self.no_epochs] c2s = x[self.no_epochs:2 * self.no_epochs] m12s = x[2 * self.no_epochs:3 * self.no_epochs] m21s = x[3 * self.no_epochs:] return c1s, c2s, m12s, m21s def mle_parameters(self, c1s, c2s, m12s, m21s): ''' Estimate MLE parameters. Provided parameters are used as start values.''' def function(x): if min(x) < 0: return float('Inf') c1, c2, m12, m21 = self._unwrap_params(x) return -self.log_likelihood(c1, c2, m12, m21) def callback(x): c1s, c2s, m12s, m21s = self._unwrap_params(x) print 'c1s:', c1s print 'c2s:', c2s print 'm12s:', m12s print 'm21s:', m21s print return self._unwrap_params( fmin(function, self._wrap_params(c1s, c2s, m12s, m21s), maxiter=1000, callback=callback))