def sample_sentences(section, n=1000):
pair_list = array(list(alignment_pairs(section=section)))
pair_len = len(pair_list)
plagiarized_sample = []
non_plagiarized_sample = []
# draw plagiarized sentences
for pair in pair_list[randint(0, high=pair_len, size=n)]:
gold = pair.gold_alignments()
if len(gold) > 0:
susp_draw, src_draw = gold[randint(0, high=len(gold))]
plagiarized_sample.append((pair.susp_fn, pair.src_fn, susp_draw, src_draw))
else:
logging.warn("Empty gold alignment for %s - %s" % (pair.susp_fn, pair.src_fn))
# draw random non-plagiarized sentence pairs
for pair in pair_list[randint(0, high=pair_len, size=n)]:
gold = pair.gold_alignments()
gold_susp_indexes = [x[0] for x in gold]
gold_src_indexes = [x[1] for x in gold]
susp_draw = choice([x for x in xrange(len(pair.susp_doc)) if x not in gold_susp_indexes])
src_draw = choice([x for x in xrange(len(pair.src_doc)) if x not in gold_src_indexes])
non_plagiarized_sample.append((pair.susp_fn, pair.src_fn, susp_draw, src_draw))
return plagiarized_sample, non_plagiarized_sample
def reset(self):
"""Randomly throw the agent to a non-goal state
"""
next_state = self.GOAL_STATE
while next_state == self.GOAL_STATE:
next_state = (randint(0, self.DIMS[0]), randint(0, self.DIMS[1]))
self.state = next_state
def generate_new_data(t):
returns = []
for c, task_type in enumerate(data_series):
last_val = 0 if t==0 else source.data[task_type][-1] - ( 0 if c == 0 else source.data[data_series[c-1]][-1])
new_value = max(0, last_val + randint(-2,2))
returns.append(new_value + (0 if len(returns) == 0 else returns[-1]))
#datetime.datetime.fromtimestamp(time.time() + t*1000) doesn't work (axis seems to require something else, the timestamps are o.k.)
return [t, returns[-1]] + returns
def podskupovi(d, n, lambda1):
list = []
for i in range(d-n):
random = nextPoisson(lambda1)
print "\n\nPoasonov: ", random
for j in range(random):
list.insert(j, randint(1,100))
for item in list:
print " ", item,
print '\n'
def update(self, im, values):
index = 9
if values[index] > 60:
self.points.append(Point(randint(im.size[0]), 0, 10))
for point in self.points:
if point.isAlive() == False:
self.points.remove(point)
else:
point.draw(values, im)
return im
def get_rdm_un_normalized_vector(dataflow, max_num=10):
"""Compute the smallest vector for un-normalized the graph.
------
Return the the vector of coefficient for un-normalize the graph.
"""
if not dataflow.is_normalized:
return
coef = {}
for arc in dataflow.get_arc_list():
random_num = randint(1, max_num)
coef[arc] = Fraction(numerator=random_num, denominator=dataflow.get_gcd(arc))
return coef
def gibbs_sampling(self, n_topics, alpha, n_iterations):
seed(0)
# randomly assign topics to words
self.word_topic_map = {w: randint(0, n_topics-1) for w in self.vocab}
n_dt = [{t: 0 for t in range(n_topics)} for _ in range(len(self.corpus))]
n_tw = [{w: 0 for w in self.vocab} for _ in range(n_topics)]
for d_index in range(len(self.corpus)):
d = self.corpus[d_index]
for w in d:
t = self.word_topic_map[w]
n_dt[d_index][t] += 1
n_tw[t][w] += 1
for i in range(n_iterations):
print("Iteration %d/%d (%f%%)..." % (i, n_iterations, 100 * i / float(n_iterations)))
for d_index in range(len(self.corpus)):
print("Document %d/%d (%f%%)..." % (d_index, len(self.corpus), 100 * d_index / float(len(self.corpus))))
d = self.corpus[d_index]
for w in d:
# i. remove current word from counts
old_topic = self.word_topic_map[w]
# TODO
if n_dt[d_index][old_topic] == 0:
print("oops dt", d_index, old_topic)
else:
n_dt[d_index][old_topic] -= 1
n_tw[old_topic][w] -= 1
# ii. estimate probabilities using 5.6, 5.7
word_topic_probs = []
for t in range(n_topics):
p_t_d = float(n_dt[d_index][t] + alpha) / (sum(n_dt[d_index].values()) + n_topics * alpha)
p_w_t = float(n_tw[t][w] + alpha) / (sum(n_tw[t].values()) + len(self.vocab) * alpha)
word_topic_probs.append(p_w_t * p_t_d)
# iii. assign w to a topic randomly
word_topic_probs = [float(p) / sum(word_topic_probs) for p in word_topic_probs]
self.word_topic_map[w] = choice(range(n_topics), p=word_topic_probs)
# iv. increment counts accordingly
topic = self.word_topic_map[w]
n_tw[topic][w] += 1
n_dt[d_index][topic] += 1
def random_Butter(n=(5, 10),
Wc=(0.1, 0.8),
W1=(0.1, 0.5),
W2=(0.5, 0.8),
form=None,
onlyEven=True,
seed=None):
"""
Generate a n-th order Butterworh filters
Parameters
----------
- n: (int) The order of the filter
- Wc: used if btype is 'lowpass' or 'highpass'
Wc is a tuple (min,max) for the cut frequency
- W1 and W2: used if btype is ‘bandpass’, ‘bandstop’
W1 and W2 are tuple (min,max) for the two start/stop frequencies
- form: (string) {None, ‘lowpass’, ‘highpass’, ‘bandpass’, ‘bandstop’}. Gives the type of filter. If None, the type is randomized
- onlyEven: if True, only even order filter are generated
- seed: if not None, indicates the seed toi use for the random part (in order to be reproductible, the seed is stored in the name of the filter)
"""
# change the seed if asked
if seed:
numpy_seed(seed)
# choose a form if asked
if form is None:
form = choice(("lowpass", "highpass", "bandpass", "bandstop"))
# choose Wn
if form in ("bandpass", "bandstop"):
# choose 2 frequencies
if W2[1] <= W1[0]:
raise ValueError("iter_random_Butter: W1 should be lower than W2")
Wn1 = (W1[1] - W1[0]) * random_sample() + W1[0]
Wn2 = (W2[1] - W2[0]) * random_sample() + W2[0]
while Wn2 <= Wn1:
Wn2 = (W2[1] - W2[0]) * random_sample() + W2[0]
W = [Wn1, Wn2]
else:
# choose 1 frequency
W = (Wc[1] - Wc[0]) * random_sample() + Wc[0]
# choose order
order = randint(*n)
if onlyEven and order % 2 == 0:
order += 1
return Butter(order, W, form, name='Butterworth-random-%d' % seed)
def handle_ack_timeout(self):
assert self.state == Transmitter.State.WAIT_ACK
self.num_retries += 1
self.cw = min(2 * self.cw, self.sim.params.cwmax)
self.backoff = randint(0, self.cw)
self.backoff_vector.append(self.backoff)
self.sim.logger.debug(
f'backoff={self.backoff}; CW={self.cw}, NR={self.num_retries})',
src=self)
if self.channel.is_busy:
self.state = Transmitter.State.BUSY
else:
self.state = Transmitter.State.BACKOFF
self.timeout = self.sim.schedule(self.sim.params.difs,
self.handle_backoff_timeout)
def sample_draw(count, size):
"""
Return random sample (without replacement) of count integers between 0 and size.
"""
if count == 0: return []
elif count > size: raise AssertionError('count can not be > size')
elif count < 0: raise AssertionError('count cannot be negative')
if size < 1: raise AssertionError('size must be > 1')
deck = range(size)
for index in range(count):
current = deck[index]
swap_index = randint(index, size)
deck[index] = deck[swap_index]
deck[swap_index] = current
return deck[:count]
def random_TF(n=(5, 10), Wc=(0.1, 0.8), W1=(0.1, 0.5), W2=(0.5, 0.8)):
"""Generate one n-th order stable butterworth filter ((num, den) of the transfer function)"""
# choose a form
form = choice(['lowpass', 'highpass', 'bandpass', 'bandstop'])
# choose Wn
if form in ("bandpass", "bandstop"):
# choose 2 frequencies such that Wn2<=Wn1
Wn1 = (W1[1] - W1[0]) * random_sample() + W1[0]
Wn2 = (W2[1] - W2[0]) * random_sample() + W2[0]
while Wn2 <= Wn1:
Wn2 = (W2[1] - W2[0]) * random_sample() + W2[0]
W = [Wn1, Wn2]
else:
# choose 1 frequency
W = (Wc[1] - Wc[0]) * random_sample() + Wc[0]
# choose order
order = randint(*n)
num, den = butter(order, W, form)
return num, den
def test_collision_domain_saturated_network():
num_clients = randint(1, 10)
from pycsmaca.simulations.shortcuts import \
collision_domain_saturated_network
sr = collision_domain_saturated_network(
num_clients=num_clients,
payload_size=PAYLOAD_SIZE,
ack_size=ACK_SIZE,
mac_header_size=MAC_HEADER,
phy_header_size=PHY_HEADER,
preamble=PREAMBLE,
bitrate=BITRATE,
difs=DIFS,
sifs=SIFS,
slot=SLOT,
cwmin=CWMIN,
cwmax=CWMAX,
connection_radius=CONNECTION_RADIUS,
speed_of_light=SPEED_OF_LIGHT,
sim_time_limit=SIM_TIME_LIMIT,
log_level=Logger.Level.WARNING)
for i in range(num_clients):
cli = sr.clients[i]
assert cli.service_time.mean() > 0
assert cli.num_retries.mean() >= 0
assert cli.queue_size.timeavg() == 0 # stations don't relay packets!
assert cli.busy.timeavg() >= 0
assert cli.num_packets_sent > 0
srv = sr.server
assert srv.arrival_intervals.mean() > 0
if num_clients > 1:
assert srv.num_rx_collided > 0
else:
assert srv.num_rx_collided == 0
assert srv.num_rx_success > 0
assert_allclose(srv.num_packets_received,
sum(cli.num_packets_sent for cli in sr.clients),
rtol=0.25)
def test_randint_117(self):
# GH 14189
random.seed(0)
expected = np.array(
[
2357136044,
2546248239,
3071714933,
3626093760,
2588848963,
3684848379,
2340255427,
3638918503,
1819583497,
2678185683,
],
dtype="int64",
)
actual = random.randint(2**32, size=10)
assert_array_equal(actual, expected)
def generate(num_seq, seq_length, alphabet, m_word_length, m_word_param, background_param): magic_thetas = [dirichlet(m_word_param) for j in range(m_word_length)] background_theta = dirichlet(background_param) sequences = [] starts = [] for k in range(num_seq): background_onehots = [multinomial(1, background_theta) for x in range(seq_length - m_word_length)] background = [alphabet[t] for t in [i.tolist().index(1) for i in background_onehots]] #background = [alphabet[t].lower() for t in [i.tolist().index(1) for i in background_onehots]] magic_onehots = [multinomial(1, theta) for theta in magic_thetas] magic_word = [alphabet[j] for j in [i.tolist().index(1) for i in magic_onehots]] start_pos = randint(seq_length - m_word_length) background[start_pos : start_pos] = magic_word sequences.append(background) starts.append(start_pos) #print starts ans = [] ans.append(starts) ans.append(sequences) return ans
def sample_where(data, count=None):
"""
Get random sample of True elements from a multi-dimensional bool array, returning
indices ala numpy.where(). Sampling is without replacement.
If count is None, return random element's indices.
If 0 < count < 1.0, return count fraction of True elements' indices.
"""
true_indices = numpy.where(data)
if count is None:
random_slice = randint(len(true_indices[0]))
return tuple([d[random_slice] for d in true_indices])
elif count == 0: return None
elif count < 1:
count = int(count * numpy.sum(data))
indicesT = []
for random_slice in sample_draw(count, len(true_indices[0])):
indicesT.append([d[random_slice] for d in true_indices])
return tuple([d for d in numpy.array(indicesT).T])
def iter_random_Elliptic(number,
n=(5, 10),
rp=(0, 10),
rs=(30, 80),
Wc=(0.1, 0.8),
W1=(0.1, 0.5),
W2=(0.5, 0.8),
form=None,
seeded=True,
quant=None):
"""
Generate some n-th order Butterworh filters
Parameters
----------
- number: number of Butterworth filters generated
- n: (int) The order of the filter
- Wc: used if btype is 'lowpass' or 'highpass'
Wc is a tuple (min,max) for the cut frequency
- W1 and W2: used if btype is ‘bandpass’, ‘bandstop’
W1 and W2 are tuple (min,max) for the two start/stop frequencies
- form: (string) {None, ‘lowpass’, ‘highpass’, ‘bandpass’, ‘bandstop’}. Gives the type of filter. If None, the type is randomized
- quant: quantized the coefficients with quant bits (None by default -> no quantization)
- seeded: (boolean) indicates if the random should be done with a particular seed or not (in order to be reproductible, the seed is stored in the name of the filter)
"""
seeds = [
randint(0, 1e9) if seeded else None for _ in range(number)
] # generate a particular seed for each random dSS, or None (if seeded is set to False)
for s in seeds:
yield random_Elliptic(n=n,
rp=rp,
rs=rs,
Wc=Wc,
W1=W1,
W2=W2,
form=form,
seed=s,
quant=quant)
def update(t):
# new_series = []
if t == 3: add_series("superseries")
if t == 6: add_series("merge")
if t == 6: add_series("project")
#
# for series in new_series:
# add_series(series)
# generates new data
new_data = generate_new_data(t)
numMessages.text = infoBoxFormat("Log Messages", t)
print("new_data: {0}".format(new_data))
rollover = None #if interval.value == 0 else interval.value
# Update the data by sending only the new data points
if(randint(0,10)>-1):
source.stream(pack_new_data(new_data), rollover)
else:
source.stream(pack_new_data(None), rollover)
def handle_message(self, packet, connection=None, sender=None):
if connection.name == 'queue':
assert self.state == Transmitter.State.IDLE
self.cw = self.sim.params.cwmin
self.backoff = randint(0, self.cw)
self.num_retries = 1
#
# Create the PDU:
#
self.pdu = DataPDU(packet,
seqn=self.__seqn,
header_size=self.phy_header_size +
self.mac_header_size,
sender_address=self.address,
receiver_address=packet.receiver_address)
self.__seqn += 1
self.__start_service_time = self.sim.stime
self.backoff_vector.append(self.backoff)
self.__busy_trace.record(self.sim.stime, 1)
self.sim.logger.debug(
f'backoff={self.backoff}; CW={self.cw},NR={self.num_retries}',
src=self)
if self.channel.is_busy:
self.state = Transmitter.State.BUSY
else:
self.state = Transmitter.State.BACKOFF
self.timeout = self.sim.schedule(self.sim.params.difs,
self.handle_backoff_timeout)
else:
raise RuntimeError(
f'unexpected handle_message({packet}, connection={connection}, '
f'sender={sender}) call')
def iter_random_dSSmp(number, stable=True, n=(5, 10), p=(1, 5), q=(1, 5), pRepeat=0.01, pReal=0.5, pBCmask=0.90, pDmask=0.8, pDzero=0.5): """ Generate some n-th order random (stable or not) state-spaces, with q inputs and p outputs copy/Adapted from control-python library (thanks guys): https://sourceforge.net/projects/python-control/ possibly already adpated from Mathworks or Octave Parameters: - number: number of state-space to generate - stable: indicate if the state-spaces are stable or not - n: tuple (mini,maxi) number of states (default: random between 5 and 10) - p: number of outputs (default: 1) - q: number of inputs (default: 1) - pRepeat: Probability of repeating a previous root (default: 0.01) - pReal: Probability of choosing a real root (default: 0.5). Note that when choosing a complex root, the conjugate gets chosen as well. So the expected proportion of real roots is pReal / (pReal + 2 * (1 - pReal)) - pBCmask: Probability that an element in B or C will not be masked out (default: 0.9) - pDmask: Probability that an element in D will not be masked out (default: 0.8) - pDzero: Probability that D = 0 (default: 0.5) Returns: - returns a generator of dSS objects (to use in a for loop for example) """ for i in range(number): if stable: yield random_dSSmp(randint(*n), randint(*p), randint(*q), pRepeat, pReal, pBCmask, pDmask, pDzero) else: nn = randint(*n) pp = randint(*p) qq = randint(*q) A = numpy.matrix(rand(nn, nn)) B = numpy.matrix(rand(nn, qq)) C = numpy.matrix(rand(pp, nn)) D = numpy.matrix(rand(pp, qq)) yield dSSmp(A, B, C, D)
def generate_graph_nx(
nodes: int,
density,
mode,
directed,
force=settings.force): # graph generation using networkx
bar = ProgBar(20, title='Generating graph', stream=sys.stdout)
if directed: # calculate edge count based on node count and density
edges = nodes * (nodes - 1) * density
if edges < nodes - 1 and not force:
print(
"Minimum graph density for this problem is {:2.0%}. "
"To generate less dense graph anyway, set argument force to True."
.format(float(1 / nodes)),
file=sys.stderr)
edges = nodes - 1
else:
edges = nodes * (nodes - 1) * density / 2
if edges < nodes - 1 and not force:
print(
"Minimum graph density for this problem is {:2.0%}. "
"To generate less dense graph anyway, set argument force to True."
.format(float(2 / nodes)),
file=sys.stderr)
edges = nodes - 1
bar.update()
G = nx.generators.random_graphs.gnm_random_graph(
nodes, edges, directed=directed) # generate random graph
bar.update()
if not directed: # check connectivity and generate new graph if failed
while not nx.is_connected(G):
G = nx.generators.random_graphs.gnm_random_graph(
nodes, edges, directed=directed)
else:
cont = False
while not cont:
cont = True
for node in G.nodes:
if len([x for x in G.neighbors(node)]) == 0:
cont = False
G = nx.generators.random_graphs.gnm_random_graph(
nodes, edges, directed=directed)
break
bar.update()
if mode == 'matrix': # convert generated networkx graph to own structure
ret = Matrix(nodes)
for x, y in G.edges:
w = randint(1, nodes)
ret.set(x, y, w)
if directed and ret.get(y, x) == 0:
ret.set(y, x, 0)
else:
ret.set(y, x, w)
bar.update()
return ret
else:
ret = ListGraph(nodes)
for x, y in G.edges:
w = randint(1, nodes)
ret.add_connection(x, y, w)
if not directed:
ret.add_connection(y, x, w)
bar.update()
return ret
def serial_test(self): # bulk tests as specified in settings.py
result_file = open('result.txt', 'a')
for algorithm in settings.algorithms:
print(algorithm.capitalize())
result_file.write("%s\n" % algorithm.capitalize())
alg_res = {}
for representation in settings.representations:
print(representation.capitalize())
result_file.write("%s\n" % representation.capitalize())
rep_res = {}
for density in settings.densities:
print('Density: {}%'.format(density * 100))
result_file.write('Density: {}%\n'.format(density * 100))
den_res = {}
for serie in settings.series:
print('Graph size: %d' % serie)
result_file.write('Graph size: %d\n' % serie)
results = []
for i in range(settings.series_entries):
gc.disable()
graph = GraphGenerator.generate_graph_nx(
serie, density, representation, settings.
is_directed[algorithm]) # generate new graph
function = getattr(
algorithms, '%s_%s' %
(algorithm, representation)) # get function
args = ()
if algorithm == 'prim' or algorithm == 'kruskal': # generate random arguments for function
args = tuple([randint(serie)])
elif algorithm == 'dijkstra' or algorithm == 'ford_bellman':
arg1 = randint(serie)
arg2 = randint(serie)
while arg2 == arg1:
arg2 = randint(serie)
args = (arg1, arg2)
start = timer()
function(graph, args) # time test
end = timer()
time = (end - start
) * 1000 # convert time to milliseconds
print(
'Entry %d | Execution time: %f milliseconds' %
(i + 1, time))
result_file.write(
'Entry %d | Execution time: %f milliseconds\n'
% (i + 1, time))
results.append(time)
del graph
gc.enable()
avg = average(results)
maxi = max(results)
mini = min(results)
print('Average time in series: %f' % avg)
result_file.write('Average time in series: %f\n' % avg)
print('Maximum execution time: %f' % maxi)
result_file.write('Maximum execution time: %f\n' %
maxi)
print('Minimum execution time: %f' % mini)
result_file.write('Minimum execution time: %f\n' %
mini)
print('-' * 30)
result_file.write('-' * 30)
result_file.write('\n')
den_res[serie] = results
rep_res[density] = den_res
alg_res[representation] = rep_res
def generate_graph(nodes, density, mode, directed, force=settings.force):
"""
graph generated via algorithm:
1. calculate edge count
2. build a tree
3. add random edges to meet edge count
"""
connected = []
disconnected = [i for i in range(nodes)]
if directed: # calculate edge count based on node count and density
edge_list = [(x, y) for x in range(nodes) for y in range(nodes)
if x != y]
edges = nodes * (nodes - 1) * density
if edges < nodes - 1 and not force:
print(
"Minimum graph density for this problem is {:2.0%}. "
"To generate less dense graph anyway, set argument force to True."
.format(float(1 / nodes)),
file=sys.stderr)
edges = nodes - 1
else:
edge_list = [(x, y) for x in range(nodes) for y in range(nodes)
if x != y]
edges = nodes * (nodes - 1) * density / 2
if edges < nodes - 1 and not force:
print(
"Minimum graph density for this problem is {:2.0%}. "
"To generate less dense graph anyway, set argument force to True."
.format(float(2 / nodes)),
file=sys.stderr)
edges = nodes - 1
bar = ProgBar(edges, title='Generating graph', stream=sys.stdout)
if mode == 'list':
graph = ListGraph(nodes)
while len(disconnected) > 0: # build a tree
if len(connected) == 0:
s = randint(nodes)
e = randint(nodes)
connected.append(s)
disconnected.remove(s)
else:
s = connected[randint(
len(connected)
)] # get starting vertex randomly from already connected nodes
e = disconnected[randint(
len(disconnected)
)] # get ending vertex randomly from not yet connected
disconnected.remove(e)
w = randint(1, nodes)
graph.add_connection(s, e, w) # add connection
if not directed:
graph.add_connection(e, s, w)
connected.append(e)
edge_list.remove((s, e)) # remove edge from the pool
if not directed:
edge_list.remove((e, s))
edges -= 1
bar.update()
while edges > 0: # add remaining edges at random
s, e = edge_list[randint(len(edge_list))]
edge_list.remove((s, e))
w = randint(nodes)
graph.add_connection(s, e, w)
if not directed:
edge_list.remove((e, s))
graph.add_connection(e, s, w)
edges -= 1
bar.update()
elif mode == 'matrix':
graph = Matrix(nodes)
while len(disconnected) > 0: # build a tree
if len(connected) == 0:
s = randint(nodes)
e = randint(nodes)
connected.append(s)
disconnected.remove(s)
else:
s = connected[randint(
len(connected)
)] # get starting vertex randomly from already connected nodes
e = disconnected[randint(
len(disconnected)
)] # get ending vertex randomly from not yet connected
disconnected.remove(e)
w = randint(1, nodes)
graph.set(s, e, w) # add connection
if not directed:
graph.set(e, s, w)
connected.append(e)
edge_list.remove((s, e)) # remove edge from the pool
if not directed:
edge_list.remove((e, s))
edges -= 1
bar.update()
bar = ProgBar(20, stream=sys.stdout)
while edges > 0: # add remaining edges at random
s, e = edge_list[randint(len(edge_list))]
edge_list.remove((s, e))
w = randint(nodes)
graph.set(s, e, w)
if not directed:
edge_list.remove((e, s))
graph.set(e, s, w)
edges -= 1
bar.update()
print("Generated graph")
return graph
def createGraph(self,
nodeNum,
arcNum,
snode,
dnode,
totalDemand,
balanced=False):
#Determining the per dnode and per snode b's for balanced version
demval = int(math.floor(totalDemand / dnode))
supmval = int(math.floor(totalDemand / snode))
#Adding desired amount of nodes
for i in range(0, nodeNum):
self.addNode()
#Supply Node Determination
dt = deepcopy(totalDemand)
t = 0
supplyIds = []
while t < snode:
index = randint(0, nodeNum - 1)
if self.nodes[index].b is None:
if t is not snode - 1:
if balanced is True:
k = randint(math.floor(3 * supmval / 4),
math.floor(supmval))
else:
k = randint(1, math.floor(dt - (snode - t)))
supplyIds.append(index)
self.nodes[index].b = k
dt = dt - k
t = t + 1
else:
self.nodes[index].b = dt
supplyIds.append(index)
t = t + 1
else:
continue
#Demand Node Determination
dt = deepcopy(totalDemand)
t = 0
demandIds = []
while t < dnode:
index = randint(0, nodeNum - 1)
if self.nodes[index].b is None:
if t is not dnode - 1:
if balanced is True:
k = randint(math.floor(3 * demval / 4),
math.floor(demval))
else:
k = randint(1, math.floor(dt - (dnode - t)))
self.nodes[index].b = k * -1
demandIds.append(index)
dt = dt - k
t = t + 1
else:
self.nodes[index].b = dt * -1
demandIds.append(index)
t = t + 1
else:
continue
#Adding Edges From Each Supply Node to Each Demand Node to Guarantee the Connectivity
arc = 0
for s in supplyIds:
for d in demandIds:
self.addEdge(self.nodes[s], self.nodes[d], 50, self.nodes[s].b)
arc = arc + 1
#Adding remaining arcs
while arc < arcNum:
index1 = randint(0, nodeNum - 1)
index2 = randint(0, nodeNum - 1)
if self.getEdge(index1, index2) is None:
if index1 is not index2:
self.addEdge(self.nodes[index1], self.nodes[index2],
randint(1, 20), randint(0, totalDemand))
arc = arc + 1
else:
continue
#Adding dummy node and connecting all nodes to this node (Otherwise it may be problematic for capacity scaling due to possible loss of strong connectivity)
self.addNode(0)
dummy = self.nodes[len(self.nodes) - 1]
for i in self.nodes:
if i is not dummy:
self.addEdge(i, dummy, 2000, 1000000000000)
self.addEdge(dummy, i, 2000, 1000000000000)
#Setting remaining b's to 0 other than supply and demand nodes
for n in self.nodes:
if n.b is None:
n.b = 0
def genereer_getal(bereik):
return randint(1, bereik)
'''
Created on Jan 2, 2019
@author: vkhoday
'''
from numpy.random import rand
from numpy.random.mtrand import randint
import pandas
from selenium import webdriver
dr =webdriver.Chrome(executable_path='C:/Users/DELL/git/Pyunit_Selenium/WebDriver/chromedriver_235')
dr.get("https://www.google.com")
y =dr.execute_script("return document.body.scrollHeight")
x =dr.execute_script("return document.body.scrollWidth")
print(x,y)
for i in range(0,10):
r =randint(26,size=(5,10))
print (r)
pd = pandas.Series(randint.random.randn(50))
def test_warns_byteorder(self):
# GH 13159
other_byteord_dt = '<i4' if sys.byteorder == 'big' else '>i4'
with pytest.deprecated_call(match='non-native byteorder is not'):
random.randint(0, 200, size=10, dtype=other_byteord_dt)
# are separately analysed posteriors.
mode = 'replace'
# Calculate entropy numbers with surprise
rel_ent, exp_rel_ent, S, sD, p = sc(sample1, sample2, mode = mode)
print('Entropy estimates for two standard normal distributions.')
print('Relative entropy D: %f'%rel_ent)
print('Expected relative entropy <D>: %f'%exp_rel_ent)
print('Surprise S: %f'%S)
print('Expected fluctuations of relative entropy sigma(D): %f'%sD)
print('p-value of Surprise: %f'%p)
# Draw random weights for the samples.
mini = 1
maxi = 10
weights1 = randint(mini, maxi, n)
weights2 = randint(mini, maxi, n)
# Calculate entropy numbers with surprise using the random weights
rel_ent, exp_rel_ent, S, sD, p = sc(sample1, sample2, mode = mode,
weights1 = weights1, weights2 = weights2)
print('Entropy estimates for two standard normal distributions.')
print('(with random weights)')
print('Relative entropy D: %f'%rel_ent)
print('Expected relative entropy <D>: %f'%exp_rel_ent)
print('Surprise S: %f'%S)
print('Expected fluctuations of relative entropy sigma(D): %f'%sD)
print('p-value of Surprise: %f'%p)
def main():
seed = 1
number_of_samples = 20000
dbd4 = DBD4(size=number_of_samples, ratio=1, thresh=6, seed=seed)
SecondaryStructureExtractor(dbd4).extract_feature()
for complex_name in dbd4.complexes:
print_info(complex_name)
c = dbd4.complexes[complex_name]
b_ligand, b_receptor = (c.bound_formation.ligand, c.bound_formation.receptor)
u_ligand, u_receptor = (c.unbound_formation.ligand, c.unbound_formation.receptor)
b_ligand_bio_residues, b_receptor_bio_residues = b_ligand.biopython_residues, b_receptor.biopython_residues
# b_l_ns, b_r_ns = NeighborSearch(b_ligand.atoms), NeighborSearch(b_receptor.atoms)
u_l_ns, u_r_ns = NeighborSearch(u_ligand.atoms), NeighborSearch(u_receptor.atoms)
index = randint(1, 30)
positives = 0
negatives = 0
lb2u = c.ligand_bound_to_unbound
rb2u = c.receptor_bound_to_unbound
p = False
n = False
with PdfPages('{0}/geometry/figures/{1}.pdf'.format(reports_directory, complex_name)) as pdf:
try:
for i in range(len(b_ligand_bio_residues)):
for j in range(len(b_receptor_bio_residues)):
if b_ligand.residues[i] not in lb2u or b_receptor.residues[j] not in rb2u:
continue
l_atoms = b_ligand_bio_residues[i].get_list()
r_atoms = b_receptor_bio_residues[j].get_list()
dist_mat = cdist([atom.get_coord() for atom in l_atoms], [atom.get_coord() for atom in r_atoms])
if p and n:
print "getting out of loop..."
raise GetOutOfLoop
if dist_mat.min() < dbd4.interaction_threshold:
if p:
continue
positives += 1
if positives != index:
continue
# b_l_points, b_l_dist = get_coords(b_l_ns, b_ligand, b_ligand.residues[i], 0.5, False)
# b_r_points, b_r_dist = get_coords(b_r_ns, b_receptor, b_receptor.residues[j], 0.5, False)
b_l_points, b_l_dist = get_coords(u_l_ns, u_ligand, lb2u[b_ligand.residues[i]], 0.5, False)
b_r_points, b_r_dist = get_coords(u_r_ns, u_receptor, rb2u[b_receptor.residues[j]], 0.5,
False)
u_l_points, u_l_dist = get_coords(u_l_ns, u_ligand, lb2u[b_ligand.residues[i]], 0.5, True)
u_r_points, u_r_dist = get_coords(u_r_ns, u_receptor, rb2u[b_receptor.residues[j]], 0.5,
True)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(b_l_points[:, 0], b_l_points[:, 1], b_l_points[:, 2], c='r')
ax.scatter(b_r_points[:, 0], b_r_points[:, 1], b_r_points[:, 2], c='b')
plt.title("Interacting Residues Bound Conformation")
pdf.savefig()
plt.close()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(u_l_points[:, 0], u_l_points[:, 1], u_l_points[:, 2], c='r')
ax.scatter(u_r_points[:, 0], u_r_points[:, 1], u_r_points[:, 2], c='b')
plt.title("Interacting Surface Residues Bound Conformation")
pdf.savefig()
plt.close()
plt.figure()
plt.plot(u_l_dist)
plt.plot(u_r_dist)
plt.legend(["bound ligand {0}".format(i), "bound receptor {0}".format(j), "unbound ligand",
"unbound receptor"])
pdf.savefig()
plt.close()
p = True
else:
if n:
continue
lb2u = c.ligand_bound_to_unbound
rb2u = c.receptor_bound_to_unbound
b_l_points, b_l_dist = get_coords(u_l_ns, u_ligand, lb2u[b_ligand.residues[i]], 0.5, False)
b_r_points, b_r_dist = get_coords(u_r_ns, u_receptor, rb2u[b_receptor.residues[j]], 0.5,
False)
u_l_points, u_l_dist = get_coords(u_l_ns, u_ligand, lb2u[b_ligand.residues[i]], 0.5, True)
u_r_points, u_r_dist = get_coords(u_r_ns, u_receptor, rb2u[b_receptor.residues[j]], 0.5,
True)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(b_l_points[:, 0], b_l_points[:, 1], b_l_points[:, 2], c='r')
ax.scatter(b_r_points[:, 0], b_r_points[:, 1], b_r_points[:, 2], c='b')
plt.title("Non-Interacting Residues Bound Conformation")
pdf.savefig()
plt.close()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(u_l_points[:, 0], u_l_points[:, 1], u_l_points[:, 2], c='r')
ax.scatter(u_r_points[:, 0], u_r_points[:, 1], u_r_points[:, 2], c='b')
plt.title("Non-Interacting Surface Residues Bound Conformation")
pdf.savefig()
plt.close()
plt.figure()
plt.plot(u_l_dist)
plt.plot(u_r_dist)
plt.legend(["bound ligand {0}".format(i), "bound receptor {0}".format(j), "unbound ligand",
"unbound receptor"])
pdf.savefig()
plt.close()
n = True
except GetOutOfLoop:
pass
def run():
#sets useful variables and gets window size
black = [0, 0, 0]
w, h = display1.get_size()
pygame.mouse.set_visible(False) #hides the mouse for the game
x = int(w / 2)
y = int(h / 2) + 200
# x, y refer to pygame coordinates of player
score = 0
flagy = -263
flagx = randint(0, scr_width - 500)
#pygame coordinates of the obstacle, the x value is randomly generated
intro()
#introduction screen displayed if it is firsttime is true
pygame.mixer.music.play(-1)
#plays the background music during gameplay
while (True):
scorefont = myfont.render('Score: %d' % score, False, (0, 0, 0))
#text that shows current score in upper left corner
if (flagy > scr_height + 270):
#detects for an obstacle successfully avoided (off the bottom of screen)
flagy = -270
flagx = randint(0, scr_width - 500)
#obstacle moved to new position above player, with random x value
score += 1
color = [randint(0, 255), randint(0, 255), randint(0, 255)]
#randomly generates a color for the background
flagy = flagy + 12
#this is the speed that the obstacle falls down
#detects for user input from keyboard (escape button only)
for event in pygame.event.get():
if (event.type == pygame.QUIT):
sys.exit()
elif (event.type == pygame.KEYDOWN):
if (event.key == pygame.K_ESCAPE):
sys.exit()
#detects user controlling player (this method must be used or else
#holding a button only renders one click, and the player will not
#continuously move. It is also checked that the player will not go
#off the screen after moving
keys = pygame.key.get_pressed()
if (keys[pygame.K_RIGHT]):
if (x + 10 in range(0, scr_width - 121)):
x = x + 10
if (keys[pygame.K_LEFT]):
if (x - 10 in range(0, scr_width)):
x = x - 10
if (not Intersection(Interval(y, y + 140), Interval(
flagy, flagy + 150)).is_EmptySet):
#checks if the intervals of y coordinates of the obstacle and player overlap
if (not Intersection(Interval(x, x + 121),
Interval(flagx, flagx + 500)).is_EmptySet):
#given that the y coordinates overlap, check if the x coordinates overlap
display1.fill(black)
global highscore #defined global because variable is in function
if (score > highscore):
#check if score this round is higher than highscore, update highscore if needed
highscore = score
savehighscore(highscore)
#this is the text on the death screen
text = myfont.render('you have died.', False, (255, 255, 255))
scoretext = myfont.render(
'Score: %d Highscore: %d' % (score, highscore), False,
(255, 255, 255))
text2 = myfont.render('press space to restart', False,
(255, 255, 255))
while (True):
#while on death screen, checks for user input
for event in pygame.event.get():
if (event.type == pygame.QUIT):
sys.exit()
elif (event.type == pygame.KEYDOWN):
if (event.key == pygame.K_ESCAPE):
sys.exit()
if (event.key == pygame.K_SPACE):
#restart the game
global firsttime
pygame.mixer.music.stop()
#stops music so it can be replayed
firsttime = False
#prevents the intro screen from showing
run()
#draws the text onto death screen
display1.blit(text, (int(scr_width / 2) - 500, 200))
display1.blit(scoretext, (int(scr_width / 2) - 500, 300))
display1.blit(text2, (int(scr_width / 2) - 500, 400))
pygame.display.update()
#clears game window, moves all objects, and redraws them. Also draws on score.
display1.fill(color)
display1.blit(player, (x, y))
display1.blit(flag, (flagx, flagy))
display1.blit(scorefont, (40, 50))
pygame.display.update()
def gibbssample(num_iters, pos_sequences, alphabet, m_word_length, m_word_param, background_param):
#print sequences
sequences = pos_sequences[1]
M = len(alphabet) # Alphabet size
K = len(sequences) # Num sequences
N = len(sequences[0]) # Seq length
alph_map = {alphabet[m] : m for m in range(M)}
iter_logpost = [[] for x in range(2)]
# Initialize hidden word starting locations
R = randint(0, N - m_word_length, K).tolist()
# Calculate sum of alphas for magic word and background distributions
A = float(sum(m_word_param))
A_back = float(sum(background_param))
# Get magic word and background symbol counts
N_m = [[0.0] * m_word_length for x in range(M)]
bg_m = [0.0] * M
for i in range(K):
for x in range(N):
if x >= R[i] and x < R[i] + m_word_length:
N_m[alph_map[sequences[i][x].upper()]][x-R[i]] += 1
else:
bg_m[alph_map[sequences[i][x].upper()]] += 1
# Begin iterations
for l in range(num_iters):
to_exclude = range(K)
for s in range(K):
# Select sequence to exclude
exclude_indx = randint(len(to_exclude))
z = to_exclude[exclude_indx]
del to_exclude[exclude_indx]
# Update counts for excluding excluded sequence
for x in range(N):
if x >= R[z] and x < R[z] + m_word_length:
N_m[alph_map[sequences[z][x].upper()]][x-R[z]] -= 1
else:
bg_m[alph_map[sequences[z][x].upper()]] -= 1
P = [[0.0] * m_word_length for x in range(M)]
P_bg = [0.0] * M
# Calculate log conditional P(s_(z,j) = m | s_(j,-z), alpha) for each symbol and m_word pos
for m in range(M):
P_bg[m] = log((bg_m[m] + background_param[m]) / (A_back + K*(N-m_word_length) - 1))
for j in range(m_word_length):
P[m][j] = log((N_m[m][j] + m_word_param[m]) / (A + K - 1))
# Calculate posterior over each starting position in s_z
r_bg_z = sum([P_bg[alph_map[m.upper()]] for m in sequences[z]])
r = [r_bg_z] * (N - m_word_length)
for s_pos in range(N - m_word_length):
for j in range(m_word_length):
idx = s_pos + j
r[s_pos] -= P_bg[alph_map[sequences[z][idx].upper()]]
r[s_pos] += P[alph_map[sequences[z][idx].upper()]][j]
# Normalize conditionals
probs = [exp(x) for x in r]
normalizer = sum(probs)
probs = [x/normalizer for x in probs]
# Update starting position for s_z
R[z] = multinomial(1,probs).tolist().index(1)
# Update counts for updating starting position of excluded sequence
for x in range(N):
if x >= R[z] and x < R[z] + m_word_length:
N_m[alph_map[sequences[z][x].upper()]][x-R[z]] += 1
else:
bg_m[alph_map[sequences[z][x].upper()]] += 1
# Calculate posterior
log_post = lgamma(A_back) - lgamma(K*(N - m_word_length) + A_back)
for m in range(M):
log_post += lgamma(bg_m[m] + background_param[m]) - lgamma(background_param[m])
for j in range(m_word_length):
log_post += lgamma(A) - lgamma(K + A)
for m in range(M):
log_post += lgamma(N_m[m][j] + m_word_param[m]) - lgamma(m_word_param[m])
iter_logpost[0].append(l)
iter_logpost[1].append(log_post)
#print[abs(pos_sequences[0][i] - R[i]) < 1 for i in range(len(R))]
#print R
return [R,iter_logpost]
with tf.Session() as sess:
sess.run(init)
for epoch in range( training_epochs ):
avg_cost = 0.
total_batch = int( mnist.train.num_examples/batch_size)
for i in range( total_batch ):
batch_xs, batch_ys = mnist.train.next_batch( batch_size )
sess.run( optimizer, feed_dict={x: batch_xs, y:batch_ys} )
avg_cost += sess.run( cost, feed_dict={x: batch_xs, y:batch_ys} ) / total_batch
if epoch % display_step == 0:
print "Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost)
print "Optimization Finished!"
# Get one and predict
r = randint( 0, mnist.test.num_examples -1 )
print "Label: ", sess.run( tf.arg_max(mnist.test.labels[r:r+1], 1) )
print "Prediction: ", sess.run( tf.arg_max(activation, 1), {x: mnist.test.images[r:r+1]} )
# Test model
correct_prediction = tf.equal( tf.arg_max(activation, 1), tf.arg_max(y, 1) )
# Calculate accuracy
accuracy = tf.reduce_mean( tf.cast(correct_prediction, "float") )
print "Accuracy:", accuracy.eval( {x: mnist.test.images, y: mnist.test.labels} )
#Show the img
# plt.imshow( mnist.test.images[r:r+1], reshape(28, 28), cmap="Greys", interpolation='nearest' )
# plt.show()
def generateNewValue(lim1, lim2):
return randint(lim1, lim2)
def MonteCarlo_Meals(data, epsilon, episodes, alpha, plan_goals):
breakfast_meals = data[data['breakfast'] == 1]
lunch_dinner = data[data['main_dish'] == 1]
inbetween_meals = data[(data['breakfast'] == 0) & (data['main_dish'] == 0)]
meal_types = [
'breakfast', 'lunch', 'dinner', 'inbetweener_1', 'inbetweener_2',
'inbetweener_3'
]
nutrition_Val = ['calories', 'fats', 'proteins', 'carbs']
good_episodes = []
counter = 0
### Generate Servings table for the number of meals
serv_table = servingsTable(plan_goals.meals)
while counter == 0:
print('Trial')
for k in range(0, episodes):
print(k)
episode_run = []
for i in range(0, plan_goals.meals):
if i == 0:
meals = breakfast_meals
elif i < 2:
meals = lunch_dinner
else:
meals = inbetween_meals
greedyselection = randint(1, 10)
if greedyselection <= epsilon:
rand_selection = randint(low=0, high=len(meals.index))
episode_run = np.append(
episode_run, meals.iloc[rand_selection]['index'])
else:
maxOfV = meals[meals['avg_val'] ==
meals['avg_val'].max()]['index']
# If multiple max values, take first
maxOfV = maxOfV.values[0]
episode_run = np.append(episode_run, maxOfV)
episode_run = episode_run.astype(int)
for i in range(2, serv_table.shape[0]):
episode = pd.DataFrame({
'meal_type':
meal_types[:len(episode_run)],
'meal_index':
episode_run,
'serving':
serv_table[i]
})
episode['meal_index'] = (episode['meal_index']).astype(int)
data['index'] = (data['index']).astype(int)
detailed_episode = episode.merge(
data[['index', 'name', 'value_ser1', 'value_ser2'] +
nutrition_Val],
left_on='meal_index',
right_on='index',
how='inner')
for col in nutrition_Val:
detailed_episode[col] = detailed_episode[
col] * detailed_episode['serving']
result = 0
reward = -1
# Total nutritional value in the entire plan
total_protein = detailed_episode['proteins'].sum()
total_fats = detailed_episode['fats'].sum()
total_calories = detailed_episode['calories'].sum()
total_carbs = detailed_episode['carbs'].sum()
if (plan_goals.needed_proteins[0] < total_protein) & (
plan_goals.needed_proteins[1] > total_protein):
result += 1
if (plan_goals.needed_carbs[0] < total_carbs) & (
plan_goals.needed_carbs[1] > total_carbs):
result += 1
if (plan_goals.needed_fats[0] <
total_fats) & (plan_goals.needed_fats[1] > total_fats):
result += 1
if abs(plan_goals.needed_calories - total_calories) < 100:
result += 1
if result == 4:
counter += 1
reward = 1
good_episodes.append(detailed_episode)
detailed_episode['return'] = reward
for v in range(0, len(detailed_episode)):
serv = detailed_episode.iloc[v]['serving']
int(serv)
if detailed_episode.iloc[v]['return'] != 0:
update = data[data['index'] == detailed_episode.iloc[v]['meal_index']][
'value_ser' + str(serv)[0]] + alpha * \
((detailed_episode.iloc[v]['return'] / plan_goals.meals) -
data[data['index'] == detailed_episode.iloc[v]['meal_index']][
'value_ser' + str(serv)[0]])
data.loc[(data['index'] ==
detailed_episode.iloc[v]['meal_index']),
('value_ser' + str(serv)[0])] = update
data['avg_val'] = data[['value_ser2',
'value_ser1']].values.max(1)
return good_episodes[0]
mode = 'replace'
# Calculate entropy numbers with surprise
rel_ent, exp_rel_ent, S, sD, p = sc(sample1, sample2, mode=mode)
print('Entropy estimates for two standard normal distributions.')
print('Relative entropy D: %f' % rel_ent)
print('Expected relative entropy <D>: %f' % exp_rel_ent)
print('Surprise S: %f' % S)
print('Expected fluctuations of relative entropy sigma(D): %f' % sD)
print('p-value of Surprise: %f' % p)
# Draw random weights for the samples.
mini = 1
maxi = 10
weights1 = randint(mini, maxi, n)
weights2 = randint(mini, maxi, n)
# Calculate entropy numbers with surprise using the random weights
rel_ent, exp_rel_ent, S, sD, p = sc(sample1,
sample2,
mode=mode,
weights1=weights1,
weights2=weights2)
print('Entropy estimates for two standard normal distributions.')
print('(with random weights)')
print('Relative entropy D: %f' % rel_ent)
print('Expected relative entropy <D>: %f' % exp_rel_ent)
print('Surprise S: %f' % S)
print('Expected fluctuations of relative entropy sigma(D): %f' % sD)
twentylstmaccdata = []
twentylstmstddata = []
twentylstmstderror = []
predictedBLLabels = []
predictedBRLabels = []
predictedBRLLabels = []
predictedBRRLabels = []
predictedBRPLabels = []
predictedRWLabels = []
offset = 100
accuracyOverall = []
for testnumber in range(30):
start = randint(7999, 9799)
end = start + offset
timestep = range(start, end)
LSTMClassificationNet.reset()
for i in timestep:
x = LSTMClassificationNet.activate(BallLiftJoint[i])
predictedBLLabels.append(argmax(x))
start = randint(7999, 9799)
end = start + offset
timestep = range(start, end)
LSTMClassificationNet.reset()
for i in timestep:
x = LSTMClassificationNet.activate(BallRollJoint[i])
predictedBRLabels.append(argmax(x))
def main():
seed = 1
number_of_samples = 20000
dbd4 = DBD4(size=number_of_samples, ratio=1, thresh=6, seed=seed)
SecondaryStructureExtractor(dbd4).extract_feature()
for complex_name in dbd4.complexes:
print_info(complex_name)
c = dbd4.complexes[complex_name]
b_ligand, b_receptor = (c.bound_formation.ligand,
c.bound_formation.receptor)
u_ligand, u_receptor = (c.unbound_formation.ligand,
c.unbound_formation.receptor)
b_ligand_bio_residues, b_receptor_bio_residues = b_ligand.biopython_residues, b_receptor.biopython_residues
# b_l_ns, b_r_ns = NeighborSearch(b_ligand.atoms), NeighborSearch(b_receptor.atoms)
u_l_ns, u_r_ns = NeighborSearch(u_ligand.atoms), NeighborSearch(
u_receptor.atoms)
index = randint(1, 30)
positives = 0
negatives = 0
lb2u = c.ligand_bound_to_unbound
rb2u = c.receptor_bound_to_unbound
p = False
n = False
with PdfPages('{0}/geometry/figures/{1}.pdf'.format(
reports_directory, complex_name)) as pdf:
try:
for i in range(len(b_ligand_bio_residues)):
for j in range(len(b_receptor_bio_residues)):
if b_ligand.residues[
i] not in lb2u or b_receptor.residues[
j] not in rb2u:
continue
l_atoms = b_ligand_bio_residues[i].get_list()
r_atoms = b_receptor_bio_residues[j].get_list()
dist_mat = cdist(
[atom.get_coord() for atom in l_atoms],
[atom.get_coord() for atom in r_atoms])
if p and n:
print "getting out of loop..."
raise GetOutOfLoop
if dist_mat.min() < dbd4.interaction_threshold:
if p:
continue
positives += 1
if positives != index:
continue
# b_l_points, b_l_dist = get_coords(b_l_ns, b_ligand, b_ligand.residues[i], 0.5, False)
# b_r_points, b_r_dist = get_coords(b_r_ns, b_receptor, b_receptor.residues[j], 0.5, False)
b_l_points, b_l_dist = get_coords(
u_l_ns, u_ligand, lb2u[b_ligand.residues[i]],
0.5, False)
b_r_points, b_r_dist = get_coords(
u_r_ns, u_receptor,
rb2u[b_receptor.residues[j]], 0.5, False)
u_l_points, u_l_dist = get_coords(
u_l_ns, u_ligand, lb2u[b_ligand.residues[i]],
0.5, True)
u_r_points, u_r_dist = get_coords(
u_r_ns, u_receptor,
rb2u[b_receptor.residues[j]], 0.5, True)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(b_l_points[:, 0],
b_l_points[:, 1],
b_l_points[:, 2],
c='r')
ax.scatter(b_r_points[:, 0],
b_r_points[:, 1],
b_r_points[:, 2],
c='b')
plt.title(
"Interacting Residues Bound Conformation")
pdf.savefig()
plt.close()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(u_l_points[:, 0],
u_l_points[:, 1],
u_l_points[:, 2],
c='r')
ax.scatter(u_r_points[:, 0],
u_r_points[:, 1],
u_r_points[:, 2],
c='b')
plt.title(
"Interacting Surface Residues Bound Conformation"
)
pdf.savefig()
plt.close()
plt.figure()
plt.plot(u_l_dist)
plt.plot(u_r_dist)
plt.legend([
"bound ligand {0}".format(i),
"bound receptor {0}".format(j),
"unbound ligand", "unbound receptor"
])
pdf.savefig()
plt.close()
p = True
else:
if n:
continue
lb2u = c.ligand_bound_to_unbound
rb2u = c.receptor_bound_to_unbound
b_l_points, b_l_dist = get_coords(
u_l_ns, u_ligand, lb2u[b_ligand.residues[i]],
0.5, False)
b_r_points, b_r_dist = get_coords(
u_r_ns, u_receptor,
rb2u[b_receptor.residues[j]], 0.5, False)
u_l_points, u_l_dist = get_coords(
u_l_ns, u_ligand, lb2u[b_ligand.residues[i]],
0.5, True)
u_r_points, u_r_dist = get_coords(
u_r_ns, u_receptor,
rb2u[b_receptor.residues[j]], 0.5, True)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(b_l_points[:, 0],
b_l_points[:, 1],
b_l_points[:, 2],
c='r')
ax.scatter(b_r_points[:, 0],
b_r_points[:, 1],
b_r_points[:, 2],
c='b')
plt.title(
"Non-Interacting Residues Bound Conformation")
pdf.savefig()
plt.close()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(u_l_points[:, 0],
u_l_points[:, 1],
u_l_points[:, 2],
c='r')
ax.scatter(u_r_points[:, 0],
u_r_points[:, 1],
u_r_points[:, 2],
c='b')
plt.title(
"Non-Interacting Surface Residues Bound Conformation"
)
pdf.savefig()
plt.close()
plt.figure()
plt.plot(u_l_dist)
plt.plot(u_r_dist)
plt.legend([
"bound ligand {0}".format(i),
"bound receptor {0}".format(j),
"unbound ligand", "unbound receptor"
])
pdf.savefig()
plt.close()
n = True
except GetOutOfLoop:
pass
for i in range(total_batch):
batch_xs, batch_ys = mnist.train.next_batch(batch_size)
sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys})
avg_cost += sess.run(cost, feed_dict={
x: batch_xs,
y: batch_ys
}) / total_batch
if epoch % display_step == 0:
print "Epoch:", '%04d' % (epoch +
1), "cost=", "{:.9f}".format(avg_cost)
print "Optimization Finished!"
# Get one and predict
r = randint(0, mnist.test.num_examples - 1)
print "Label: ", sess.run(tf.arg_max(mnist.test.labels[r:r + 1], 1))
print "Prediction: ", sess.run(tf.arg_max(activation, 1),
{x: mnist.test.images[r:r + 1]})
# Test model
correct_prediction = tf.equal(tf.arg_max(activation, 1), tf.arg_max(y, 1))
# Calculate accuracy
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print "Accuracy:", accuracy.eval({
x: mnist.test.images,
y: mnist.test.labels
})
#Show the img
# plt.imshow( mnist.test.images[r:r+1], reshape(28, 28), cmap="Greys", interpolation='nearest' )
def get_random_tile():
return SPAWN_CHANCE_LIST[randint(0, len(SPAWN_CHANCE_LIST))]
def fill(self):
for i in range(0, self.x):
for j in range(0, self.y):
self.matrix[i, j] = randint(100)
print(self.matrix)
return (self.matrix)
def model(df):
# tfidfconverter = TfidfVectorizer(max_features=1, min_df=1, max_df=0.7, stop_words=stopwords.words('english'))
# job_id = tfidfconverter.fit_transform(df["job_id"]).toarray()
df.drop(["job_id"],inplace=True,axis=1)
# [randint(1, 4) for i in range(0,df["file_size"].count())]
df.drop(["operation"],inplace=True,axis=1)
where_are_NaNs = np.isnan(df)
df[where_are_NaNs] = 592
df2= pd.DataFrame();
df2["file_size"]=[randint(500, 1000) for i in range(0,80)]
df2["output_size"]=[randint(5, 10000) for i in range(0,80)]
df2["file_size"]=[randint(400,1300) for i in range(0,80)]
df.append(df2,ignore_index=True)
pso_optimization(df)
y = df["output"]
df.drop(["output"],inplace=True,axis=1)
X =df;
names = ["Nearest Neighbors", "Linear SVM", "RBF SVM","Gaussian Process",
"Decision Tree", "Random Forest", "Neural Net", "AdaBoost",
"Naive Bayes"]
classifiers = [
KNeighborsClassifier(3),
SVC(kernel="linear", C=0.025),
SVC(gamma=2, C=1),
GaussianProcessClassifier(1.0 * RBF(1.0)),
DecisionTreeClassifier(max_depth=5),
RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1),
MLPClassifier(alpha=1, max_iter=1000),
AdaBoostClassifier(),
GaussianNB()
]
# Splitting the dataset into the Training set and Test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
sc = StandardScaler()
X_train = sc.fit_transform(X_train)
X_test = sc.transform(X_test)
print("##################Without PCA####################")
# iterate over classifiers
score=[]
time_withoutPCA = []
for name, clf in zip(names, classifiers):
start = time.clock()
clf.fit(X_train, y_train)
y_score=clf.score(X_test, y_test)
score.append(y_score)
time_withoutPCA.append(time.clock() - start)
# print("time_withoutPCA: ", time_withoutPCA)
print(name,y_score)
print("time_withoutPCA: ", time_withoutPCA)
plot_bar_x(names, score, titlle="Various Algorithm without PCA")
plot_bar_x_execution_time(names, time_withoutPCA, titlle="Excution time without PCA")
print("#################WITH PCA#########################")
#########PCA 1#############
# pca = PCA()
# X_train = pca.fit_transform(X_train)
# X_test = pca.transform(X_test)
##############PCA 2###########
pca = PCA(n_components=3)
X_train = pca.fit_transform(X_train)
X_test = pca.transform(X_test)
score_withPCA = []
time_withPCA=[]
for name, clf in zip(names, classifiers):
start=time.clock()
clf.fit(X_train, y_train)
y_hat= clf.predict(X_test)
y_score_pca=clf.score(X_test, y_test)
# plt.plot(list(y_hat),'ro',linewidth=7.0)
# plt.plot(list(y_test), 'g^', linewidth=7.0)
# plt.show()
score_withPCA.append(y_score_pca)
print(name,y_score_pca)
time_withPCA.append(time.clock() - start)
print("time_withPCA: ", time_withPCA)
plot_bar_x(names, score_withPCA, titlle="Various Algorithm with PCA")
plot_bar_x_execution_time(names, time_withPCA, titlle="Excution time with PCA")
def get_random_mover():
i = randint(0, 4)
movers = ['8', '9', '10', '11']
return movers[i]
def gibbs_sampling(self, alpha, n_iterations):
n_topics = self.n_topics
# initialize all counts to 0
n_d_t = [[0 for _ in range(n_topics)] for _ in range(len(self.corpus))]
n_t_w = {w: [0 for _ in range(n_topics)] for w in self.vocab}
# store intermediate values for estimating parameters
doc_sums = [float(len(d) + n_topics * alpha) for d in self.corpus]
topic_sums = [len(self.vocab) * alpha for _ in range(n_topics)]
word_topic_map = [[None for _ in d] for d in self.corpus]
# randomly assign topics to words, and set up initial counts
for di in range(len(self.corpus)):
d = self.corpus[di]
for wi in range(len(d)):
w = d[wi]
t = randint(0, n_topics)
word_topic_map[di][wi] = t
n_t_w[w][t] += 1
n_d_t[di][t] += 1
topic_sums[t] += 1
for i in range(n_iterations):
for di in range(len(self.corpus)):
pct_done = 100 * (i * len(self.corpus) + di) / float(len(self.corpus) * n_iterations)
print("Iteration %d/%d, Document %d/%d.... (%2.2f%%)" % \
(i, n_iterations, di, len(self.corpus), pct_done))
d = self.corpus[di]
for wi in range(len(d)):
w = d[wi]
# i. remove current word from counts
old_topic = word_topic_map[di][wi]
n_d_t[di][old_topic] -= 1
n_t_w[w][old_topic] -= 1
topic_sums[old_topic] -= 1
# ii. estimate probabilities using 5.6, 5.7
word_topic_probs = []
for t1 in range(n_topics):
p_t_d = (n_d_t[di][t1] + alpha) / doc_sums[di]
p_w_t = (n_t_w[w][t1] + alpha) / topic_sums[t1]
word_topic_probs.append(p_t_d * p_w_t)
s = float(sum(word_topic_probs))
word_topic_probs = [p/s for p in word_topic_probs]
# iii. assign w to a topic randomly
new_topic = choice(list(range(n_topics)), p=word_topic_probs)
word_topic_map[di][wi] = new_topic
# iv. increment counts accordingly
n_d_t[di][new_topic] += 1
n_t_w[w][new_topic] += 1
topic_sums[new_topic] += 1
# finalize parameters
for di in range(len(self.corpus)):
self.p_t_d.append([(n_d_t[di][t1] + alpha) / doc_sums[di] for t1 in range(n_topics)])
for w in self.vocab:
self.p_w_t[w] = [(n_t_w[w][t1] + alpha) / topic_sums[t1] for t1 in range(n_topics)]
# also store counts
self.n_t_w = n_t_w
def get_tile_code_for_buffer():
i = randint(0, len(SPAWN_CHANCE_LIST))
return str(SPAWN_CHANCE_LIST[i])
twentylstmaccdata = []
twentylstmstddata = []
twentylstmstderror = []
predictedBLLabels = []
predictedBRLabels = []
predictedBRLLabels = []
predictedBRRLabels = []
predictedBRPLabels = []
predictedRWLabels = []
print "1st Iteration, noiseless test data"
offset = 100
accuracyOverall = []
for testnumber in range(30):
start = randint(8000,9980)
x = tdnnclassifier.activate(BallLiftJoint[start:start+10].flatten())
predictedBLLabels.append(argmax(x))
start = randint(8000,9980)
x = tdnnclassifier.activate(BallRollJoint[start:start+10].flatten())
predictedBRLabels.append(argmax(x))
start = randint(8000,9980)
x = tdnnclassifier.activate(BellRingLJoint[start:start+10].flatten())
predictedBRLLabels.append(argmax(x))
start = randint(8000,9980)
x = tdnnclassifier.activate(BellRingRJoint[start:start+10].flatten())
predictedBRRLabels.append(argmax(x))
def spawn_tile():
return SPAWN_CHANCE_LIST[randint(0, len(SPAWN_CHANCE_LIST))]
def __init__(self, input=None, n_visible=784, n_hidden=500, no_bias=False, non_linearity="sigmoid"):
"""
Initialize the dA class by specifying the number of visible units (the
dimension d of the input ), the number of hidden units ( the dimension
d' of the latent or hidden space ) and the corruption level. The
constructor also receives symbolic variables for the input, weights and
bias. Such a symbolic variables are useful when, for example the input
is the result of some computations, or when weights are shared between
the dA and an MLP layer. When dealing with SdAs this always happens,
the dA on layer 2 gets as input the output of the dA on layer 1,
and the weights of the dA are used in the second stage of training
to construct an MLP.
:type input: theano.tensor.TensorType
:param input: a symbolic description of the input or None for
standalone dA
:type n_visible: int
:param n_visible: number of visible units
:type n_hidden: int
:param n_hidden: number of hidden units
:type continuous_corruption: bool
:param continuous_corruption: instead of just zeroing out randomly-chosen elements, scale all the
1-valued inputs randomly to floats chosen uniformly in the range (1-corruption_level) to 1.
"""
self.n_visible = n_visible
self.num_features = n_visible # Alias
self.n_hidden = n_hidden
self.non_linearity = non_linearity
if non_linearity == "sigmoid":
self.activation_fn = T.nnet.sigmoid
self.inverse_activation_fn = lambda x: T.log(x / (1-x))
elif non_linearity == "tanh":
self.activation_fn = T.tanh
self.inverse_activation_fn = T.arctanh
else:
raise ValueError("unkown non-linearity '%s'. Must be 'sigmoid' or 'tanh'" % non_linearity)
# create a Theano random generator that gives symbolic random values
theano_rng = RandomStreams(randint(2 ** 30))
# note : W' was written as `W_prime` and b' as `b_prime`
# W is initialized with `initial_W` which is uniformely sampled
# from -4*sqrt(6./(n_visible+n_hidden)) and
# 4*sqrt(6./(n_hidden+n_visible))the output of uniform if
# converted using asarray to dtype
# theano.config.floatX so that the code is runable on GPU
initial_W = numpy.asarray(
uniform(
low=-numpy.sqrt(6. / (n_hidden + n_visible)),
high=numpy.sqrt(6. / (n_hidden + n_visible)),
size=(n_visible, n_hidden),
),
dtype=theano.config.floatX
)
W = theano.shared(value=initial_W, name='W', borrow=True)
bvis = theano.shared(
value=numpy.zeros(
n_visible,
dtype=theano.config.floatX
),
borrow=True
)
bhid = theano.shared(
value=numpy.zeros(
n_hidden,
dtype=theano.config.floatX
),
name='b',
borrow=True
)
self.W = W
# b corresponds to the bias of the hidden
self.b = bhid
# b_prime corresponds to the bias of the visible
self.b_prime = bvis
# tied weights, therefore W_prime is W transpose
self.W_prime = self.W.T
self.theano_rng = theano_rng
# if no input is given, generate a variable representing the input
if input is None:
# we use a matrix because we expect a minibatch of several
# examples, each example being a row
self.x = T.dmatrix(name='input')
else:
self.x = input
self.x_as_int = T.cast(self.x, "int8")
if no_bias:
# Don't include a bias in the network
# The bias still features in the equations, but isn't include among the params, so doesn't get updated
# It therefore retains its initial values: 0
self.params = [self.W]
else:
self.params = [self.W, self.b, self.b_prime]
self.hidden_layer = self.get_hidden_values(self.x)
self._b_copy = None
self._b_prime_copy = None
self._hidden_fn = None
self._probs_fn = None
def can_spawn_crafting_chest():
return randint(0, CHUNK_SIZE * CHUNK_SIZE) < 5
import Queue
import unittest
from main.model.Game import Game
from main.model.Robot import Robot
import mock
from main.states.NearResistanceState import NearResistanceState
from main.states.NearLetterBoardState import NearLetterBoardState
from numpy.random.mtrand import randint
from main.model.Puck import Puck
RANDOM_COLOR_CODE = randint(0,9)
class NearLetterBoardStateTest(unittest.TestCase):
def setUp(self):
Robot.initHardwareDevices = mock.Mock(return_value="")
Robot.rotateToAngle = mock.Mock(return_value="")
Robot.findLetterInLetterBoard = mock.Mock(return_value="D")
Robot.setCamMiddle = mock.Mock(return_value="")
Robot.setCamUp = mock.Mock(return_value="")
NearResistanceState.fetchResistance = mock.Mock(return_value="")
self.robot = Robot(Queue.Queue())
self.aGame = Game(self.robot, Queue.Queue())
self.aGame.currentState = NearLetterBoardState(self.aGame)
self.aGame.listOfPucks = [Puck(RANDOM_COLOR_CODE), Puck(RANDOM_COLOR_CODE), Puck(RANDOM_COLOR_CODE)]
self.aGame.setPositionToReadInLetterBoard(2)
def test_whenGameDoAnActionStateGameStateShouldChangeAtTheEnd(self):
self.aGame.doAction()
self.assertTrue(self.aGame.getCurrentStateName() == "HasReadLetterBoardState")
def __init__(self, x=50, y=50, ttl=10):
self.x = x
self.y = y
self.lastUpdate = time.time() * 1000
self.endTime = time.time() * 1000 + (ttl * 1000)
self.color = (randint(255), randint(255), randint(255))
