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)
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))
