def score(self, text):
total_score = 0
prev_word = None
for current_word in text:
current_score = 0
#print('current word is {}'.format(current_word))
if current_word in self.pos_features:
current_score += math.log2(self.pos_features[current_word])
# #print('+1')
if current_word in self.neg_features:
current_score -= math.log2(self.neg_features[current_word])
# print('-1')
if prev_word is not None:
# print('prev word is {}'.format(prev_word))
if prev_word in self.inc_features:
current_score *= 1.5
# print('*2')
elif prev_word in self.dec_features:
current_score /= 1.5
# print('/2')
elif prev_word in self.inv_features:
current_score *= -1.0
# print('-')
prev_word = current_word
total_score += current_score
return total_score
def NaiveBayes(class_list,variables_counter,path):
test = pd.read_csv(path,sep='\t',names=['num','class','desc'],header = None)
final_list = []
desc_list = test['desc'].tolist()
test_class = test['class']
total_train_files = sum(class_count.values())
i = 0
for line in desc_list:
class_prob.clear()
if type(line) is not str:
continue
record = line.split()
for word in record:
for classes in class_list:
prob_word_in_class = 0.0
class_counter = complete_dict[classes]
class_desc_overall_count = sum(class_counter.values())
class_word_unique_count = len(variables_counter)
word_count = class_counter.get(word,0)
prob_word_in_class = ( ((math.log2((word_count+1)) - math.log2((class_desc_overall_count + class_word_unique_count)))))
if class_prob.get(classes,0) != 0:
class_prob[classes] = class_prob[classes] + prob_word_in_class
else:
class_prob[classes] = prob_word_in_class
class_prob[classes] = class_prob[classes] + math.log2(class_count[classes]/total_train_files)
#print(class_prob,max(class_prob,key=class_prob.get))
final_list.append(max(class_prob,key=class_prob.get))
accuracy(final_list,test)
def tag(self, sent):
"""Returns the most probable tagging for a sentence.
sent -- the sentence.
"""
sent = list(sent)
hmm = self.hmm
tagset = hmm.tagset()
self._pi = pi = {0: {(START,) * (hmm.n - 1): (log2(1.0), [])}}
for k, w in enumerate(sent):
pi[k + 1] = {}
tag_out_probs = [(t, hmm.out_prob(w, t)) for t in tagset]
for t, out_p in [(t, p) for t, p in tag_out_probs if p > 0.0]:
for prev_tags, (log_p, tag_sent) in pi[k].items():
trans_p = hmm.trans_prob(t, prev_tags)
if trans_p > 0.0:
ts = (prev_tags + (t,))[1:]
new_lp = log_p + log2(trans_p) + log2(out_p)
if ts not in pi[k + 1] or new_lp > pi[k + 1][ts][0]:
pi[k + 1][ts] = (new_lp, tag_sent + [t])
max_lp = M_INF
res = None
for prev_tags, (log_p, tagging) in pi[len(sent)].items():
trans_p = hmm.trans_prob(STOP, prev_tags)
if trans_p > 0:
new_lp = log_p + log2(trans_p)
if new_lp > max_lp:
max_lp = new_lp
res = tagging
return res
def fattal(img, beta=0.90, normalize=True):
Lori = hydra.core.lum(img)
L = np.log(Lori + 1.0e-6)
h, w = L.shape
levels = int(round(math.log2(min(h, w))) - math.log2(32))
E = calcedge(L)
alph = 0.1 * np.average(E)
Phi = attenuatemap(L, alph, beta, 0, levels)
G = gradient(L, method='forward')
G[:,:,0] = np.multiply(G[:,:,0], Phi)
G[:,:,1] = np.multiply(G[:,:,1], Phi)
divG = hydra.core.remove_specials(divergence(G, method='backward'))
Ld = np.exp(poisson_solver(divG))
if normalize:
Ld = Ld / hydra.core.max_quart(Ld, 0.99995)
Ld = np.maximum(Ld, 0.0)
Ld = np.minimum(Ld, 1.0)
ret = np.zeros(img.shape)
for c in range(3):
ret[:,:,c] = img[:,:,c] / Lori * Ld
ret = hydra.core.remove_specials(ret)
ret = np.maximum(ret, 0.0)
ret = np.minimum(ret, 1.0)
return ret
def log_probability( self, sequence, transitions_weight = None, outputs_weight = 1 ):
"""
Returns the log-probability of the given symbol sequence. If the
sequence is labelled, then returns the joint log-probability of the
symbol, state sequence. Otherwise, uses the forward algorithm to find
the log-probability over all label sequences.
:return: the log-probability of the sequence
:rtype: float
:param sequence: the sequence of symbols which must contain the TEXT
property, and optionally the TAG property
:type sequence: Token
"""
if transitions_weight is None:
transitions_weight = 1
sequence = self._transform( sequence )
T = len( sequence )
EPSILON = ''
channelModel = 0
sourceModel = 0
if T > 0 and sequence[ 0 ][ _TAG ] is not None:
last_state = sequence[ 0 ][ _TAG ]
if last_state != EPSILON:
if transitions_weight:
sourceModel += transitions_weight * self._priors.logprob( last_state )
else:
if transitions_weight:
sourceModel += transitions_weight * math.log2( globalModelParameters.EpsilonTransition )
channelModel += outputs_weight * self._output_logprob( last_state, sequence[ 0 ][ _TEXT ] )
for t in range( 1, T ):
state = sequence[ t ][ _TAG ]
if last_state != EPSILON:
if state != EPSILON:
if transitions_weight:
sourceModel += transitions_weight * self._transitions[ last_state ].logprob( state )
else:
if transitions_weight:
sourceModel += transitions_weight * math.log2( globalModelParameters.EpsilonTransition )
else:
# check if last_state is epsilon; if so then transition with probability of Epsilon
if transitions_weight:
sourceModel += transitions_weight * math.log2( globalModelParameters.EpsilonTransition )
channelModel += outputs_weight * self._output_logprob( state, sequence[ t ][ _TEXT ] )
last_state = state
# FIXME changed exponentiation
return { 'HMMtotal': (sourceModel + channelModel),
'HMMchannel': channelModel,
'HMMsource': sourceModel,
'sequence': sequence}
def main():
hashlist = []
diglist = []
transactionlistobj = open(sys.argv[1])
transactionlist = transactionlistobj.read()
splittransactionlist = str.splitlines(transactionlist)
nextpow2 = pow(2,math.ceil(math.log2(len(splittransactionlist))))
for i in range(len(splittransactionlist),nextpow2):
splittransactionlist.append("null") #splitting list and appending null
for i in range(0,len(splittransactionlist)):
hashlist.append(hashlib.sha256(splittransactionlist[i].encode('utf-8'))) #hashing initial list
diglist.append(hashlist[i].hexdigest()) #generating initial digested hash
for i in range(0,math.ceil(math.log2(nextpow2))): #for each power of 2
for j in range(0,int(len(diglist)/2)): #for half the list
sha256 = hashlib.sha256(diglist[j+j].encode('utf-8')+diglist[j+(j+1)].encode('utf-8'))
diglist[j] = sha256.hexdigest()
return diglist[0]
def calc_posprob(sentence,file1,file2):
prob_p =math.log2(pos_count_sep/(pos_count_sep+neg_count_sep))
voca=open(file1).read()
vocab=voca.split()
with open(file1) as f:
vocab_len= sum(1 for _ in f)
pos_word=open(file2).read()
pos_words=pos_word.split()
#with open(file1) as f:
# total_pos= sum(1 for _ in f)
total_pos=sum_words(file2)
for word in sentence:
if word in vocab:
if word in pos_words:
index= pos_words.index(word)
count= int(pos_words[index+1])
prob_1= math.log2(count+1/(total_pos+vocab_len))
prob_p= prob_p+prob_1
else:
prob_1 = math.log2(1/(total_pos+vocab_len))
prob_p= prob_p+prob_1
return prob_p
def write_axi_csr(filename, registers, module_name="AXI_CSR", register_width=32): # check that register width is a power of 2 assert int(log2(register_width)) == log2(register_width), "register_width must be power of 2" register_byte_width = register_width // 8 log2_register_byte_width = int(log2(register_byte_width)) # figure out some constants ceil_log2_num_regs = ceil( log2(max(reg.addr for reg in registers) + 1 ) ) axi_addr_width = ceil_log2_num_regs + log2_register_byte_width num_regs = 2**(ceil_log2_num_regs) # maximum register width for some alignment nicieties justification_width = max(len(reg.label) for reg in registers if reg.mode == "read" or reg.mode == "write" ) with open(filename, "w") as FID: FID.write( t.render( MODULE_NAME=module_name, registers=registers, JUSTIFICATION_WIDTH=justification_width, NUM_REGS=num_regs, AXI_ADDR_WIDTH=axi_addr_width, REGISTER_WIDTH=register_width, REGISTER_BYTE_WIDTH=register_byte_width, LOG2_REGISTER_BYTE_WIDTH=log2_register_byte_width ) )
def run_simulation(num_blocks_per_set, num_words_per_block, cache_size,
replacement_policy, num_addr_bits, word_addrs):
num_blocks = cache_size // num_words_per_block
num_sets = num_blocks // num_blocks_per_set
# Ensure that the number of bits used to represent each address is always
# large enough to represent the largest address
num_addr_bits = max(num_addr_bits, int(math.log2(max(word_addrs))) + 1)
num_offset_bits = int(math.log2(num_words_per_block))
num_index_bits = int(math.log2(num_sets))
num_tag_bits = num_addr_bits - num_index_bits - num_offset_bits
refs = get_addr_refs(
word_addrs, num_addr_bits,
num_offset_bits, num_index_bits, num_tag_bits)
cache, ref_statuses = read_refs_into_cache(
num_sets, num_blocks_per_set, num_index_bits,
num_words_per_block, replacement_policy, refs)
print()
display_addr_refs(refs, ref_statuses)
print()
display_cache(cache)
print()
def test_EquationBC_mixedpoisson_matfree_fieldsplit(eq_type, mat_type, porder):
# Mixed poisson with EquationBCs
# matfree with fieldsplit pc
solver_parameters = {'mat_type': mat_type,
'ksp_type': 'gmres',
'ksp_atol': 1e-09,
'ksp_rtol': 1e-09,
'ksp_max_it': 200000,
'ksp_divtol': 1e8,
'pc_type': 'fieldsplit',
'pc_fieldsplit_type': 'schur',
'pc_fieldsplit_schur_fact_type': 'full',
'fieldsplit_0_ksp_type': 'gmres',
'fieldsplit_0_ksp_rtol': 1.e-12,
'fieldsplit_0_pc_type': 'python',
'fieldsplit_0_pc_python_type': 'firedrake.AssembledPC',
'fieldsplit_0_assembled_pc_type': 'asm',
'fieldsplit_1_ksp_type': 'gmres',
'fieldsplit_1_ksp_rtol': 1.e-12,
'fieldsplit_1_pc_type': 'none'}
err = []
if eq_type == "linear":
for i, mesh_num in enumerate([8, 16]):
err.append(linear_poisson_mixed(solver_parameters, mesh_num, porder))
elif eq_type == "nonlinear":
for i, mesh_num in enumerate([8, 16]):
err.append(nonlinear_poisson_mixed(solver_parameters, mesh_num, porder))
assert(abs(math.log2(err[0][0]) - math.log2(err[1][0]) - (porder+1)) < 0.03)
def test_tag2(self):
tagset = {"D", "N", "V"}
trans = {
("<s>", "<s>"): {"D": 1.0},
("<s>", "D"): {"N": 1.0},
("D", "N"): {"V": 0.8, "N": 0.2},
("N", "N"): {"V": 1.0},
("N", "V"): {"</s>": 1.0},
}
out = {"D": {"the": 1.0}, "N": {"dog": 0.4, "barks": 0.6}, "V": {"dog": 0.1, "barks": 0.9}}
hmm = HMM(3, tagset, trans, out)
tagger = ViterbiTagger(hmm)
x = "the dog barks".split()
y = tagger.tag(x)
pi = {
0: {("<s>", "<s>"): (log2(1.0), [])},
1: {("<s>", "D"): (log2(1.0), ["D"])},
2: {("D", "N"): (log2(0.4), ["D", "N"])},
3: {
("N", "V"): (log2(0.8 * 0.4 * 0.9), ["D", "N", "V"]),
("N", "N"): (log2(0.2 * 0.4 * 0.6), ["D", "N", "N"]),
},
}
self.assertEqualPi(tagger._pi, pi)
self.assertEqual(y, "D N V".split())
def ndcg(run, qrels, detailed = False):
"""
Computes NDCG using the formula
DCG_p = rel_1 + \sum_{i = 2}^p( rel_i / log_2(i) )
Where p is the number of entries of the given run for
a certain topic, and rel_i is the relevance score of the
document at rank i.
"""
details = {}
avg = 0
for topicId, entryList in run.entries.items():
relevancesByRank = qrels.getRelevanceScores( topicId, [doc for (doc, _, _) in entryList] )
sumdcg = relevancesByRank[0] + sum( [ relScore / math.log2(rank)
for rank, relScore in enumerate(relevancesByRank[1:], start=2)] )
#sumdcg = sum( [ (2**relScore - 1) / math.log2(rank+1)
# for rank, relScore in enumerate(relevancesByRank, start=1)] )
relevancesByRank.sort(reverse = True) # sort the relevance list descending order
sumIdcg = relevancesByRank[0] + sum( [ relScore / math.log2(rank)
for rank, relScore in enumerate(relevancesByRank[1:], start=2)] )
#sumIdcg = sum( [ (2**relScore - 1) / math.log2(rank+1)
# for rank, relScore in enumerate(relevancesByRank, start=1)] )
if sumIdcg == 0: print(topicId, relevancesByRank)
details[topicId] = sumdcg / sumIdcg
avg += sumdcg / sumIdcg
numtopics = qrels.getNTopics()
return avg / numtopics if not detailed else (avg / numtopics, details)
def clog(pagerank):
vector = list(sorted(pagerank, reverse=True))
k = [math.log2(i) for i in range(1, len(vector) + 1)]
y = [math.log2(i) for i in vector]
A = np.vstack([k, np.ones(len(k))]).T
m, c = np.linalg.lstsq(A, y)[0]
return m
def __init__(self, Loader, Encoder, Parser, freq_threshold, vectors, candidates):
print("Initializing MDL Learner for this round (loading data).")
#Initialize
self.language = Encoder.language
self.Encoder = Encoder
self.Loader = Loader
self.Parser = Parser
self.freq_threshold = freq_threshold
self.tabu_start = False
#Get fixed units costs per representation type
self.type_cost = -math.log2(float(1.0/3.0))
number_of_words = len(list(self.Encoder.word_dict.keys()))
self.lex_cost = -math.log2(float(1.0/number_of_words))
number_of_pos = len(list(self.Encoder.pos_dict.keys()))
self.pos_cost = -math.log2(float(1.0/number_of_pos))
number_of_domains = len(list(set(self.Encoder.domain_dict.values())))
self.domain_cost = -math.log2(float(1.0/number_of_domains))
#Load candidate constructions to use as grammar
self.vectors = vectors
#Reformat candidate to be equal length for numba
self.candidates = self.Parser.format_grammar(candidates)
def test_EquationBC_mixedpoisson_matrix_fieldsplit(eq_type, mat_type, porder):
# Mixed poisson with EquationBCs
# aij with fieldsplit pc
solver_parameters = {"mat_type": mat_type,
"ksp_type": "gmres",
"ksp_rtol": 1.e-10,
"ksp_atol": 1.e-10,
"ksp_max_it": 500000,
"pc_type": "fieldsplit",
"pc_fieldsplit_type": "schur",
"pc_fieldsplit_schur_fact_type": "full",
"fieldsplit_0_ksp_type": "gmres",
"fieldsplit_0_pc_type": "asm",
"fieldsplit_0_ksp_rtol": 1.e-12,
"fieldsplit_1_ksp_type": "gmres",
"fieldsplit_1_ksp_rtol": 1.e-12,
"fieldsplit_1_pc_type": "none"}
err = []
if eq_type == "linear":
for i, mesh_num in enumerate([8, 16]):
err.append(linear_poisson_mixed(solver_parameters, mesh_num, porder))
elif eq_type == "nonlinear":
for i, mesh_num in enumerate([8, 16]):
err.append(nonlinear_poisson_mixed(solver_parameters, mesh_num, porder))
assert(abs(math.log2(err[0][0]) - math.log2(err[1][0]) - (porder+1)) < 0.03)
def test_EquationBC_poisson_matfree(eq_type, mat_type, porder, with_bbc):
# Test standard poisson with EquationBCs
# matfree
solver_parameters = {'mat_type': mat_type,
'ksp_type': 'gmres',
'ksp_atol': 1e-10,
'ksp_rtol': 1e-10,
'ksp_max_it': 200000,
'ksp_divtol': 1e8}
err = []
if with_bbc:
if eq_type == "linear":
for mesh_num in [8, 16]:
err.append(linear_poisson_bbc(solver_parameters, mesh_num, porder))
elif eq_type == "nonlinear":
for mesh_num in [8, 16]:
err.append(nonlinear_poisson_bbc(solver_parameters, mesh_num, porder))
else:
if eq_type == "linear":
for mesh_num in [8, 16]:
err.append(linear_poisson(solver_parameters, mesh_num, porder))
elif eq_type == "nonlinear":
for mesh_num in [8, 16]:
err.append(nonlinear_poisson(solver_parameters, mesh_num, porder))
assert(abs(math.log2(err[0]) - math.log2(err[1]) - (porder+1)) < 0.01)
def test_effective_window_size(self):
log_window_sizes = [math.log2(z) for z in self.window_sizes]
plot = PointPlot()
plot.new_plot("Effective Window Size", rows=1, num_curves=self.num_estimations+1)
avg_err_bayes = self.get_errors(self.num_estimations)
for i in range (0,len(self.window_sizes)):
for k in range (0, self.num_estimations+1):
self.print_values(k, self.window_sizes[i], avg_err_bayes[i][k], avg_err_bayes[i][0])
for k in range(0, len(avg_err_bayes[0])): # which is numestimations+1
k_array = avg_err_bayes[:,k]
log_k_array = [math.log2(y) for y in k_array]
if k == 0:
plot.add_data_to_plot(log_k_array,log_window_sizes,label = "Naive ("+str(k)+" Shifts)")
else:
plot.add_data_to_plot(log_k_array, log_window_sizes, label=str(k)+" Shifts")
"""naive = avg_err_bayes[0]
avg_err_naive = [naive]* len(avg_err_bayes)
plot.add_to_plot()"""
plot.create_legend()
plot.save_plot("effective_window_size_plot")
def save(self):
presets = list(all_presets())
t = self.instance
# Identify + apply selected preset
selected_index = self.cleaned_data["preset_rules"]
selected_preset = next(p for p in presets if p.name == selected_index)
selected_preferences = get_preferences_data(selected_preset, t)
for preference in selected_preferences:
t.preferences[preference['key']] = preference['new_value']
# Apply public info presets
do_public = self.cleaned_data["public_info"]
public_preset = next((p for p in presets if p.name == do_public), False)
if public_preset:
public_preferences = get_preferences_data(public_preset, t)
for preference in public_preferences:
t.preferences[preference['key']] = preference['new_value']
# Apply the credits
if self.cleaned_data['tournament_staff'] != self.fields['tournament_staff'].initial:
t.preferences["public_features__tournament_staff"] = self.cleaned_data["tournament_staff"]
# Create break rounds (need to do so after we know teams-per-room)
open_break = BreakCategory.objects.filter(tournament=t, is_general=True).first()
# Check there aren't already break rounds (i.e. when importing demos)
if open_break and not t.break_rounds().exists():
if t.pref('teams_in_debate') == 'bp':
num_break_rounds = math.ceil(math.log2(open_break.break_size / 2))
else:
num_break_rounds = math.ceil(math.log2(open_break.break_size))
auto_make_break_rounds(t, num_break_rounds, open_break)
def computeHash(inputFile):
# Initialize a list for storing each transaction from the file
try:
transactionsList = open(inputFile, 'rt').read().split('\n')
except FileNotFoundError:
print("The file cannot be found. Please enter a valid name.")
return
# If there's a newline character at the end, account for it
if len(transactionsList[len(transactionsList) - 1]) == 0:
transactionsList = transactionsList[:len(transactionsList) - 1]
nextLogOfTwo = math.log2(len(transactionsList))
# If the number of transactions in the list is not a power of 2, then append the string 'null' into it until it is
if not nextLogOfTwo.is_integer():
# Find what the next log of two is
nextLogOfTwo = math.ceil(math.log2(len(transactionsList)))
targetNumOfList = int(math.pow(2, nextLogOfTwo))
# And append 'null'
for i in range(0, targetNumOfList - len(transactionsList), 1):
transactionsList.append('null')
else:
nextLogOfTwo = int(nextLogOfTwo)
# Encode each of the items in transactionsList to their corresponding representations in bytes
for indexOfTrans in range(0, len(transactionsList), 1):
transactionsList[indexOfTrans] = bytes(transactionsList[indexOfTrans], 'utf-8')
hashes = []
currLevelHash = list(transactionsList)
nextLevelHash = []
for j in range(0, len(currLevelHash), 1):
hashOfEachElem = hashlib.sha256()
hashOfEachElem.update(currLevelHash[j])
nextLevelHash.append(hashOfEachElem)
currLevelHash = nextLevelHash
# Now start hashing and concatenating each pair of elements up till nextLogOfTwo
for i in range(0, nextLogOfTwo, 1):
nextLevelHash = []
for j in range(0, len(currLevelHash) - 1, 2):
hashOfFirstElem = currLevelHash[j].hexdigest()
hashOfSecondElem = currLevelHash[j+1].hexdigest()
bothElemsConcatenated = hashOfFirstElem + hashOfSecondElem
hashOfBothElems = hashlib.sha256()
hashOfBothElems.update(bytes(bothElemsConcatenated, 'utf-8'))
nextLevelHash.append(hashOfBothElems)
currLevelHash = nextLevelHash
# Set hashes to be equal to currLevelHash
hashes = currLevelHash
# And return the hexdigest of the root hash
return hashes[0].hexdigest()
def immediateToBytecode(imm):
"""
The immediate operand rotate field is a 4 bit unsigned integer which specifies a shift
operation on the 8 bit immediate value. This value is zero extended to 32 bits, and then
subject to a rotate right by twice the value in the rotate field. (ARM datasheet, 4.5.3)
:param imm:
:return:
"""
if imm == 0:
return 0, 0, False
if imm < 0:
val, rot, _ = immediateToBytecode(~imm)
return val, rot, True
mostSignificantOne = int(math.log2(imm))
leastSignificantOne = int(math.log2((1 + (imm ^ (imm - 1))) >> 1))
if mostSignificantOne < 8:
# Are we already able to fit the value in the immediate field?
return imm & 0xFF, 0, False
elif mostSignificantOne - leastSignificantOne < 8:
# Does it fit in 8 bits?
# If so, we want to put the MSB to the utmost left possible in 8 bits
# Remember that we can only do an EVEN number of right rotations
if mostSignificantOne % 2 == 0:
val = imm >> (mostSignificantOne - 6)
rot = (32 - (mostSignificantOne - 6)) // 2
else:
val = imm >> (mostSignificantOne - 7)
rot = (32 - (mostSignificantOne - 7)) // 2
return val & 0xFF, rot, False
else:
# It is impossible to generate the requested value
return None
def surprisals(counts):
if isinstance(counts, Counter):
counts = counts.items()
counts = list(counts)
A = log2(sum(c for _, c in counts))
for x, count in counts:
yield x, -log2(count) + A
def filter_mapping_bias(genomeA, genomeB):
'''Takes two dicts of hyrbid data mapped on each genome and
returns a single dict of genomeA data with the biased genes
removed. GenomeA is ideally the genome with the best assembly.'''
unbiased = {}
genesA = list(hybridA.keys())
genesB = list(hybridB.keys())
genes = list(set(genesA).intersection(genesB))
genes.sort()
for gene in genes:
expAA = genomeA[gene][0]
expAB = genomeA[gene][1]
expBA = genomeB[gene][0]
expBB = genomeB[gene][1]
# Minimum cutoff of 20 reads per gene, half or more replicates significant
if genomeA[gene][2] + genomeA[gene][3] > 20 and genomeA[gene][4] >= 0.5:
valueA = log2(expAA/expAB)
valueB = log2(expBA/expBB)
# Cutoff for mapping bias (could play around with this)
if abs(valueA-valueB) < 1.5:
unbiased[gene] = valueA
else:
unbiased[gene] = "NA"
else:
unbiased[gene] = "NA"
return(unbiased)
def getCount(i):
number = i
count = 0
while True:
if number in computed:
return computed[number]
if number % 2 == 0:
lognumber = math.log2(number)
intlognumber = int(lognumber)
if lognumber == intlognumber:
count += lognumber + 1
break
else:
divide = math.pow(2, int(lognumber))
while number % divide != 0:
divide /= 2
number = (number / divide)*3+1
count += int(math.log2(divide))+1
else:
number = number * 3 + 1
count += 1
computed[i] = count
return count
def compute_mutual_info(N00, N01, N11, N10):
if N11 <= 0:
return 0.
if N10 <= 0:
return 0.
N0x = N01 + N00
Nx0 = N10 + N00
N1x = N10 + N11
Nx1 = N01 + N11
N = N00 + N01 + N11 + N10
#print(N00, N01, N10, N11)
term1 = (N*N11)/(N1x*Nx1)
term2 = (N*N01)/(N0x*Nx1)
term3 = (N*N10)/(N1x*Nx0)
term4 = (N*N00)/(N0x*Nx0)
w1 = N11 / N
w2 = N01 / N
w3 = N10 / N
w4 = N00 / N
score = w1 * math.log2(term1) + w2 * math.log2(term2) + w3 * math.log2(term3) + w4 * math.log2(term4)
return score
def __create_tournament_tree(self):
'''
Creates list for every rounds. Connects every list item between other
items, that connections makes tournament tree.
@return: list of interconnected list items
'''
tournament_rounds = []
# create lists for every round
for i in range(int(math.log2(self.competitors_count))):
round_list = self._init_round_list(i)
tournament_rounds.append(round_list)
# make interconnections between rounds - tournament tree
for i in range(int(math.log2(self.competitors_count - 1))):
if len(tournament_rounds[- 1 - i]) > 1:
for j in range(len(tournament_rounds[- 1 - i]) // 2):
k = (2 * j)
tournament_rounds[- 1 - i][k].next_round = \
tournament_rounds[- 1 - i - 1][j]
tournament_rounds[- 1 - i][k + 1].next_round = \
tournament_rounds[- 1 - i - 1][j]
tournament_rounds[- 1 - i - 1][j].previous_match1 = \
tournament_rounds[- 1 - i][k]
tournament_rounds[- 1 - i - 1][j].previous_match2 = \
tournament_rounds[- 1 - i][k + 1]
# set current round variable to index for the first round
self.__current_round = len(tournament_rounds) - 1
# return all rounds
return tournament_rounds
def qsort_based_counter(a, b, x):
len_x = len(x)
result = [0] * len_x
checked = {}
len_a = len(a)
len_b = len(b)
if not len_a:
return result
qsort(a, 0, len_a, math.floor(math.log2(len_a)))
qsort(b, 0, len_b, math.floor(math.log2(len_b)))
print(a)
print(b)
# a = sorted(a)
# b = sorted(b)
for i in range(0, len(x)):
if x[i] < a[0]:
continue
if x[i] in checked:
result[i] = result[checked[x[i]]]
else:
a_idx = bisect.bisect_right(a, x[i])
b_idx = bisect.bisect_left(b, x[i])
result[i] = a_idx - b_idx
checked[x[i]] = i
return result
def GetSampleLincData(sample, linc_exp):
"""
Get the data for each linc for that sample. Get log2 fold change for FPKM compared to average and median of all samples for the linc.
Args:
sample = Sample from the input file name.
linc_exp = Name of file containing the expression data for each linc in every sample.
Returns:
linc_dict = Dict containing signal of every SE position for the sample {(chr, (start, stop)): ((linc_id, linc_name), signal)}
"""
# Dict to hold data.
linc_dict = {}
with open(linc_exp) as f:
# Get the sample index.
header = f.readline().strip()
sample_idx = GetSampleIdx(header, sample)
for line in f:
line = line.strip().split("\t")
data = [float(x) for x in line[5:]] # Convert all data to floats.
linc_med = log2(float(median(data))) # Get log2 median of list.
linc_avg = log2(float(mean(data))) # Get log2 average of the list.
linc_val = log2(float(line[sample_idx])) # Get log2 of the linc FPKM for the sample.
linc_med_FC = linc_val - linc_med
linc_avg_FC = linc_val - linc_avg
# Grab data and add to the dict.
chrom, start, stop, linc_id, linc_name = line[0], int(line[1]), int(line[2]), line[3], line[4]
linc_dict[(chrom, (start, stop))] = ((linc_id, linc_name), (linc_med_FC, linc_avg_FC))
return linc_dict
def I(self, term, cluster):
n = len(self.docVector)
n00 = n10 = n11 = n01 = 0
for id in self.docVector:
if self.docCluster[id] == cluster:
if term in self.docVector[id].dict.keys():
n11 += 1
else:
n01 += 1
else:
if term in self.docVector[id].dict.keys():
n10 += 1
else:
n00 += 1
n1_ = n10 + n11
n_1 = n01 + n11
n0_ = n00 + n01
n_0 = n00 + n10
# #print('cluster : '+cluster.__str__())
# #print('n00 = ',n00)
# #print('n01 = ', n01)
# #print('n10 = ',n10)
# #print('n11 = ', n11)
a1 = n11 / n * log2(n * n11 / (n1_ * n_1)) if n11 != 0 else 0
a2 = n01 / n * log2(n * n01 / (n0_ * n_1)) if n01 != 0 else 0
a3 = n10 / n * log2(n * n10 / (n1_ * n_0)) if n10 != 0 else 0
a4 = n00 / n * log2(n * n00 / (n0_ * n_0)) if n00 != 0 else 0
return a1 +a2 + a3 + a4
def log_value(x):
import math
import numpy as np
if type(x) == list or type(x) == np.ndarray:
return [math.log2(x_i) for x_i in x if x_i != 0]
else:
return math.log2(x)
def channelModel( candidate_object ):
partitionProbData = [ ]
for partition in candidate_object[ 'partitions' ]:
partitionProbData.append( HMMmodel.log_probability( partition,
transitions_weight = globalModelParameters.TransitionWeight ) )
partitionProbData.sort(key=lambda arg: arg['HMMtotal'],reverse=True)
TopPartitionsProbData=partitionProbData[:globalModelParameters.NUM_PARTITIONS]
candidate_object.pop( 'partitions' )
candidate_object[ 'totalProb' ] = 0
candidate_object[ 'channelProb' ] = round( math.log2(sum(map(lambda arg: 2**arg[ 'HMMtotal' ],TopPartitionsProbData),0)) ,
3 )
candidate_object[ 'langProb' ] = 0
candidate_object[ 'HMMchannel' ] = round( math.log2(sum(map(lambda arg: 2**arg[ 'HMMchannel' ],TopPartitionsProbData),0)) ,
3 )
candidate_object[ 'HMMsource' ] = round( math.log2(sum(map(lambda arg: 2**arg[ 'HMMsource' ],TopPartitionsProbData),0)) , 3 )
candidate_object[ 'maxPartition' ] = TopPartitionsProbData[0]['sequence']
candidate_object['topPartitionsDict'] = TopPartitionsProbData
return candidate_object
def lohhla(self):
sampleID = self.sample
pairID = self.pair
resultsDir = self.output
tmpDir = resultsDir + "/tempFile/LOH_" + sampleID
mkdir(tmpDir)
# 对HLA结果进行提取
self.extractHLAResults()
# 肿瘤纯度与倍性评估
self.TempPurityPloidy()
# HLAfasta来源
# https://github.com/jason-weirather/hla-polysolver/blob/master/data/abc_complete.fasta
HLAloc = "/home/bioinfo/ubuntu/software/LOHHLA"
HLAfasta = "/home/bioinfo/ubuntu/software/LOHHLA/data/abc_complete.fasta"
HLAexon = "/home/bioinfo/ubuntu/software/LOHHLA/data/hla.dat"
cmd = """
Rscript {HLAloc}/LOHHLAscript.R \\
--patientId {sampleID} \\
--outputDir {tmpDir} \\
--normalBAMfile {resultsDir}/bam/{pairID}.bam \\
--tumorBAMfile {resultsDir}/bam/{sampleID}.bam \\
--BAMDir {resultsDir}/bam \\
--hlaPath {tmpDir}/{sampleID}.hlas \\
--HLAfastaLoc {HLAfasta} \\
--CopyNumLoc {tmpDir}/{sampleID}.solutions.txt \\
--mappingStep TRUE \\
--minCoverageFilter 10 \\
--fishingStep TRUE \\
--cleanUp FALSE \\
--gatkDir /home/bioinfo/ubuntu/software/picard \\
--novoDir /home/bioinfo/ubuntu/software/novocraft \\
--LOHHLA_loc {HLAloc} \\
--HLAexonLoc {HLAexon}
""".format(HLAloc=HLAloc,
sampleID=sampleID,
tmpDir=tmpDir,
resultsDir=resultsDir,
pairID=pairID,
HLAfasta=HLAfasta,
HLAexon=HLAexon)
print(cmd)
os.system(cmd)
# results
f_list = os.listdir(tmpDir)
lohfile = "-"
for f in f_list:
if "DNA.HLAlossPrediction_" in f:
lohfile = f
if lohfile == "-":
print("未找到结果")
exit()
else:
lohf = open(tmpDir + "/" + lohfile, "r")
loh_results = open(tmpDir + "/" + sampleID + ".loh.txt", "w")
loh_results.write("HLAType\tHLACopyNumWithBAFBin\tpval\tLOHstat\n")
for line in lohf:
if not line.startswith("message"):
lines = line.split("\t")
HLAtype = lines[1][0:5]
if lines[0].startswith("homozygous_alleles"):
HLAtype2copyNumWithBAFBin = "-"
pVal = "-"
LOHstat = "FALSE"
else:
HLAtype2copyNumWithBAFBin = lines[28]
pVal = lines[33]
if pVal == "NA":
LOHstat = "-"
# 参考 https://github.com/pyc1216/hlaloh-pipeline/blob/master/scripts/get_result.py 获得回报结果
elif float(pVal) < 0.01 and float(
HLAtype2copyNumWithBAFBin) < math.log2(0.5):
LOHstat = "TRUE"
else:
LOHstat = "FALSE"
loh_results.write(HLAtype + "\t" +
HLAtype2copyNumWithBAFBin + "\t" + pVal +
"\t" + LOHstat + "\n")
loh_results.close()
lohf.close()
shutil.copy(tmpDir + "/" + sampleID + ".loh.txt",
resultsDir + "/LOH/" + sampleID + ".loh.txt")
print("LOH分析完成")
def information_gain(features, attribute_index, targets):
"""
TODO: Implement me!
Information gain is how a decision tree makes decisions on how to create
split points in the tree. Information gain is measured in terms of entropy.
The goal of a decision tree is to decrease entropy at each split point as much as
possible. This function should work perfectly or your decision tree will not work
properly.
Information gain is a central concept in many machine learning algorithms. In
decision trees, it captures how effective splitting the tree on a specific attribute
will be for the goal of classifying the training data correctly. Consider
data points S and an attribute A. S is split into two data points given binary A:
S(A == 0) and S(A == 1)
Together, the two subsets make up S. If A was an attribute perfectly correlated with
the class of each data point in S, then all points in a given subset will have the
same class. Clearly, in this case, we want something that captures that A is a good
attribute to use in the decision tree. This something is information gain. Formally:
IG(S,A) = H(S) - H(S|A)
where H is information entropy. Recall that entropy captures how orderly or chaotic
a system is. A system that is very chaotic will evenly distribute probabilities to
all outcomes (e.g. 50% chance of class 0, 50% chance of class 1). Machine learning
algorithms work to decrease entropy, as that is the only way to make predictions
that are accurate on testing data. Formally, H is defined as:
H(S) = sum_{c in (classes in S)} -p(c) * log_2 p(c)
To elaborate: for each class in S, you compute its prior probability p(c):
(# of elements of class c in S) / (total # of elements in S)
Then you compute the term for this class:
-p(c) * log_2 p(c)
Then compute the sum across all classes. The final number is the entropy. To gain
more intution about entropy, consider the following - what does H(S) = 0 tell you
about S?
Information gain is an extension of entropy. The equation for information gain
involves comparing the entropy of the set and the entropy of the set when conditioned
on selecting for a single attribute (e.g. S(A == 0)).
For more details: https://en.wikipedia.org/wiki/ID3_algorithm#The_ID3_metrics
Args:
features (np.array): numpy array containing features for each example.
attribute_index (int): which column of features to take when computing the
information gain
targets (np.array): numpy array containing labels corresponding to each example.
Output:
information_gain (float): information gain if the features were split on the
attribute_index.
"""
data = list(features[:, attribute_index])
label = {}
totalyesno = targets.shape[0]
attributecount = {}
aveInfoEntropy = 0
for i in range(len(data)):
if str(data[i]) in label:
label[str(data[i])].append(i)
else:
label[str(data[i])] = [i]
total_yes = 0
total_no = 0
for i in targets:
if i == 0:
total_yes += 1
else:
total_no += 1
yesfrac = (total_yes / totalyesno)
nofrac = (total_no / totalyesno)
if yesfrac == 0 or nofrac == 0:
entropyS = 0
else:
entropyS = -((yesfrac) * log2(yesfrac)) - ((nofrac) * log2(nofrac))
entropyA = {}
fractionA = {}
for key in label:
no = 0
yes = 0
attributecount[key] = len(label[key])
for each in label[key]:
if targets[each] == 0:
no += 1
else:
yes += 1
frac = [(yes) / (yes + no), (no) / (yes + no)]
if frac[0] == 0 or frac[1] == 0:
entro = 0
else:
entro = -(frac[0] * (log2(frac[0]))) - (frac[1] * (log2(frac[1])))
entropyA[key] = entro
fractionA[key] = frac
for key in label:
aveInfoEntropy += (attributecount[key] / totalyesno) * entropyA[key]
infoGain = entropyS - aveInfoEntropy
"""print("entropy {}".format(entropyA))
print("fraction [1, 0] format: {}".format(fractionA))
print("ave info entropy = {}".format(aveInfoEntropy))
print(attributecount)
print("entropyS = {}".format(entropyS))
print(type(infoGain))
"""
return infoGain
def _get_prediction(self, data, theta):
"""Make prediction on data based on each theta.
Args:
data (numpy.ndarray): 2-D array, NxD, N data points, each with D dimension
theta (list[numpy.ndarray]): list of 1-D array, parameters sets for variational form
Returns:
Union(numpy.ndarray or [numpy.ndarray], numpy.ndarray or [numpy.ndarray]):
list of NxK array, list of Nx1 array
"""
circuits = []
num_theta_sets = len(theta) // self._var_form.num_parameters
theta_sets = np.split(theta, num_theta_sets)
def _build_parameterized_circuits():
var_form_support = isinstance(self._var_form, QuantumCircuit) \
or self._var_form.support_parameterized_circuit
feat_map_support = isinstance(self._feature_map, QuantumCircuit) \
or self._feature_map.support_parameterized_circuit
if var_form_support and feat_map_support and self._parameterized_circuits is None:
parameterized_circuits = self.construct_circuit(
self._feature_map_params,
self._var_form_params,
measurement=not self._quantum_instance.is_statevector)
self._parameterized_circuits = \
self._quantum_instance.transpile(parameterized_circuits)[0]
_build_parameterized_circuits()
for thet in theta_sets:
for datum in data:
if self._parameterized_circuits is not None:
curr_params = dict(zip(self._feature_map_params, datum))
curr_params.update(dict(zip(self._var_form_params, thet)))
circuit = self._parameterized_circuits.assign_parameters(
curr_params)
else:
circuit = self.construct_circuit(
datum,
thet,
measurement=not self._quantum_instance.is_statevector)
circuits.append(circuit)
results = self._quantum_instance.execute(
circuits, had_transpiled=self._parameterized_circuits is not None)
circuit_id = 0
predicted_probs = []
predicted_labels = []
for _ in theta_sets:
counts = []
for _ in data:
if self._quantum_instance.is_statevector:
temp = results.get_statevector(circuit_id)
outcome_vector = (temp * temp.conj()).real
# convert outcome_vector to outcome_dict, where key
# is a basis state and value is the count.
# Note: the count can be scaled linearly, i.e.,
# it does not have to be an integer.
outcome_dict = {}
bitstr_size = int(math.log2(len(outcome_vector)))
for i, _ in enumerate(outcome_vector):
bitstr_i = format(i, '0' + str(bitstr_size) + 'b')
outcome_dict[bitstr_i] = outcome_vector[i]
else:
outcome_dict = results.get_counts(circuit_id)
counts.append(outcome_dict)
circuit_id += 1
probs = return_probabilities(counts, self._num_classes)
predicted_probs.append(probs)
predicted_labels.append(np.argmax(probs, axis=1))
if len(predicted_probs) == 1:
predicted_probs = predicted_probs[0]
if len(predicted_labels) == 1:
predicted_labels = predicted_labels[0]
return predicted_probs, predicted_labels
if __name__ == "__main__":
while True:
try:
# int a, cin >> a
a = int(input())
except:
break
# 數學相關
math.ceil(x) #上高斯
math.floor(x) #下高斯
math.factorial(x) #階乘
math.fabs(x) #絕對值
math.fsum(arr) #跟sum一樣但更精確(小數點問題)
math.gcd(x, y) #bj4
math.exp(x) #e^x
math.log(x, base)
math.log2(x) #2為底
math.log10(x) #10為底
math.sqrt(x)
math, pow(x, y) #精確些(float型態)
math.sin(x)
# cos tan asin acos atan atan2(弧度)
# sinh cosh tanh acosh asinh atanh
math.hypot(x, y) #歐幾里德範數
math.degrees(x) #x從弧度轉角度
math.radians(x) #x從角度轉弧度
math.gamma(x) #x的gamma函數
math.pi #常數
math.e #常數
math.inf
def get_axial_shape(x):
"Simple heuristic to suggest axial_shape givem max_seq_len (2 factors)"
return (2**math.ceil(math.log2(x**0.5)), 2**math.floor(math.log2(x**0.5)))
current_dict["R_unknown_images"] = len(
images_list_unknown) / len(images_list)
current_dict["N_classes"] = len(uni_all)
current_dict["N_known_classes"] = len(uni_known)
current_dict["N_unknown_classes"] = len(uni_unknown)
N_images = len(images_list)
current_count = {w: 0 for w in uni_all}
for A in images_list_all:
w = A.split("/")[-2]
current_count[w] += 1
H = 0
for c in current_count.values():
if c > 0:
p = c / N_images
H = H - (p * log2(p))
current_dict["entropy"] = H
current_dict["ranking"] = 2**H
entropy_list.append((H, counter_storage))
data_set = list_data_class(
image_list=images_list,
transform_supervised=image_transform_supervised)
data_loader = DataLoader(dataset=data_set,
batch_size=batch_size,
shuffle=False,
num_workers=n_cpu)
N_data = data_set.__len__()
for batch_id, x_supervised in enumerate(data_loader, 0):
assert batch_id == 0
"""
from math import log2
def to_decimal(ip):
return sum([int(b) << ((3 - i) * 8) for i, b in enumerate(ip.split('.'))])
def to_ip(n):
return '.'.join([str(n >> (i * 8) & 255) for i in range(3, -1, -1)])
while True:
try:
n = int(input())
except EOFError:
break
first = to_decimal(input())
diff = 0
for i in range(n - 1):
c = to_decimal(input())
diff |= (first ^ c)
try:
mask = ((1 << int(log2(diff) + 1)) - 1) ^ -1
except ValueError:
mask = ~diff
print(to_ip(first & mask))
print(to_ip(mask))
from queue import deque
from math import log2
MAX_NUM = 10**16
N = int(input())
primenum = []
for i in range(2, int(log2(N)) + 1):
for n in primenum:
if i % n == 0:
break
else:
primenum.append(i)
kouho_num = set()
for n in primenum:
for i in range(1, int(log2(MAX_NUM)) + 1):
if n**i <= N:
kouho_num.add(n**i)
else:
break
queue = deque([(N, 0, kouho_num)])
res = 0
while queue:
divnum, countnum, pnum = queue.popleft()
def __init__(self, hres=800, vres=600, with_csi_interpreter=True):
self.enable = Signal(reset=1)
self.vtg_sink = vtg_sink = stream.Endpoint(video_timing_layout)
self.uart_sink = uart_sink = stream.Endpoint([("data", 8)])
self.source = source = stream.Endpoint(video_data_layout)
# # #
csi_width = 8 if with_csi_interpreter else 0
# Font Mem.
# ---------
os.system(
"wget https://github.com/enjoy-digital/litex/files/6076336/ter-u16b.txt"
) # FIXME: Store Font in LiteX?
os.system("mv ter-u16b.txt ter-u16b.bdf")
font = import_bdf_font("ter-u16b.bdf")
font_width = 8
font_heigth = 16
font_mem = Memory(width=8, depth=4096, init=font)
font_rdport = font_mem.get_port(has_re=True)
self.specials += font_mem, font_rdport
# Terminal Mem.
# -------------
term_colums = 128 # 80 rounded to next power of two.
term_lines = math.floor(vres / font_heigth)
term_depth = term_colums * term_lines
term_init = [ord(c) for c in [" "] * term_colums * term_lines]
term_mem = Memory(width=font_width + csi_width,
depth=term_depth,
init=term_init)
term_wrport = term_mem.get_port(write_capable=True)
term_rdport = term_mem.get_port(has_re=True)
self.specials += term_mem, term_wrport, term_rdport
# UART Terminal Fill.
# -------------------
# Optional CSI Interpreter.
if with_csi_interpreter:
self.submodules.csi_interpreter = CSIInterpreter()
self.comb += uart_sink.connect(self.csi_interpreter.sink)
uart_sink = self.csi_interpreter.source
self.comb += term_wrport.dat_w[font_width:].eq(
self.csi_interpreter.color)
self.submodules.uart_fifo = stream.SyncFIFO([("data", 8)], 8)
self.comb += uart_sink.connect(self.uart_fifo.sink)
uart_sink = self.uart_fifo.source
# UART Reception and Terminal Fill.
x_term = term_wrport.adr[:7]
y_term = term_wrport.adr[7:]
y_term_rollover = Signal()
self.submodules.uart_fsm = uart_fsm = FSM(reset_state="RESET")
uart_fsm.act("RESET", NextValue(x_term, 0), NextValue(y_term, 0),
NextState("CLEAR-XY"))
uart_fsm.act(
"CLEAR-XY", term_wrport.we.eq(1),
term_wrport.dat_w[:font_width].eq(ord(" ")),
NextValue(x_term, x_term + 1),
If(
x_term == (term_colums - 1), NextValue(x_term, 0),
NextValue(y_term, y_term + 1),
If(y_term == (term_lines - 1), NextValue(y_term, 0),
NextState("IDLE"))))
uart_fsm.act(
"IDLE",
If(
uart_sink.valid,
If(
uart_sink.data == ord("\n"),
uart_sink.ready.eq(1), # Ack sink.
NextState("INCR-Y")).Elif(
uart_sink.data == ord("\r"),
uart_sink.ready.eq(1), # Ack sink.
NextState("RST-X")).Else(NextState("WRITE"))))
uart_fsm.act("WRITE", uart_sink.ready.eq(1), term_wrport.we.eq(1),
term_wrport.dat_w[:font_width].eq(uart_sink.data),
NextState("INCR-X"))
uart_fsm.act("RST-X", NextValue(x_term, 0), NextState("CLEAR-X"))
uart_fsm.act(
"INCR-X", NextValue(x_term, x_term + 1), NextState("IDLE"),
If(x_term == (80 - 1), NextValue(x_term, 0), NextState("INCR-Y")))
uart_fsm.act("RST-Y", NextValue(y_term, 0), NextState("CLEAR-X"))
uart_fsm.act(
"INCR-Y", NextValue(y_term, y_term + 1), NextState("CLEAR-X"),
If(y_term == (term_lines - 1), NextValue(y_term_rollover, 1),
NextState("RST-Y")))
uart_fsm.act(
"CLEAR-X", NextValue(x_term, x_term + 1), term_wrport.we.eq(1),
term_wrport.dat_w[:font_width].eq(ord(" ")),
If(x_term == (term_colums - 1), NextValue(x_term, 0),
NextState("IDLE")))
# Video Generation.
# -----------------
ce = (vtg_sink.valid & vtg_sink.ready)
# Timing delay line.
latency = 2
timing_bufs = [
stream.Buffer(video_timing_layout) for i in range(latency)
]
self.comb += vtg_sink.connect(timing_bufs[0].sink)
for i in range(len(timing_bufs) - 1):
self.comb += timing_bufs[i].source.connect(timing_bufs[i + 1].sink)
self.comb += timing_bufs[-1].source.connect(
source, keep={"valid", "ready", "last", "de", "hsync", "vsync"})
self.submodules += timing_bufs
# Compute X/Y position.
x = vtg_sink.hcount[int(math.log2(font_width)):]
y = vtg_sink.vcount[int(math.log2(font_heigth)):]
y_rollover = Signal(8)
self.comb += [
If(~y_term_rollover, y_rollover.eq(y)).Else(
# FIXME: Use Modulo.
If((y + y_term + 1) >= term_lines,
y_rollover.eq(y + y_term + 1 - term_lines)).Else(
y_rollover.eq(y + y_term + 1)), )
]
# Get character from Terminal Mem.
term_dat_r = Signal(font_width)
self.comb += term_rdport.re.eq(ce)
self.comb += term_rdport.adr.eq(x + y_rollover * term_colums)
self.comb += [
term_dat_r.eq(term_rdport.dat_r[:font_width]),
If(
(x >= 80) | (y >= term_lines),
term_dat_r.eq(ord(" ")), # Out of range, generate space.
)
]
# Translate character to video data through Font Mem.
self.comb += font_rdport.re.eq(ce)
self.comb += font_rdport.adr.eq(term_dat_r * font_heigth +
timing_bufs[0].source.vcount[:4])
bit = Signal()
cases = {}
for i in range(font_width):
cases[i] = [bit.eq(font_rdport.dat_r[font_width - 1 - i])]
self.comb += Case(
timing_bufs[1].source.hcount[:int(math.log2(font_width))], cases)
# FIXME: Add Palette.
self.comb += [
If(
bit,
Case(
term_rdport.dat_r[font_width:], {
0: [Cat(source.r, source.g, source.b).eq(0xffffff)],
1: [Cat(source.r, source.g, source.b).eq(0x34e289)],
})).Else(Cat(source.r, source.g, source.b).eq(0x000000), )
]
def calculate_entropy(p):
if (p==0 or p==1):
return 0.0
else:
return -1*(p*math.log2(p) + (1-p)*math.log2(1-p))
def test_code_length_of_two_letters_is_computed_correctly(self):
self.assertEqual(Arima().compress([5, 7]),
int(math.ceil(-math.log2(math.pow(1 / 256, 2)))))
def __init__(self, bottom_up, in_features, out_channels, norm="", top_block=None, fuse_type="sum",reduction=16):
# bottom_up = 是具备{"res2": [56*56*256], "res3":[28*28*512],"res4":[14*14*1024], "res5": [7*7*2048]}的骨干网
# in_features = ["res2", "res3", "res4", "res5"]
# out_channels = 256
super(DesFPN, self).__init__()
# 对传入的bottom_up进行断言 判断类型是否是Backbone
assert isinstance(bottom_up, Backbone)
# Feature map strides and channels from the bottom up network (e.g. ResNet)
# 获取bottom_up的输出类型作为FPN的输入类型
input_shapes = bottom_up.output_shape()
# f in ["res2", "res3", "res4", "res5"], 获取res块的步长 in_strides = [stride2, stride3, ...]
in_strides = [input_shapes[f].stride for f in in_features]
# 获取["res2", "res3", "res4", "res5"]各自的channel = [256， 512， 1025， 2048]
in_channels = [input_shapes[f].channels for f in in_features]
# aug_lateral_conv = 最顶层的channel
# aug_lateral_conv = in_channels[-1]
# 验证strides
_assert_strides_are_log2_contiguous(in_strides)
# 横向卷积层
lateral_convs = []
# 输出卷积层
output_convs = []
across_convs = []
senets_convs = []
use_bias = norm == ""
for idx, in_channel in enumerate(in_channels):
lateral_norm = get_norm(norm, out_channels)
output_norm = get_norm(norm, out_channels)
across_norm = get_norm(norm, out_channels)
# 设置横向卷积层
lateral_conv = Conv2d(
in_channel, out_channels, kernel_size=1, bias=use_bias, norm=lateral_norm
)
across_conv = Conv2d(
in_channel, out_channels, kernel_size=1, bias=use_bias, norm=lateral_norm
)
senet_conv = SELayer(in_channel, out_channels)
# 设置输出卷积层
output_conv = Conv2d(
out_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1,
bias=use_bias,
norm=output_norm,
)
# 卷积层权重初始化参数
weight_init.c2_xavier_fill(lateral_conv)
weight_init.c2_xavier_fill(output_conv)
weight_init.c2_xavier_fill(across_conv)
stage = int(math.log2(in_strides[idx]))
# 在模型中添加上配置信息
self.add_module("fpn_lateral{}".format(stage), lateral_conv)
self.add_module("fpn_output{}".format(stage), output_conv)
self.add_module("fpn_across{}".format(stage), across_conv)
# 将卷积层添加到list中方便计算
lateral_convs.append(lateral_conv)
output_convs.append(output_conv)
across_convs.append(across_conv)
senets_convs.append(senet_conv)
# senet
self.conv1x1 = nn.Conv2d(2048, 256, kernel_size=1, bias=False)
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Sequential(
nn.Linear(256, 256 // reduction, bias=False),
nn.ReLU(inplace=True),
nn.Linear(256 // reduction, 256, bias=False),
nn.Sigmoid()
)
# Place convs into top-down order (from low to high resolution)
# to make the top-down computation in forward clearer.
# 将横向卷积逆序成 [conv(2048*256)...conv(256, 256)]
self.lateral_convs = lateral_convs[::-1]
# 将输出卷积逆序 conv(256, 256) ...
self.output_convs = output_convs[::-1]
self.across_convs = across_convs[::-1]
self.senets_convs = senets_convs[::-1]
# top_block = None
self.top_block = top_block
# self.in_features = ["res2", "res3", "res4", "res5"]
self.in_features = in_features
# self.bottom_up = Backbone
self.bottom_up = bottom_up
# Return feature names are "p<stage>", like ["p2", "p3", ..., "p6"]
self._out_feature_strides = {"p{}".format(int(math.log2(s))): s for s in in_strides}
# top block output feature maps.
if self.top_block is not None:
for s in range(stage, stage + self.top_block.num_levels):
self._out_feature_strides["p{}".format(s + 1)] = 2 ** (s + 1)
# self._out_feature_strides.keys() = ["p2", "p3", ... "p6"]
self._out_features = list(self._out_feature_strides.keys())
self._out_feature_channels = {k: out_channels for k in self._out_features}
# 顶层的步长
self._size_divisibility = in_strides[-1]
assert fuse_type in {"avg", "sum"}
self._fuse_type = fuse_type
def test_code_length_of_one_letter_is_computed_correctly(self):
self.assertEqual(Arima().compress([5]),
int(math.ceil(-math.log2(1 / 256))))
def query(data, table, left, right):
number_of_elements = right - left + 1
end_query = math.floor(math.log2(number_of_elements))
return min(
data[table[left][end_query]],
data[table[left + number_of_elements - (1 << end_query)][end_query]])
def __init__(self, array):
self.array = [i for i in array]
self.n = len(array)
self.m = 1 + int(math.log2(self.n))
self.stats = stat(array, self.m)
def extractE(self, wf, nodelist, MList, rf=True, annotation=None, window=1, inc=None, aa=True):
"""
Regenerates the signal from each of nodes and finds max standardized E.
Args:
1. wf - WaveletFunctions with a homebrew wavelet tree (list of ndarray nodes)
2. nodelist - will reconstruct signal and run detections on each of these nodes separately
3. MList - passed here to allow multiple Ms to be tested from one reconstruction
4. rf - bandpass to species freq range?
5. annotation - for calculating noise properties during training
6-7. window, inc - window / increment length, seconds
8. antialias - True/False
Return: ndarrays of MxTxN energies, for each of M values, T windows and N nodes
"""
if inc is None:
inc = window
resol = window
else:
resol = (math.gcd(int(100 * window), int(100 * inc))) / 100
annotation = np.array(annotation)
duration = len(wf.tree[0])
# Window, inrement, and resolution are converted to true seconds based on the tree samplerate
samplerate = wf.treefs
win_sr = math.ceil(window * samplerate)
inc_sr = math.ceil(inc * samplerate)
resol_sr = math.ceil(resol * samplerate)
# number of windows of length inc
nw = int(np.ceil(duration / inc_sr))
nodenum = 0
maxE = np.zeros((len(MList), nw, len(nodelist)))
for node in nodelist:
useWCenergies = False
# Option 1: use wavelet coef energies directly
if useWCenergies:
# how many samples went into one WC?
samples_wc = 2**math.floor(math.log2(node+1))
duration = int(duration/samples_wc)
# put WC from test node(s) on the new tree
C = wf.tree[node][0::2]
# Option 2: reconstruct from the WCs, as before
else:
samples_wc = 1
C = wf.reconstructWP2(node, antialias=aa, antialiasFilter=True)
# Sanity check for all zero case
if not any(C):
continue
if len(C) > duration:
C = C[:duration]
C = np.abs(C)
N = len(C)
# Compute threshold using mean & sd from non-call sections
if annotation is not None:
noiseSamples = np.repeat(annotation == 0, resol_sr/samples_wc)
noiseSamples = noiseSamples[:len(C)]
else:
print("Warning: no annotations detected in file")
noiseSamples = np.full(len(C), True)
meanC = np.mean(np.log(C[noiseSamples]))
stdC = np.std(np.log(C[noiseSamples]))
# Compute the energy curve (a la Jinnai et al. 2012)
# using different M values, for a single node.
for indexM in range(len(MList)):
# Compute the number of samples in a window -- species specific
# Convert M to number of WCs
M = int(MList[indexM] * win_sr/samples_wc)
E = ce.EnergyCurve(C, M)
# for each sliding window, find largest E
start = 0
for j in range(nw):
end = min(N, int(start + win_sr/samples_wc))
# NOTE: here we determine the statistic (mean/max...) for detecting calls
maxE[indexM, j, nodenum] = (np.log(np.mean(E[start:end])) - meanC) / stdC
start += int(inc_sr/samples_wc)
nodenum += 1
C = None
E = None
del C
del E
gc.collect()
return maxE
from math import log2 DSIZE = 32 # data size ASIZE = 32 # address size RAM_DEPTH = 128 # RAM size in words NUM_REGS = 32 # number of registers REG_ASIZE = int(log2(NUM_REGS)) # register address size ALU_FUN_SIZE = 4 OPCODE_SIZE = 6 OPCODE_RANGE = (32, 26) FUNCT_SIZE = 6 FUNCT_RANGE = (6, 0) IMMEDIATE_SIZE = 16 IMMEDIATE_RANGE = (16, 0) RS_RANGE = (26, 21) RT_RANGE = (21, 16) RD_RANGE = (16, 11) JUMP_IMM_RANGE = (26, 0)
def branch_point_differences(n, mode):
out_dict = {}
syllables_dict = {}
for nest, birds_list in meta_nest_dict.items():
nest_dict = {}
nest_syllable_dict = {}
pupil_IDs = birds_list[:-1]
tutor_ID = birds_list[-1]
for pupil_ID in pupil_IDs:
fp1 = directory + prefix + tutor_ID + '.csv'
fp2 = directory + prefix + pupil_ID + '.csv'
distrib_1 = entropy.branchpoints(fp1, [2, n + 1])[n]
distrib_2 = entropy.branchpoints(fp2, [2, n + 1])[n]
bird1_branchpoints = []
bird2_branchpoints = []
for branchpoint_1 in distrib_1.keys():
bird1_branchpoints.append(branchpoint_1)
for branchpoint_2 in distrib_2.keys():
bird2_branchpoints.append(branchpoint_2)
branchpoints_to_analyze = [
value for value in bird1_branchpoints
if value in bird2_branchpoints
]
branchpoints_dict = {}
for branchpoint in branchpoints_to_analyze:
differences_dict = {}
if branchpoint in distrib_1.values():
count1 = distrib_1[branchpoint]['count']
else:
count1 = 0
if branchpoint in distrib_2.values():
count2 = distrib_1[branchpoint]['count']
else:
count2 = 0
transitions_to_analyze = list(
distrib_1[branchpoint]['transitions'].keys()) + list(
distrib_2[branchpoint]['transitions'].keys())
for transition in transitions_to_analyze:
if transition not in distrib_1[branchpoint][
'transitions'].keys():
bird1_value = 0.00000001
else:
bird1_value = distrib_1[branchpoint]['transitions'][
transition]
if transition not in distrib_2[branchpoint][
'transitions'].keys():
bird2_value = 0.00000001
else:
bird2_value = distrib_2[branchpoint]['transitions'][
transition]
if mode == 'euclidean':
difference = abs(bird1_value - bird2_value)
if mode == 'dkl':
difference = bird1_value * math.log2(
bird1_value / bird2_value)
if mode == 'log':
difference = abs(
math.log2(bird1_value) - math.log2(bird2_value))
differences_dict[transition] = difference
divergence = sum(differences_dict.values())
branchpoints_dict[branchpoint] = {
'tutor_count': count1,
'pupil_count': count2,
'divergence': divergence
}
divergences = []
counts = []
for branchpoint, subdict in branchpoints_dict.items():
divergences.append(subdict['divergence'])
shared_branchpoints = len(branchpoints_dict.keys())
out_dict[nest] = nest_dict
syllables_dict[nest] = nest_syllable_dict
matrix_version = []
syllables_matrix_version = []
for nest, nestdict in out_dict.items():
for bird, birdresult in nestdict.items():
matrix_version.append(birdresult)
for nest, nestdict in syllables_dict.items():
for bird, birddict in nestdict.items():
for syl, syldict in birddict.items():
syllables_matrix_version.append(
[nest, bird, syl, syldict['divergence']])
with open("./output/bird_divergence.csv", 'w') as output_file:
writer = csv.writer(output_file)
for row in matrix_version:
writer.writerow([row])
with open("./output/syllable_divergence.csv", 'w') as output_file:
writer = csv.writer(output_file)
writer.writerow(['Nest', 'BirdID', 'Syllable', 'Divergence'])
for row in syllables_matrix_version:
writer.writerow(row)
return [matrix_version, syllables_dict]
def __init__(self,
n,
uni=None,
iso=None,
phys_dim=2,
dangle=False,
site_ind_id="k{}",
site_tag_id="I{}",
**tn_opts):
# short-circuit for copying MERA
if isinstance(n, MERA):
super().__init__(n)
for ep in MERA._EXTRA_PROPS:
setattr(self, ep, getattr(n, ep))
return
self._site_ind_id = site_ind_id
self._site_tag_id = site_tag_id
self.cyclic = True
if not is_power_of_2(n):
raise ValueError("``n`` should be a power of 2.")
nlayers = round(log2(n))
if isinstance(uni, np.ndarray):
uni = (uni, )
if isinstance(iso, np.ndarray):
iso = (iso, )
unis = itertools.cycle(uni)
isos = itertools.cycle(iso)
def gen_mera_tensors():
u_ind_id = site_ind_id
for i in range(nlayers):
# index id connecting to layer below
l_ind_id = u_ind_id
# index id connecting to isos to unis
m_ind_id = rand_uuid() + "_{}"
# index id connecting to layer above
u_ind_id = rand_uuid() + "_{}"
# number of tensor sites in this layer
eff_n = n // 2**i
for j in range(0, eff_n, 2):
# generate the unitary:
# ul | | ur
# UNI
# ll | | lr
# j j+1
ll, lr = map(l_ind_id.format, (j, (j + 1) % eff_n))
ul, ur = map(m_ind_id.format, (j, (j + 1) % eff_n))
inds = (ll, lr, ul, ur)
tags = {"_UNI", "_LAYER{}".format(i)}
if i == 0:
tags.add(site_tag_id.format(j))
tags.add(site_tag_id.format(j + 1))
yield Tensor(next(unis), inds, tags=tags)
# generate the isometry (offset by one effective site):
# | ui
# ISO
# ll | | lr
# j+1 j+2
ll, lr = map(m_ind_id.format, (j + 1, (j + 2) % eff_n))
ui = u_ind_id.format(j // 2)
inds = (ll, lr, ui)
tags = {"_ISO", "_LAYER{}".format(i)}
if i < nlayers - 1 or dangle:
yield Tensor(next(isos), inds, tags)
else:
# don't leave dangling index at top
yield Tensor(
np.eye(phys_dim, dtype=next(isos).dtype) / 2**0.5,
inds[:-1], tags)
super().__init__(gen_mera_tensors(),
check_collisions=False,
structure=site_tag_id)
# tag the MERA with the 'causal-cone' of each site
for i in range(nlayers):
for j in range(n):
# get isometries in the same layer
for t in self.select_neighbors(j):
if f'_LAYER{i}' in t.tags:
t.add_tag(f'I{j}')
# get unitaries in layer above
for t in self.select_neighbors(j):
if f'_LAYER{i + 1}' in t.tags:
t.add_tag(f'I{j}')
def next_power_of_2(n: int) -> int:
return 1 << ceil(log2(n))
def bits(n: int, max: Optional[int] = None) -> Sequence[int]:
len = math.ceil(math.log2(max)) if max is not None else 0
return list(map(int, bin(n)[2:].zfill(len)))
def retune_alpha(alpha, new_frequency, starting_frequency=1):
return 2**(math.log2(alpha) * starting_frequency / new_frequency)
def ent_cal(data,val,f):
cnt=0
yes=0
if(f==0):#greater or equal
for i in range(9):
if(data[i][0]>=val):
cnt+=1
if(data[i][3]=='Y'):
yes+=1
else:#less or equal
for i in range(9):
if(data[i][0]<=val):
cnt+=1
if(data[i][3]=='Y'):
yes+=1
print("yes=",end='')
print(yes)
print("cnt=",end='')
print(cnt)
if(cnt==0):
py0=1
pn0=1
else:
py0=yes/cnt
pn0=1-py0
if(yes==0):
py0=1
if(cnt==yes):
pn0=1
print("py0=",end='')
print(py0)
print("pn0=",end='')
print(pn0)
ent0=(py0*math.log2(py0)+pn0*math.log2(pn0))*(-1)
print("ent0=",end='')
print(ent0)
cnt1=9-cnt
yes1=6-yes
if(cnt1==0):
py1=1
pn1=1
else:
py1=yes1/cnt1
pn1=1-py1
if(yes1==0):
py1=1
if(cnt1==yes1):
pn1=1
print()
print()
print("py1=",end='')
print(py1)
print("pn1=",end='')
print(pn1)
ent1=(py1*math.log2(py1)+pn1*math.log2(pn1))*(-1)
print("ent1=",end='')
print(ent1)
x=cnt/10
print("x=",end='')
print(x)
ent=(x)*ent0+(1-x)*ent1
print()
print("ent=",end='')
print(ent)
print("-----------------------------------------")
print()
return ent
# e**x - 1 반환 x = int(input()) print(math.expm1(x)) # x의 로그화한 밑을 밑으로 반환합니다 (기본값은 e). x = int(input()) base = 10 print(math.log(x, base)) # 1 + x의 자연로그를 반환합니다 x = int(input()) print(math.log1p(x)) # x의 밑이 2 인 로그 값을 반환합니다 x = int(input()) print(math.log2(x)) # x의 밑이 10 인 로그 값을 반환합니다 x = int(input()) print(math.log10(x)) # x를 거듭제곱 y로 올림 x = int(input()) y = int(input()) print(math.pow(x, y)) # x의 제곱근을 반환 x = int(input()) print(math.sqrt(x)) # x의 아크 코사인을 반환합니다
import numpy as np
import math
import random
NUM_PICTURES = 20
NUM_ITERATIONS = math.ceil(NUM_PICTURES * NUM_PICTURES *
math.log2(NUM_PICTURES))
rank = [[[] for col in range(NUM_PICTURES)] for row in range(NUM_PICTURES)]
images = np.random.rand(NUM_PICTURES)
def compare(targetIndex, index1, index2):
if (math.fabs(images[targetIndex] - images[index1]) <=
math.fabs(images[targetIndex] - images[index2])):
winner = index1
loser = index2
else:
winner = index2
loser = index1
print("{}: {} is closer than {}".format(images[targetIndex],
images[winner], images[loser]))
return (winner, loser)
print(images)
for i in range(NUM_ITERATIONS):
target = i % NUM_PICTURES
index1 = np.random.randint(NUM_PICTURES)
def plog(x):
return (-1)*math.log2(x)
def get_entropy_from_dict(char_dict):
res = sum(-i * math.log2(i) for i in char_dict.values())
return res
prog.h(input_qubit[3]) # number=20
# circuit end
return prog
if __name__ == '__main__':
key = "00000"
f = lambda rep: str(int(rep == key))
prog = make_circuit(5, f)
backend = BasicAer.get_backend('statevector_simulator')
sample_shot = 7924
info = execute(prog, backend=backend).result().get_statevector()
qubits = round(log2(len(info)))
info = {
np.binary_repr(i, qubits): round(
(info[i] * (info[i].conjugate())).real, 3)
for i in range(2**qubits)
}
backend = FakeVigo()
circuit1 = transpile(prog, backend, optimization_level=2)
writefile = open("../data/startQiskit_Class1876.csv", "w")
print(info, file=writefile)
print("results end", file=writefile)
print(circuit1.depth(), file=writefile)
print(circuit1, file=writefile)
writefile.close()
def infoMeasure(n, p):
return -math.log2(prob(n, p))
def forward(self, images, features, gt_instances=None):
assert not self.training
features = [features[f] for f in self.in_features]
objectness_logits_pred, anchor_deltas_pred = self.rpn_head(features)
# TODO is the needed?
# objectness_logits_pred = [t.sigmoid() for t in objectness_logits_pred]
assert isinstance(images, ImageList)
if self.tensor_mode:
im_info = images.image_sizes
else:
im_info = torch.Tensor([[im_sz[0], im_sz[1],
torch.Tensor([1.0])]
for im_sz in images.image_sizes
]).to(images.tensor.device)
assert isinstance(im_info, torch.Tensor)
rpn_rois_list = []
rpn_roi_probs_list = []
for scores, bbox_deltas, cell_anchors_tensor, feat_stride in zip(
objectness_logits_pred,
anchor_deltas_pred,
iter(self.anchor_generator.cell_anchors),
self.anchor_generator.strides,
):
scores = scores.detach()
bbox_deltas = bbox_deltas.detach()
rpn_rois, rpn_roi_probs = torch.ops._caffe2.GenerateProposals(
scores,
bbox_deltas,
im_info,
cell_anchors_tensor,
spatial_scale=1.0 / feat_stride,
pre_nms_topN=self.pre_nms_topk[self.training],
post_nms_topN=self.post_nms_topk[self.training],
nms_thresh=self.nms_thresh,
min_size=self.min_box_side_len,
# correct_transform_coords=True, # deprecated argument
angle_bound_on=True, # Default
angle_bound_lo=-180,
angle_bound_hi=180,
clip_angle_thresh=1.0, # Default
legacy_plus_one=False,
)
rpn_rois_list.append(rpn_rois)
rpn_roi_probs_list.append(rpn_roi_probs)
# For FPN in D2, in RPN all proposals from different levels are concated
# together, ranked and picked by top post_nms_topk. Then in ROIPooler
# it calculates level_assignments and calls the RoIAlign from
# the corresponding level.
if len(objectness_logits_pred) == 1:
rpn_rois = rpn_rois_list[0]
rpn_roi_probs = rpn_roi_probs_list[0]
else:
assert len(rpn_rois_list) == len(rpn_roi_probs_list)
rpn_post_nms_topN = self.post_nms_topk[self.training]
device = rpn_rois_list[0].device
input_list = [
to_device(x, "cpu")
for x in (rpn_rois_list + rpn_roi_probs_list)
]
# TODO remove this after confirming rpn_max_level/rpn_min_level
# is not needed in CollectRpnProposals.
feature_strides = list(self.anchor_generator.strides)
rpn_min_level = int(math.log2(feature_strides[0]))
rpn_max_level = int(math.log2(feature_strides[-1]))
assert (
rpn_max_level - rpn_min_level +
1) == len(rpn_rois_list
), "CollectRpnProposals requires continuous levels"
rpn_rois = torch.ops._caffe2.CollectRpnProposals(
input_list,
# NOTE: in current implementation, rpn_max_level and rpn_min_level
# are not needed, only the subtraction of two matters and it
# can be infer from the number of inputs. Keep them now for
# consistency.
rpn_max_level=2 + len(rpn_rois_list) - 1,
rpn_min_level=2,
rpn_post_nms_topN=rpn_post_nms_topN,
)
rpn_rois = to_device(rpn_rois, device)
rpn_roi_probs = []
proposals = self.c2_postprocess(im_info, rpn_rois, rpn_roi_probs,
self.tensor_mode)
return proposals, {}
