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,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, 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, 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')
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
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 __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.
