def create_huffman_tree(word_counts):
"""Make a huffman tree from a dictionary containing word counts.
This method creates a binary huffman tree, that is required for
:class:`BinaryHierarchicalSoftmax`.
For example, ``{0: 8, 1: 5, 2: 6, 3: 4}`` is converted to
``((3, 1), (2, 0))``.
Args:
word_counts (``dict`` of ``int`` key and ``int`` or ``float`` values.):
Dictionary representing counts of words.
Returns:
Binary huffman tree with tuples and keys of ``word_coutns``.
"""
if len(word_counts) == 0:
raise ValueError('Empty vocabulary')
q = PriorityQueue()
for w, c in word_counts.iteritems():
q.put((c, w))
while q.qsize() >= 2:
(count1, word1) = q.get()
(count2, word2) = q.get()
count = count1 + count2
tree = (word1, word2)
q.put((count, tree))
return q.get()[1]
class LazyQueue:
def __init__(self):
self._queue = PriorityQueue()
def enq(self, item):
self._queue.put(item)
def deq(self):
if self._queue.empty():
return None
else:
return self._queue.get()
def __len__(self):
return self._queue.qsize()
def mget(self, n):
if n > self._queue.qsize():
n = self._queue.qsize()
lst = []
for _ in xrange(n):
lst.append(self._queue.get())
return lst
def extend(self, iterable):
for ele in iterable:
self.enq(ele)
def append(self, item):
self.enq(item)
def MRVval(self):
q = PriorityQueue()
for blank in self.blanks:
possible = self.getAllVal(blank, False)
q.put((len(possible), blank))
blanks = []
blanks.append(q.get())
minVal = blanks[0][0]
while not q.empty():
next = q.get()
if next[0] == minVal:
blanks.append(next)
else:
break
dmax = len(self.getAssocBlks(blanks[0][1]))
dmaxBlank = blanks[0]
for blank in blanks:
degree = len(self.getAssocBlks(blank[1]))
if degree > dmax:
dmaxBlank = blank
dmax = degree
return dmaxBlank[1]
def getMRV(self):
# Build the MRV priority queue
q = PriorityQueue()
for blank in self.AllEmptyPositions:
possible = self.getPossibleValues(blank, True)
q.put((len(possible), blank))
# Get the first one among (possibly equal)
blanks = []
blanks.append(q.get())
minVal = blanks[0][0]
# Build max Degree list
while not q.empty(): # Get all equally-prioritized blanks
next = q.get()
if next[0] == minVal:
blanks.append(next)
else:
break
maxDeg = len(self.getNeighborBlanks(blanks[0][1]))
maxDegBlank = blanks[0]
for blank in blanks:
degree = len(self.getNeighborBlanks(blank[1]))
if degree > maxDeg:
maxDegBlank = blank
maxDeg = degree
return maxDegBlank[1]
class QueueBackend(QueueInterface):
def __init__(self, unique=False, **kwargs):
super(QueueInterface, self).__init__(**kwargs)
self.queue_object = PriorityQueue()
self.unique = unique
self.unique_dict = {}
def put(self, task, priority):
if self.unique:
key = unique_key(task)
if key in self.unique_dict:
return
self.unique_dict[key] = True
self.queue_object.put((priority, task))
def get(self, timeout):
priority, task = self.queue_object.get(True, timeout)
if self.unique:
key = unique_key(task)
del self.unique_dict[key]
return task
def size(self):
return self.queue_object.qsize()
def clear(self):
try:
while True:
self.queue_object.get(False)
except Empty:
pass
def run(boardS, populationS, maxKills, v): #finds one optimal placement for queens generation = PriorityQueue() #intital population for g in range(populationS): n=getRandomBoard(boardS) generation.put((fitness(n),n)) best=generation.get() count=1 bestL=best vari=0 while best[0]>maxKills: if v: print str(best) if best==bestL: vari+=1 if vari>5: change=mutate(best[1], 1) #print change best=(fitness(change),change) else: vari=1 bestL=best generation.put(best) generation=newGeneration(generation) best=generation.get() count+=1 if v: print "Solution: "+str(best[1]) +" in "+str(count)+" generations" print return count
def solve(self): nexts = PriorityQueue() while True: self.step += 1 self.current.visited = True possibilities = visitable_points(self.current, self.maze) for node in possibilities: nexts.put((node.get_cost(), node)) next = nexts.get() try: while next[1].visited or (not are_neighbors(next[1].coords(), self.current.coords())): next = nexts.get(False) self.current = next[1] self.solution.append((self.step,self.current, str(self))) except Queue.Empty: try: self.current = self.solution.pop()[1] self.step -= 1 except IndexError: print "No solution" exit(1) self.update()
def mapper():
reader = csv.reader(sys.stdin, delimiter='\t')
writer = csv.writer(sys.stdout, delimiter='\t',
quotechar='"', quoting=csv.QUOTE_ALL)
pq = PriorityQueue()
topsize = 10
result = []
for line in reader:
# YOUR CODE HERE
post = line[4]
if pq.qsize() < topsize:
pq.put((len(post), line))
else:
minpost = pq.get()
if minpost[0] >= post[0]:
pq.put((len(minpost), line))
else:
pq.put((len(post), line))
for i in range(topsize):
result.append(pq.get())
# writer.writerow(line)
result.sort(key=lambda x: x[0])
for r in result:
writer.writerow(r[1])
def getMRV(self):
q = PriorityQueue()
for blank in self.blanks:
possible = self.getPossibleValues(blank, True)
q.put((len(possible), blank))
blanks = []
blanks.append(q.get())
minVal = blanks[0][0]
while not q.empty(): #Get all equally-prioritized blanks
next = q.get()
if next[0] == minVal:
blanks.append(next)
else:
break
maxDeg = len(self.getNeighborBlanks(blanks[0][1]))
maxDegBlank = blanks[0]
for blank in blanks:
degree = len(self.getNeighborBlanks(blank[1]))
if degree > maxDeg:
maxDegBlank = blank
maxDeg = degree
return maxDegBlank[1]
def getMRV():
q = PriorityQueue()
for blank in blanks:
possible = getPossibleValues(blank)
q.put((len(possible), blank))
#Get the first one among (possibly equal)
min_blanks = []
min_blanks.append(q.get())
minVal = min_blanks[0][0]
#Build max Degree list
while not q.empty(): #Get all equally-prioritized blanks
next = q.get()
if next[0] == minVal:
min_blanks.append(next)
else:
break
maxDeg = len(getNeighborBlanks(min_blanks[0][1]))
maxDegBlank = min_blanks[0]
for blank1 in min_blanks:
degree = len(getNeighborBlanks(blank1[1]))
if degree > maxDeg:
maxDegBlank = blank1
maxDeg = degree
return maxDegBlank[1]
def getLocalOutlierFactors(vects, k):
#TMP HACK
return [0]*len(vects)
pairDist = getPairwiseDist(vects)
#The list of neighbor ids for each point
neighbors = [None for x in range(len(vects))]
#Populate each of these lists with the k nearest neighbors
for i in range(len(vects)):
pq = PriorityQueue()
for j in range(len(vects)):
if(i != j):
pq.put((-pairDist[i][j], j))
if(pq.qsize() > k):
pq.get()
neighbors[i] = [neighborId for (negDist, neighborId) in pq.queue]
#print("neighbors " + str(neighbors))
#For each point, the distance to its kth nearest neighbor
kDist = [0] * len(vects)
for i in range(len(vects)):
for j in neighbors[i]:
kDist[i] = max(kDist[i], pairDist[i][j])
#print("kdist " + str(kDist))
#local reachability density - the inverse of the average reachability distance to all of my neighbors
lrd = [0] * len(vects)
for i in range(len(vects)):
#first compute the sum
for j in neighbors[i]:
lrd[i] += max(kDist[j], pairDist[i][j])
#normalize and invert in one step
lrd[i] = k / lrd[i]
#print("lrd " + str(lrd))
#local outlier factor - average ratio of neighbor densities to my density
lof = [0] * len(vects)
for i in range(len(vects)):
#first compute the sum
for j in neighbors[i]:
lof[i] += lrd[j]
#normalize and divide by my density
lof[i] = lof[i] / (k*lrd[i])
#print("lof " + str(lof))
return lof
def beamSearch(self,a,sv):
# get 1 hot vector
a = self._get1hot(a,self.da)
sv= self._get1hot(sv,self.dsv)
# end nodes
endnodes = []
# initial layers
h0,c0 = np.zeros(self.dh),np.zeros(self.dh)
# starting node
node = BeamSearchNode(h0,c0,None,1,0,1)
node.sv = sv
node.a = a
# queue for beam search
nodes= PriorityQueue()
nodes.put((-node.eval(),node))
qsize = 1
# start beam search
while True:
# give up when decoding takes too long
if qsize>10000: break
# fetch the best node
score, n = nodes.get()
# if end of sentence token
if n.wordid==1 and n.prevNode!=None:
# update score with sem cost
n.logp -= np.sum(abs(n.sv))
score = -n.eval()
endnodes.append((score,n))
# if reach maximum # of sentences required
if len(endnodes)>=self.overgen: break
else: continue
# decode for one step using decoder
words, probs, sv, c, h = self._gen(n)
# put them into a queue
for i in range(len(words)):
node = BeamSearchNode(h,c,n,words[i],
n.logp+np.log10(probs[i])-
np.sum(0.0001*(100.0**abs(sv-n.sv)))
,n.leng+1)
node.sv = sv
node.a = a
nodes.put( (-node.eval(),node) )
# increase qsize
qsize += len(words)-1
# if no finished nodes, choose the top scored paths
if len(endnodes)==0:
endnodes = [nodes.get() for n in range(self.overgen)]
# choose nbest paths, back trace them
utts = []
for score,n in sorted(endnodes,key=operator.itemgetter(0)):
utt = [n.wordid]
while n.prevNode!=None:
# back trace
n = n.prevNode
utt.append(n.wordid)
utt = utt[::-1]
utts.append((score,utt))
return utts
class BHCAgenda(object):
"""
Maintain a priority queue for possible merges
"""
def __init__(self, sufficient_condition=None):
if not sufficient_condition:
self.sufficient_condition = lambda score: True
else:
self.sufficient_condition = sufficient_condition
self.priority_queue = PriorityQueue()
self.graveyard = set()
def add_many(self, iterable):
for item in iterable:
pass
def pop(self):
score, (left_index, right_index) = self.priority_queue.get()
# print "popped with score %2.5f" % score
# either left or right index is in graveyard, then draw another
# or score is not good enough
# but no matter what, the queue size must be larger than 0
while ((left_index in self.graveyard or
right_index in self.graveyard or
not self.sufficient_condition(score)) and
self.priority_queue.qsize() > 0):
# print 'trying a second time. '
score, (left_index, right_index) = self.priority_queue.get()
# print 'score this time: %2.5f' % score
# avoiding queue errors
if ( (left_index in self.graveyard or
right_index in self.graveyard or
not self.sufficient_condition(score)) and
self.priority_queue.qsize() == 0):
return 0,0,0
# bookkeep seen things
self.graveyard.add(left_index)
self.graveyard.add(right_index)
return score, left_index, right_index
def clear(self):
self.priority_queue = PriorityQueue()
self._put = self.strategy(self.priority_queue)
self.graveyard = set()
self.manifest = set()
def push(self, score, left, right):
"""
The queue needs to have the score as the first item in the tuple
This is how it orders the queue
"""
self.priority_queue.put((score, (left, right)))
def __len__(self):
return self.priority_queue.qsize()
def search_schedule(plant):
# todo AI scheduling alg can base on this: heat priorities in q, caster priorities
# todo put index to the heats, delete heat+1, group+1
# todo AI: find a fastest schedule, then cal the adjustment room in time, then shift the EAF tasks
# todo AI: exchange the groups orders, see what happens with the final ECost
# todo aim for a ChemE journal paper
# currently, heat/group starting at 1, time starting at 0
"""Find a feasible schedule by matching heats and equipment units.
Main Idea:
Match available heats (intermediate products) to available equipment units.
Maintain availability by priority queues (priority index: available time).
"""
schedule = []
q_t_h = PriorityQueue() # ready time (priority), heat
for heat in range(1, plant.num_heats+1):
q_t_h.put((0, heat))
for stage in [1, 2, 3]:
q_t_u = PriorityQueue() # ready time (priority), unit
for unit, num in plant.stage2units[str(stage)].items():
for u_id in range(num):
q_t_u.put((0, unit, u_id))
q_t_h_next = PriorityQueue() # ready time of heat for next stage
while not q_t_h.empty():
t_heat, heat = q_t_h.get()
t_unit, unit, u_id = q_t_u.get()
t_start = max(t_heat, t_unit)
task = plant.tasks[unit][heat-1]
t_end_process = t_start + plant.task_duration[task]
q_t_u.put((t_end_process, unit, u_id))
# todo, RTN2
transport = plant.tasks['TR_S%d' % stage][heat-1]
t_end_trans = t_end_process + plant.task_duration[transport]
q_t_h_next.put((t_end_trans, heat))
schedule.append((stage, heat, unit, u_id, task, t_start, t_end_process, t_end_process))
schedule.append((stage, heat, 'TR_S%d' % stage, 0, transport, t_end_process, t_end_trans, t_end_trans))
q_t_h = q_t_h_next
heat2time = dict()
while not q_t_h.empty():
t, heat = q_t_h.get()
heat2time[heat] = t
q_t_caster = PriorityQueue() # ready time (priority), unit
for unit, num in plant.stage2units['4'].items():
for u_id in range(num):
q_t_caster.put((0, unit, u_id))
for group in range(1, plant.num_groups+1):
t_caster, caster, caster_id = q_t_caster.get()
t_group = max([heat2time[heat] - plant.heat_consume_time_in_group[caster][heat]
for heat in plant.group2heats[str(group)]])
t_start = max(t_group, t_caster)
task = plant.tasks[caster][group-1]
t_end_process = t_start + plant.task_duration[task]
t_cleanup = t_start + plant.task_cleanup_duration[task]
schedule.append((4, group, caster, caster_id, task, t_start, t_end_process, t_cleanup))
q_t_caster.put((t_cleanup, caster, caster_id))
return schedule
def get_matches(vector, num_matches):
best_matches = PriorityQueue(num_matches)
good_matches = PriorityQueue(num_matches)
ok_matches = PriorityQueue(num_matches)
matches_found = 0
vectors = get_vectors()
for v in vectors:
r = sim_coeff(vector, v)
print(r)
if r<.5:
print("not a match")
continue
if r<.7:
print("Ok Match Found")
ok_matches.put((r, v))
matches_found += 1
print(v)
if matches_found == num_matches:
break
else:
continue
if r<.9:
print("Good Match Found")
good_matches.put((r, v))
matches_found += 1
print(v)
if matches_found == num_matches:
break
else:
continue
if r<=1:
print("Great Match Found")
best_matches.put((r, v))
if not ok_matches.empty():
ok_matches.get()
else:
matches_found += 1
print(v)
if matches_found == num_matches:
break
else:
continue
if r>1:
print("Esthena is bad at math.")
print("Ok: ")
while not ok_matches.empty():
print(ok_matches.get())
print("Good: ")
while not good_matches.empty():
print(good_matches.get())
print("Best: ")
while not best_matches.empty():
print(best_matches.get())
class WorkersList(object):
"""docstring for WorkersList"""
def __init__(self):
super(WorkersList, self).__init__()
self.queue = PriorityQueue()
self.workers = []
def empty_queue(self):
while not self.queue.empty():
next_level = self.queue.get()
print 'Processing level:', next_level.schedule
def get_from_queue(self):
return self.queue.get()
def queue_size(self):
return self.queue.size()
def _collect_workers(self):
while not self.queue.empty():
next_job = self.queue.get()
worker = Worker(next_job, next_job.description)
self.workers.append(worker)
worker.start()
def start(self):
self._collect_workers()
for worker in self.workers:
worker.join()
def put_in_queue(self, job):
self.queue.put(job)
def stop_single_worker(self, value):
for worker in self.workers:
if worker.name == value:
worker.triggerStop = False
break
else:
raise WorkerException("Worker with name/id {}".format(value))
def stop_all_workers(self):
for worker in self.workers:
worker.triggerStop = False
def terminate_all_workers(self):
for worker in workers:
worker.terminate()
def terminate_single_worker(self, value):
for worker in self.workers:
if worker.name == value:
worker.terminate()
break
else:
raise WorkerException("Worker with name/id {}".format(value))
class EventsCollection(object):
def __init__(self):
self.events = PriorityQueue()
def add_event(self, event):
self.events.put(event)
def pop(self):
self.events.get()
def search_image(filepath, codebook, tfidf, control="with_tfidf"):
print_detail = True
k, _ = codebook.shape
if print_detail:
print "-------------------------------------------------------------------------------"
bow = get_bow(filepath, codebook)
if print_detail:
print "-------------------------------------------------------------------------------"
print "tfidf matrix shape:"
print tfidf.shape
print "-------------------------------------------------------------------------------"
print "Bag of Word of: ", filepath
print bow
print "-------------------------------------------------------------------------------"
_, l = tfidf.shape
control = "no_tfidf"
if control == "with_tfidf":
idi = np.zeros((1, l))
for i in range(k):
if bow[i] != 0:
idi = np.add(idi, tfidf[i])
rank = [(i, j) for (i, j) in zip([i for i in range(l)], idi.tolist()[0])]
else:
bow = [float(i) / sum(bow) for i in bow.tolist()]
rank = np.dot(np.asarray(bow), tfidf)
rank = [(i, j) for (i, j) in zip([i for i in range(l)], rank.tolist())]
q = PriorityQueue(50)
for (x, y) in rank:
if not q.full():
q.put(Image(y, x))
else:
if y > q.queue[0].similarity():
q.get()
q.put(Image(y, x))
result = []
while not q.empty():
result.append(q.get())
# images_data_path = "/Users/minhuigu/FoodAdvisor/app/outputs/images_data.txt"
# images_folder = "/Users/minhuigu/Desktop/"
# img_list = []
# json_content = open(images_data_path).read()
# for each in json.loads(json_content):
# img_list.append(images_folder + each['relpath'])
#
# for a in [i.id() for i in result][::]:
# print img_list[a]
if print_detail:
print "Best rank images: "
print [i.id() for i in result][::]
print "-------------------------------------------------------------------------------"
# decreasing according to similarity
return [i.id() for i in result][::]
def solve(ropes):
if len(ropes) <= 1: return 0
min_heap = PriorityQueue()
for i in ropes:
min_heap.put(i)
total = 0
while min_heap.qsize() > 1:
cost = min_heap.get() + min_heap.get()
total += cost
min_heap.put(cost)
return total
def buildHuffmanTree(strlen, charFreqList):
pq = PriorityQueue()
for key, value in charFreqList.iteritems():
pq.put((float(value) / float(strlen), HuffmanNode(key, float(value) / float(strlen))))
while pq.qsize() > 2:
x,y,z = pq.get(), pq.get(), pq.get()
pq.put((x[0] + y[0] + z[0], HuffmanNode(None, x[0] + y[0] +z [0], x[1], y[1], z[1])))
return pq.get()[1]
def construct_huffman_tree(freqs):
pq = PriorityQueue()
for i in freqs:
pq.put(TreeNode(i))
for i in xrange(len(freqs)-1):
left = pq.get()
right = pq.get()
# (left.val,right.val).p()
node = TreeNode(left.val+right.val)
node.left, node.right = left, right
pq.put(node)
return pq.get()
def kMostFreqHeapThreePass(nums, k):
freq = {}
heap = PriorityQueue(k)
# count
for i in nums: freq[i] = freq.get(i, 0)+1
for key, val in freq.iteritems():
if not heap.full():
heap.put((val, key))
else:
if heap.queue[0][0] < val:
heap.get()
heap.put((val, key))
return [itm[1] for itm in reversed(heap.queue)]
def compute_k_closest_stars(stars, k):
if len(stars) == 0:
return
max_heap = PriorityQueue()
for i in xrange(k):
max_heap.put(stars[i])
for i in xrange(k+1, len(stars)):
top = max_heap.get()
max_heap.put(max(top, stars[i]))
res = []
while not max_heap.empty():
res.append(max_heap.get().name)
res.reverse()
return res
def enumerate_min(n):
pl = primes.primes_list
# graph
startnode = (2, ((2, 1),))
"""(2,((2,1),(3,1),(5,1),
(7,1),(11,1),(13,1),
(17,1),(19,1),(23,1),
(29,1),(31,1),(37,1)))"""
nodes = set(startnode)
nextnodes = PriorityQueue()
nextnodes.put(startnode)
cur_node = nextnodes.get()
cur_comb = combinations_distinct(cur_node[1])
max_found = 0
# print max,raw_input()
while cur_comb < n:
value, curprimes = cur_node
# nextnodes are added
# we increment an existing primes, and we add an existing
# add 1 to each existing prime
prev = curprimes[0][1] + 1
for i, p in enumerate(curprimes):
prime, count = p
if count + 1 > prev:
break
prev = count + 1
# check if this way can even theoretically get
# us to where we want
newprimes = curprimes[:i] + ((prime, count + 1),) + curprimes[i + 1 :]
newnode = degen_product(newprimes), newprimes
if newnode not in nodes:
nodes.add(newnode)
nextnodes.put(newnode)
# add new prime
newprimes = curprimes + ((int(pl[(len(curprimes))]), 1),)
newvalue = degen_product(newprimes)
newnode = newvalue, newprimes
if newnode not in nodes:
nodes.add(newnode)
nextnodes.put(newnode)
cur_node = nextnodes.get()
cur_comb = combinations_distinct(cur_node[1])
value, curprimes = cur_node
if cur_comb > max_found:
print (value, cur_comb, curprimes)
max_found = cur_comb
print cur_node, combinations_distinct(cur_node[1])
def plot_method_pairs_and_matrix(case_studies,fileappend=''):
case_cov=np.cov(case_studies.transpose())
case_corr=np.corrcoef(case_studies.transpose())
cmatrix= case_corr
fig = plt.figure(figsize=(twocol,twocol),dpi=figdpi,tight_layout=True)
ax = fig.add_subplot(111)
ppl.pcolormesh(fig,ax,cmatrix[inds][:,inds],#-np.diag([.99]*len(meths)),
yticklabels=np.array(mindex)[inds].tolist(),
xticklabels=np.array(mindex)[inds].tolist(),
cmap=ppl.mpl.cm.RdBu,vmax=0.4,vmin= -0.4)
ax.tick_params(axis='both', which='major', labelsize=8)
plt.setp(ax.get_xticklabels(), rotation='vertical')
cm=dark2
[l.set_color(cm[m_codes[mindex.index(l.get_text())]]) for i,l in enumerate(ax.get_yticklabels())]
[l.set_color(cm[m_codes[mindex.index(l.get_text())]]) for i,l in enumerate(ax.get_xticklabels())]
fig.show()
fig.savefig(figure_path+('method_matrix%s.pdf'%fileappend))
#Show the highly correlated methods
pq=PQ()
pq_cross=PQ()
for i in range(len(meths)):
for j in range(i+1,len(meths)):
m1text='(%s) %s'%(meths[i,1],meths[i,0])
m2text='(%s) %s'%(meths[j,1],meths[j,0])
pq.put((-cmatrix[i,j],(m1text,m2text)))
if meths[i,1]!= meths[j,1]:
pq_cross.put((-cmatrix[i,j],(m1text,m2text)))
# Output the method correlations
# Sets how many highly correlated methods should be displayed
print_cap = 20
moutfile = open(results_path+('method_corrs%s.csv'%fileappend),'w')
print 'All methods:'
for i in range(pq.qsize()):
v,(m1,m2)=pq.get()
if i < print_cap:
print '%.2f & %s & %s\\\\'%(-v,m1,m2)
moutfile.write('%.9f | %s | %s\n'%(-v,m1,m2))
moutfile.close()
moutfile = open(results_path+('method_corrs_cross%s.csv'%fileappend),'w')
print 'Just cross methods:'
for i in range(pq_cross.qsize()):
v,(m1,m2)=pq_cross.get()
if i < print_cap:
print '%.2f & %s & %s\\\\'%(-v,m1,m2)
moutfile.write('%.9f | %s | %s\n'%(-v,m1,m2))
moutfile.close()
class Astar:
def __init__(self, start, goal, n):
self.path = []
self. visited = []
self.priority_queue = PriorityQueue()
self.start = start
self.goal = goal
self.n = n
def solve(self):
start_state = State(value=self.start, start=self.start, goal=self.goal, n=self.n)
self.priority_queue.put((0, start_state))
while(not self.path and self.priority_queue.qsize()):
closest_child = self.priority_queue.get()[1]
closest_child.create_children()
self.visited.append(closest_child.value)
for child in closest_child.children:
if child.value not in self.visited:
# If child's value is equal to goal, solution is found
if child.value == self.goal:
self.path = child.path
break
self.priority_queue.put((child.cost, child))
if not self.path:
print "Goal is unreachable. Terminating program."
return self.path
def ucs(source, target, graph):
""" Uniform-cost graph search """
queue = PriorityQueue() # fringe
queue.put((0, source))
parent = {source:None}
visited = {}
while not queue.empty():
(d, v_in) = queue.get()
if v_in not in visited or d < visited[v_in]:
if v_in == target:
return (d, build_path(parent, target))
for v_out in graph.adj(v_in):
cost = graph.distance(v_in, v_out) + d
if v_out not in visited:
queue.put((cost, v_out))
parent[v_out] = v_in
visited[v_in] = cost
return None
class PoolStreamData(StreamData):
def __init__(self, feat_path, feature_maker, label_path=None, fold_in_cv=None):
self.pool = PriorityQueue(100000)
super(PoolStreamData, self).__init__(feat_path, feature_maker, label_path, fold_in_cv)
self.fill_pool()
def fill_pool(self):
while not self.pool.full():
try:
ins = super(PoolStreamData,self).next()
self.pool.put((random.random(),ins)) # insert ins with random priority --> kind of random shuffle
except StopIteration:
break
def rewind(self):
self.pool = PriorityQueue(100000)
super(PoolStreamData,self).rewind()
self.fill_pool()
def next(self):
try:
(_,ins) = self.pool.get(False)
except Empty:
raise StopIteration
self.fill_pool()
return ins
def solve(N, L, start, goal):
"""search for minimum bit switches to make start == goal
NB: treat goal and start as sets of currents -- that is, order doesn't
matter in comparing start to goal and all currents in start/goal
are mutually unique"""
# BFS w/ priority queue; queue orders by min bits flipped;
# we don't use an 'explored' set because we may need to revisit the same
# configuration of currents several times as index i increments;
# instead, to constrain the search space, we use the is_consistent filter
# before placing a state in the queue in order to check that the
# configuration of currents in that state is consistent with goal at least
# up to bit i-1
start_state = (0, start, 0) # ( n_bits_flipped, state_of_currents, index )
queue = PriorityQueue()
queue.put( start_state )
while not queue.empty():
nchanges, state, index = queue.get()
if is_goal(state, goal):
return nchanges
for nch,s,i in successors(nchanges, state, index):
if is_consistent(s, goal, i):
# when i = len(goal)+1, s will be added to queue
# only if s == goal
queue.put([nch, s, i])
return 'NOT POSSIBLE'
class EventQueue(object):
def __init__(self):
"""Event queue for executing events at
specific timepoints.
In current form it is NOT thread safe."""
self.q = PriorityQueue()
def schedule(self, f, ts):
"""Schedule f to be execute at time ts"""
self.q.put(EqItem(ts, f))
def schedule_recurring(self, f, interval):
"""Schedule f to be run every interval seconds.
It will be run for the first time interval seconds
from now"""
def recuring_f():
f()
self.schedule(recuring_f, time.time() + interval)
self.schedule(recuring_f, time.time() + interval)
def run(self):
"""Execute events in the queue as timely as possible."""
while True:
event = self.q.get()
now = time.time()
if now < event.ts:
time.sleep(event.ts - now)
event.f()
def astar_multi(env,
starts,
goals,
constraint_fn=lambda node, lastnode, t: True):
starts = tuple(starts)
goals = tuple(goals)
pq = PriorityQueue()
cost = 0.0
t = 0.0
heur = sum(
[env.estimate(start, goal, t) for start, goal in zip(starts, goals)])
costmap = {starts: cost}
prevmap = {starts: None}
pq.put((heur + cost, starts, t))
while not pq.empty():
totcost, curr, t = pq.get()
at_goal = all([node == goal for node, goal in zip(curr, goals)])
if at_goal:
return construct_path_multi(prevmap, curr)
transitions = [env.next(node, t) for node in curr]
children = [[t[0] for t in node] for node in transitions]
step_costs = [[t[1] for t in node] for node in transitions]
children_combined = combine_actions(children)
step_costs_combined = combine_actions(step_costs)
for child, step_cost in zip(children_combined, step_costs_combined):
if len(set(child)) < len(child): # skip if there is a collision
continue
child_t = t + 1
if not constraint_fn(child, curr, child_t):
continue
child_cost = costmap.get(curr, float('inf')) + sum(step_cost)
if child_cost < costmap.get(child, float('inf')):
prevmap[child] = curr
costmap[child] = child_cost
child_totcost = sum([
env.estimate(child_i, goal_i, child_t)
for child_i, goal_i in zip(child, goals)
]) + child_cost
pq.put((child_totcost, child, child_t))
return None
def AStar(self, heuristic):
startTime = time()
expanded = 0
PQueue = PriorityQueue()
visited = set()
queueGrids = set() #Grids In Queue But Not Visited Yet
PQueue.put((heuristic(self.initialState), self.initialState))
while (not PQueue.empty()):
front = (PQueue.get())[1]
queueGrids.discard(front.grid)
if front.grid in visited: #Visited Before
continue
if front.grid in queueGrids: #Found in Queue
for node in PQueue.queue:
grid = node[1].grid
if grid == front.grid:
if node[0] > front.cost + heuristic(node[1]):
node[0] = front.cost + heuristic(node[1])
#Processing
if front.isGoal():
path = front.backTrack()
#self.drawGrids(path)
self.processResult(path, front.cost, expanded,
time() - startTime,
"AStar-" + heuristic.__name__[:9])
return path
visited.add(front.grid)
expanded += 1
queueGrids.add(front.grid)
children = front.generateChildren() #Expanding
for child in children:
PQueue.put((heuristic(child) + child.cost, child))
return False
def search(targest_artist_profile, ogartist, connection):
underrated = PriorityQueue()
lokey = set()
fringe = q.Queue()
fringe.put(ogartist)
getRelatedArtists_bfs(ogartist, lokey, {ogartist[1]}, fringe, [])
quadrant_size = len(lokey) / 4
lokey_list = list(lokey)
processes = []
qu = mp.Queue()
for i in range(0, 4):
process = Process(
target=generateProfilePriority,
args=(lokey_list[0 + (quadrant_size * i):(quadrant_size * i) +
quadrant_size], targest_artist_profile, qu))
process.start()
processes += [process]
for process in processes:
process.join()
print '-------------results--------------'
while not qu.empty():
item = qu.get()
print item
underrated.put(item)
results = []
while not underrated.empty():
item = underrated.get()
results.append(item)
a = (json.dumps({"a": results})).encode()
json_file_size = str(len(a))
print(json_file_size)
connection.send(json_file_size)
connection.send("\n")
connection.send(a)
print(a)
def get_inferred_norms(self, topNorms=1):
call(["java", self.javaAppClass])
pq = PriorityQueue()
normProbabilities = {}
with open(self.oniOutputFileName, 'r') as fOutOni:
for line in fOutOni:
parts = line.split(
) # norm as a string of action chars, and then probability
if len(parts) > 0:
norm = ('eventually', parts[0][0]) if len(
parts[0]) == 1 else (parts[0][0], 'next', parts[0][1])
pq.put((float(parts[1]), norm))
normProbabilities[norm] = float(parts[1])
with open(self.pniOutputFileName, 'r') as fOutPni:
for line in fOutPni:
parts = line.split(
) # norm as a string of action chars, and then probability
if len(parts) > 0:
norm = ('never', parts[0][0]) if len(
parts[0]) == 1 else (parts[0][0], 'not next',
parts[0][1])
pq.put((float(parts[1]), norm))
normProbabilities[norm] = float(parts[1])
sorted_norms = []
while not pq.empty():
sorted_norms += [pq.get()[1]]
norms = [x for x in reversed(sorted_norms)]
# Check that we select either the topNorms, or the first ones with the same odds
for (i, n) in enumerate(norms):
if normProbabilities[n] == 0:
topNorms = i
break
if (i + 1 == topNorms):
tied = len(norms) > i + 1 and (
normProbabilities[n] == normProbabilities[norms[i + 1]])
if (tied):
topNorms += 1
else:
break
#endfor
return norms[0:topNorms]
def find_path(start, goal):
global xx
im = Image.open("output.png") #Can be many different formats.
output = Image.new('RGBA', im.size)
pix = im.load()
dimensions = im.size #Get the width and hight of the image for iterating over
width = dimensions[0]
height = dimensions[1]
# initial parameters
frontier = PriorityQueue()
frontier.put(start, 0)
closed_set = []
costs_so_far = {}
came_from = {}
open_set = [start]
costs_so_far[start] = 0
came_from[start] = None
max_y = height
max_x = width
while not frontier.empty():
xx = xx + 1
current = frontier.get()
if current[0] == goal[0] and current[1] == goal[1]:
break
x = current[0]
y = current[1]
for i in range(-1, 2):
for j in range(-1, 2):
if x + i < max_x and y + j < max_y and x + i >= 0 and y + j >= 0 and x + i != x and y + j != y:
new_cost = costs_so_far[current] + pix[x + i, y + j][0]
if (x + i, y +
j) not in costs_so_far or new_cost < costs_so_far[
(x + i, y + j)]:
costs_so_far[(x + i, y + j)] = new_cost
priority = new_cost + heuristic(goal, (x + i, y + j))
frontier.put((x + i, y + j), priority)
came_from[(x + i, y + j)] = current
if xx > 1000:
break
#print current
return (came_from, costs_so_far)
def a_star_tsp(self, num_cities, g, s_city_name):
s_time = time.time()
num_nodes = 0
s = g[s_city_name]
q = PriorityQueue()
q.put((0, [[s_city_name], 0]))
num_nodes += 1
while not q.empty():
temp = q.get()[1]
path = temp[0]
prev_acc_cost = temp[1]
if time.time() - s_time > 300:
return path, prev_acc_cost, num_nodes, False
# Travelled all cities and then back to start
if len(path) == num_cities + 1:
return path, prev_acc_cost, num_nodes, True
# Travelled all cities
if len(path) == num_cities:
heur, acc_cost = self.calc_heur(g, path, s_city_name, s, prev_acc_cost)
new_path = path[:]
new_path.append(s_city_name)
q.put((heur, [new_path, acc_cost]))
num_nodes += 1
# Haven't travelled all cities
else:
not_visited = set(path).symmetric_difference(set(g.keys()))
for city in not_visited:
heur, acc_cost = self.calc_heur(g, path, city, s, prev_acc_cost)
new_path = path[:]
new_path.append(city)
q.put((heur, [new_path, acc_cost]))
num_nodes += 1
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
if lists == None or len(lists) == 0:
return []
pq = PriorityQueue()
res = []
for node in lists:
if node:
pq.put((node.val, node))
while not pq.empty():
node = pq.get()[1]
res.append(node.val)
node = node.next
if node:
pq.put((node.val, node))
return res
def mergeKLists(self, lists):
priorityQueue = PriorityQueue()
for l in lists:
if l:
priorityQueue.put((l.val, l))
head = ListNode(-1)
pointer = head
while not priorityQueue.empty():
nodeVal, node = priorityQueue.get()
pointer.next = ListNode(nodeVal)
pointer = pointer.next
node = node.next
if node:
priorityQueue.put((node.val, node))
return head.next
def merge(lists):
# error checking
if not lists:
return []
lists = filter(lambda x: x != [], lists)
# initialize priority queue
pqueue = PriorityQueue()
for lst in lists:
if lst:
pqueue.put((lst[0], lst[1:]))
# merge the arrays
result = []
while not pqueue.empty():
elt = pqueue.get()
num, rest = elt[0], elt[1]
result.append(num)
if rest:
pqueue.put((rest[0], rest[1:]))
return result
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
from Queue import PriorityQueue # in py3, use queue
head = p = ListNode(0)
q = PriorityQueue()
for l in lists:
if l:
# in py3, 当第一个值一样的时候，比较第二个值，所以若第二值不支持比较，就会报错。
q.put((l.val, l))
while not q.empty():
val, node = q.get()
p.next = node
p = p.next
if node.next:
q.put((node.next.val, node.next))
return head.next
def calcHeuristic( envObj, agent): exploredState = set() #set to store explored states #We will assume that agent always takes bus pq = PriorityQueue() pq.put(QueueNode(envObj.goal, 0, 0, None, State(envObj.goal, Mode.bus))) while (not pq.empty()): curr = pq.get() if (curr.ind in exploredState): continue envObj.graph[curr.ind].heuristic = curr.g #save heuristic for curr.ind exploredState.add(curr.ind) for edge in envObj.graph[curr.ind].adjList: if edge.destination in exploredState: continue g = curr.g + edge.wt pq.put(QueueNode(edge.destination, g, g, curr, State(curr.ind, Mode.bus))) for node in envObj.graph: node.heuristic = node.heuristic / agent.busMaxSpeed
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
head = point = ListNode(0)
q = PriorityQueue()
for node in lists:
if node:
q.put((node.val, node))
while not q.empty():
val, node = q.get()
point.next = ListNode(val)
point = point.next
if node.next:
q.put((node.next.val, node.next))
return head.next
def getP3(puzzle, pattern):
output = ''
tempMap = {}
pq = PriorityQueue()
for key in pattern:
tempMap[key] = 0
pq.put((key, key))
#print 'keyA', key
for i in range(len(puzzle)):
for j in range(len(puzzle)):
if puzzle[i][j] in pattern:
temp = ''
temp += str(i + 1)
temp += str(j + 1)
tempMap[puzzle[i][j]] = temp
#print 'num',puzzle[i][j],i,j
while not pq.empty():
key = pq.get()[1]
output += str(tempMap[key])
#print 'keyB', key, 'value', tempMap[key]
return output
def aStarSearch(graph, h, start, goal):
frontier = PriorityQueue()
frontier.put((0, start))
cost = {}
cost[start] = 0
parents = {}
while not frontier.empty():
_, current = frontier.get()
if current == goal:
return backtrace(parents, start, goal)
successors = graph[current]
for successor in successors:
cost[successor] = cost[current] + graph[current][successor]
parents[successor] = current
frontier.put((h[successor] + cost[successor], successor))
def getStrongest(self, arr, k):
"""
:type arr: List[int]
:type k: int
:rtype: List[int]
"""
res = []
pq = PQ()
length = len(arr)
arr.sort()
median = arr[int((length - 1) / 2)]
for i in range(length):
pq.put((-abs(arr[i] - median), -arr[i], i))
for i in range(k):
tmp = pq.get()
res.append(arr[tmp[2]])
return res
def lazy_prim_simplified(self):
"""
wrap a method visit() to make it more compact
:return:
"""
processed = {}
pq = PriorityQueue()
# start from 0
pq = self.visit(0, pq, processed)
while not pq.empty():
cur_node_w, cur_node_from, cur_node_to = pq.get()
# if processed, do nothing
if processed.get(cur_node_to) is True:
continue
# if not processed yet, it is one edge in MST
self.mst.append((cur_node_from, cur_node_to, cur_node_w))
# visit the other node in current minimum weight edge
pq = self.visit(cur_node_to, pq, processed)
self.mst_weight = self._calc_weight()
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
# THIS WAS WHAT I WAS LOOKING FOR
# NOT HHAVING TO MANUALLY PUSH A NEW NODE TO THEH TAIL, O(N)
head = pt = ListNode()
q = PriorityQueue()
for ll in lists:
cur = ll
while cur is not None:
q.put(cur.val)
cur = cur.next
while not q.empty():
i = q.get()
pt.next = ListNode(i)
pt = pt.next
return head.next
def fix_graph(self, roots):
graph = self.buildGraph
fixed_graph = nx.Graph()
pq = PQ()
for node in roots:
self.add_node_to_queue_z(node, graph, pq)
fixed_graph.add_node(node)
#Now the priority queue has been initialized
while not pq.empty(): #While there are still edges
print fixed_graph.number_of_nodes()
(node, edge) = pq.get()
print 'in the loop'
if not (edge[1]
in fixed_graph): #if sink of edge hasn't been added yet
fixed_graph.add_node(edge[1])
fixed_graph.add_edge(node, edge[1], points=edge[2])
self.add_node_to_queue_z(edge[1], graph, pq)
return fixed_graph
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
dummy = cur = ListNode(0)
queue = PriorityQueue()
# O(k)
for l in lists:
if l: # there may be empty linked list
queue.put((l.val, l))
# O(nlogk),因为一共有n个元素
while not queue.empty():
# O(logk)
val, node = queue.get()
cur.next = node
cur = cur.next
node = node.next
if node:
queue.put((node.val, node))
return dummy.next
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
if lists is None:
return None
if len(lists) == 0:
return []
cur = ListNode()
newHead = cur
q = PriorityQueue()
for node in lists:
if node:
q.put((node.val, node))
while q.qsize() > 0:
cur.next = q.get()[1]
cur = cur.next
if cur.next:
q.put((cur.next.val, cur.next))
return newHead.next
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
head = point = ListNode(0) # dummy node to point to new linked list
q = PriorityQueue()
# initial iteration through lists, if linked list not empty, put its head as a (value, node) pair in PQ
for l in lists:
if l: q.put((l.val, l))
# get the (value, node) pair at the front of the PQ and add a new node with the value to the linked list
# use node.next to get the next lowest element of the linked list to add to the PQ
while not q.empty():
val, node = q.get()
point.next = ListNode(val)
point = point.next
node = node.next
if node: q.put((node.val, node))
return head.next
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
if len(lists) == 0:
return None
dummy = ListNode(None)
current = dummy
pq = PriorityQueue()
for list in lists:
if list:
pq.put((list.val, list))
while pq.qsize() > 0:
current.next = pq.get()[1]
current = current.next
if current.next:
pq.put((current.next.val, current.next))
return dummy.next
def findPlan(self):
frontier = PriorityQueue()
frontier.put((0, Node(self.start, None, None, 0)))
count = 0
while (not frontier.empty()):
node = frontier.get(False)[1]
count += 1
if count % 100 == 0:
print(count)
if (node.state.contains(self.goal)):
print('Found goal', count)
return self.get_action_sequance(node)
actions = self.domain.getApplicableActions(node.state)
for action in actions:
newState = action.apply(node.state)
newNode = Node(newState, action, node, node.cost + 1)
frontier.put((newNode.cost, newNode))
def a_star_search(graph, start, goal):
frontier = PriorityQueue()
frontier.put(start, 0)
came_from = {start: None}
cost_so_far = {start: 0}
while not frontier.empty():
current = frontier.get()
if current == goal:
break
for next in graph.neighbors(current):
new_cost = cost_so_far[current] + graph.cost(current, next)
if next not in cost_so_far or new_cost < cost_so_far[next]:
cost_so_far[next] = new_cost
priority = new_cost + heuristic(goal, next)
frontier.put(next, priority)
came_from[next] = current
return came_from, cost_so_far
def AStar():
queue = PriorityQueue()
cur_node = Node(0, 0)
queue.put((get_FCost(cur_node), cur_node))
visited = [get_index(cur_node)]
path = [-1 for _ in xrange(width * height)]
while not queue.empty():
_, cur_node = queue.get()
for node in find_next_nodes(cur_node):
if get_index(node) in visited:
continue
path[get_index(node)] = get_index(cur_node)
if is_target(node):
print_path(path)
return
queue.put((get_FCost(node), node))
visited.append(get_index(node))
print 'not found'
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
pq = PriorityQueue()
head = point = ListNode(0)
for l in lists:
if l:
pq.put((l.val, l))
while not pq.empty():
val, node = pq.get()
point.next = ListNode(val)
point = point.next
node = node.next
if node:
pq.put((node.val, node))
return head.next
def MCV(self, assigned):
"""
Degree Heuristic for variable selection
:param assigned: Assigned variables
:return: index (x, y)
"""
pq = PriorityQueue()
# assign row and col conflict scores, and assign values to tileDomain
for row in range(self.n):
for col in range(self.n):
if not assigned[self.getIndex(row, col)]:
neighbours = self.neighbours(self.getIndex(row, col))
x = 0
for n in neighbours:
if not assigned[n]:
x += 1
pq.put((x, self.getIndex(row, col)))
[val, idx] = pq.get()
return idx
def aStarBetweenTwoNodes(self, nodeA, nodeB):
frontier = PriorityQueue()
frontier.put((0, str(nodeA)))
cost_so_far = {}
cost_so_far[nodeA] = 0
parentMap = {}
while not frontier.empty():
s = frontier.get()[1]
if s == nodeB:
self.addDotsBetweenTwoNodes(nodeA, nodeB, s, parentMap)
break
for i in self.vertex[s]['edge']:
new_cost = cost_so_far[s] + 1
if i not in cost_so_far or new_cost < cost_so_far[i]:
cost_so_far[i] = new_cost
priority = new_cost + self.manhattan(s, nodeB)
frontier.put((priority, i))
parentMap[i] = s
def kClosest(self, points, K):
"""
:type points: List[List[int]]
:type K: int
:rtype: List[List[int]]
"""
pq = PriorityQueue()
result = []
for point in points:
x, y = point
distance = math.sqrt(x**2 + y**2)
pq.put((distance, point))
for _ in range(K):
distance, point = pq.get()
result.append(point)
return result
def solve(n, k):
q = PriorityQueue()
counts = {n: 1}
q.put(-n)
while k > 0:
v = -q.get()
if v not in counts:
continue
count = counts[v]
del counts[v]
k -= count
if k <= 0:
return v
if v % 2 == 1:
q.put(-(v / 2))
add_to(counts, v / 2, count * 2)
else:
q.put(-(v / 2))
add_to(counts, v / 2, count)
q.put(-((v / 2) - 1))
add_to(counts, (v / 2) - 1, count)
