def getInfo(data, target, theta):
afterSigmoid = sigmoid(data.dot(theta))
firstList = [ ]
for k in afterSigmoid:
m = []
for x in k:
m.append(bigfloat.log(x,bigfloat.precision(precision)))
firstList.append(m)
secondList = [ ]
for k in afterSigmoid:
m = []
for x in k:
m.append(bigfloat.log( bigfloat.sub(1. , x) , bigfloat.precision(precision)))
secondList.append(m)
Ein = 0.
m = []
for x,y in zip(firstList, secondList):
for a,b,t in zip(x,y,target):
value = bigfloat.add( bigfloat.mul(t[0],a, bigfloat.precision(precision)) , bigfloat.mul( bigfloat.sub(1. ,t[0], bigfloat.precision(precision)) ,a, bigfloat.precision(precision)))
m.append(value)
for item in m:
Ein = bigfloat.add(item, Ein, bigfloat.precision(precision))
Ein = - Ein
print(Ein)
gradient = -data.T.dot(target-afterSigmoid)
return (Ein, gradient)
def BICrss(n, k, rss): """Calculate the Bayesian Information Criterion value, using: - n: number of observations - k: number of parameters - rss: residual sum of squares """ return n + n * log(2 * pi) + n * log(rss / n) + (log(n)) * (k + 1)
def AICrss(n, k, rss): """Calculate the Akaike Information Criterion value, using: - n: number of observations - k: number of parameters - rss: residual sum of squares """ return n * log((2 * pi) / n) + n + 2 + n * log(rss) + 2 * k
def HQCrss(n, k, rss): """Calculate the Hannan-Quinn information Criterion value, using: - n: number of observations - k: number of parameters - rss: residual sum of squares """ return n * log(rss / n) + 2 * k * log(log(n))
def degdist_bigfloat(self, maxdeg, n, mindeg=0):
"""Returns the degree distribution from 0 to maxdeg degree.
It should be use with the (iterated) link probability measure.
Parameters:
maxdeg: the maximal degree for we calculate the degree distribution
n: the size of the network (the number of vertices)
Returns:
rho: the degree distribution as a list with length of maxdeg+1.
The index k gives the probability of having degree k.
"""
assert isinstance(n, int) and isinstance(maxdeg, int) and n > maxdeg
import bigfloat
context = bigfloat.Context(precision=10)
divs = self.divs
n_intervals = len(divs)
lengths = [divs[i] - divs[i - 1] for i in xrange(1, n_intervals)]
lengths.insert(0, divs[0])
log_lengths = numpy.log(lengths)
# Eq. 5, where ...
avgdeg = [
bigfloat.BigFloat(n * sum(
[self.probs[i][j] * lengths[j] for j in xrange(n_intervals)]),
context=context) for i in xrange(n_intervals)
]
#log_factorial = [ 0.5*bigfloat.log(2*math.pi, context=context) + (d+.5)*bigfloat.log(d, context=context) - d
# for d in xrange(1,maxdeg+1) ]
log_factorial = [
bigfloat.log(bigfloat.factorial(k), context=context)
for k in xrange(1, maxdeg + 1)
]
log_factorial.insert(0, 0)
rho = [bigfloat.BigFloat(0, context=context)] * (maxdeg + 1)
# Eq. 4
for i in xrange(n_intervals):
# Eq. 5
log_rho_i = [
(bigfloat.mul(k, bigfloat.log(avgdeg[i]), context=context) -
log_factorial[k] - avgdeg[i])
for k in xrange(mindeg, maxdeg + 1)
]
log_rho_i_length = [
log_rho_i[k] + log_lengths[i]
for k in xrange(mindeg, maxdeg + 1)
]
for k in xrange(mindeg, maxdeg + 1):
rho[k] += bigfloat.exp(log_rho_i_length[k], context=context)
return rho
def extrainfo(self):
try:
expected = self.calc_ExpectedToBuy()
expectedWithBuy = self.calc_ExpectedToBuy(self.lastbuy)
print "\n==Information=="
print "To complete the album alone is expected " \
"you to buy {:.2f} stickers ({:.2f} packs)" \
", paying {}{:.2f} for it.".format(expected, expected / self.spp,
self.highersign,
(expected *
self.valueperunit)
/ self.valuetohigher)
print "You will need to pay " \
"{}{:.2f} for {:.2f} stickers if you plan to buy the last " \
"{}{} directly " \
"from the company.".format(self.highersign,
(expectedWithBuy *
self.valueperunit)
/ self.valuetohigher,
expectedWithBuy,
self.lastbuy if self.lastbuy > 1 else "\b",
" stickers" if self.lastbuy > 1 else " sticker")
print "N=n*(log(n)+Euler constant) = " \
"{}".format(self.n * bigfloat.log(self.n) +
bigfloat.const_euler())
print "---------------"
except ZeroDivisionError:
print("Cannot devide by zero.")
def JoLe_eq(temp, B0, E, E_D, T_pk):
"""Johnson - Lewin model, used for estimating trait values at
a given temperature."""
global K
function = B0 * exp(1) ** (-E / (K * temp)) / (1 + exp(1) ** (1 / K
* (E_D / T_pk + K * log(E / (E_D - E)) - (E_D / temp))))
return numpy.array(map(log, function), dtype=numpy.float64)
def visualize(self):
print("-" * 80)
intervals = {'value': [], 'length': [], 'probability': []}
self.print_intervals(intervals)
v, l, p = intervals['value'], intervals['length'], intervals[
'probability']
h = [bf.log(p[i] / l[i]) for i in range(len(v))]
plt.bar(v, h, width=l, align='edge')
plt.show()
print("-" * 80 + "\n")
def degdist_bigfloat(self, maxdeg, n, mindeg=0):
"""Returns the degree distribution from 0 to maxdeg degree.
It should be use with the (iterated) link probability measure.
Parameters:
maxdeg: the maximal degree for we calculate the degree distribution
n: the size of the network (the number of vertices)
Returns:
rho: the degree distribution as a list with length of maxdeg+1.
The index k gives the probability of having degree k.
"""
assert isinstance(n, int) and isinstance(maxdeg, int) and n > maxdeg
import bigfloat
context = bigfloat.Context(precision=10)
divs = self.divs
n_intervals = len(divs)
lengths = [divs[i] - divs[i-1] for i in xrange(1, n_intervals)]
lengths.insert(0, divs[0])
log_lengths = numpy.log(lengths)
# Eq. 5, where ...
avgdeg = [bigfloat.BigFloat(n*sum([self.probs[i][j]*lengths[j]
for j in xrange(n_intervals)]), context=context) for i in xrange(n_intervals)]
#log_factorial = [ 0.5*bigfloat.log(2*math.pi, context=context) + (d+.5)*bigfloat.log(d, context=context) - d
# for d in xrange(1,maxdeg+1) ]
log_factorial = [bigfloat.log(bigfloat.factorial(k), context=context)
for k in xrange(1, maxdeg+1)]
log_factorial.insert(0, 0)
rho = [bigfloat.BigFloat(0, context=context)] * (maxdeg+1)
# Eq. 4
for i in xrange(n_intervals):
# Eq. 5
log_rho_i = [(bigfloat.mul(k, bigfloat.log(avgdeg[i]), context=context) - log_factorial[k] - avgdeg[i])
for k in xrange(mindeg, maxdeg+1)]
log_rho_i_length = [log_rho_i[k] + log_lengths[i]
for k in xrange(mindeg, maxdeg+1)]
for k in xrange(mindeg, maxdeg+1):
rho[k] += bigfloat.exp(log_rho_i_length[k], context=context)
return rho
def GenLn2(self):
with precision(128):
ln2 = bigfloat.log(2.0)
l = bin64(ln2).hex1int() & 0xffffffffe0000000
ld = bin64(hex_to_double(l))
print(".ln_lead = ", double_to_hex(ld), ld.hex())
with precision(128):
t = ln2 - ld
tail = bin64(t)
print(".ln_tail = ", double_to_hex(tail), tail.hex())
def GenTable(self):
#newsize = self.table_size + 1
newsize = self.table_size << 1
for j in range(0, newsize): # 0 to 256
with precision(256):
f = bigfloat.log(1 + j / newsize)
f_leadint = bin64(f).hex1int() & 0xfffffffff0000000
f_tail = f - hex_to_double(f_leadint)
#print("%x"%f_leadint, double_to_hex(float(f_tail)))
print("{", "0x%x, %s" % (f_leadint, double_to_hex(f_tail)), "},")
def GenLn2(self):
with precision(128):
ln2 = bigfloat.log(2.0)
h = -ln2 / self.table_size
hint = bin64(h).hex1int() & 0xffffffffffff0000
hd = bin64(hex_to_double(hint))
print(".ln2by_tblsz_head = ", hd.hex())
with precision(128):
t = h - hd
tail = bin64(t)
print(".ln2by_tblsz_tail = ", tail.hex())
def compute_entropy(probabilities):
# Compute Shannon Entropy of the given distribution
# https://en.wikipedia.org/wiki/Entropy_(information_theory)
# SE = - ∑ P_i * log_b( P_i )
# where
# P_i is the probability of sample i
# log_b is log-base-b
# It is not clear in the Pereyra paper what units were used, so we
# try the two most common bases: 2 and e
entropy = 0.0
for probability in probabilities:
# base e: entropy measured in nats
entropy -= probability * bigfloat.log(probability)
return entropy
def compute_entropy(probabilities):
# Compute Shannon Entropy of the given distribution
# https://en.wikipedia.org/wiki/Entropy_(information_theory)
# SE = - ∑ P_i * log_b( P_i )
# where
# P_i is the probability of sample i
# log_b is log-base-b
# It is not clear in the Pereyra paper what units were used, so we
# try the two most common bases: 2 and e
entropy = 0.0
for probability in probabilities:
# base e: entropy measured in nats
entropy -= probability * bigfloat.log(probability)
return entropy
def JoLe(params, temp, data):
"""Johnson - Lewin model, used by the optimizer."""
global K
# Get the parameters.
E = params['E'].value
E_D = params['E_D'].value
T_pk = params['T_pk'].value
B0 = params['B0'].value
# Prevent E being higher than E_D, by punishing the optimizer with huge
# numbers when that is the case.
if E >= E_D:
return 1e10
# Otherwise, fit the model!
function = B0 * exp(1) ** (-E / (K * temp)) / (1 + exp(1) ** (1 / K
* (E_D / T_pk + K * log(E / (E_D - E)) - (E_D / temp))))
return numpy.array(map(log, function) - data, dtype=numpy.float64)
def get_free_energies(self):
"""
Give the free energy by
.. math::
F_{\\text{all configs}}(T, V) = - k_B T \ln Z_{\\text{all configs}}(T, V).
:return: The free energy on the temperature-volume grid.
"""
try:
import bigfloat
except ImportError:
raise ImportError(
"Install ``bigfloat`` package to use {0} object!".format(
self.__class__.__name__))
with bigfloat.precision(self.precision):
log_z = np.array([bigfloat.log(d) for d in self.total],
dtype=float)
return -K * self.temperature * log_z
def get_E_and_E_D(dataset):
"""Estimate E and E_D using linear regression."""
global K
temps = []
trait_vals = []
# Convert temps to 1/K*(temps + 273.15).
for row in dataset:
temps.append(1 / (K * (float(row[4]) + 273.15)))
trait_vals.append(log(float(row[5])))
# Perform a regression of temps vs trait_vals.
(slope, intercept, r_value, p_value, std_err) = linregress(temps,
trait_vals)
# Return arbitrary values if the regression was not successful.
if numpy.isnan(slope):
return 10, 30
# Otherwise, return the slope as E and slope * 10 as E_D.
else:
return abs(slope), abs(slope) * 10
def get_free_energies(self):
"""
The free energy calculated from the partition function :math:`Z_{\\text{all configs}}(T, V)` by
.. math::
F_{\\text{all configs}}(T, V) = - k_B T \ln Z_{\\text{all configs}}(T, V).
:return: The free energy on a temperature-volume grid.
"""
try:
import bigfloat
except ImportError:
raise ImportError(
"Install ``bigfloat`` package to use {0} object!".format(
self.__class__.__name__))
with bigfloat.precision(self.precision):
log_z = np.array([
bigfloat.log(d)
for d in self.partition_functions_for_each_configuration
],
dtype=float)
return -K * self.temperature * log_z
def absErrorAE(predictedTime, survivalTime):
return abs(bf.log(predictedTime) - bf.log(survivalTime))
def fit_sharpe_schoolfield(dataset, B0_start, E_start, T_pk_start, E_D_start):
"""Fit the Sharpe-Schoolfield model."""
global K
# Store temperatures and log-transformed trait values.
temps = []
trait_vals = []
for row in dataset:
# Convert temperatures to Kelvin.
temps.append(float(row[4]) + 273.15)
trait_vals.append(log(float(row[5])))
# Convert temps and trait_vals to numpy arrays.
temps = numpy.array(temps, dtype=numpy.float64)
trait_vals = numpy.array(trait_vals, dtype=numpy.float64)
# Prepare the parameters and their bounds.
params = Parameters()
params.add('B0', value=B0_start)
params.add('E', value=E_start, min=0.00001, max=10)
params.add('E_D', value=E_D_start, min=0.00001, max=30)
params.add('T_pk', value=T_pk_start, min=273.15 - 10, max=273.15 + 150)
try:
# Try and fit!
result = minimize(sharpe_schoolf,
params,
args=(temps, trait_vals),
xtol=1e-12,
ftol=1e-12,
maxfev=100000)
except Exception:
# If fitting failed, return.
return None
# Check if we have a covariance matrix (just in case we don't for any reason).
if result.covar is None:
return None
# Since we're still here, fitting was successful!
# In the highly unlikely scenario that E == E_D, add a tiny number to
# E_D to avoid division by zero.
if params['E'].value == params['E_D'].value:
params['E_D'].value += 0.000000000000001
# Calculate B(T_ref), B_pk, and the operational niche width.
B_T_ref = exp(1)**sharpe_schoolf_eq(numpy.array([273.15]),
params['B0'].value, params['E'].value,
params['E_D'].value,
params['T_pk'].value)
B_pk = exp(1)**sharpe_schoolf_eq(numpy.array([params['T_pk'].value]),
params['B0'].value, params['E'].value,
params['E_D'].value, params['T_pk'].value)
operational_niche_width = calculate_operational_niche_width(params,
B_pk[0],
T_ref=273.15)
robjects.r("rm(list=ls())")
robjects.r.assign("K", K)
robjects.r.assign("covar_mat", result.covar)
robjects.r.assign(
"Schoolf_coeffs",
robjects.FloatVector((params['B0'].value, params['E'].value,
params['E_D'].value, params['T_pk'].value)))
B_T_ref_stderr = robjects.r(
"deltamethod( ~ x1 / (1 + (x2/(x3 - x2)) * exp(x3 / K * (1 / x4 - 1 / 273.15))), Schoolf_coeffs, covar_mat)^2"
)[0]
B_T_ref_1_4_stderr = robjects.r(
"deltamethod( ~ (x1 / (1 + (x2/(x3 - x2)) * exp(x3 / K * (1 / x4 - 1 / 273.15))))^(1/4), Schoolf_coeffs, covar_mat)^2"
)[0]
log_E_stderr = robjects.r(
"deltamethod(~ log(x2), Schoolf_coeffs, covar_mat)^2")[0]
T_pk_squared_stderr = robjects.r(
"deltamethod(~ x4^2, Schoolf_coeffs, covar_mat)^2")[0]
log_E_D_stderr = robjects.r(
"deltamethod(~ log(x3), Schoolf_coeffs, covar_mat)^2")[0]
B_pk_stderr = robjects.r(
"deltamethod( ~ (x1 * exp((-x2) * (1/(K * x4) - 1/(K * 273.15)))) / (1 + (x2/(x3 - x2))), Schoolf_coeffs, covar_mat)^2"
)[0]
log_B_pk_stderr = robjects.r(
"deltamethod( ~ log((x1 * exp((-x2) * (1/(K * x4) - 1/(K * 273.15)))) / (1 + (x2/(x3 - x2)))), Schoolf_coeffs, covar_mat)^2"
)[0]
[operational_niche_width_stderr, log_operational_niche_width_stderr
] = bootstrap_operational_niche_width(dataset)
# Calculate the fitted trait values.
pred = exp(1)**sharpe_schoolf_eq(temps, params['B0'].value,
params['E'].value, params['E_D'].value,
params['T_pk'].value)
pred = numpy.array(pred, dtype=numpy.float64)
# Collect measured trait values without log transformation.
trait_vals_no_log = []
for row in dataset:
trait_vals_no_log.append(float(row[5]))
# Calculate the residual sum of squares.
residuals = trait_vals_no_log - pred
rss = sum(residuals**2)
# Temperatures ...
temperatures = ""
for element in temps:
temperatures += str(element - 273.15) + ','
temperatures = temperatures[:-1]
# Trait Values ...
trait_values = ""
for element in trait_vals_no_log:
trait_values += str(element) + ','
trait_values = trait_values[:-1]
# If, for whatever reason, the residual sum of squares is
# 'not a number' or infinite, then return.
if numpy.isnan(rss) or numpy.isinf(rss):
return None
# Calculate the total sum of squares.
tss = sum((trait_vals_no_log - numpy.mean(trait_vals_no_log))**2)
# Calculate the R-squared value.
if tss == 0:
fit_goodness = 1
else:
fit_goodness = 1 - (rss / tss)
# Number of data points before and after T_pk ...
count_temps = []
points_before_pk = 0
points_after_pk = 0
for row in dataset:
if float(row[4]) in count_temps:
continue
else:
count_temps.append(float(row[4]))
if float(row[4]) < (params['T_pk'].value - 273.15):
points_before_pk += 1
elif float(row[4]) > (params['T_pk'].value - 273.15):
points_after_pk += 1
result_line = [
dataset[0][1], dataset[0][7], dataset[0][8], temperatures,
trait_values, dataset[0][2],
str(B_T_ref[0]**(1 / 4.0)),
str(B_T_ref_1_4_stderr),
str(log(params['E'].value)),
str(log_E_stderr),
str(log(operational_niche_width)),
str(log_operational_niche_width_stderr),
str((params['T_pk'].value - 273.15)**2),
str(T_pk_squared_stderr),
str(log(B_pk[0])),
str(log_B_pk_stderr),
str(log(params['E_D'].value)),
str(log_E_D_stderr),
str(fit_goodness),
str(points_before_pk),
str(points_after_pk)
]
return result_line
def parallel_ONW_for_bootstrap(arg):
global temporary_dataset
numpy.random.seed(arg)
resampled_indices = numpy.floor(
numpy.random.rand(len(temporary_dataset)) *
len(temporary_dataset)).astype(int)
resampled_dataset = numpy.array(temporary_dataset)[
resampled_indices, :].tolist()
(B0_start, E_start, T_pk_start,
E_D_start) = generate_starting_values(resampled_dataset)
temps = []
trait_vals = []
for row in resampled_dataset:
# Convert temperatures to Kelvin.
temps.append(float(row[4]) + 273.15)
trait_vals.append(log(float(row[5])))
# Convert temps and trait_vals to numpy arrays.
temps = numpy.array(temps, dtype=numpy.float64)
trait_vals = numpy.array(trait_vals, dtype=numpy.float64)
# Prepare the parameters and their bounds.
params = Parameters()
params.add('B0', value=B0_start)
params.add('E', value=E_start, min=0.00001, max=10)
params.add('E_D', value=E_D_start, min=0.00001, max=30)
params.add('T_pk', value=T_pk_start, min=273.15 - 10, max=273.15 + 150)
try:
# Try and fit!
result = minimize(sharpe_schoolf,
params,
args=(temps, trait_vals),
xtol=1e-12,
ftol=1e-12,
maxfev=100000)
except Exception:
# If fitting failed, return None.
result = None
if result is not None:
# In the highly unlikely scenario that E == E_D, add a tiny number to
# E_D to avoid division by zero.
if params['E'].value == params['E_D'].value:
params['E_D'].value += 0.000000000000001
B_pk = exp(1)**sharpe_schoolf_eq(numpy.array([params['T_pk'].value]),
params['B0'].value, params['E'].value,
params['E_D'].value,
params['T_pk'].value)
current_operational_niche_width = calculate_operational_niche_width(
params, B_pk[0], T_ref=273.15)
return (current_operational_niche_width)
else:
return (None)
def absErrorAE(predictedTime, survivalTime):
return abs(bf.log(predictedTime) - bf.log(survivalTime))
def schoolfield_model(dataset, B0_start, E_start, T_pk_start, E_D_start):
"""Prepare the Schoolfield model."""
global K
# Store temperatures and log-transformed trait values.
temps = []
trait_vals = []
for row in dataset:
# Convert temperatures to Kelvin.
temps.append(float(row[4]) + 273.15)
trait_vals.append(log(float(row[5])))
# Convert temps and trait_vals to numpy arrays.
temps = numpy.array(temps, dtype=numpy.float64)
trait_vals = numpy.array(trait_vals, dtype=numpy.float64)
# Prepare the parameters and their bounds.
params = Parameters()
params.add('B0', value=B0_start)
params.add('E', value=E_start, min=0.00001, max=30)
params.add('E_D', value=E_D_start, min=0.00001, max=50)
params.add('T_pk', value=T_pk_start, min=273.15, max=273.15 + 150)
try:
# Set the random seed.
numpy.random.seed(1337)
# Try and fit!
minimize(schoolf, params, args=(temps, trait_vals))
except Exception:
# If fitting failed, return.
return None, None, None, None
# Since we're still here, fitting was successful!
points_before_pk = 0
points_after_pk = 0
# Collect measured trait values without log transformation.
trait_vals_no_log = []
for row in dataset:
trait_vals_no_log.append(float(row[5]))
# Get the number of data points before and after T_pk.
if float(row[4]) < (params['T_pk'].value - 273.15):
points_before_pk += 1
elif float(row[4]) > (params['T_pk'].value - 273.15):
points_after_pk += 1
# Calculate the estimated trait values.
pred = exp(
1) ** schoolf_eq(temps,
params['B0'].value,
params['E'].value,
params['E_D'].value,
params['T_pk'].value)
pred = numpy.array(pred, dtype=numpy.float64)
# Calculate the residual sum of squares.
residuals = trait_vals_no_log - pred
rss = sum(residuals ** 2)
# If, for whatever reason, the residual sum of squares is
# 'not a number' or infinite, then return.
if numpy.isnan(rss) or numpy.isinf(rss):
return None, None, None, None
# Calculate the total sum of squares.
tss = sum((trait_vals_no_log - numpy.mean(trait_vals_no_log)) ** 2)
# If the total sum of squares is 0, then we have a perfect fit!
if tss == 0:
fit_goodness = 1
# Otherwise, calculate the R-Squared value.
else:
fit_goodness = 1 - (rss / tss)
# Get the values of the three Information Criteria for this fit.
AIC_schoolfield = AICrss(len(temps), 4, rss)
BIC_schoolfield = BICrss(len(temps), 4, rss)
HQC_schoolfield = HQCrss(len(temps), 4, rss)
# Create a list of Species, Standardised Species, Reference, Trait,
# Latitude, Longitude ...
result_line = [
dataset[0][0], dataset[0][1], dataset[0][2], dataset[0][3],
dataset[0][7], dataset[0][8]
]
# Temperatures ...
temperatures = ""
for element in temps:
temperatures += str(element - 273.15) + ','
temperatures = temperatures[:-1]
result_line.append(temperatures)
# Trait Values ...
trait_values = ""
for element in trait_vals_no_log:
trait_values += str(element) + ','
trait_values = trait_values[:-1]
result_line.append(trait_values)
# B0 and B0_stderr ...
result_line.append(str(params['B0'].value))
result_line.append(str(params['B0'].stderr))
# E and E_stderr ...
result_line.append(str(params['E'].value))
result_line.append(str(params['E'].stderr))
# T_pk and T_pk_stderr ...
result_line.append(str(params['T_pk'].value - 273.15))
result_line.append(str(params['T_pk'].stderr))
# E_D and E_D_stderr ...
result_line.append(str(params['E_D'].value))
result_line.append(str(params['E_D'].stderr))
# No theta and theta_stderr for this model!
result_line.append("NA")
result_line.append("NA")
# R-squared ...
result_line.append(str(fit_goodness))
# Formula ...
result_line.append(
"log(Trait_value) = log(B0 * exp(-E * ((1/(" + str(K) \
+ " * temp)) - (1/(" + str(K) \
+ " * 273.15))))/(1 + (E/(E_D - E)) * exp(E_D/" \
+ str(K) + " * (1/T_pk - 1/temp))))")
# Model name ...
result_line.append("Schoolfield")
# Implementation ...
result_line.append("lmfit.minimize (Python package)")
# Number of data points before and after T_pk ...
result_line.append(str(points_before_pk))
result_line.append(str(points_after_pk))
return AIC_schoolfield, BIC_schoolfield, HQC_schoolfield, result_line
def interval_log(interval, context_down, context_up):
lower, upper = interval
out_interval = [bf.log(lower, context_down), bf.log(upper, context_up)]
derivs = [1 / lower, 0], [0, 1 / upper]
return out_interval, derivs
def fit_sharpe_schoolfield(dataset, B0_start, E_start, T_pk_start, E_D_start):
"""Fit the Sharpe-Schoolfield model."""
global K
# Store temperatures and log-transformed trait values.
temps = []
trait_vals = []
for row in dataset:
# Convert temperatures to Kelvin.
temps.append(float(row[4]) + 273.15)
trait_vals.append(log(float(row[5])))
# Convert temps and trait_vals to numpy arrays.
temps = numpy.array(temps, dtype=numpy.float64)
trait_vals = numpy.array(trait_vals, dtype=numpy.float64)
# Prepare the parameters and their bounds.
params = Parameters()
params.add('B0', value=B0_start)
params.add('E', value=E_start, min=0.00001, max=30)
params.add('E_D', value=E_D_start, min=0.00001, max=50)
params.add('T_pk', value=T_pk_start, min=273.15 - 10, max=273.15 + 150)
try:
# Try and fit!
minimize(sharpe_schoolf,
params,
args=(temps, trait_vals),
xtol=1e-12,
ftol=1e-12,
maxfev=100000)
except Exception:
# If fitting failed, return.
return None
# Since we're still here, fitting was successful!
# In the highly unlikely scenario that E == E_D, add a tiny number to
# E_D to avoid division by zero.
if params['E'].value == params['E_D'].value:
params['E_D'].value += 0.000000000000001
# Calculate the fitted trait values.
pred = exp(1)**sharpe_schoolf_eq(temps, params['B0'].value,
params['E'].value, params['E_D'].value,
params['T_pk'].value)
pred = numpy.array(pred, dtype=numpy.float64)
# Collect measured trait values without log transformation.
trait_vals_no_log = []
for row in dataset:
trait_vals_no_log.append(float(row[5]))
# Calculate the residual sum of squares.
residuals = trait_vals_no_log - pred
rss = sum(residuals**2)
# If, for whatever reason, the residual sum of squares is
# 'not a number' or infinite, then return.
if numpy.isnan(rss) or numpy.isinf(rss):
return None
# Calculate the total sum of squares.
tss = sum((trait_vals_no_log - numpy.mean(trait_vals_no_log))**2)
# Calculate the R-squared value.
if tss == 0:
fit_goodness = 1
else:
fit_goodness = 1 - (rss / tss)
result_line = [
dataset[0][0], dataset[0][2], dataset[0][3],
str(params['B0'].value),
str(params['E'].value),
str(params['T_pk'].value - 273.15),
str(params['E_D'].value),
str(fit_goodness)
]
return result_line
def calculate_log_probability(self,
bag,
camera_network,
max_steps,
verbose=False):
prior_prob = 1.0
log_motion_model_prob = np.log(prior_prob)
prob_movements = []
n_skipped = 0
timesteps = 0
# quite important we discount ones without enough steps
# because each step adds like 10^-3 to the probability...
if bag.get_message_count() < max_steps:
raise Exception("Bag does not have enough messages")
for i, msg in enumerate(bag):
if i >= max_steps:
break
timesteps += 1
msg = msg.message
true_odom = msg.true_odom
ekf_odom = msg.ekf_odom
true_pos = point_to_numpy(true_odom.pose.pose.position)
ekf_pos = point_to_numpy(ekf_odom.pose.pose.position)
true_rpy = quat_to_rpy(
quat_to_numpy(true_odom.pose.pose.orientation))
true_heading = true_rpy[2]
ekf_rpy = quat_to_rpy(quat_to_numpy(
ekf_odom.pose.pose.orientation))
ekf_heading = ekf_rpy[2]
ekf_vel = point_to_numpy(ekf_odom.twist.twist.linear)
ekf_time = ekf_odom.header.stamp.to_sec()
ekf_positional_cov = np.array(ekf_odom.pose.covariance).reshape(
6, 6)[:2, :2]
last_ekf_pos = np.array(list(msg.last_ekf_state[:2]) + [0.0])
last_ekf_heading = msg.last_ekf_state[2]
last_true_pos = point_to_numpy(msg.last_true_pos)
last_true_heading = msg.last_true_heading
camera_update = msg.camera_update
if msg.has_camera_update:
# no longer need to correct since sampling normal => add to true pos has replaced direct raytracing :'(
# corrected_camera_position = apply_time_correction(camera_update, ekf_vel, ekf_time)
corrected_camera_position = point_to_numpy(
camera_update.position)
prob_sensor_measurements = self.sensor_model(
camera_network, camera_update.source_camera_id,
corrected_camera_position, ekf_pos)
eta = self.get_normalizer(camera_network,
corrected_camera_position[:2],
camera_update.source_camera_id,
ekf_pos[:2],
ekf_positional_cov,
n_samples=1000)
else:
prob_sensor_measurements = 1 # ie. there were none
eta = 1
if np.array_equal(last_true_pos, true_pos):
continue
log_prob_movement = self.log_motion_model(last_ekf_pos,
ekf_pos,
last_ekf_heading,
ekf_heading,
last_true_pos,
true_pos,
last_true_heading,
true_heading,
scaling=1,
verbose=verbose)
value = log_prob_movement + bf.log(prob_sensor_measurements / eta)
# value = log_prob_movement
if value == 0.0:
print "*********** 0.0!! ********"
n_skipped += 1
continue
log_motion_model_prob += value
if verbose:
print("Log prob xt -> xt+1: {0}".format(log_prob_movement))
print("prob sensor measurement: {0}".format(
prob_sensor_measurements))
print("eta: {0}".format(eta))
print("Current log prob: {0}".format(log_motion_model_prob))
# prob_movements.append(prob_movement)
# if motion_model_prob > 1000:
# print(motion_model_prob)
return log_motion_model_prob, timesteps, n_skipped
