def __log_add(self, left, right):
if (right < left):
return left + math.log1p(math.exp(right - left))
elif (right > left):
return right + math.log1p(math.exp(left - right))
else:
return left + self.M_LN2
def my_features(u, t):
vector = []
#vector += [float(edits_num(u, t, p)) for p in periods]
vector += [math.log1p(user_lastedit[(u,t)]-user_frstedit[(u,t)])]
vector += [math.log1p(numpy.reciprocal(numpy.mean(user_edit_freq[u])))]
#vector += [float(artis_num(u, t, p)) for p in periods]
return vector
def logadd(self, alpha): x = alpha[0] y = alpha[1] if y <= x: return x + math.log1p(math.exp(y-x)) else: return y + math.log1p(math.exp(x-y))
def B(x):
y=None
if math.sin(x/(x**2+2))+math.exp(math.log1p(x)+1)==0 or x==0:
y='Neopredelen'
else:
y=(1/(math.sin(x/(x**2+2))+math.exp(math.log1p(x)+1)))-1
return y
def testing(test_list, vocabulary, P1, P2, pp, np):
result_value = []
for test in test_list:
test = test.split()
# print test
sum_of_pprob = 0
sum_of_nprob = 0
for word in test:
if vocabulary.count(word):
index = vocabulary.index(word)
sum_of_pprob += math.log1p(pp[index])
sum_of_nprob += math.log1p(np[index])
positiveProbability = sum_of_pprob + math.log1p(P1)
negativeProbability = sum_of_nprob + math.log1p(P2)
# print positiveProbability
# print negativeProbability
# input('probability')
if positiveProbability >= negativeProbability:
result_value.append('+')
else:
result_value.append('-')
return result_value
def transition(dist, a, f, logspace=0):
"""
Compute transition probabilities for a HMM.
to compute transition probabilities between hidden-states,
when moving from time t to t+1,
the genetic distance (cM) between the two markers are required.
Assuming known parameters a and f.
lf logspace = 1, calculations are log-transformed.
Key in dictionary: 0 = not-IBD, 1 = IBD.
"""
if logspace == 0:
qk = exp(-a*dist)
T = { # 0 = not-IBD, 1 = IBD
1: {1: (1-qk)*f + qk, 0: (1-qk)*(1-f)},
0: {1: (1-qk)*f, 0: (1-qk)*(1-f) + qk}
}
else:
if dist == 0:
dist = 1e-06
ff = 1-f
ad = a*dist
A = expm1(ad)
AA = -expm1(-ad)
T = { # 0 = not-IBD, 1 = IBD
1: {1: log1p(A*f)-ad, 0: log(AA*ff)},
0: {1: log(AA*f), 0: log1p(A*ff)-ad}}
return T
def test_log1p(self):
import math
self.ftest(math.log1p(1 / math.e - 1), -1)
self.ftest(math.log1p(0), 0)
self.ftest(math.log1p(math.e - 1), 1)
self.ftest(math.log1p(1), math.log(2))
def log_sum(left,right): if right < left: return left + log1p(exp(right - left)) elif left < right: return right + log1p(exp(left - right)); else: return left + log1p(1)
def log_add(left, right):
if (right < left):
return left + math.log1p(math.exp(right - left))
elif (right > left):
return right + math.log1p(math.exp(left - right))
else:
return left + M_LN2
def mandelbrot(n): z = complex(0,0) for i in range(max_iter): z = complex.add(complex.multiply(z,z),n) if cabs(z) >= escape_radius: smooth = i + 1 - int(math.log1p(math.log1p(cabs(z)))/math.log1p(escape_radius)) return int(smooth) return True
def drift(active_editors_test, grouped_edits, time_train, time_test):
"""Calculate drift
"""
average_train = sum([math.log1p(count_edits(grouped_edits[editor], time_train, 5))
for editor in active_editors_test])/len(active_editors_test)
average_test = sum([math.log1p(count_edits(grouped_edits[editor], time_test, 5))
for editor in active_editors_test])/len(active_editors_test)
return average_test - average_train
def test_log1p(self):
import math
self.ftest(math.log1p(1/math.e-1), -1)
self.ftest(math.log1p(0), 0)
self.ftest(math.log1p(math.e-1), 1)
self.ftest(math.log1p(1), math.log(2))
raises(ValueError, math.log1p, -1)
raises(ValueError, math.log1p, -100)
def logadd(x, y):
if y == 0:
return x
if x == 0:
return y
if y <= x:
return x + math.log1p(math.exp(y - x))
else:
return y + math.log1p(math.exp(x - y))
def __call__(self, response, a, result):
text = get_text_from_html(a)
this_features = defaultdict(float)
norm = 0.0
for token in parse_string(text, self.default_language):
this_features[self.prefix + "__" + token] += 1.0
norm += 1
norm = log1p(norm)
result.features.update((t, log1p(c) / norm) for t, c in this_features.viewitems())
return result
def compute_scale_for_cesium(coordmin, coordmax):
'''
Cesium quantized positions need to be in uint16
This function computes the best scale to apply to coordinates
to fit the range [0, 65535]
'''
max_int = np.iinfo(np.uint16).max
delta = abs(coordmax - coordmin)
scale = 10 ** -(math.floor(math.log1p(max_int / delta) / math.log1p(10)))
return scale
def geometric(data, p):
denom = math.log1p(-p)
data.start_example(GEOMETRIC_LABEL)
while True:
probe = fractional_float(data)
if probe < 1.0:
result = int(math.log1p(-probe) / denom)
assert result >= 0, (probe, p, result)
data.stop_example()
return result
def next_temp(initial_temp, iteration, max_iteration, current_temp, slope=None, standard_deviation=None):
if Config.SA_AnnealingSchedule == 'Linear':
temp = (float(max_iteration-iteration)/max_iteration)*initial_temp
print ("\033[36m* COOLING::\033[0m CURRENT TEMP: "+str(temp))
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Exponential':
temp = current_temp * Config.SA_Alpha
print ("\033[36m* COOLING::\033[0m CURRENT TEMP: "+str(temp))
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Logarithmic':
# this is based on "A comparison of simulated annealing cooling strategies"
# by Yaghout Nourani and Bjarne Andresen
temp = Config.LogCoolingConstant * (1.0/log10(1+(iteration+1))) # iteration should be > 1 so I added 1
print ("\033[36m* COOLING::\033[0m CURRENT TEMP: "+str(temp))
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Adaptive':
temp = current_temp
if iteration > Config.CostMonitorQueSize:
if 0 < slope < Config.SlopeRangeForCooling:
temp = current_temp * Config.SA_Alpha
print ("\033[36m* COOLING::\033[0m CURRENT TEMP: "+str(temp))
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Markov':
temp = initial_temp - (iteration/Config.MarkovNum)*Config.MarkovTempStep
if temp < current_temp:
print ("\033[36m* COOLING::\033[0m CURRENT TEMP: "+str(temp))
if temp <= 0:
temp = current_temp
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Aart':
# This is coming from the following paper:
# Job Shop Scheduling by Simulated Annealing Author(s): Peter J. M. van Laarhoven,
# Emile H. L. Aarts, Jan Karel Lenstra
if iteration % Config.CostMonitorQueSize == 0 and standard_deviation is not None and standard_deviation != 0:
temp = float(current_temp)/(1+(current_temp*(log1p(Config.Delta)/standard_deviation)))
print ("\033[36m* COOLING::\033[0m CURRENT TEMP: "+str(temp))
elif standard_deviation == 0:
temp = float(current_temp)*Config.SA_Alpha
print ("\033[36m* COOLING::\033[0m CURRENT TEMP: "+str(temp))
else:
temp = current_temp
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Huang':
if standard_deviation is not None and standard_deviation != 0:
temp = float(current_temp)/(1+(current_temp*(log1p(Config.Delta)/standard_deviation)))
print ("\033[36m* COOLING::\033[0m CURRENT TEMP: "+str(temp))
elif standard_deviation == 0:
temp = float(current_temp)*Config.SA_Alpha
print ("\033[36m* COOLING::\033[0m CURRENT TEMP: "+str(temp))
else:
temp = current_temp
# ----------------------------------------------------------------
else:
raise ValueError('Invalid Cooling Method for SA...')
return temp
def _get_thruput(_ce_endpoint):
if _ce_endpoint not in worker_ce_backend_throughput_dict:
q_good_init = 0.
q_good_fin = 0.
else:
q_good_init = float(sum(worker_ce_backend_throughput_dict[_ce_endpoint][_st]
for _st in ('submitted', 'running', 'finished')))
q_good_fin = float(sum(worker_ce_backend_throughput_dict[_ce_endpoint][_st]
for _st in ('submitted',)))
thruput = (log1p(q_good_init) - log1p(q_good_fin))
return thruput
def get_ir_distances(self):
"""Converts the IR distance readings into a distance in meters"""
ir_distances = [ \
max( min( (log1p(3960) - log1p(reading))/30 +
self.robot.ir_sensors.rmin,
self.robot.ir_sensors.rmax),
self.robot.ir_sensors.rmin)
for reading in self.robot.ir_sensors.readings ]
return ir_distances
def getIRDistance(self, robotInfo_):
"""Converts the IR distance readings into a distance in meters.
"""
# Get the current parameters of the sensor
readings = robotInfo_["sensors"]["ir"]["readings"]
rmin = robotInfo_["sensors"]["ir"]["rmin"]
rmax = robotInfo_["sensors"]["ir"]["rmax"]
# Conver the readings to a distance (in m)
dists = [max( min( (log1p(3960) - log1p(r))/30 + rmin, rmax), rmin) for r in readings]
return dists
def get_stream_rating(broadcast_id):
periscope_api = PeriscopeAPI()
users = periscope_api.getBroadcastUsers(broadcast_id)
rating = 0
for user in users['live']:
rating += log1p(user['n_followers']) * (1 + 0.05 * user['n_hearts_given'])
for user in users['replay']:
rating += log1p(user['n_followers']) * (1 + 0.05 * user['n_hearts_given']) * 0.6
rating += 0.1 * users['n_web_watched']
return round(rating)
def contrast(self,beta):
for x in range(self.width):
for y in range(self.height):
gray, gray1, gray2 = self.imag.getpixel((x,y))
maxim=max(gray,gray1,gray2)
#minim=min(gray,gray1,gray2)
q=int((maxim*((log1p(maxim+gray))/(log1p(maxim+maxim)))))
#q=q*gray+beta
self.newImag.putpixel((x,y),(q,q,q))
self.newImag.save("testContrast1.jpg",self.imag.format)
self.newImag.show()
print("Done...")
def logadd(a,b):
"""
compute log(exp(a) + exp(b))
"""
if a == -INFINITY:
return b
if b == -INFINITY:
return a
if b < a: # b - a < 0
return a + math.log1p(math.exp(b - a))
else: # a - b < 0
return b + math.log1p(math.exp(a - b))
def inverse_log_fq(token, sent):
'''
calculate the penalty for the token's inverse log frequency
:param token:
:param sent:
:return:
'''
fdist = nltk.FreqDist(sent)
if log1p(fdist[token]):
return 1/log1p(fdist[token])
else:
return 0
def d1Calculation():
first_part = stock_price / strike_price
math.log1p(first_part)
variance = standard_deviation * standard_deviation
second_part = ( risk_free_rate + variance / 2 ) * time
n_root = (1.0 / standard_deviation)
third_part = math.pow(time,n_root)
d1_answer = ( first_part + second_part ) / third_part
return d1_answer
def get_ir_distances(self):
"""Converts the IR distance readings into a distance in meters"""
default_value = 3960
#Assignment week2
ir_distances = [] #populate this list
#self.robot.ir_sensors.readings | (may want to use this)
for reading in self.robot.ir_sensors.readings:
val = max( min( (log1p(3960) - log1p(reading))/30 + 0.02 , 3960) , 0.02)
ir_distances.append(val)
#End Assignment week2
return ir_distances
def segi(x):
"""
T1.1.T2.4. these are for sequoia in seq ntl park
proxy: none
badness: no foliage
source: biopak, equation 395
accuracy: biomass at 0.95, density is stated to be 0.358
"""
biomass = math.exp(-11.0174 + 2.5907 * math.log1p(float(x)))
jenkbio = round(0.001*math.exp(-2.2304+2.4435*math.log1p(round(x,2))),4)
return (biomass, jenkbio)
def testing(test_list, univocabulary, bivocabulary, P1, P2, upp, unp, bpp, bnp):
result_value = []
for test in test_list:
test = test.split()
if univocabulary.count(test[0]) == 0:
sum_of_pprob = 0
sum_of_nprob = 0
else:
sum_of_pprob = math.log1p(upp[univocabulary.index(test[0])])
sum_of_nprob = math.log1p(unp[univocabulary.index(test[0])])
for i in range(len(test)-1):
word = test[i]+" "+test[i+1]
if bivocabulary.count(word):
index = bivocabulary.index(word)
sum_of_pprob += math.log1p(bpp[index])
sum_of_nprob += math.log1p(bnp[index])
else:
if univocabulary.count(test[i+1]):
index = univocabulary.index(test[i+1])
sum_of_pprob += math.log1p(upp[index])
sum_of_nprob += math.log1p(unp[index])
positiveProbability = sum_of_pprob + math.log1p(P1)
negativeProbability = sum_of_nprob + math.log1p(P2)
if positiveProbability >= negativeProbability:
result_value.append('+')
else:
result_value.append('-')
return result_value
def log_add(first_logarithm, second_logarithm):
'''
Add to real numbers in log-space. This function should preferebly be used with
the logarithms of small real values.
@param first_logarithm: The logarithm of the first number
@param second_logarithm: The logarithm of the second number
@return: The logarithm of the sum of the two numbers
'''
if first_logarithm >= second_logarithm:
return second_logarithm + log1p(exp(first_logarithm - second_logarithm))
else:
return first_logarithm + log1p(exp(second_logarithm - first_logarithm))
def atanh(x):
"NOT_RPYTHON"
if isnan(x):
return x
absx = abs(x)
if absx >= 1.:
raise ValueError("math domain error")
if absx < _2_to_m28:
return x
if absx < .5:
t = absx + absx
t = .5 * log1p(t + t * absx / (1. - absx))
else:
t = .5 * log1p((absx + absx) / (1. - absx))
return copysign(t, x)
def ln(self, x): return math.log1p(x) def logx(self, x, base): return math.log(x,base)
def word_meaning(vector_set):
cls_set = {}
corpus_freq_w = [0] * (len(vector_set[0]) - 1)
for v in vector_set:
if v[len(v) -
1] not in cls_set: # last item of each vector indicates its label
cls_set.update({v[len(v) - 1]:
v[:len(v) - 1]}) # v[:len(v)-1] indicates vector
else:
cls_set[v[len(v) - 1]] = np.add(cls_set[v[len(v) - 1]],
v[:len(v) - 1])
# Each vector contains the frequency of words, we can find the number of each words in a vector defined by
# the label of class, by iteratively summing them up... v[len(v)- 1] indicates the label
corpus_freq_w = np.add(corpus_freq_w, v[:len(v) - 1])
# Compute the number of words in each class and collect it in the set cls_w_length
cls_w_lengths = {}
for cl in cls_set:
count = 0
for w in cls_set[cl]:
count += w
cls_w_lengths.update({cl: count})
# Compute the whole number of words in the corpus (training set)
corpus_length = 0
for cl_freq in cls_w_lengths:
corpus_length += cls_w_lengths[cl_freq]
# Calculates meaning values of each word for each class. At first calculates values for each word in each class and
# then collect them in the set cls_meaning
l = corpus_length
cls_meaning = {}
for cl_lbl in cls_set:
b = cls_w_lengths[cl_lbl]
if l != 0 and b != 0: # Check the exception condition L = 0 and B = 0
n = l / b
else:
n = 1
length = len(cls_set[cl_lbl])
meaning_vec = [0] * length
for w in range(length):
m = cls_set[cl_lbl][w]
k = corpus_freq_w[w]
w_nfa = combination(k, m) * (n**(1 - m))
if m != 0:
meaning_vec[w] = (-1 / m) * math.log1p(w_nfa)
else:
meaning_vec[w] = 0
cls_meaning.update({cl_lbl: meaning_vec})
return cls_meaning
new_genome.count(kmer) * 100 /
(len(new_genome) - k + 1)))
cake += 'Ratio \t{}\n'.format(
str(
int(
all_ends.count(kmer) * 100 /
(len(all_ends) - k + 1)) /
(int(new_genome.count(kmer) * 100) /
(len(new_genome) - k + 1))))
pvalue = stats.chi2_contingency(
[[len(all_ends), len(new_genome)],
[all_ends.count(kmer),
new_genome.count(kmer)]])[1]
print('P-value = {}\n'.format(pvalue))
cake += 'P-value for {} \t{}\n'.format(
kmer, str(math.log1p(pvalue)))
all_p_values.append(pvalue)
contr += 1
else:
lable_k.append(kmer)
if args.reverse == 'Yes':
all_sb_friq.append((new_genome.count(kmer) * 100 /
(len(new_genome) - k + 1)) +
(reverse_genome.count(kmer) * 100 /
(len(reverse_genome) - k + 1)))
end_sb_friq.append((all_ends.count(kmer) * 100 /
(len(all_ends) - k + 1)) +
(reverse_ends.count(kmer) * 100 /
(len(reverse_ends) - k + 1)))
else:
all_sb_friq.append(
def refine_probs(self):
""" refine_probs()
Improve the estimated probabilities used by working with
the full set of data allocated to each node, rather than
just the initial sub-set used to create/split nodes.
"""
# travel up from leaves improving log_rk etc.
for level_it in range(len(self.assignments) - 1, -1, -1):
# print(level_it, self.nodes[level_it].keys())
for node_it in self.nodes[level_it]:
node = self.nodes[level_it][node_it]
if node.tree_terminated:
if node.nk > 1:
# log_rk, etc are accurate
node.log_dk = node.true_bhc.root_node.log_dk
node.log_pi = node.true_bhc.root_node.log_pi
node.logp = node.true_bhc.root_node.logp
node.log_ml = node.true_bhc.root_node.log_ml
node.log_rk = node.true_bhc.root_node.log_rk
else:
node.log_dk = self.crp_alpha
node.log_pi = 0.
node.logp = self.data_model.log_marginal_likelihood(
node.data)
node.log_ml = node.logp
node.log_rk = 0.
elif node.truncation_terminated:
node.log_dk = (math.log(self.crp_alpha) +
math.lgamma(node.nk))
node.log_pi = 0.
node.logp = self.data_model.log_marginal_likelihood(
node.data)
node.log_ml = node.logp
node.log_rk = 0.
else:
left_child = self.nodes[level_it + 1][node_it * 2]
right_child = self.nodes[level_it + 1][node_it * 2 + 1]
node.log_dk = np.logaddexp(
math.log(self.crp_alpha) + math.lgamma(node.nk),
left_child.log_dk + right_child.log_dk)
node.log_pi = -math.log1p(
math.exp(left_child.log_dk + right_child.log_dk -
math.log(self.crp_alpha) -
math.lgamma(node.nk)))
neg_pi = math.log(-math.expm1(node.log_pi))
node.logp = self.data_model.log_marginal_likelihood(
node.data)
node.log_ml = np.logaddexp(
node.log_pi + node.logp,
neg_pi + left_child.log_ml + right_child.log_ml)
node.log_rk = node.log_pi + node.logp - node.log_ml
# travel down from top improving
for level_it in range(1, len(self.assignments)):
for node_it in self.nodes[level_it]:
node = self.nodes[level_it][node_it]
parent_node = self.nodes[level_it - 1][int(node_it / 2)]
node.prev_wk = (parent_node.prev_wk *
(1 - math.exp(parent_node.log_rk)))
for n in range(N):
x = X[:, n]
x2 = np.zeros([1, 2])
x2[0][0] = x[0] - mean_k_est[0]
x2[0][1] = x[1] - mean_k_est[1]
y = np.zeros([2, 1])
y[0][0] = x[0] - mean_k_est[0]
y[1][0] = x[1] - mean_k_est[1]
cov = cov + res[n] * np.dot(y, x2)
cov_k_est = cov / float(Nk)
alpha_k_est = Nk / N
mean[:, k] = mean_k_est
Cova[:, :, k] = cov_k_est
alpha[0][k] = alpha_k_est
### Likelihood evaluation
final_liklihood = 0
for n in range(N):
x = X[:, n]
log = 0
for k in range(K):
[rr, dd] = responsibility(x, mean, Cova, alpha, k, Model)
log = log + math.log1p(dd)
final_likelihood = final_likelihood + log
print final_likelihood
ite = ite + 1
### After converging the means and variances will be printed
print mean
print Cova
print alpha
def gen_sweetwords(train, data_in, N):
"""Given the training data and input passwords, generate N sweetwords
for each input password. One of the sweetwords is the input password.
1. Start by checking if the subword of input password OR
the entire input password itself belong to a category.
2. If a category can be identified AND it is not the 'nums' category,
select up to 3 + ln(N) sample training passwords from the category.
Then, generate N sweetwords using those samples.
3. Else if the subword is not short (> 4 chars) select up to ln(N) sample
training passwords at random from the entire training set.
Then, generate N sweetwords using those samples.
4. Else (the subword is too short and/or the password is all non-letters)
use algo1 to generate N sweetwords.
Let the output be a list of N sweetwords (including the input password)
for each input password.
Returns: The output as a list of list of strings.
"""
# The row number corresponding to each category
# In other words, these are 1-indexed and not 0-indexed
rnames = [
11, 12, 16, 18, 19, 24, 30, 35, 37, 43, 44, 45, 46, 50, 51, 55, 61, 64,
65, 67, 70, 71, 74, 76, 77, 78, 81, 86, 92, 93, 95, 97, 98, 99, 100
]
rmisc = [
6, 8, 14, 26, 27, 31, 32, 33, 36, 39, 47, 57, 58, 59, 69, 73, 83, 85,
87, 89, 96
]
rlove = [5, 13, 15, 22, 34, 38, 52, 53, 56, 62, 68, 79, 80, 90]
rpopcult = [25, 29, 41, 49, 54, 63, 66, 75, 88, 91, 94]
rnums = [1, 2, 3, 7, 9, 17, 21, 23, 40, 48, 72, 82]
rlazy = [4, 10, 20, 28, 42, 60, 84]
# A list of passwords split by categories
names = list(map(lambda x: train[x - 1], rnames))
misc = list(map(lambda x: train[x - 1], rmisc))
love = list(map(lambda x: train[x - 1], rlove))
popcult = list(map(lambda x: train[x - 1], rpopcult))
nums = list(map(lambda x: train[x - 1], rnums))
lazy = list(map(lambda x: train[x - 1], rlazy))
category = {
"names": names,
"misc": misc,
"love": love,
"popcult": popcult,
"nums": nums,
"lazy": lazy
}
output = []
swords = get_subwords(data_in)
catnms = get_categories(data_in, swords)
for i, pw in enumerate(data_in):
genpwds = []
if (catnms[i] in category.keys()) and (catnms[i] != "nums"):
# If the password or subword exists in the training data
randsamples = np.random.choice(category[catnms[i]],
3 + round(math.log1p(N))).tolist()
randsamples.append(pw)
# Remove duplicates in samples:
samples = []
for elem in randsamples:
if elem not in samples:
samples.append(elem)
genpwds.extend(gen_with_samples(pw, swords[i], samples, N))
output.append(genpwds)
elif len(swords[i]["subword"]) > 4:
# If the password or subword does not exist in the training data
# But, the subword is long enough to replace
randsamples = np.random.choice(train,
round(math.log1p(N))).tolist()
randsamples.append(pw)
# Remove duplicates in samples:
samples = []
for elem in randsamples:
if elem not in samples:
samples.append(elem)
genpwds.extend(gen_with_samples(pw, swords[i], samples, N))
output.append(genpwds)
else:
# If the subword is too short or if the password is all non-letters
algo1_result = algo1.honeyWordGenerator([pw], N - 1)[0]
genpwds.extend(algo1_result)
output.append(genpwds)
return output
def calc_hp(dir=[1], inv=[1]):
# * map_to_range(random(), 0, 1, 0.5, 1.5)
return round(log1p(prod(dir) * prod(map(lambda x: 1 / x, inv))), 2)
def next_temp(initial_temp,
iteration,
max_iteration,
current_temp,
slope=None,
standard_deviation=None):
if Config.SA_AnnealingSchedule == 'Linear':
temp = (float(max_iteration - iteration) /
max_iteration) * initial_temp
print("\033[36m* COOLING::\033[0m CURRENT TEMP: " + str(temp))
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Exponential':
temp = current_temp * Config.SA_Alpha
print("\033[36m* COOLING::\033[0m CURRENT TEMP: " + str(temp))
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Logarithmic':
# this is based on "A comparison of simulated annealing cooling strategies"
# by Yaghout Nourani and Bjarne Andresen
temp = Config.LogCoolingConstant * (
1.0 / log10(1 + (iteration + 1))
) # iteration should be > 1 so I added 1
print("\033[36m* COOLING::\033[0m CURRENT TEMP: " + str(temp))
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Adaptive':
temp = current_temp
if iteration > Config.CostMonitorQueSize:
if 0 < slope < Config.SlopeRangeForCooling:
temp = current_temp * Config.SA_Alpha
print("\033[36m* COOLING::\033[0m CURRENT TEMP: " + str(temp))
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Markov':
temp = initial_temp - (iteration /
Config.MarkovNum) * Config.MarkovTempStep
if temp < current_temp:
print("\033[36m* COOLING::\033[0m CURRENT TEMP: " + str(temp))
if temp <= 0:
temp = current_temp
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Aart':
# This is coming from the following paper:
# Job Shop Scheduling by Simulated Annealing Author(s): Peter J. M. van Laarhoven,
# Emile H. L. Aarts, Jan Karel Lenstra
if iteration % Config.CostMonitorQueSize == 0 and standard_deviation is not None and standard_deviation != 0:
temp = float(current_temp) / (
1 + (current_temp *
(log1p(Config.Delta) / standard_deviation)))
print("\033[36m* COOLING::\033[0m CURRENT TEMP: " + str(temp))
elif standard_deviation == 0:
temp = float(current_temp) * Config.SA_Alpha
print("\033[36m* COOLING::\033[0m CURRENT TEMP: " + str(temp))
else:
temp = current_temp
# ----------------------------------------------------------------
elif Config.SA_AnnealingSchedule == 'Huang':
if standard_deviation is not None and standard_deviation != 0:
temp = float(current_temp) / (
1 + (current_temp *
(log1p(Config.Delta) / standard_deviation)))
print("\033[36m* COOLING::\033[0m CURRENT TEMP: " + str(temp))
elif standard_deviation == 0:
temp = float(current_temp) * Config.SA_Alpha
print("\033[36m* COOLING::\033[0m CURRENT TEMP: " + str(temp))
else:
temp = current_temp
# ----------------------------------------------------------------
else:
raise ValueError('Invalid Cooling Method for SA...')
return temp
def log1p_exp(val):
"""Numerically stable implementation of `log(1 + exp(val))`."""
if val > 0.0:
return val + log1p(exp(-val))
else:
return log1p(exp(val))
def math_log1p(A, B):
i = cuda.grid(1)
B[i] = math.log1p(A[i])
def get_log(num):
num = math.log1p(num)
return num
def compute_alphas(Input_Vector, Errors):
alphas = []
for i in range(len(Errors)):
alphas.append(.5 * math.log1p((1 - Errors[i]) / Errors[i]))
return alphas
def log1p(self):
self.result = False
self.current = math.log1p(math.radians(float(txtDisplay.get())))
self.display(self.current)
prob_predic = np.load(path_prob_uni + '/' + name_file)
prob_predic = sorted(enumerate(prob_predic),
key=lambda x: list(x[1])[1],
reverse=True)
doc = open(path_data_labels_test + name_file.replace('.npy', ''),
'r').read().strip()
arr_all_sents = doc.split("\n")
print('prob', len(prob_predic), 'all sent', len(arr_all_sents))
sents_values = []
for s in prob_predic:
index = int(s[0])
posi_fea = math.log1p(1 / (1 + index))
sent = arr_all_sents[index][2:]
ele = (index, sent,
text_utils_eng.clean_stem_sent(sent, list_stopwords),
s[1][1], posi_fea * 10)
sents_values.append(ele)
# sents_values = sorted(sents_values, key=lambda x: x[0])
summari = mmr_selection_eng.make_summary(sents_values, 0.95)
summari = re.sub(r'\s+', ' ', summari)
f = open(path_results + '/system_' + id, 'w')
f.write(summari)
def performAnalysis():
"""Perform the analysis."""
global magList
global phaList
global sweepit
global admittanceMatrix
global currentMatrix
result = ""
formAdmittanceMatrix()
admittanceMatrix = np.array(admittanceMatrix)
currentMatrix = np.array(currentMatrix)
basecurrentMatrix = copy.deepcopy(currentMatrix)
voltageMatrix = [0 for i in currentMatrix]
# voltageMatrixOld = [0 for i in currentMatrix]
voltageAcrossOld = 0
conv = 100000
while conv > 10**-20:
nlJacobian = [[0 for j in i] for i in admittanceMatrix]
currentMatrix = copy.deepcopy(basecurrentMatrix)
# form currentMatrix & complete nlJacobian
for i in commands:
commandtext = i.split(' ')
if not(i.startswith('.')):
nodes = getNodes(commandtext[2])
if (commandtext[0].lower() == 'd'):
print(commandtext[1])
node1 = nodeList.index(nodes[0])
node2 = nodeList.index(nodes[1])
voltageAcross = 0
if ((node1 == 0) & (node2 == 0)):
voltageAcross = 0
elif(node1 == 0):
voltageAcross = -voltageMatrix[node2 - 1]
elif(node2 == 0):
voltageAcross = voltageMatrix[node1 - 1]
else:
voltageAcross = voltageMatrix[node1 - 1] - voltageMatrix[node2 - 1]
if (voltageAcrossOld < vCriticalDiode):
pass
else:
voltageAcross = voltageAcrossOld + thermalVoltage * \
math.log1p((((voltageAcross - voltageAcrossOld) / thermalVoltage) + 1).real)
diodeCurrent = satCurrent * (math.e ** (voltageAcross / thermalVoltage) - 1)
print(voltageAcross)
if node1 != 0:
currentMatrix[node1 - 1] -= diodeCurrent
nlJacobian[node1 - 1][node1 - 1] += -diodeCurrent / thermalVoltage
if node2 != 0:
currentMatrix[node2 - 1] += diodeCurrent
nlJacobian[node2 - 1][node2 - 1] += -diodeCurrent / thermalVoltage
if((node1 != 0) & (node2 != 0)):
nlJacobian[node1 - 1][node2 - 1] += diodeCurrent / thermalVoltage
nlJacobian[node2 - 1][node1 - 1] += diodeCurrent / thermalVoltage
Jacobian = admittanceMatrix - nlJacobian
voltageMatrix2 = np.dot(np.linalg.inv(Jacobian), -np.dot(nlJacobian, voltageMatrix) + currentMatrix)
conv = 0
for i in range(len(voltageMatrix)):
conv += (voltageMatrix[i] - voltageMatrix2[i])**2
for i in range(len(voltageMatrix)):
if ((voltageMatrix[i] - voltageMatrix2[i]) > 10):
voltageMatrix2[i] = voltageMatrix[i] - 10
elif ((voltageMatrix2[i] - voltageMatrix[i]) > 10):
voltageMatrix2[i] = voltageMatrix[i] + 10
voltageMatrix = copy.copy(voltageMatrix2)
# admittanceMatrixInvert = np.linalg.inv(admittanceMatrix)
# solutionMatrix = np.dot(admittanceMatrixInvert, currentMatrix)
# solutionMatrix = solutionMatrix.tolist()
solutionMatrix = voltageMatrix.tolist()
for i in range(len(commands)):
commandtext = commands[i].split(' ')
if not(commands[i].startswith('.')):
nodes = getNodes(commandtext[2])
if ((commandtext[0].lower() == 'r') | (commandtext[0].lower() == 'g') |
(commandtext[0].lower() == 'l') | (commandtext[0].lower() == 'c') |
(commandtext[0].lower() == 'd')):
if not(commandtext[0].lower() == 'd'):
componentValue = getComponentValue(commandtext[3])
node1 = nodeList.index(nodes[0])
node2 = nodeList.index(nodes[1])
voltageAcross = 0
if ((node1 == 0) & (node2 == 0)):
voltageAcross = 0
elif(node1 == 0):
voltageAcross = -solutionMatrix[node2 - 1]
elif(node2 == 0):
voltageAcross = solutionMatrix[node1 - 1]
else:
voltageAcross = solutionMatrix[node1 - 1] - solutionMatrix[node2 - 1]
if(commandtext[0].lower() == 'r'):
voltageMatrixLabels.append("I(" + commandtext[1] + ")")
solutionMatrix.append(voltageAcross / componentValue)
elif(commandtext[0].lower() == 'g'):
voltageMatrixLabels.append("I(" + commandtext[1] + ")")
solutionMatrix.append(voltageAcross * componentValue)
elif(commandtext[0].lower() == 'l'):
if (simulationDomain == "AC"):
componentAdmittance = (-1j) / (2 * math.pi * simulationFrequency * componentValue)
voltageMatrixLabels.append("I(" + commandtext[1] + ")")
solutionMatrix.append(voltageAcross * componentAdmittance)
elif(commandtext[0].lower() == 'c'):
if (simulationDomain == "AC"):
componentAdmittance = (1j) * (2 * math.pi * simulationFrequency * componentValue)
voltageMatrixLabels.append("I(" + commandtext[1] + ")")
solutionMatrix.append(voltageAcross * componentAdmittance)
elif(commandtext[0].lower() == 'd'):
voltageMatrixLabels.append("I(" + commandtext[1] + ")")
solutionMatrix.append(satCurrent * (math.e ** (voltageAcross / thermalVoltage) - 1))
for i in range(len(solutionMatrix)):
# print(voltageMatrixLabels[i] + " = " + str(solutionMatrix[i]))
print(voltageMatrixLabels[i] + " = " + str(rect2pol(solutionMatrix[i])[0]) + "[" + str(rect2pol(solutionMatrix[i])[1]) + "]")
result += voltageMatrixLabels[i] + " = " + str(rect2pol(solutionMatrix[i])[0]) + "[" + str(rect2pol(solutionMatrix[i])[1]) + "]\n"
if len(toGraph) > 0:
a = rect2pol(solutionMatrix[nodeList.index(toGraph[0]) - 1])[0]
b = rect2pol(solutionMatrix[nodeList.index(toGraph[0]) - 1])[1]
c = rect2pol(solutionMatrix[nodeList.index(toGraph[1]) - 1])[0]
d = rect2pol(solutionMatrix[nodeList.index(toGraph[1]) - 1])[1]
if simulationParameters[1].lower() == "op":
plot2sine(a, b, c, d)
elif simulationParameters[1].lower() == "sweep":
magList[sweepit] = rect2pol(solutionMatrix[nodeList.index(simulationParameters[6].lower()) - 1])[0]
phaList[sweepit] = rect2pol(solutionMatrix[nodeList.index(simulationParameters[6].lower()) - 1])[1]
sweepit += 1
return result
# In[ ]:
# In[34]:
df_res['result'] = df_res['result'] / 6
df_res['result_lgb_dart'] = df_res['result_lgb_dart'] / 6
# In[ ]:
# In[35]:
df_res['count_na'] = online_train['count'].apply(lambda x: np.nan
if x == 0 else x)
df_res['m'] = df_res['count_na'].apply(
lambda x: max(0.61, 1 / math.log1p(x + 1)))
# In[ ]:
# In[36]:
df_res['result_PostProcess'] = df_res['result'] * df_res['m']
df_res['result_lgb_dart_PostProcess'] = df_res['result_lgb_dart'] * df_res['m']
# In[ ]:
# In[ ]:
# In[ ]:
# In[37]:
# In[103]:
############# [Test Code]
# print ui_buy
# In[135]:
# get train X,Y
x = np.zeros((len(train_data29), 4))
y = np.zeros((len(train_data29), ))
index = 0
for line in train_data29:
uid = (line[0], line[1], line[-1] - 1)
for i in range(4):
x[index][i] = math.log1p(ui_dict[i][uid] if uid in ui_dict[i] else 0)
uid = (line[0], line[1], line[-1])
y[index] = 1 if uid in ui_buy else 0
index += 1
# In[136]:
# get prediction px
px = np.zeros((len(train_data30), 4))
index = 0
for line in train_data30:
uid = (line[0], line[1], line[-1] - 1)
for i in range(4):
px[index][i] = math.log1p(ui_dict[i][uid] if uid in ui_dict[i] else 0)
index += 1
# R R3 (N4;N0) 100""" netlist = """.DC OP .GND N0 OPAMP3 O0 (N3;N2;N1) V V0 (N2;N0) 10.0 R R1 (N3;N0) 1000.0 R R2 (N3;N1) 1000.0 """ sweepit = 0 satCurrent = 10**-14 thermalVoltage = 0.026 magList = [0 for i in range(100)] phaList = [0 for i in range(100)] i = 0 vCriticalDiode = thermalVoltage * math.log1p(thermalVoltage / (math.sqrt(2) * satCurrent)) simulationDomain = "" simulationFrequencies = [] simulationParameters = [] toGraph = [] commands = [] nodeList = [] nodeListNatural = [] voltageSources = 0 groundNode = "n0" nodeCount = 0 admittanceMatrix = [] currentMatrix = [] groundNodeIndex = [] voltageMatrixLabels = [] simulationFrequency = 0
indices = [index[w] for w in tokens if w in index]
z = len(indices)
for k in range(0, z):
context[indices[k]][indices[k]] += 1
contextCount[indices[k]] += 1
p[indices[k]] += 1
for l in range(k + 1, z):
context[indices[k]][indices[l]] += 1
context[indices[l]][indices[k]] += 1
idf = [math.log((m + 1) / x) for x in contextCount]
for k in range(0, n):
p[k] = math.log1p(p[k]) * idf[k]
total = sum(p)
p = list(map(lambda x: x / total, p))
total = 0
for k in range(0, n):
for l in range(0, n):
context[k][l] = math.log1p(context[k][l]) * idf[l]
total += sum(context[k])
for k in range(0, n):
for l in range(0, n):
context[k][l] /= total
#context[k][l] *= idf[l]
def arcProbability(self):
try:
# Next code applies product of probabilities, or sum of logs of probabilities
if Classifier.weightFormula == '4' or Classifier.weightFormula == '5':
for arc in Classifier.globalArcs: # for each TLINK in the final classifier
relTuple = ()
for i in range(15):
if Classifier.weightFormula == '4': # use sum of logs
prob = 0
else: # use product of probabilities
prob = 1
assignedByClassifier = False # relType was not assigned by any classifier - possible future use
for cl in Classifier.classifierList:
if Classifier.globalArcs[arc][cl][i] == 1:
assignedByClassifier = True # if at least one classifier assigns the relType, set to True
if Classifier.weightFormula == '4': # if '4' use sum of logs formula
prob += math.log1p(
Classifier.getWeight(cl))
else: # if '5' use product formula
prob *= Classifier.getWeight(cl)
else:
if Classifier.weightFormula == '4':
prob += math.log1p(
1 - Classifier.getWeight(cl))
else:
prob *= 1 - Classifier.getWeight(cl)
# if assignedByClassifier == False: # if no classifier assigned the reltype, weigh according to popularity of reltype
# prob *= Classifier.probReltype[i] # might implement this later
relTuple += (prob, )
self.setFinalClassifier(arc, relTuple)
return Classifier.finalArcs
# If formula is '3' or '6' or '7', need to normalise sum of weights to 1
if Classifier.weightFormula == '3' or Classifier.weightFormula >= '6':
totalWeight = float(0)
for cl in Classifier.classifierList:
totalWeight += Classifier.getWeight(
cl) # get total weight of all classifiers
for cl in Classifier.classifierList:
Classifier.setWeight(
cl,
Classifier.getWeight(cl) / totalWeight
) # divide each classifier weight by total weight to normalise sum to 1
# Next code applies LOSS functions
if Classifier.weightFormula >= '6':
for arc in Classifier.globalArcs: # for each TLINK in the final classifier
relTuple = ()
for i in range(15):
prob = 0
for cl in Classifier.classifierList:
if Classifier.globalArcs[arc][cl][
i] != 1: # if prediction doesn't match
t = 1
else:
t = 0
if Classifier.weightFormula == '6':
prob += t * Classifier.getWeight(
cl
) # add classifier's weight to total probability
elif Classifier.weightFormula == '7':
prob += t * Classifier.getWeight(
cl) # hinge loss
elif Classifier.weightFormula == '8':
prob += t * Classifier.getWeight(
cl) * Classifier.getWeight(
cl) # square loss
elif Classifier.weightFormula == '9':
prob += t * math.log1p(
Classifier.getWeight(cl)) + t * math.log1p(
1 -
Classifier.getWeight(cl)) # log loss
if Classifier.weightFormula == '6':
prob = 1 - prob # invert the loss
prob *= Classifier.probReltype[
i] # multiply total by prior probability of reltype
else:
prob *= (
Classifier.probReltype[i] - 1
) # multiply by probability of NOT being reltype and negate for Maximise objective function
relTuple += (prob, )
self.setFinalClassifier(arc, relTuple)
return Classifier.finalArcs
for arc in Classifier.globalArcs: # for each TLINK in the final classifier
if Classifier.weightFormula != '1':
numClassifiers = float(len(Classifier.classifierList)
) # total number of classifiers
else:
numClassifiers = float(
0
) # increment for each classifier that detects the arc
relTuple = self.emptyTuple
for cl in Classifier.classifierList:
if cl in Classifier.globalArcs[
arc]: # if classifier has identified the arc
if Classifier.weightFormula == '1' and sum(
Classifier.globalArcs[arc][cl]) >= 1:
numClassifiers += 1 # if weight is proportion of classifiers that identified arc, increment number
relTuple = self.addRelTuple(
relTuple, Classifier.globalArcs[arc][cl], cl
) # add this classifier's probability to the existing tuple of probabilities
else:
relTuple = self.addRelTuple(
relTuple, self.noneTuple, cl
) # redundant unless we introduce NONE as valid reltype
if Classifier.weightFormula == '1': # if weight is number of classifiers that identified arc, need to divide probability by this number
newTuple = ()
for prob in relTuple: # for each relType
newTuple += (
prob / numClassifiers,
) # set to proportion of classifiers that assigned that relType
# if numClassifiers > 1: # temporary
self.setFinalClassifier(arc, newTuple)
elif Classifier.weightFormula == '3':
if sum(
relTuple
) >= 0.5: # arc is only included if total probability greater than threshold (default 0.5)
self.setFinalClassifier(arc, relTuple)
else:
self.setFinalClassifier(arc, relTuple)
except Exception as X:
print "Error assigning probabilities to relTypes "
raise
return Classifier.finalArcs
def word_doc_counts(
self,
*,
normalize: str = "lemma",
weighting: str = "count",
smooth_idf: bool = True,
as_strings: bool = False,
filter_stops: bool = True,
filter_punct: bool = True,
filter_nums: bool = True,
) -> Dict[Union[int, str], Union[int, float]]:
"""
Map the set of unique words in :class:`Corpus` to their *document* counts
as absolute, relative, inverse, or binary frequencies of occurence.
Args:
normalize: If "lemma", lemmatize words before counting; if
"lower", lowercase words before counting; otherwise, words are
counted using the form with which they appear.
weighting ({"count", "freq", "idf"}): Type of weight to assign to words.
If "count" (default), weights are the absolute number (count)
of documents in which word appears. If "freq", word doc counts
are normalized by the total document count, giving their relative
frequencies of occurrence. If "idf", weights are the log of the
inverse relative frequencies: ``log(n_docs / word_doc_count)``
or (if ``smooth_idf`` is True) ``log(1 + (n_docs / word_doc_count))`` .
smooth_idf: If True, add 1 to all word doc counts when
calculating "idf" weighting, equivalent to adding a single
document to the corpus containing every unique word.
as_strings: If True, words are returned as strings; if False
(default), words are returned as their unique integer ids
filter_stops: If True (default), stop word counts are removed.
filter_punct: If True (default), punctuation counts are removed.
filter_nums: If True (default), number counts are removed.
Returns:
Mapping of a unique word id or string (depending on the value
of ``as_strings``) to the number of documents in which it appears
weighted as absolute, relative, or binary frequencies (depending
on the value of ``weighting``).
See Also:
:func:`textacy.vsm.get_doc_freqs() <textacy.vsm.matrix_utils.get_doc_freqs>`
"""
word_doc_counts_: Union[Counter[Any], Dict[Any, Union[int, float]]]
word_doc_counts_ = collections.Counter()
for doc in self:
word_doc_counts_.update(
doc._.to_bag_of_words(
normalize=normalize,
weighting="binary",
as_strings=as_strings,
filter_stops=filter_stops,
filter_punct=filter_punct,
filter_nums=filter_nums,
))
if weighting == "count":
word_doc_counts_ = dict(word_doc_counts_)
elif weighting == "freq":
n_docs = self.n_docs
word_doc_counts_ = {
word: count / n_docs
for word, count in word_doc_counts_.items()
}
elif weighting == "idf":
n_docs = self.n_docs
if smooth_idf is True:
word_doc_counts_ = {
word: math.log1p(n_docs / count)
for word, count in word_doc_counts_.items()
}
else:
word_doc_counts_ = {
word: math.log(n_docs / count)
for word, count in word_doc_counts_.items()
}
else:
raise ValueError(
errors.value_invalid_msg("weighting", weighting,
{"count", "freq", "idf"}))
return word_doc_counts_
def classify(dictInput, dictModel, dictIDF, nGrams):
script_name = "models.classify"
if dictInput == {}:
return None
if dictModel == {}:
return None
if dictIDF == {}:
return None
if dictInput.has_key("_words"):
print script_name, "error: input model is not normalized, _words key found"
if dictModel.has_key("_words"):
print script_name, "error: reference model is not normalized, _words key found"
if dictIDF.has_key("_words"):
print script_name, "error: idf model is not normalized, _words key found"
fScore = 0.0
dictExplain = {}
# this is applied directly to the final score, so use sparingly
size_adjust = 1.0
# upper
if len(dictInput) > 500:
size_adjust = 0.7
# lower
if len(dictInput) < 100:
size_adjust = 2.0
if len(dictInput) < 25:
size_adjust = 6.0
if len(dictInput) < 10:
size_adjust = 10.0
if len(dictInput) < 3:
size_adjust = 20.0
if len(dictInput) < 2:
size_adjust = 33.0
# tbd: this needs work...
# input_vs_model = (float(len(dictInput)) / float(len(dictModel))) # e.g. .004
# if input_vs_model > .002:
# size_adjust = 0.67
# print size_adjust,
# compute average frequencies for various lengths
dict_freqs = compute_average_frequency_by_length(dictModel)
for gram in dictInput.keys():
if float(dictInput[gram]) > 1.0:
continue
gram_count = count_grams(gram)
if gram_count > 1:
gc = 0
gl = 0
for g in gram.split('_'):
gc = gc + 1
gl = gl + len(g)
gram_average_length = float(gl) / float(gc)
else:
gram_average_length = len(gram)
# is it in the classification model?
if dictModel.has_key(gram):
idf = dictModel[gram]
if dictIDF.has_key(gram):
if dictIDF[gram] > idf:
idf = dictIDF[gram]
else:
continue
# compute tf/idf
fContrib = float(
(float(dictInput[gram]) / float(idf)) *
(math.log1p(gram_average_length) * (gram_average_length**2)))
# aggregate
if fContrib > 1.0:
# accept notable contributions only
fScore = fScore + fContrib
# add to explain dictionary
if dictExplain.has_key(gram):
dictExplain[gram] = dictExplain[gram] + fContrib
else:
dictExplain[gram] = fContrib
# end if
# end for
# aggregate the top 20 hits into the score
# to do: rewrite so that we score as the model (dictInput) is built, and stop as soon as we have 10 hits
fScore1 = 0.0
fScoreFinal = 0.0
xTop = 50
top = xTop
lstExplain = sorted(dictExplain.iteritems(),
key=operator.itemgetter(1),
reverse=True)
for (term, count) in lstExplain:
if count > 1.0:
fScore1 = fScore1 + 1.0
if count > 0.25 and count <= 1.0:
fScore1 = fScore1 + 0.75
if count > 0.1 and count <= 0.25:
fScore1 = fScore1 + 0.5
top = top - 1
if top == 0:
break
# adjust small models
fScore1 = fScore1 * size_adjust
# end for
if len(dictInput) < 100:
fScoreFinal = float(float(fScore1) / (float(xTop) / 1.5))
else:
fScoreFinal = float(float(fScore1) / float(xTop))
if fScoreFinal > 1.0:
fScoreFinal = 1.0
return [fScoreFinal, dictExplain]
def test_log1p(self):
import math
self.ftest(math.log1p(1 / math.e - 1), -1)
self.ftest(math.log1p(0), 0)
self.ftest(math.log1p(math.e - 1), 1)
self.ftest(math.log1p(1), math.log(2))
#!/usr/bin/python
import random
import math
a = 0
b = 1000
p = 0.8
cont = 0.0
a = 0
for a in range(a, b):
u = random.random()
cont = a + (math.log1p(1.0 - u) / math.log1p(p))
a = a + 1
print float(cont / b)
def h(p):
q = 1 - p
return -(q * log1p(-p) + p * log(p)) / (log(2) * p)
def cu_kernel_forward(log_probs, labels, alpha, log_p, T, U, blank, lock):
"""
Compute forward pass for the forward-backward algorithm using Numba cuda kernel.
Sequence Transduction with naive implementation : https://arxiv.org/pdf/1211.3711.pdf
Arguments
---------
log_probs : tensor
4D Tensor of (batch x TimeLength x LabelLength x outputDim) from the Transducer network.
labels : tensor
2D Tensor of (batch x MaxSeqLabelLength) containing targets of the batch with zero padding.
alpha : tensor
3D Tensor of (batch x TimeLength x LabelLength) for forward computation.
log_p : tensor
1D Tensor of (batch) for forward cost computation.
T : tensor
1D Tensor of (batch) containing TimeLength of each target.
U : tensor
1D Tensor of (batch) containing LabelLength of each target.
blank : int
Blank indice.
lock : tensor
2D Tensor of (batch x LabelLength) containing bool(1-0) lock for parallel computation.
"""
# parallelize the forward algorithm over batch and target length dim
b = cuda.blockIdx.x
u = cuda.threadIdx.x
t = 0
if u <= U[b]:
# for each (B,U) Thread
# wait the unlock of the previous computation of Alpha[b,U-1,:]
# Do the computation over the whole Time sequence on alpha[B,U,:]
# and then unlock the target U+1 for computation
while t < T[b]:
if u == 0:
if t > 0:
alpha[b, t, 0] = (alpha[b, t - 1, 0] +
log_probs[b, t - 1, 0, blank])
cuda.atomic.add(lock, (b, u + 1), -1)
t += 1
else:
if cuda.atomic.add(lock, (b, u), 0) < 0:
if t == 0:
alpha[b, 0,
u] = (alpha[b, 0, u - 1] +
log_probs[b, 0, u - 1, labels[b, u - 1]])
else:
# compute emission prob
emit = (alpha[b, t, u - 1] +
log_probs[b, t, u - 1, labels[b, u - 1]])
# compute no_emission prob
no_emit = (alpha[b, t - 1, u] +
log_probs[b, t - 1, u, blank])
# do logsumexp between log_emit and log_no_emit
alpha[b, t, u] = max(no_emit, emit) + math.log1p(
math.exp(-abs(no_emit - emit)))
if u < U[b]:
cuda.atomic.add(lock, (b, u + 1), -1)
cuda.atomic.add(lock, (b, u), 1)
t += 1
if u == U[b]:
# for each thread b (utterance)
# normalize the loss over time
log_p[b] = (alpha[b, T[b] - 1, U[b]] +
log_probs[b, T[b] - 1, U[b], blank]) / T[b]
def geometric_int(p):
if p <= 0: return arbitrary_int()
elif p >= 1: return 0
denom = log1p(-p)
return int(log(rand()) / denom)
def h(p):
return -(p * log(p) + (1 - p) * log1p(-p))
def geometric(p):
if p <= 0 or p > 1:
raise ValueError('p must be in the interval (0.0, 1.0]')
if p == 1:
return 1
return int(math.log1p(-random.random()) / math.log1p(-p)) + 1
print("exp(4) is ", exp_x)
# expm1(x) Returns e**x - 1
exp_x1 = math.expm1(4)
print("expm1(4) is ", exp_x1)
# log(x[, base]) > log of 5 with base e.
log_5 = math.log(5)
print("log(5) is ", log_5)
log_5b2 = math.log(5, 2)
print("log(5, 2) is ", log_5b2)
print("exp(log_5b2, 2) is ", math.pow(2, log_5b2))
# log1p(x) > 1+x base e.
log1p_x = math.log1p(5)
print("log1p(5) is ", log1p_x)
# log2(5) > log of 5 with base 2.
log2 = math.log2(5)
print("log2(5) is ", log2)
print("***************** Angular Conversions ********************** ")
# ##############################################
# Angular conversion.
# Py(22/7) radians = 180 degrees.
radian = 57.2985 # 1 Radian = 57.2958 degrees.
deg = math.degrees(4)
print("degree(4) is ", deg)
print("4 * radian is ", (4 * radian))
