def generate_random_objects(cls, count):
rand_1 = random.randint(140, size=count)
rand_2 = random.randint(140, size=count)
rand_3 = random.randint(1100000000, 1100999999, size=count)
rand_4 = random.randint(3, size=count)
user_pk = User.objects.latest('pk').pk + 1
generated_count = 0
for i in range(0, count):
first_name = first_names[rand_1.item(i)]
last_name = last_names[rand_2.item(i)]
student_id = rand_3.item(i)
grade_level = rand_4.item(i)
user = User.objects.create_user(
username=user_pk,
password=user_pk,
first_name=first_name,
last_name=last_name,
)
user_profile = UserProfile.objects.create(
user=user,
mobile='6787901506',
is_student=True,
)
student_profile= StudentProfile.objects.create(
user_profile=user_profile,
student_id = student_id,
grade_level=grade_level,
)
user_pk += 1
generated_count += 1
print('Generated StudentProfile %d (UserProfile %d User %d)' %(student_profile.pk, user_profile.pk, user.pk))
return generated_count
def setUp(self):
self.ntime = 2048
self.nfreq = 10
self.data = sp.zeros((self.ntime, 4, self.nfreq))
self.n_bins_cal = 64
# Set channel dependant gain.
self.level = 0.1*(self.nfreq + sp.arange(self.nfreq))
# Add noise.
self.data[:,:,:] += (0.1 * self.level
* rand.randn(self.ntime, 4, self.nfreq))
# Add DC level.
self.dc = 10 * self.level
self.data += self.dc
# First can transition.
self.first_trans = rand.randint(0, self.n_bins_cal // 2)
# The following randomly assigns self.neg to -1 or 1.
self.neg = 0
while not self.neg: self.neg = rand.randint(-1, 2)
# First upward edge:
if self.neg == 1:
self.offset = self.first_trans
else:
self.offset = self.first_trans + self.n_bins_cal // 2
self.data[:,0,:] += self.level
for ii in range(self.ntime//self.n_bins_cal) :
s = slice(self.first_trans + ii*self.n_bins_cal, self.first_trans +
(2*ii+1)*self.n_bins_cal//2)
self.data[s, 0, :] += self.neg * self.level
# Transition values and locations.
self.t_slice = slice(self.first_trans, sys.maxint, self.n_bins_cal//2)
self.t_vals = 0.5 + 0.1 * rand.randn(2*self.ntime//self.n_bins_cal,
self.nfreq)
self.t_vals *= - self.level
def pair_vectors(pairs, features, words, output_path):
vectorizer = DictVectorizer()
vectors = vectorizer.fit_transform(x[1] for x in features)
vector_map = {word:vector for word, vector in
itertools.izip((x[0].split('/')[0] for x in features),
vectors)}
# Positive examples
positive = []
record = []
for specific, general in pairs:
positive.append(vector_map[general] - vector_map[specific])
record.append( (specific, general, 1) )
pair_set = set([tuple(x) for x in pairs])
non_positive = []
for i in range(len(positive)):
first = second = None
while first == second or (first, second) in pair_set:
first = words[random.randint(len(words))]
second = words[random.randint(len(words))]
non_positive.append(vector_map[second] - vector_map[first])
record.append( (first, second, 0) )
data = vstack(positive + non_positive)
target = [1]*len(positive) + [0]*len(non_positive)
# Save dataset
with open(os.path.join(output_path,'wn-noun-dependencies.mat'), 'wb') as data_file:
dump_svmlight_file(data, target, data_file)
with open(os.path.join(output_path,'wn-noun-dependencies.json'), 'w') as record_file:
json.dump(record, record_file)
def __trim_borders(self, x, target):
y = x.reshape(3, 256, 256, x.shape[1])
if self.test: # don't need to loop over cases
if self.multiview:
start_positions = [(0,0), (0, self.border_size*2),
(self.border_size, self.border_size),
(self.border_size*2, 0), (self.border_size*2, self.border_size*2)]
end_positions = [(sy+self.inner_size, sx+self.inner_size) for (sy,sx) in start_positions]
for i in xrange(self.num_views/2):
pic = y[:,start_positions[i][0]:end_positions[i][0],start_positions[i][1]:end_positions[i][1],:]
target[:,i * x.shape[1]:(i+1)* x.shape[1]] = pic.reshape((self.get_data_dims(),x.shape[1]))
target[:,(self.num_views/2 + i) * x.shape[1]:(self.num_views/2 +i+1)* x.shape[1]] = pic[:,:,::-1,:].reshape((self.get_data_dims(),x.shape[1]))
else:
pic = y[:,self.border_size:self.border_size+self.inner_size,self.border_size:self.border_size+self.inner_size, :] # just take the center for now
target[:,:] = pic.reshape((self.get_data_dims(), x.shape[1]))
else:
for c in xrange(x.shape[1]): # loop over cases
#startY, startX = self.border_size, self.border_size
startY, startX = nr.randint(0,self.border_size*2 + 1), nr.randint(0,self.border_size*2 + 1)
endY, endX = startY + self.inner_size, startX + self.inner_size
pic = y[:,startY:endY,startX:endX, c]
if nr.randint(2) == 0: # also flip the image with 50% probability
pic = pic[:,:,::-1]
target[:,c] = pic.reshape((self.get_data_dims(),))
def read_new_file():
global Xtest, Ytest, Ysig2, target, X, Y, thetaArgs, theta, EI, yoffset, hyperprior
filename = filestem + str(rng.randint(10)) + '.txt'
print 'This is %s' % (filename)
data = np.loadtxt(filename)
Xtest = data[:,0:-1] # everything except the last column
target = data[:,-1] # just the last column
D = 1 # dimensionality of search space
yoffset = 0.0 # to keep track of shifts up and down to y-axis
initNumSamples = 2 # number of initial inputs
#xlo,xhi =0.01,4.0 # just the plotting boundary, not a real constrait :(
#Xtest = np.arange(xlo,xhi,(xhi-xlo)/100.0) # the inputs we'll keep track of.
d = len(np.ravel(Xtest))
Xtest = Xtest.reshape((d,1))
# take the initial samples
X = np.zeros((initNumSamples))
Y = np.zeros((initNumSamples,))
for s in range(initNumSamples):
i = rng.randint(0,d)
X[s] = Xtest[i]
Y[s] = target[i]
initX,initY = X,Y
# Here we initialise hyperparameters, and make initial predictions.
(init_theta, hyperprior) = gp.setAndSampleHyperprior(D) # initial hyperparams
thetaArgs = (X.reshape(len(X),1),Y,hyperprior) # fmin_cg needs these all in one box.
theta = fmin_cg(gp.calcNegLogPosterior,init_theta, gp.calcNegGradLogPosterior, [thetaArgs], gtol=1e-2,disp=0)
Ytest,Ysig2 = gp.calcGPPrediction(theta,thetaArgs,Xtest)
EI = calcEI(Ytest,Ysig2,np.max(Y))
def simula(N, n, PM, beta, pmig, grupos, listafitness, listafitness_m, mpvencer, x):
s = int(time.time() + random.randint(0, 2**32-1) + x) % (2**32-1)
random.seed(s)
s = int(time.time() + random.randint(0, 2**32-1) + x) % (2**32-1)
np.random.seed(s)
IT = 50002
#IT = 5002
precisao = 0.01
AL = []
AL.append(np.count_nonzero(grupos)/(N*n))
crit = 0. if AL[0] > (1.-precisao) else 1.
# Para cada periodo, os grupos entram em conflito e se reproduzem, e
# os individuos sofrem mutacao e migram entre os grupos
for it in xrange(1,IT):
if abs(AL[it-1]-crit)<precisao:
print "Acabou na geracao ", it -1
break
#
knums = [np.count_nonzero(line) for line in grupos]
glabels = conflito(N,knums,beta,listafitness_m, mpvencer) if N>1 \
else knums
grupos = reproducao_ind(N,n,listafitness,listafitness_m,glabels)
grupos = mutacao(N,n,PM,grupos)
grupos = migracao(N,n,grupos,pmig)
freqA = float(np.count_nonzero(grupos))/(N*n)
AL.append(freqA)
logger.debug("%d \t----------->\t %f" %(it,freqA))
return it-1
def test_boolean(self):
a = rand(3,5,8)
V = rand(5,8)
g1 = randint(0,5,size=15)
g2 = randint(0,8,size=15)
V[g1,g2] = -V[g1,g2]
assert (array([a[0][V>0],a[1][V>0],a[2][V>0]]) == a[:,V>0]).all()
def test_dot_mm_plus_equals(self, its=50):
for it in range(its):
size = random.choice([0, 1, randint(0, 10), randint(0, 100)])
a_bm = gen_BandMat(size)
b_bm = gen_BandMat(size)
c_bm = gen_BandMat(size)
diag = None if rand_bool() else randn(size)
diag_value = np.ones((size,)) if diag is None else diag
a_full = a_bm.full()
b_full = b_bm.full()
c_full = c_bm.full()
l = c_bm.l
u = c_bm.u
array_mem = get_array_mem(a_bm.data, b_bm.data, c_bm.data)
if diag is not None:
diag_mem = get_array_mem(diag)
bm.dot_mm_plus_equals(a_bm, b_bm, c_bm, diag=diag)
c_full += fl.band_ec(
l, u,
np.dot(np.dot(a_full, np.diag(diag_value)), b_full)
)
assert_allclose(c_bm.full(), c_full)
assert get_array_mem(a_bm.data, b_bm.data, c_bm.data) == array_mem
if diag is not None:
assert get_array_mem(diag) == diag_mem
def test_dot_mm_partial(self, its=50):
for it in range(its):
size = random.choice([0, 1, randint(0, 10), randint(0, 100)])
a_bm = gen_BandMat(size)
b_bm = gen_BandMat(size)
l = random.choice([0, 1, randint(0, 10)])
u = random.choice([0, 1, randint(0, 10)])
diag = None if rand_bool() else randn(size)
diag_value = np.ones((size,)) if diag is None else diag
a_full = a_bm.full()
b_full = b_bm.full()
c_bm = bm.dot_mm_partial(l, u, a_bm, b_bm, diag=diag)
c_full = fl.band_ec(
l, u,
np.dot(np.dot(a_full, np.diag(diag_value)), b_full)
)
assert c_bm.l == l
assert c_bm.u == u
assert c_bm.size == size
assert_allclose(c_bm.full(), c_full)
assert not np.may_share_memory(c_bm.data, a_bm.data)
assert not np.may_share_memory(c_bm.data, b_bm.data)
if diag is not None:
assert not np.may_share_memory(c_bm.data, diag)
def test_grouped_hist_layout(self):
import matplotlib.pyplot as plt
n = 100
df = DataFrame({'gender': np.array(['Male',
'Female'])[random.randint(2,
size=n)],
'height': random.normal(66, 4, size=n),
'weight': random.normal(161, 32, size=n),
'category': random.randint(4, size=n)})
self.assertRaises(ValueError, df.hist, column='weight', by=df.gender,
layout=(1, 1))
self.assertRaises(ValueError, df.hist, column='weight', by=df.gender,
layout=(1,))
self.assertRaises(ValueError, df.hist, column='height', by=df.category,
layout=(1, 3))
self.assertRaises(ValueError, df.hist, column='height', by=df.category,
layout=(2, 1))
self.assertEqual(df.hist(column='height', by=df.gender,
layout=(2, 1)).shape, (2,))
plt.close('all')
self.assertEqual(df.hist(column='height', by=df.category,
layout=(4, 1)).shape, (4,))
plt.close('all')
self.assertEqual(df.hist(column='height', by=df.category,
layout=(4, 2)).shape, (4, 2))
def load_cropped_images(imagepath, imgdim, cropped_mean_image, crop_dim, \
eigvalue, eigvector, sigma=0.1, test=False ):
"""
Please note that mean_image should be the cropped mean
"""
dimX = crop_dim[0] * crop_dim[1] * crop_dim[2]
ndata = len(imagepath)
pb = np.sqrt(eigvalue).reshape((1,-1)) * eigvector
a = np.dot(pb, rd.randn(3, len(imagepath))) * sigma
res = np.tile(-cropped_mean_image.reshape((dimX, 1),order='F'),[1, ndata])
nr, nc, dummy = np.floor((np.asarray(imgdim) - np.asarray(crop_dim))/2) + 1
sr_list = rd.randint(nr, size=ndata) if not test else [nr-1] * ndata
sc_list = rd.randint(nc, size=ndata) if not test else [nc-1] * ndata
if not test:
f = lambda curimg,r,c,i: curimg[r:r+crop_dim[0],c:c+crop_dim[1],:].reshape((dimX),order='F') + np.tile(a[...,i].reshape((1,3)),[1,dimX/3]).reshape((dimX),order='F')
else:
f = lambda curimg,r,c,i: curimg[r:r+crop_dim[0],c:c+crop_dim[1],:].reshape((dimX),order='F')
for i,p in enumerate(imagepath):
curimg = np.array(Image.open(p))
sr = sr_list[i]
sc = sc_list[i]
res[...,i] += f(curimg, sr,sc,i)
return sr_list, sc_list, res
def test_pandas_groupby_apply():
""" Test pandas.DataFrame.groupby(...).progress_apply """
try:
from numpy.random import randint
from tqdm import tqdm_pandas
import pandas as pd
except:
raise SkipTest
with closing(StringIO()) as our_file:
df = pd.DataFrame(randint(0, 50, (500, 3)))
dfs = pd.DataFrame(randint(0, 50, (500, 3)),
columns=list('abc'))
tqdm_pandas(tqdm(file=our_file, leave=False, ascii=True))
df.groupby(0).progress_apply(lambda x: None)
tqdm_pandas(tqdm(file=our_file, leave=False, ascii=True))
dfs.groupby(['a']).progress_apply(lambda x: None)
our_file.seek(0)
# don't expect final output since no `leave` and
# high dynamic `miniters`
nexres = '100%|##########|'
if nexres in our_file.read():
our_file.seek(0)
raise AssertionError("\nDid not expect:\n{0}\nIn:{1}\n".format(
nexres, our_file.read()))
def run_training_and_return_test_results():
print('START TRAINING_______________________________')
# initialize variables to random values
init = tf.initialize_all_variables()
sess.run(init)
# run optimizer on entire training data set many times
train_size = train_ins.shape[0]
for epoch in range(20000):
start = rng.randint(train_size-15)
batch_size = rng.randint(2,50)
end = min(train_size, start+batch_size)
sess.run(optimizer, feed_dict={x: train_ins[start:end], y_: train_outs[start:end]})#.reshape(1,-1).T})
# every 1000 iterations record progress
if (epoch+1)%1000== 0:
t,s, c = sess.run([ total_return, sharpe, costfn], feed_dict={x: train_ins, y_: train_outs})#.reshape(1,-1).T})
t = np.mean(t)
s = np.mean(s)
print("Epoch:", '%04d' % (epoch+1), "cost=",c, "total return=", "{:.9f}".format(t),
"sharpe=", "{:.9f}".format(s))
#print(t)
print('DONE TRAINING _______________________________')
d_tr, t_tr = sess.run([daily_returns, total_return], feed_dict={x: train_ins, y_: train_outs})
d_te, t_te = sess.run([daily_returns, total_return], feed_dict={x: test_ins, y_: test_outs})
t_tr = np.mean(t_tr)
t_te = np.mean(t_te)
print("total return train=", "{:.9f}".format(t_tr))
print("total return test=", "{:.9f}".format(t_te))
return t_tr, t_te
def opponent_rollout(self,solver, s):
acts = self.legal_actions(s)
if len(acts) > 0:
some_in_tree = False
best_in_tree = 100
best_action = 100
count = 0
for act in acts:
s_prime, reward = self.generative_model(s, act, 2)
if reward == -1.0:
return act
if solver.to_tuple(s_prime) in solver.tree:
count += 1
if solver.tree[solver.to_tuple(s_prime)][0] < best_in_tree:
best_in_tree = solver.tree[solver.to_tuple(s_prime)][0]
best_action = act
if count > 0:
if uniform(0,1) > count/len(acts):
return best_action
else:
return acts[randint(0, len(acts))]
else:
return acts[randint(0, len(acts))]
else:
return 'Draw'
def generate_multimask_test_data(num_masks, num_points, num_features):
# step 1: generate masks
found = set()
all_masks = []
for i in xrange(num_masks):
while True:
u, = randint(2, size=num_features).nonzero()
h = u.tostring()
if h not in found:
found.add(h)
all_masks.append(u)
break
assert len(all_masks)==num_masks
# step 2: generate data
fet = []
fmask = []
offsets = []
unmasked = []
n = 0
offsets = [n]
for i in xrange(num_points):
u = all_masks[randint(num_masks)]
fet.append(rand(len(u)))
fmask.append(0.5+0.5*rand(len(u)))
unmasked.append(u)
n += len(u)
offsets.append(n)
assert len(offsets)==num_points+1
fet = hstack(fet)
fmask = hstack(fmask)
unmasked = hstack(unmasked)
offsets = array(offsets)
return RawSparseData(full(num_features, 0.5), full(num_features, 1./12), # mean/var of rand()
fet, fmask, unmasked, offsets).to_sparse_data()
def write_exam(self,teacher,toughness_level):
for pupil in self.pupils:
# will this pupil try to betray and copy?
# let's decide random-influenced but probability-based
random_number=rand()
if random_number < pupil.honesty_level:
will_try_betrayal=False
else:
will_try_betrayal=True
if will_try_betrayal:
# copying from who? imagine random seating and choosing the better of two neighbours
# need to randomly sample two different ones from the list of pupils in the class
while True:
fellowA=self.pupils[randint(self.size)]
fellowB=self.pupils[randint(self.size)]
if not (fellowA is fellowB):
break
if fellowA.skill_level > fellowB.skill_level:
pupil.write_exam(copy_from_fellow=fellowA, exam_toughness=toughness_level)
else:
pupil.write_exam(copy_from_fellow=fellowB, exam_toughness=toughness_level)
if rand() < teacher.betrayal_check_probability:
betrayal_discovered=True
else:
betrayal_discovered=False
if betrayal_discovered:
# what happens then? grade becomes zero? or skill-level minus 3?
# discovery should lead to increased fear and honesty next time
raise NotImplementedError('This is up to you.')
else:
# what happens then? grade will be influenced by own and fellow's skill level
# no discovery should lead to decreased fear less honesty next time
raise NotImplementedError('This is up to you.')
else:
pupil.write_exam(exam_toughness=toughness_level)
def sample_patch_masks(obs_count, im_shape, patch_shape, patch_count=1):
"""
Sample a random patch mask for each image in X.
"""
rows = patch_shape[0]
cols = patch_shape[1]
min_row = 0
max_row = im_shape[0] - rows
if (max_row <= min_row):
off_row = np.zeros((obs_count, patch_count), dtype=np.int64)
else:
off_row = npr.randint(min_row, high=max_row,
size=(obs_count, patch_count))
min_col = 0
max_col = im_shape[1] - cols
if (max_col <= min_col):
off_col = np.zeros((obs_count, patch_count), dtype=np.int64)
else:
off_col = npr.randint(min_col, high=max_col,
size=(obs_count, patch_count))
dummy = np.zeros(im_shape)
mask = np.ones((obs_count, im_shape[0] * im_shape[1]))
for i in range(obs_count):
for j in range(patch_count):
# reset the dummy mask
dummy = (0. * dummy) + 1.
# select a random patch in the dummy mask
dummy[off_row[i, j]:(off_row[i, j] + rows), off_col[i, j]:(off_col[i, j] + cols)] = 0.
# turn off the patch in the final mask
mask[i, :] = mask[i, :] * dummy.ravel()
return mask.astype(theano.config.floatX)
def createPopulation(self, number, radius, fitness = None):
"""This method creates the agents and put them in the grid
"""
for i in range(number):
row = random.randint(self.rows)
column = random.randint(self.columns)
self.addAgent(Agent(row,column,radius, fitness))
def hc_only_explore_step(rl_config, Q, state, epsilon=0.9):
rid2rl_actions = rl_config.rl_actions
id2rl_state = rl_config.rl_state_ids
rl_state2id = {v: k for k, v in id2rl_state.items()}
act = -1
while (act == -1):
is_greed = rand(1) < epsilon
if is_greed:
idx = state.tolist() + [[x for x in range(len(rid2rl_actions.keys()))]]
act = np.argmax(Q[tuple(idx)])
val = np.max(Q[tuple(idx)])
if val <= 0.00000000001:
is_greed = False
if not is_greed:
if rand(1) < 0.9:
act = randint(0, 7)
else:
act = randint(7, len(rid2rl_actions.keys()))
(next_state, act, isFinished) = rl_config.transition_function(rl_config, state, act, Q)
reward = rl_config.reward_function(rl_config, state, act, next_state)
sarsa_state = np.concatenate((state, [act], [reward], next_state))
length = sarsa_state.shape[0]
sarsa_state = np.reshape(sarsa_state, (1,length))
return (next_state, sarsa_state, isFinished)
def __getVectorC(self, length):
# ensure at least 1/3 positive values
data = npr.randint(-10, 10, [length, 1])
posCount = np.ceil(length / 3)
data[:posCount, 0] = npr.randint(0, 10, posCount)
npr.shuffle(data)
return np.matrix(data)
def draw_sinusoid(img, thickness, radius, clearance, bgr_color):
"""
Draws a sinusoid primitive
Args:
img(:class:`numpy.ndarray(dtype=unit8)`): image to draw on
(OpenCV format)
thickness(int): line thickness
radius(float): approx size of the primitive
clearance(float): approx clearance from pic borders
"""
[b, g, r] = [int(x) for x in bgr_color]
h, w, _ = img.shape
x_center = randint(low=clearance, high=(w - 1) - clearance)
y_center = randint(low=0 + clearance, high=(h - 1) - clearance)
start_angle = uniform(low=0, high=2 * numpy.pi)
x_points = numpy.linspace(-pi / 2, pi / 2, 100)
points = [[x / (pi / 2), sin(4 * x)] for x in x_points]
points = warped_polyline(points, [x_center, y_center], start_angle, 40)
points = numpy.array(points, numpy.int32)
cv2.polylines(img, [points], False, [b, g, r], thickness=thickness)
def rand_word_pairs(phrase_list, pair_count, context_size):
"""Sample anchor/context LUT key pairs for skip-gram training.
Parameters:
phrase_list: list of lists/vectors of LUT keys representing phrases
pair_count: number of training pairs of LUT keys to sample
context_size: half-width of context window to sample positives from
NOTE: Samples are always drawn uniformly from within a context
window that was already clipped to fit the source phrase.
Outputs:
anchor_keys: vector of np.uint32 (samp_count,)
context_keys: vector of np.uint32 (samp_count,)
phrase_keys: vector of np.uint32 (samp_count,)
"""
phrase_count = len(phrase_list)
anchor_keys = np.zeros((pair_count,), dtype=np.uint32)
context_keys = np.zeros((pair_count,), dtype=np.uint32)
phrase_keys = np.zeros((pair_count,), dtype=np.uint32)
for i in range(pair_count):
phrase_keys[i] = npr.randint(0, phrase_count)
phrase = phrase_list[phrase_keys[i]]
phrase_len = len(phrase)
a_idx = npr.randint(0, phrase_len)
c_max = min((a_idx+context_size+1), phrase_len)
c_min = max((a_idx-context_size), 0)
c_idx = a_idx
while (c_idx == a_idx):
c_idx = npr.randint(c_min, c_max)
anchor_keys[i] = phrase[a_idx]
context_keys[i] = phrase[c_idx]
anchor_keys = anchor_keys.astype(np.uint32)
context_keys = context_keys.astype(np.uint32)
phrase_keys = phrase_keys.astype(np.uint32)
return [anchor_keys, context_keys, phrase_keys]
def bootstrap(y_true, probs):
"""
bootstrap: bootstrap the training data, mainly used to increase volume of hard negative examples for training
parameters:
y_true: ground truth of training data
probs: predictions of the model
"""
global neg_pool
neg_pool_size = len(neg_pool)
hard_size = int(neg_pool_size * hard_ratio)
easy_size = neg_pool_size - hard_size
neg_idcs = np.arange(len(y_true))[y_true.sum(axis = 1) == 0]
sort_idcs = np.argsort(probs[neg_idcs, :].max(axis = 1))
hard_idcs = bootstrap_idcs[neg_idcs[sort_idcs[-hard_size:]]]
if easy_mode == 'random':
easy_idcs = bootstrap_idcs[neg_idcs[nr.randint(0, len(neg_idcs), (easy_size,))]]
elif easy_mode == 'easy':
easy_idcs = neg_pool[:easy_size]
elif easy_mode == 'all':
easy_idcs = neg_pool[nr.randint(0, len(neg_pool), (easy_size,))]
else:
sys.exit('Wrong easy mode')
neg_pool = np.concatenate([easy_idcs, hard_idcs])
def initSim(N, n, A, c, alpha):
#grupos = np.zeros((N,n))
#grupos = inicializa(N,n,A,grupos) if A<(N*n) else np.ones((N,n))
if A == N*n:
knums = [n]*N
else:
if A < n*N/2:
knums = [0]*N
for i in xrange(A):
sorteio = random.randint(0,N-1)
while(knums[sorteio]==n-1):
sorteio = random.randint(0,N-1)
knums[sorteio] += 1
else:
knums = [n]*N
for i in xrange(N*n-A):
sorteio = random.randint(0,N-1)
while(knums[sorteio]==0):
sorteio = random.randint(0,N-1)
knums[sorteio] -= 1
#grupos_com_A = [random.randint(0,N-1) for i in xrange(A)]
#contagem = Counter(grupos_com_A)
#knums = [contagem.get(k, 0) for k in xrange(N)]
listafitness = cria_listaf(c,n)
listafitness_m = cria_listafm(c,n)
mpvencer = matriz_vencedores(alpha, n)
#return grupos, listafitness, listafitness_m, mpvencer
return knums, listafitness, listafitness_m, mpvencer
def run(N, K, S):
random.seed(S)
seed(S)
s = ""
for i in range(K):
s += choice("abcdefghijklmnopqrstuvwxyz")
Q = randint(1, N+1)
trip = {}
curr = 1
for i in s:
if (curr, i) in trip:
curr = trip[(curr, i)]
else:
dest = randint(1, N+1)
trip[(curr, i)] = dest
curr = dest
M = randint(K, MAXM+1)
tent = 0
while tent < 100 and len(trip) != M:
curr = randint(1, N+1)
c = choice("abcdefghijklmnopqrstuvwxyz")
if (curr, c) not in trip:
dest = randint(1, N+1)
trip[(curr, c)] = dest
else:
tent += 1
print len(trip), N, K
for i in s:
print i,
print
for i in trip:
print i[0], trip[i], i[1]
def bootstrap_test(sample1, sample2, k = 1000, p_value = 0.05, two_tailed = True):
"""
Test the null hypothesis that the two samples are independent from each other
thanks to pearson coefficients.
Note that we keep nan values during the resampling (and eliminate them to compute
the pearson coefficient).
Remember: if True, the coefficient is NOT significant.
"""
# eliminate all entries which have a nan in one of the sample.
sample1_bis, sample2_bis = zip(*[zz for zz in zip(sample1, sample2) if not np.isnan(zz[0]) and not np.isnan(zz[1])])
r_sample = pearsonr(sample1_bis, sample2_bis)[0]
sample1_bis = np.array(sample1_bis)
sample2_bis = np.array(sample2_bis)
n = len(sample1_bis)
try:
assert n == len(sample2_bis)
except:
Exception("Samples must have same sizes.")
r_resample = np.zeros(k)
for i in xrange(k):
s1_rand = sample1_bis[randint(0, n, n)] # Resampling with the same size
s2_rand = sample2_bis[randint(0, n, n)]
s1_rand_bis, s2_rand_bis = zip(*[zz for zz in zip(s1_rand, s2_rand) if not np.isnan(zz[0]) and not np.isnan(zz[1])])
r_resample[i] = pearsonr(s1_rand_bis, s2_rand_bis)[0]
ci = np.percentile(r_resample, [p_value/2., 1.-p_value/2.])
#print "Percentiles:", ci
return ci[0]<r_sample<ci[1]
def gen_BandMat_simple(size):
"""Generates a random BandMat."""
l = random.choice([0, 1, randint(0, 10)])
u = random.choice([0, 1, randint(0, 10)])
data = randn(l + u + 1, size)
transposed = rand_bool()
return bm.BandMat(l, u, data, transposed=transposed)
def rand_word_seqs(phrase_list, seq_count, seq_len, null_key):
"""Sample LUT key n-grams from a list of phrases.
Given a list of phrases, where each phrase is described by a list of
keys into a look-up-table, sample random n-grams of keys from the
sequences, where n is given by seq_len. The sampled n-grams are only
constrained to have their final item inside the source phrase. When any
of the first n-1 items in a sampled sequence are not in the source phrase,
they are assigned the key given by null_key.
"""
phrase_count = len(phrase_list)
seq_keys = np.zeros((seq_count, seq_len), dtype=np.uint32)
phrase_keys = np.zeros((seq_count,), dtype=np.uint32)
for i in range(seq_count):
phrase_keys[i] = npr.randint(0, phrase_count)
phrase = phrase_list[phrase_keys[i]]
phrase_len = len(phrase)
final_key = npr.randint(0, phrase_len)
seq_keys[i,-1] = phrase[final_key]
for j in range(seq_len-1):
preceding_key = final_key - seq_len + j + 1
if (preceding_key < 0):
seq_keys[i,j] = null_key
else:
seq_keys[i,j] = phrase[preceding_key]
seq_keys = seq_keys.astype(np.uint32)
phrase_keys = phrase_keys.astype(np.uint32)
return [seq_keys, phrase_keys]
def wrd():
import datetime
from numpy import random as random
return datetime.datetime(random.randint(1970, 2014),
random.randint(1, 10),
random.randint(1, 20))
def randintbasic(TEprobmat,amax,banvalue): #selection of jp: jp is a random node L=len(TEprobmat[banvalue,:]) v=npr.randint(L) while v==banvalue: v=npr.randint(L) return v
def generate_varchar(length):
return ''.join(chr(num) for num in randint(32, 128, length))
col_types = {
'bool', 'tinyint', 'smallint', 'int', 'bigint', 'real', 'double', 'date',
'datetime', 'varchar({})'.format(varchar_length),
'nvarchar({})'.format(varchar_length)
}
pos_test_vals = {
'bool': (0, 1, True, False, 2, 3.6, 'test', (1997, 5, 9), (1997, 12, 12,
10, 10, 10)),
'tinyint': (randint(0, 255), randint(0, 255), 0, 255, True, False),
'smallint': (randint(-32768, 32767), 0, -32768, 32767, True, False),
'int': (randint(-2147483648,
2147483647), 0, -2147483648, 2147483647, True, False),
'bigint':
(randint(1 - max_bigint,
max_bigint), 0, 1 - max_bigint, max_bigint, True, False),
'real': (float('inf'), float('-inf'), float('+0'), float('-0'),
round(uniform(1e-6, 1e6),
5), 837326.52428, True, False), # float('nan')
'double': (float('inf'), float('-inf'), float('+0'), float('-0'),
uniform(1e-6, 1e6), True, False), # float('nan')
'date': (date(1998, 9, 24), date(2020, 12, 1), date(1997, 5,
9), date(1993, 7, 13)),
'datetime':
(datetime(1001, 1, 1, 10, 10, 10), datetime(1997, 11, 30, 10, 10, 10),
def seek_key(self):
self.private = randint(0, self.p-1) # 秘密鍵
self.public = self.r ** self.private # 公開鍵
def main():
li = [
10, 25, 50, 100, 150, 200, 250, 300, 350, 400, 450, 500, 1000, 1500,
2000, 2500, 3000
]
x = np.array(li)
y = np.zeros((6, x.shape[0]))
for i, s in enumerate(li):
print '\n'
print "n = {}".format(s**2)
print '---------------------------'
a = np.asfortranarray(randint(0, 10, size=(s, s)), dtype='d')
#Conversion using copy from int64 to float64
#Dot should ensure positive semi-definite
data = np.dot(a, a.T)
del a
#Numpy Cholesky Decomposition (Dense Matrix)
spd_matrix = data.copy()
t1 = time.time()
np_chol = cholesky(spd_matrix)
t2 = time.time()
print "Numpy Implementation took {} seconds".format(t2 - t1)
y[0][i] = t2 - t1
if s <= 200:
#Naive
spd_matrix = data.copy()
t1 = time.time()
out = naivechol(spd_matrix)
t2 = time.time()
np.testing.assert_allclose(out, np_chol, rtol=1e-07)
print "Naive implementation took {} seconds".format(t2 - t1)
y[1][i] = t2 - t1
else:
y[1][i] = np.nan
#Cython
spd_matrix = data.copy()
t1 = time.time()
out = cython_implementation(spd_matrix)
t2 = time.time()
#np.testing.assert_allclose(out, np_chol, rtol=1e-07)
print "Cython implementation took {} seconds".format(t2 - t1)
y[2][i] = t2 - t1
if s <= 500:
#Vectorized
spd_matrix = data.copy()
t1 = time.time()
out = vectorizedchol(spd_matrix)
t2 = time.time()
#np.testing.assert_allclose(out, np_chol, rtol=1e-07)
print "Vectorized implementation took {} seconds".format(t2 - t1)
y[3][i] = t2 - t1
else:
y[3][i] = np.nan
if s <= 500:
#Mixed Naive / Cython
spd_matrix = data.copy()
t1 = time.time()
out = mixedcython(spd_matrix)
t2 = time.time()
np.testing.assert_allclose(out, np_chol, rtol=1e-07)
print "Mixed Cython/Python implementation took {} seconds".format(
t2 - t1)
y[4][i] = t2 - t1
else:
y[4][i] = np.nan
if s <= 500:
#new cholesky
spd_matrix = data.copy()
t1 = time.time()
out = purepythoncholesky(spd_matrix)
t2 = time.time()
print "Pure Python Cholesky implementation took {} seconds".format(
t2 - t1)
y[5][i] = t2 - t1
else:
y[5][i] = np.nan
#plot
labels = ['NP', 'Naive', 'Cython', 'Vect', 'Mixed C/P']
for i in range(y.shape[0]):
plt.plot(x, y[i], label=labels[i])
plt.show()
passed_particles21 = 0 #particles which passed 0th site lattice 2 -> lattice 1
passed_particles22 = 0 #particles which passed 0th site lattice 2 -> lattice 2
current11 = 0
current12 = 0
current21 = 0
current22 = 0
densities1 = np.zeros(
N) #average occupation density for each site in lattice 1
densities2 = np.zeros(
N) #average occupation density for each site in lattice 2
L1, L2 = init_positions_particles1(N, int(M[mm]))
for i in range(steps):
for j in range(2 * N):
site = rd.randint(0, 2 * N)
update(site)
#cutoff (steady state) period
if i == steady_state: #we start measuring from 0
passed_particles11 = 0
passed_particles12 = 0
passed_particles21 = 0
passed_particles22 = 0
#update site densities
if i >= steady_state:
l1 = L1 > 0 #remove ones and twos -> boolean
l1 = l1.astype(int) #make them integers
l2 = L2 > 0 #remove ones and twos -> boolean
l2 = l2.astype(int) #make them integers
def detect(save_img=False):
out, source, weights, view_img, save_txt, imgsz, save_csv = \
opt.output, opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size, opt.save_csv
webcam = source == '0' or source.startswith('rtsp') or source.startswith(
'http') or source.endswith('.txt')
# Initialize
device = select_device(opt.device)
# if os.path.exists(out):
# shutil.rmtree(out) # delete output folder
# os.makedirs(out) # make new output folder
half = device.type != 'cpu' # half precision only supported on CUDA
# Load model
model = attempt_load(weights, map_location=device) # load FP32 model
imgsz = check_img_size(imgsz, s=model.stride.max()) # check img_size
if half:
model.half() # to FP16
# Second-stage classifier
classify = False
if classify:
modelc = load_classifier(name='resnet101', n=2) # initialize
modelc.load_state_dict(
torch.load('weights/resnet101.pt',
map_location=device)['model']) # load weights
modelc.to(device).eval()
# Set Dataloader
vid_path, vid_writer = None, None
if webcam:
view_img = True
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz)
else:
save_img = True
dataset = LoadImages(source, img_size=imgsz)
# Get names and colors
names = model.module.names if hasattr(model, 'module') else model.names
colors = [[random.randint(0, 255) for _ in range(3)]
for _ in range(len(names))]
# csv output
csv_output = []
# Run inference
t0 = time.time()
img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img
_ = model(img.half() if half else img
) if device.type != 'cpu' else None # run once
for path, img, im0s, vid_cap in dataset:
img = torch.from_numpy(img).to(device)
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
if img.ndimension() == 3:
img = img.unsqueeze(0)
# Inference
t1 = time_synchronized()
pred = model(img, augment=opt.augment)[0]
# Apply NMS
pred = non_max_suppression(pred,
opt.conf_thres,
opt.iou_thres,
classes=opt.classes,
agnostic=opt.agnostic_nms)
t2 = time_synchronized()
# Apply Classifier
if classify:
pred = apply_classifier(pred, modelc, img, im0s)
# Process detections
for i, det in enumerate(pred): # detections per image
if webcam: # batch_size >= 1
p, s, im0 = path[i], '%g: ' % i, im0s[i].copy()
else:
p, s, im0 = path, '', im0s
save_path = str(Path(out) / Path(p).name)
txt_path = str(Path(out) / Path(p).stem) + (
'_%g' % dataset.frame if dataset.mode == 'video' else '')
s += '%gx%g ' % img.shape[2:] # print string
gn = torch.tensor(im0.shape)[[1, 0, 1,
0]] # normalization gain whwh
if det is not None and len(det):
# Rescale boxes from img_size to im0 size
det[:, :4] = scale_coords(img.shape[2:], det[:, :4],
im0.shape).round()
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += '%g %ss, ' % (n, names[int(c)]) # add to string
# Write results
for *xyxy, conf, cls in det:
if save_txt: # Write to file
with open(txt_path + '.txt', 'a') as f:
xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) /
gn).view(-1).tolist() # normalized xywh
f.write(('%g ' * 5 + '\n') %
(cls, *xywh)) # label format
if save_csv: # csv output append
xyxyNormalized = (torch.tensor(xyxy) / gn).tolist()
csv_output.append([
Path(p).name,
int(cls),
float(conf), *xyxyNormalized
])
if save_img or view_img: # Add bbox to image
# label = '%s' % (names[int(cls)])
label = '%s %.2f' % (names[int(cls)], conf)
# plot_one_box(xyxy, im0, label=label, color=colors[int(cls)], line_thickness=2)
plot_one_box(xyxy,
im0,
label=label,
color=colors[int(cls)])
# Print time (inference + NMS)
print('%sDone. (%.3fs)' % (s, t2 - t1))
# Stream results
if view_img:
cv2.imshow(p, im0)
if cv2.waitKey(1) == ord('q'): # q to quit
raise StopIteration
# Save results (image with detections)
if save_img:
if dataset.mode == 'images':
cv2.imwrite(save_path, im0)
else:
if vid_path != save_path: # new video
vid_path = save_path
if isinstance(vid_writer, cv2.VideoWriter):
vid_writer.release(
) # release previous video writer
fourcc = 'mp4v' # output video codec
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
vid_writer = cv2.VideoWriter(
save_path, cv2.VideoWriter_fourcc(*fourcc), fps,
(w, h))
vid_writer.write(im0)
# write csv output
if save_csv:
current_time = datetime.datetime.now(
pytz.timezone('Asia/Seoul')).strftime('%Y-%m-%d-%H-%M')
with open(
f'/DL_data_big/AI_factory_dataset/tracking_recognition/ai_factory_tracking/dataset/yolo_output/output_{current_time}.csv',
'w',
newline='') as f:
f_writer = csv.writer(f)
f_writer.writerow([
'ImageID', 'LabelName', 'Conf', 'XMin', 'XMax', 'YMin', 'YMax'
])
f_writer.writerows(csv_output)
print("csv saved")
if save_txt or save_img:
print('Results saved to %s' % Path(out))
if platform == 'darwin' and not opt.update: # MacOS
os.system('open ' + save_path)
print('Done. (%.3fs)' % (time.time() - t0))
def randomizeTexture(texture, level=1):
'''
Set the values for a texture from parameters.
param: texture - bpy.data.texture to modify.
level - designated tweaked settings to use
-> Below 10 is a displacement texture
-> Between 10 and 20 is a base material texture
'''
noises = [
'BLENDER_ORIGINAL', 'ORIGINAL_PERLIN', 'IMPROVED_PERLIN', 'VORONOI_F1',
'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4', 'VORONOI_F2_F1',
'VORONOI_CRACKLE'
]
if texture.type == 'CLOUDS':
if randint(0, 1) == 0:
texture.noise_type = 'SOFT_NOISE'
else:
texture.noise_type = 'HARD_NOISE'
if level != 11:
tempInt = randint(0, 6)
else:
tempInt = randint(0, 8)
texture.noise_basis = noises[tempInt]
texture.noise_depth = 8
if level == 0:
texture.noise_scale = gauss(0.625, 1 / 24)
elif level == 2:
texture.noise_scale = 0.15
elif level == 11:
texture.noise_scale = gauss(0.5, 1 / 24)
if texture.noise_basis in [
'BLENDER_ORIGINAL', 'ORIGINAL_PERLIN', 'IMPROVED_PERLIN',
'VORONOI_F1'
]:
texture.intensity = gauss(1, 1 / 6)
texture.contrast = gauss(4, 1 / 3)
elif texture.noise_basis in [
'VORONOI_F2', 'VORONOI_F3', 'VORONOI_F4'
]:
texture.intensity = gauss(0.25, 1 / 12)
texture.contrast = gauss(2, 1 / 6)
elif texture.noise_basis == 'VORONOI_F2_F1':
texture.intensity = gauss(0.5, 1 / 6)
texture.contrast = gauss(2, 1 / 6)
elif texture.noise_basis == 'VORONOI_CRACKLE':
texture.intensity = gauss(0.5, 1 / 6)
texture.contrast = gauss(2, 1 / 6)
elif texture.type == 'MUSGRAVE':
# musgraveType = ['MULTIFRACTAL', 'RIDGED_MULTIFRACTAL',
# 'HYBRID_MULTIFRACTAL', 'FBM', 'HETERO_TERRAIN']
texture.musgrave_type = 'MULTIFRACTAL'
texture.dimension_max = abs(gauss(0, 0.6)) + 0.2
texture.lacunarity = beta(3, 8) * 8.2 + 1.8
if level == 0:
texture.noise_scale = gauss(0.625, 1 / 24)
texture.noise_intensity = 0.2
texture.octaves = 1.0
elif level == 2:
texture.intensity = gauss(1, 1 / 6)
texture.contrast = 0.2
texture.noise_scale = 0.15
texture.octaves = 8.0
elif level == 10:
texture.intensity = gauss(0.25, 1 / 12)
texture.contrast = gauss(1.5, 1 / 6)
texture.noise_scale = 0.5
texture.octaves = 8.0
elif level == 12:
texture.octaves = uniform(1, 3)
elif level > 12:
texture.octaves = uniform(2, 8)
else:
texture.intensity = gauss(1, 1 / 6)
texture.contrast = 0.2
texture.octaves = 8.0
elif texture.type == 'DISTORTED_NOISE':
tempInt = randint(0, 8)
texture.noise_distortion = noises[tempInt]
tempInt = randint(0, 8)
texture.noise_basis = noises[tempInt]
texture.distortion = skewedGauss(2.0, 2.6666, (0.0, 10.0), False)
if level == 0:
texture.noise_scale = gauss(0.625, 1 / 24)
elif level == 2:
texture.noise_scale = 0.15
elif level >= 12:
texture.noise_scale = gauss(0.2, 1 / 48)
elif texture.type == 'STUCCI':
stucciTypes = ['PLASTIC', 'WALL_IN', 'WALL_OUT']
if randint(0, 1) == 0:
texture.noise_type = 'SOFT_NOISE'
else:
texture.noise_type = 'HARD_NOISE'
tempInt = randint(0, 2)
texture.stucci_type = stucciTypes[tempInt]
if level == 0:
tempInt = randint(0, 6)
texture.noise_basis = noises[tempInt]
texture.noise_scale = gauss(0.625, 1 / 24)
elif level == 2:
tempInt = randint(0, 6)
texture.noise_basis = noises[tempInt]
texture.noise_scale = 0.15
elif level >= 12:
tempInt = randint(0, 6)
texture.noise_basis = noises[tempInt]
texture.noise_scale = gauss(0.2, 1 / 30)
else:
tempInt = randint(0, 6)
texture.noise_basis = noises[tempInt]
elif texture.type == 'VORONOI':
metrics = [
'DISTANCE', 'DISTANCE_SQUARED', 'MANHATTAN', 'CHEBYCHEV',
'MINKOVSKY_HALF', 'MINKOVSKY_FOUR', 'MINKOVSKY'
]
# Settings for first dispalcement level:
if level == 0:
tempInt = randint(0, 1)
texture.distance_metric = metrics[tempInt]
texture.noise_scale = gauss(0.625, 1 / 24)
texture.contrast = 0.5
texture.intensity = 0.7
elif level == 2:
texture.noise_scale = 0.15
tempInt = randint(0, 6)
texture.distance_metric = metrics[tempInt]
elif level >= 12:
tempInt = randint(0, 1)
texture.distance_metric = metrics[tempInt]
texture.noise_scale = gauss(0.125, 1 / 48)
texture.contrast = 0.5
texture.intensity = 0.7
else:
tempInt = randint(0, 6)
texture.distance_metric = metrics[tempInt]
return
def generate_varchar(length):
return ''.join(chr(num) for num in randint(32, 128, length))
def __call__(self, image, boxes=None, labels=None):
if random.randint(2):
alpha = random.uniform(self.lower, self.upper)
image *= alpha
return image, boxes, labels
def __call__(self, image, boxes=None, labels=None):
if random.randint(2):
image[:, :, 0] += random.uniform(-self.delta, self.delta)
image[:, :, 0][image[:, :, 0] > 360.0] -= 360.0
image[:, :, 0][image[:, :, 0] < 0.0] += 360.0
return image, boxes, labels
def __call__(self, image, boxes=None, labels=None):
if random.randint(2):
delta = random.uniform(-self.delta, self.delta)
image += delta
return image, boxes, labels
def generateObject(context, muX, sigmaX, scaleX, upperSkewX, muY, sigmaY,
scaleY, upperSkewY, muZ, sigmaZ, scaleZ, upperSkewZ, base,
shift, scaleDisplace, scale_fac):
x = []
y = []
z = []
shape = randint(0, 11)
# Cube
# Use parameters to re-scale cube:
# Reversed if/for nesting. Should be a little faster.
if shape == 0:
for j in range(8):
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif shape == 1:
for j in range(8):
if j in [0, 1, 3, 4]:
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif j in [2, 5]:
if sigmaX == 0:
x.append(0)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 4)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif j in [6, 7]:
if sigmaX == 0:
x.append(0)
else:
x.append(skewedGauss(0, sigmaX, scaleX, upperSkewX) / 4)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 4)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif shape == 2:
for j in range(8):
if j in [0, 2, 5, 7]:
if sigmaX == 0:
x.append(scaleX[0] / 4)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 4)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 4)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 4)
elif j in [1, 3, 4, 6]:
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif shape == 3:
for j in range(8):
if j > 0:
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
else:
if sigmaX == 0:
x.append(0)
else:
x.append(skewedGauss(0, sigmaX, scaleX, upperSkewX) / 8)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 8)
if sigmaZ == 0:
z.append(0)
else:
z.append(skewedGauss(0, sigmaZ, scaleZ, upperSkewZ) / 8)
elif shape == 4:
for j in range(10):
if j in [0, 9]:
if sigmaX == 0:
x.append(0)
else:
x.append(skewedGauss(0, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif j in [1, 2, 3, 4]:
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif j in [5, 7]:
if sigmaX == 0:
x.append(0)
else:
x.append(skewedGauss(0, sigmaX, scaleX, upperSkewX) / 3)
if sigmaY == 0:
y.append(scaleY[0] / 3)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 3)
if sigmaZ == 0:
z.append(0)
else:
z.append(skewedGauss(0, sigmaZ, scaleZ, upperSkewZ) / 6)
elif j in [6, 8]:
if sigmaX == 0:
x.append(scaleX[0] / 3)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 3)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 3)
if sigmaZ == 0:
z.append(0)
else:
z.append(skewedGauss(0, sigmaZ, scaleZ, upperSkewZ) / 6)
elif shape == 5:
for j in range(10):
if j == 0:
if sigmaX == 0:
x.append(0)
else:
x.append(skewedGauss(0, sigmaX, scaleX, upperSkewX) / 8)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 8)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif j in [1, 2]:
if sigmaX == 0:
x.append(scaleZ[0] * .125)
else:
x.append(
skewedGauss(muX, sigmaX, scaleX, upperSkewX) * 0.125)
if sigmaY == 0:
y.append(scaleZ[0] * 0.2165)
else:
y.append(
skewedGauss(muY, sigmaY, scaleY, upperSkewY) * 0.2165)
if sigmaZ == 0:
z.append(0)
else:
z.append(skewedGauss(0, sigmaZ, scaleZ, upperSkewZ) / 4)
elif j == 3:
if sigmaX == 0:
x.append(scaleX[0] / 4)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 4)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 4)
if sigmaZ == 0:
z.append(0)
else:
z.append(skewedGauss(0, sigmaZ, scaleZ, upperSkewZ) / 4)
elif j in [4, 6]:
if sigmaX == 0:
x.append(scaleX[0] * 0.25)
else:
x.append(
skewedGauss(muX, sigmaX, scaleX, upperSkewX) * 0.25)
if sigmaY == 0:
y.append(scaleY[0] * 0.433)
else:
y.append(
skewedGauss(muY, sigmaY, scaleY, upperSkewY) * 0.433)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif j == 5:
if sigmaX == 0:
x.append(scaleX[0] / 4)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 4)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif j in [7, 9]:
if sigmaX == 0:
x.append(scaleX[0] * 0.10825)
else:
x.append(
skewedGauss(muX, sigmaX, scaleX, upperSkewX) * 0.10825)
if sigmaY == 0:
y.append(scaleY[0] * 0.2165)
else:
y.append(
skewedGauss(muY, sigmaY, scaleY, upperSkewY) * 0.2165)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif j == 8:
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 4)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif shape == 6:
for j in range(7):
if j > 0:
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
else:
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif shape == 7:
for j in range(10):
if j in [1, 3, 4, 5, 8, 9]:
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
else:
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(0)
else:
y.append(skewedGauss(0, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif shape == 8:
for j in range(7):
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif shape == 9:
for j in range(8):
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif shape == 10:
for j in range(7):
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
elif shape == 11:
for j in range(7):
if sigmaX == 0:
x.append(scaleX[0] / 2)
else:
x.append(skewedGauss(muX, sigmaX, scaleX, upperSkewX) / 2)
if sigmaY == 0:
y.append(scaleY[0] / 2)
else:
y.append(skewedGauss(muY, sigmaY, scaleY, upperSkewY) / 2)
if sigmaZ == 0:
z.append(scaleZ[0] / 2)
else:
z.append(skewedGauss(muZ, sigmaZ, scaleZ, upperSkewZ) / 2)
# This is for scaling the displacement textures.
# Scale the vertices so that their average is equal to 1 * scale factor.
if scaleDisplace:
averageX = (sum(x) / len(x)) * scale_fac[0]
for i in range(len(x)):
x[i] /= averageX
averageY = (sum(y) / len(y)) * scale_fac[1]
for i in range(len(y)):
y[i] /= averageY
averageZ = (sum(z) / len(z)) * scale_fac[2]
for i in range(len(z)):
z[i] /= averageZ
# Build vertex and face arrays:
if shape == 1:
verts = [(-x[0], -y[0], -z[0]), (x[1], -y[1], -z[1]),
(x[2], -y[2], z[2]), (-x[3], y[3], -z[3]),
(x[4], y[4], -z[4]), (x[5], y[5], z[5]), (x[6], y[6], z[6]),
(x[7], y[7], -z[7])]
faces = [[0, 1, 2], [0, 1, 7], [3, 0, 7], [3, 4, 7], [1, 4, 7],
[3, 4, 5], [1, 2, 6], [1, 4, 6], [4, 5, 6], [0, 2, 6],
[0, 3, 6], [3, 5, 6]]
elif shape == 2:
verts = [(-x[0], y[0], -z[0]), (x[1], -y[1], -z[1]),
(x[2], y[2], -z[2]), (-x[3], y[3], -z[3]),
(-x[4], -y[4], z[4]), (x[5], y[5], z[5]), (x[6], y[6], z[6]),
(-x[7], y[7], z[7])]
faces = [[0, 1, 2], [0, 2, 3], [0, 3, 7], [0, 7, 4], [1, 4, 5],
[0, 1, 4], [5, 1, 2], [5, 2, 6], [3, 2, 6], [3, 6, 7],
[5, 4, 7], [5, 6, 7]]
elif shape == 3:
verts = [(x[0], y[0], z[0]), (x[1], -y[1], -z[1]), (x[2], y[2], -z[2]),
(-x[3], y[3], -z[3]), (x[4], -y[4], z[4]), (x[5], y[5], z[5]),
(-x[6], y[6], z[6]), (-x[7], -y[7], z[7])]
faces = [[0, 1, 2], [0, 2, 3], [0, 3, 6], [0, 6, 7], [0, 7, 4],
[0, 4, 1], [5, 4, 1, 2], [5, 6, 3, 2], [5, 4, 7, 6]]
elif shape == 4:
verts = [(x[0], y[0], z[0]), (x[1], -y[1], -z[1]), (x[2], y[2], -z[2]),
(-x[3], y[3], -z[3]), (-x[4], -y[4], -z[4]),
(x[5], -y[5], -z[5]), (x[6], y[6], -z[6]),
(x[7], y[7], -z[7]), (-x[8], y[8], -z[8]),
(x[9], y[9], -z[9])]
faces = [[0, 1, 6], [0, 6, 2], [0, 2, 7], [0, 7, 3], [0, 3, 8],
[0, 8, 4], [0, 4, 5], [0, 5, 1], [1, 9, 2], [2, 9, 3],
[3, 9, 4], [4, 9, 1], [1, 6, 2], [2, 7, 3], [3, 8, 4],
[4, 5, 1]]
elif shape == 5:
verts = [(x[0], y[0], z[0]), (x[1], -y[1], z[1]), (x[2], y[2], z[2]),
(-x[3], y[3], z[3]), (x[4], -y[4], -z[4]),
(x[5], y[5], -z[5]), (x[6], y[6], -z[6]),
(-x[7], y[7], -z[7]), (-x[8], y[8], -z[8]),
(-x[9], -y[9], -z[9])]
faces = [[0, 1, 2], [0, 2, 3], [0, 3, 1], [1, 4, 5], [1, 5, 2],
[2, 5, 6], [2, 6, 7], [2, 7, 3], [3, 7, 8], [3, 8, 9],
[3, 9, 1], [1, 9, 4], [4, 5, 9], [5, 6, 7], [7, 8, 9],
[9, 5, 7]]
elif shape == 6:
verts = [(x[0], y[0], z[0]), (x[1], -y[1], -z[1]), (x[2], y[2], -z[2]),
(-x[3], y[3], -z[3]), (-x[4], y[4], z[4]),
(-x[5], -y[5], z[5]), (-x[6], -y[6], -z[6])]
faces = [[0, 1, 2], [0, 2, 3, 4], [0, 1, 6, 5], [0, 4, 5],
[1, 2, 3, 6], [3, 4, 5, 6]]
elif shape == 7:
verts = [(x[0], y[0], z[0]), (x[1], -y[1], -z[1]), (x[2], y[2], -z[2]),
(x[3], y[3], -z[3]), (-x[4], y[4], -z[4]),
(-x[5], y[5], z[5]), (-x[6], y[6], z[6]),
(-x[7], y[7], -z[7]), (-x[8], -y[8], -z[8]),
(-x[9], -y[9], z[9])]
faces = [[0, 1, 2], [0, 2, 3], [0, 5, 6], [0, 6, 9], [0, 1, 8, 9],
[0, 3, 4, 5], [1, 2, 7, 8], [2, 3, 4, 7], [4, 5, 6, 7],
[6, 7, 8, 9]]
elif shape == 8:
verts = [(x[0], y[0], z[0]), (x[1], -y[1], -z[1]), (x[2], y[2], -z[2]),
(-x[3], y[3], -z[3]), (-x[4], -y[4], -z[4]),
(-x[5], -y[5], z[5]), (-x[6], y[6], z[6])]
faces = [[0, 2, 1], [0, 1, 4], [0, 4, 5], [0, 5, 6], [0, 6, 3, 2],
[2, 1, 4, 3], [3, 6, 5, 4]]
elif shape == 9:
verts = [(-x[0], -y[0], -z[0]), (-x[1], y[1], -z[1]),
(-x[2], y[2], z[2]), (-x[3], -y[3], z[3]),
(x[4], -y[4], -z[4]), (x[5], y[5], -z[5]), (x[6], y[6], z[6]),
(x[7], -y[7], z[7])]
faces = [[0, 1, 6, 2], [1, 5, 7, 6], [5, 4, 3, 7], [4, 0, 2, 3],
[0, 1, 5, 4], [3, 2, 6, 7]]
elif shape == 10:
verts = [(-x[0], -y[0], -z[0]), (-x[1], y[1], -z[1]),
(-x[2], y[2], z[2]), (x[3], -y[3], z[3]), (x[4], y[4], z[4]),
(x[5], y[5], -z[5]), (x[6], -y[6], -z[6])]
faces = [[0, 2, 3], [0, 3, 6], [0, 1, 5, 6], [2, 3, 4], [0, 1, 2],
[1, 2, 4, 5], [3, 4, 5, 6]]
elif shape == 11:
verts = [(-x[0], -y[0], -z[0]), (-x[1], y[1], -z[1]),
(-x[2], y[2], z[2]), (x[3], -y[3], z[3]), (x[4], y[4], z[4]),
(x[5], y[5], -z[5]), (x[6], -y[6], -z[6])]
faces = [[0, 2, 3], [0, 3, 6], [0, 1, 5, 6], [2, 3, 4], [5, 6, 3],
[1, 5, 3, 4], [0, 1, 4, 2]]
else:
verts = [(-x[0], -y[0], -z[0]), (-x[1], y[1], -z[1]),
(-x[2], -y[2], z[2]), (-x[3], y[3], z[3]),
(x[4], -y[4], -z[4]), (x[5], y[5], -z[5]),
(x[6], -y[6], z[6]), (x[7], y[7], z[7])]
faces = [[0, 1, 3, 2], [0, 1, 5, 4], [0, 4, 6, 2], [7, 5, 4, 6],
[7, 3, 2, 6], [7, 5, 1, 3]]
# name = "Rock." + str(base + shift).zfill(3)
name = "rock"
# Make object:
obj = createMeshObject(context, verts, [], faces, name)
if scaleDisplace:
# bpy.data.objects[name].scale = Vector((averageX, averageY, averageZ))
obj.scale = Vector((averageX, averageY, averageZ))
# For a slight speed bump / Readability:
# mesh = bpy.data.meshes[name]
mesh = obj.data
# Apply creasing:
if shape == 0:
for i in range(12):
# todo: "0.375 / 3"? WTF? That = 0.125. . . .
# *** Completed 7/15/2011: Changed second one ***
mesh.edges[i].crease = gauss(0.125, 0.125)
elif shape == 1:
for i in [0, 2]:
mesh.edges[i].crease = gauss(0.5, 0.125)
for i in [6, 9, 11, 12]:
mesh.edges[i].crease = gauss(0.25, 0.05)
for i in [5, 7, 15, 16]:
mesh.edges[i].crease = gauss(0.125, 0.025)
elif shape == 2:
for i in range(18):
mesh.edges[i].crease = gauss(0.125, 0.025)
elif shape == 3:
for i in [0, 1, 6, 10, 13]:
mesh.edges[i].crease = gauss(0.25, 0.05)
mesh.edges[8].crease = gauss(0.5, 0.125)
elif shape == 4:
for i in [5, 6, 7, 10, 14, 16, 19, 21]:
mesh.edges[i].crease = gauss(0.5, 0.125)
elif shape == 7:
for i in range(18):
if i in [0, 1, 2, 3, 6, 7, 8, 9, 13, 16]:
mesh.edges[i].crease = gauss(0.5, 0.125)
elif i in [11, 17]:
mesh.edges[i].crease = gauss(0.25, 0.05)
else:
mesh.edges[i].crease = gauss(0.125, 0.025)
elif shape == 8:
for i in range(12):
if i in [0, 3, 8, 9, 10]:
mesh.edges[i].crease = gauss(0.5, 0.125)
elif i == 11:
mesh.edges[i].crease = gauss(0.25, 0.05)
else:
mesh.edges[i].crease = gauss(0.125, 0.025)
elif shape == 9:
for i in range(12):
if i in [0, 3, 4, 11]:
mesh.edges[i].crease = gauss(0.5, 0.125)
else:
mesh.edges[i].crease = gauss(0.25, 0.05)
elif shape == 10:
for i in range(12):
if i in [0, 2, 3, 4, 8, 11]:
mesh.edges[i].crease = gauss(0.5, 0.125)
elif i in [1, 5, 7]:
mesh.edges[i].crease = gauss(0.25, 0.05)
else:
mesh.edges[i].crease = gauss(0.125, 0.025)
elif shape == 11:
for i in range(11):
if i in [1, 2, 3, 4, 8, 11]:
mesh.edges[i].crease = gauss(0.25, 0.05)
else:
mesh.edges[i].crease = gauss(0.125, 0.025)
return obj
def __call__(self, image, boxes=None, labels=None):
if random.randint(2):
swap = self.perms[random.randint(len(self.perms))]
shuffle = SwapChannels(swap) # shuffle channels
image = shuffle(image)
return image, boxes, labels
'''
from numpy import random
def moyenne(tab):
s=0
for x in tab:
s+=x
return s/len(tab)
def variance(tab):
m=moyenne(tab)
s=0
for x in tab:
s+=(x-m)**2
return s/len(tab)
def var(tab):
s=0;
ss=0;
for x in tab:
s+=x
ss+=x**2
n=len(tab)
return ss/n-(s/n)**2
tab=random.randint(1,100,20)
print(tab)
print(moyenne(tab))
print(variance(tab))
print(var(tab))
def __call__(self, image, boxes=None, labels=None):
if random.randint(2):
image[:, :, 1] *= random.uniform(self.lower, self.upper)
return image, boxes, labels
def __init__(self,
n_in,
n_rec,
tau=20.,
thr=0.03,
dt=1.,
n_refractory=0,
dtype=tf.float32,
n_delay=1,
rewiring_connectivity=-1,
in_neuron_sign=None,
rec_neuron_sign=None,
dampening_factor=0.3,
injected_noise_current=0.,
V0=1.):
"""
Tensorflow cell object that simulates a LIF neuron with an approximation of the spike derivatives.
:param n_in: number of input neurons
:param n_rec: number of recurrent neurons
:param tau: membrane time constant
:param thr: threshold voltage
:param dt: time step of the simulation
:param n_refractory: number of refractory time steps
:param dtype: data type of the cell tensors
:param n_delay: number of synaptic delay, the delay range goes from 1 to n_delay time steps
:param reset: method of resetting membrane potential after spike thr-> by fixed threshold amount, zero-> to zero
"""
if np.isscalar(tau): tau = tf.ones(n_rec, dtype=dtype) * np.mean(tau)
if np.isscalar(thr): thr = tf.ones(n_rec, dtype=dtype) * np.mean(thr)
tau = tf.cast(tau, dtype=dtype)
dt = tf.cast(dt, dtype=dtype)
self.dampening_factor = dampening_factor
# Parameters
self.n_delay = n_delay
self.n_refractory = n_refractory
self.dt = dt
self.n_in = n_in
self.n_rec = n_rec
self.data_type = dtype
self._num_units = self.n_rec
self.tau = tf.Variable(tau, dtype=dtype, name="Tau", trainable=False)
self._decay = tf.exp(-dt / tau)
self.thr = tf.Variable(thr,
dtype=dtype,
name="Threshold",
trainable=False)
self.V0 = V0
self.injected_noise_current = injected_noise_current
self.rewiring_connectivity = rewiring_connectivity
self.in_neuron_sign = in_neuron_sign
self.rec_neuron_sign = rec_neuron_sign
with tf.variable_scope('InputWeights'):
# Input weights
if 0 < rewiring_connectivity < 1:
self.w_in_val, self.w_in_sign, self.w_in_var, _ = weight_sampler(
n_in,
n_rec,
rewiring_connectivity,
neuron_sign=in_neuron_sign)
else:
self.w_in_var = tf.Variable(rd.randn(n_in, n_rec) /
np.sqrt(n_in),
dtype=dtype,
name="InputWeight")
self.w_in_val = self.w_in_var
self.w_in_val = self.V0 * self.w_in_val
self.w_in_delay = tf.Variable(rd.randint(
self.n_delay, size=n_in * n_rec).reshape(n_in, n_rec),
dtype=tf.int64,
name="InDelays",
trainable=False)
self.W_in = weight_matrix_with_delay_dimension(
self.w_in_val, self.w_in_delay, self.n_delay)
with tf.variable_scope('RecWeights'):
if 0 < rewiring_connectivity < 1:
self.w_rec_val, self.w_rec_sign, self.w_rec_var, _ = weight_sampler(
n_rec,
n_rec,
rewiring_connectivity,
neuron_sign=rec_neuron_sign)
else:
if rec_neuron_sign is not None or in_neuron_sign is not None:
raise NotImplementedError(
'Neuron sign requested but this is only implemented with rewiring'
)
self.w_rec_var = Variable(rd.randn(n_rec, n_rec) /
np.sqrt(n_rec),
dtype=dtype,
name='RecurrentWeight')
self.w_rec_val = self.w_rec_var
recurrent_disconnect_mask = np.diag(np.ones(n_rec, dtype=bool))
self.w_rec_val = self.w_rec_val * self.V0
self.w_rec_val = tf.where(recurrent_disconnect_mask,
tf.zeros_like(self.w_rec_val),
self.w_rec_val) # Disconnect autotapse
self.w_rec_delay = tf.Variable(rd.randint(
self.n_delay, size=n_rec * n_rec).reshape(n_rec, n_rec),
dtype=tf.int64,
name="RecDelays",
trainable=False)
self.W_rec = weight_matrix_with_delay_dimension(
self.w_rec_val, self.w_rec_delay, self.n_delay)
def get_minibatch(roidb, num_classes):
"""Given a roidb, construct a minibatch sampled from it."""
num_images = len(roidb)
# Sample random scales to use for each image in this batch
random_scale_inds = npr.randint(0, high=len(cfg.TRAIN.SCALES),
size=num_images)
assert(cfg.TRAIN.BATCH_SIZE % num_images == 0), \
'num_images ({}) must divide BATCH_SIZE ({})'. \
format(num_images, cfg.TRAIN.BATCH_SIZE)
rois_per_image = cfg.TRAIN.BATCH_SIZE / num_images
fg_rois_per_image = np.round(cfg.TRAIN.FG_FRACTION * rois_per_image).astype(np.int)
# Get the input image blob, formatted for caffe
im_blob, im_scales = _get_image_blob(roidb, random_scale_inds)
blobs = {'data': im_blob}
if cfg.TRAIN.HAS_RPN:
assert len(im_scales) == 1, "Single batch only"
assert len(roidb) == 1, "Single batch only"
# gt boxes: (x1, y1, x2, y2, cls)
gt_inds = np.where(roidb[0]['gt_classes'] != 0)[0]
gt_boxes = np.empty((len(gt_inds), 5), dtype=np.float32)
gt_boxes[:, 0:4] = roidb[0]['boxes'][gt_inds, :] * im_scales[0]
gt_boxes[:, 4] = roidb[0]['gt_classes'][gt_inds]
blobs['gt_boxes'] = gt_boxes
blobs['im_info'] = np.array(
[[im_blob.shape[2], im_blob.shape[3], im_scales[0]]],
dtype=np.float32)
else: # not using RPN
# Now, build the region of interest and label blobs
rois_blob = np.zeros((0, 5), dtype=np.float32)
labels_blob = np.zeros((0), dtype=np.float32)
bbox_targets_blob = np.zeros((0, 4 * num_classes), dtype=np.float32)
bbox_inside_blob = np.zeros(bbox_targets_blob.shape, dtype=np.float32)
# all_overlaps = []
for im_i in xrange(num_images):
labels, overlaps, im_rois, bbox_targets, bbox_inside_weights \
= _sample_rois(roidb[im_i], fg_rois_per_image, rois_per_image,
num_classes)
# Add to RoIs blob
rois = _project_im_rois(im_rois, im_scales[im_i])
batch_ind = im_i * np.ones((rois.shape[0], 1))
rois_blob_this_image = np.hstack((batch_ind, rois))
rois_blob = np.vstack((rois_blob, rois_blob_this_image))
# Add to labels, bbox targets, and bbox loss blobs
labels_blob = np.hstack((labels_blob, labels))
bbox_targets_blob = np.vstack((bbox_targets_blob, bbox_targets))
bbox_inside_blob = np.vstack((bbox_inside_blob, bbox_inside_weights))
# all_overlaps = np.hstack((all_overlaps, overlaps))
# For debug visualizations
# _vis_minibatch(im_blob, rois_blob, labels_blob, all_overlaps)
blobs['rois'] = rois_blob
blobs['labels'] = labels_blob
if cfg.TRAIN.BBOX_REG:
blobs['bbox_targets'] = bbox_targets_blob
blobs['bbox_inside_weights'] = bbox_inside_blob
blobs['bbox_outside_weights'] = \
np.array(bbox_inside_blob > 0).astype(np.float32)
return blobs
def detect(opt):
source, weights, view_img, save_txt, imgsz = opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size
save_img = not opt.nosave and not source.endswith(
'.txt') # save inference images
webcam = source.isnumeric() or source.endswith(
'.txt') or source.lower().startswith(
('rtsp://', 'rtmp://', 'http://', 'https://'))
# Directories
save_dir = increment_path(Path(opt.project) / opt.name,
exist_ok=opt.exist_ok) # increment run
(save_dir / 'labels' if save_txt else save_dir).mkdir(
parents=True, exist_ok=True) # make dir
# Initialize
set_logging()
device = select_device(opt.device)
half = device.type != 'cpu' # half precision only supported on CUDA
# Load model
model = attempt_load(weights, map_location=device) # load FP32 model
stride = int(model.stride.max()) # model stride
imgsz = check_img_size(imgsz, s=stride) # check img_size
if half:
model.half() # to FP16
# Second-stage classifier
classify = False
if classify:
modelc = load_classifier(name='resnet101', n=2) # initialize
modelc.load_state_dict(
torch.load('weights/resnet101.pt',
map_location=device)['model']).to(device).eval()
# Set Dataloader
vid_path, vid_writer = None, None
if webcam:
view_img = check_imshow()
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz, stride=stride)
else:
dataset = LoadImages(source, img_size=imgsz, stride=stride)
# Get names and colors
names = model.module.names if hasattr(model, 'module') else model.names
colors = [[random.randint(0, 255) for _ in range(3)] for _ in names]
# Run inference
if device.type != 'cpu':
model(
torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(
next(model.parameters()))) # run once
t0 = time.time()
for path, img, im0s, vid_cap in dataset:
img = torch.from_numpy(img).to(device)
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
if img.ndimension() == 3:
img = img.unsqueeze(0)
# Inference
t1 = time_synchronized()
pred = model(img, augment=opt.augment)[0]
# Apply NMS
pred = non_max_suppression(pred,
opt.conf_thres,
opt.iou_thres,
classes=opt.classes,
agnostic=opt.agnostic_nms)
t2 = time_synchronized()
# Apply Classifier
if classify:
pred = apply_classifier(pred, modelc, img, im0s)
# Process detections
for i, det in enumerate(pred): # detections per image
if webcam: # batch_size >= 1
p, s, im0, frame = path[i], '%g: ' % i, im0s[i].copy(
), dataset.count
else:
p, s, im0, frame = path, '', im0s.copy(), getattr(
dataset, 'frame', 0)
p = Path(p) # to Path
save_path = str(save_dir / p.name) # img.jpg
txt_path = str(save_dir / 'labels' / p.stem) + (
'' if dataset.mode == 'image' else f'_{frame}') # img.txt
s += '%gx%g ' % img.shape[2:] # print string
gn = torch.tensor(im0.shape)[[1, 0, 1,
0]] # normalization gain whwh
if len(det):
# Rescale boxes from img_size to im0 size
det[:, :4] = scale_coords(img.shape[2:], det[:, :4],
im0.shape).round()
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += f"{n} {names[int(c)]}{'s' * (n > 1)}, " # add to string
# Write results
for *xyxy, conf, cls in reversed(det):
if save_txt: # Write to file
xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) /
gn).view(-1).tolist() # normalized xywh
line = (cls, *xywh, conf) if opt.save_conf else (
cls, *xywh) # label format
with open(txt_path + '.txt', 'a') as f:
f.write(('%g ' * len(line)).rstrip() % line + '\n')
if save_img or opt.save_crop or view_img: # Add bbox to image
c = int(cls) # integer class
label = None if opt.hide_labels else (
names[c]
if opt.hide_conf else f'{names[c]} {conf:.2f}')
plot_one_box(xyxy,
im0,
label=label,
color=colors[c],
line_thickness=opt.line_thickness)
if opt.save_crop:
save_one_box(xyxy,
im0s,
file=save_dir / 'crops' / names[c] /
f'{p.stem}.jpg',
BGR=True)
# Print time (inference + NMS)
print(f'{s}Done. ({t2 - t1:.3f}s)')
# Stream results
if view_img:
cv2.imshow(str(p), im0)
cv2.waitKey(1) # 1 millisecond
# Save results (image with detections)
if save_img:
if dataset.mode == 'image':
cv2.imwrite(save_path, im0)
else: # 'video' or 'stream'
if vid_path != save_path: # new video
vid_path = save_path
if isinstance(vid_writer, cv2.VideoWriter):
vid_writer.release(
) # release previous video writer
if vid_cap: # video
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
else: # stream
fps, w, h = 30, im0.shape[1], im0.shape[0]
save_path += '.mp4'
vid_writer = cv2.VideoWriter(
save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps,
(w, h))
vid_writer.write(im0)
if save_txt or save_img:
s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
print(f"Results saved to {save_dir}{s}")
print(f'Done. ({time.time() - t0:.3f}s)')
if i == 0: # Correção para o primeiro spin
ve[i] = L-1
vd[i] = i+1 # Vizinho à direita
if i == L-1: # Correção para o último spin
vd[i] = 0
# Definimos uma função para calcular a energia de uma configuração
def Energia(s):
soma = 0.0
for i in range(L):
soma += -J*s[i]*s[vd[i]] -B*s[i]
return soma
# Simulação. Definimos uma função para implementar um único passo
# de Monte Carlo. Buscamos coletar médias apenas após a equilibração.
s = 1-2*random.randint(2, size=L) # Estados iniciais aleatórios dos spins
def passo_MC(s,boltz): # Função que implementa um passo de Monte Carlo
z = random.rand(L) # Sorteamos L números aleatórios
# Damos a cada spin a chance de mudar de estado, mas aqui fazemos
# isso aleatoriamente para minimizar correlações entre mudanças.
for i in random.permutation(L):
bf = boltz[s[i],s[ve[i]] + s[vd[i]]]
if z[i] < bf or (bf == boltz[s[i],0] and z[i]<0.5):# Mudança foi aceita?
s[i] = -s[i] # Registramos a mudança
return s
for iT in range(nT):
E_plot = []
T = T_lista[iT]
print("Simulando à temperatura T=",T)
def select(data, num):
return data[random.randint(0, data.shape[0], num)]
def download_page_disease(department_code, page_num=1, try_num=3):
#获取下载页面的编号
code_page = '\\'.join([department_code, str(page_num)])
#读取缓存
html_text = read_page_cache(code_page)
#如果没有缓存，则下载该网页并缓存
if not html_text:
#设定 post 内容
request_payload = {
"departmentCode": department_code,
"icd10code": "",
"pageNo": page_num,
"pageSize": "50",
"recordFlag": "record",
"searchText": "",
"symptomsWords": ""
}
#print (request_payload)
#如果还有下载次数
if try_num:
#设定访问主页链接
target_url = 'http://ccdas.ipmph.com/rwDisease/getRwDiseaseList'
#设置 用户代理
random_header = get_request_headers()
#设置 IP代理
random_proxy = get_ip_proxy()
#print (random_header, '\t', random_proxy)
#下载之前，暂停
sleep_time = random.randint(5, 10)
print('Sleep {}s .. Downloading {}'.format(sleep_time, code_page))
sleep(sleep_time)
#下载
try:
html_res = requests.request(method='POST',
url=target_url,
headers=random_header,
proxies=random_proxy,
json=request_payload)
#print (html_res)
except Exception as err:
print('Download {} Error: {}'.format(code_page, err))
print('The Rest Download Number is {} ..'.format(try_num - 1))
return (download_page_disease(department_code, page_num,
try_num - 1))
else:
#将下载的网页保存
if html_res:
html_text = html_res.text
save_page_cache(html_text, code_page)
#print (html_text)
#print_to_json(html_text, 'test_post_1.txt')
else:
#如果下载次数用完，则不再下载，返回 None
print('Download Number is 0 ! {} Return None'.format(code_page))
html_text = None
else:
#再次缓存该文件
save_page_cache(html_text, code_page)
#返回 总页数
if page_num == 1:
try:
html_json = json.loads(html_text)
except:
return (None)
else:
#print (html_json['result']['totlePage'])
return (html_json['result']['totlePage'])
def __init__(self, rare, iClass=None, iName=None):
self.Rarity = rare
# Pick the part to Augment
if iClass is not None and iClass in self.Slots:
self.Class = iClass
else:
self.Class = choice(self.Slots)
m_name, m_info = self.__choose_material()
if self.Class == 'Arm' and randint(4) == 1:
self.Slot_Special = Firearm(self.Rarity)
self.Name = self.Slot_Special.Name + " Arm"
elif self.Class == 'Arm':
self.Slot_Special = Weapon(self.Rarity,
iClass=choice(
list(possible_melee.keys())))
self.Name = self.Slot_Special.Name + " Arm"
elif self.Class == 'Leg':
nam = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13][self.Rarity:self.Rarity + 9]
self.Slot_Special = str(
choice([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
][self.Rarity:self.Rarity + 9],
p=[
0.360000001, 0.252839506, 0.169382716, 0.106666667,
0.061728395, 0.031604938, 0.013333333, 0.003950617,
0.000493827
]) * 10)
self.Slot_Special = '+' + self.Slot_Special + ' Base Movement Speed'
self.Name = m_name + ' Legs'
elif self.Class == 'Eye':
self.Slot_Special = str(
choice([3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
][self.Rarity:self.Rarity + 9],
p=[
0.360000001, 0.252839506, 0.169382716, 0.106666667,
0.061728395, 0.031604938, 0.013333333, 0.003950617,
0.000493827
]) * 10) + " "
self.Name = m_name + ' Optical Implant'
if self.Rarity < 2:
self.Slot_Special += ' ft. Darkvision'
elif self.Rarity < 4:
self.Slot_Special += ' ft. Thermal'
elif self.Rarity == 4:
self.Slot_Special = str(eval(self.Slot_Special) - 40)
self.Slot_Special += ' ft. True Sight'
elif self.Class == 'Nose':
self.Slot_Special = ""
elif self.Class == 'Brain':
num = str(
choice([1, 1, 2, 2, 3, 4, 5, 6, 7, 8, 9, 9,
9][self.Rarity:self.Rarity + 9],
p=[
0.360000001, 0.252839506, 0.169382716, 0.106666667,
0.061728395, 0.031604938, 0.013333333, 0.003950617,
0.000493827
]))
self.Slot_Special = "+" + num + " " + choice(
['STR', 'DEX', 'CON', 'INT', 'WIS', 'CHA'])
self.Name = m_name + " " + self.Class + " Implant"
elif self.Class == 'Chest':
self.Slot_Special = Armor(self.Rarity, iName="")
self.Name = self.Slot_Special.Name + " Natural Armor"
# Are there potential Add-ins?
self.__add_ins()
# Change name if necessary
if iName is not None:
self.Name = iName
l = []
for k in xrange(2,maxK + 1):
l.append([])
dN = np.power(2,k-1)
print k
for i in xrange(numNBINS):
l[k-2].append([])
nMin = 1 + i*dN
nMax = 1 + (1 + i)*dN
bins = []
for x in xrange(numHBINS):
bins.append([[],[]])
for j in xrange(NUMTRIALS/numNBINS):
N = random.randint(nMin, nMax)
vnum = random.randint(0, models[k-2].shape[0])
verse = models[k-2][vnum].tolist()[0]
obs = get_obs(verse, N, k)
h = entropy(obs, k)
bins[np.int(0.999999*h/HbinWidth)][0].append(obs)
bins[np.int(0.999999*h/HbinWidth)][1].append(vnum)
for x in xrange(numHBINS):
mbins = [np.asmatrix(bins[x][0]),np.asarray(bins[x][1])]
l[k-2][i].append(mbins)
#Finally pickling the result for later use
f = open("obs.pkl", "wb")
cPickle.dump(l, f)
f.close()
def simulate(ntrials, region, T, printonswap=False, printbrackets=True):
"""
If region is "west" "midwest" "south" or "east" we'll run a bracket based
just on those teams.
If it's "all" we'll run a full bracket.
If it's a list of teams, we'll run a bracket based just on that list.
So, one way you might want to do things is to simulate 10000 runs for each
of the four brackets,
then run your final four explicitly, e.g.
T = 1.5
simulate(10000,'midwest',T)
# record results
simulate(10000,'south',T)
# record results
simulate(10000,'west',T)
# record results
simulate(10000,'east',T)
# record results
simulate(10000,['Louisville','Kansas','Wisconsin','Indiana'],T)
"""
if type(region) in (type([]), type(())):
teams = region[:]
else:
teams = _teams.teams[region]
b = Bracket(teams, T)
energy = b.energy()
ng = sum(b.games_in_rounds) # total number of games
# Let's collect some statistics
brackets = []
for trial in range(ntrials):
g = randint(0, ng) # choose a random game to swap
#print "attempted swap for game",g#,"in round",round[g]
#newbracket = deepcopy(b)
newbracket = b.copy()
newbracket.swap(g)
newenergy = newbracket.energy()
ediff = newenergy - energy
if ediff <= 0:
b = newbracket
energy = newenergy
if printonswap:
print("LOWER")
print(b)
else:
if random() < exp(-ediff / T):
b = newbracket
energy = newenergy
if printonswap:
print("HIGHER")
print(b)
brackets.append(b)
lb, mcb, mcb_count, unique_brackets, lowest_sightings = \
Stats.gather_uniquestats(brackets)
sr = SimulationResults(brackets, unique_brackets, lb, lowest_sightings,
mcb, mcb_count)
if printbrackets:
print("Lowest energy bracket")
print(lb)
print("Most common bracket (%s)" % mcb_count)
print(mcb)
return sr
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
select wd40s with repeats 6n,7n,8n
"""
from wdsp import Wdsp
import numpy as np
from numpy.random import randint
with open('wd648_uniprot_select_cd-hit_90_7.wdsp') as wdsp_f:
wdsp = Wdsp(wdsp_f)
pro_num = len(wdsp.pros)
for i in range(100):
with open('random_' + str(i) + '.fa', 'w') as w_f:
for j in range(2):
pro = wdsp.pros[randint(0, pro_num)]
seq = wdsp.seqs[pro]
print >> w_f, '> ', pro
for s in [seq[i:i + 80] for i in range(0, len(seq), 80)]:
print >> w_f, s
# ## Task 2: Implement a simple reflex agent
#
# The simple reflex agent randomly walks around but reacts to the bumper sensor by not bumping into the wall and to dirt with sucking.
# In[1426]:
createSquares()
#for some reason, between task1 and task2, all squares were being initialized to clean (isDirty = False)
#even though I instantiate a new environment and even though numDirty is not zero
#this for loop takes numDirty and reallocates which squares are dirty just to take care of this problem
#not my favorite way to solve this problem, but it solves the problem
for x in range(numDirty):
i = random.randint(0,n-1)
j = random.randint(0, n-1)
#if the random square is already dirty, find random indexes until find a clean square
while(environment[i][j].isDirty == True):
i = random.randint(0,n-1)
j = random.randint(0, n-1)
environment[i][j].isDirty = True
#assortment of actions that can be randomly selected from
randomMove = ["north", "east", "west", "south"]
exNMove = ["east", "west", "south"]
exSMove = ["east", "west", "north"]
exEMove = ["south", "west", "north"]
exWMove = ["east", "south", "north"]
def generatefigures(data_stage='training1', num_areas=8, area_dis=32, num_numerosities=32, num_fig=200,
pix_buffer=1, noise_lev1=0.15, noise_lev2=0.3, dim_fig=30, pickle_data=True):
"""Generate training and testing data for the RBM.
Parameters:
:param data_stage: function of the data to be produced (default: 'training1')
:param num_areas: number of area levels (default: 8)
:param area_dis: distance between areas in pixels (default: 32)
:param num_numerosities: range of numerosities (default: 32)
:param num_fig: number of figures to be generated per area - numerosity combination (default: 200)
:param pix_buffer: buffer between objects in the figures (default: 1)
:param noise_lev1: first noise level in generating object dimensions (default: 0.15)
:param noise_lev2: second noise level in generating object dimensions (default: 0.3)
:param dim_fig: dimensions in pixels of the (square) figures to be generated (default: 30)
:param pickle_data: whether to pickle data or return it (default: True)
:return: file or dictionary with data figures and supplementary information, depending on variable pickle_data.
Dictionary elements:
'data_array': array containing the figures as rows, shape: (num_fig_tot, dim_fig^2)
'data_array_info': list of lists containing information about the dataset per figure [fig_index, area, numerosity]
'obj_info': list of arrays. One array per figure, shape: [fig_numerosity, 4]. Each row of the array contains the
dimensions and coordinates of an object: (obj_width, obj_height, obj_x, obj_y).
'parameter_list': list containing information about the dataset at large: [num_areas (int), num_numerosities (int),
num_fig (int), area_dis (int), areas (list), numerosities (list)
'surf_area': list with length num_fig_tot containing the total surface area of all objects per figure in pixels
"""
areas = [((x + 1) * area_dis) for x in range(num_areas)] # List of cumulative surface areas [32-256]
# (actual surface areas will vary slightly because of gaussian noise added in loop below)
numerosities = [(x + 1) for x in range(num_numerosities)] # Create list of numerosities [1-32]
num_fig_tot = num_areas * num_numerosities * num_fig # Total number of images to be created
fig_counter = 0 # Figure counter, up to (num_fig_tot-1) (=51,200-1)
dim_fig_tot = dim_fig**2 # Get length of input vector
# Some parameters for future use
parameter_list = [num_areas, num_numerosities, num_fig, area_dis, areas, numerosities]
while_limit = 200 # Set maximum times new coordinates are generated before quitting
while_limit2 = 300 # Set maximum times all object coordinates are reset before quitting
data_array = np.zeros((num_fig_tot, dim_fig_tot)) # Make data array to insert images in, then to be pickled
data_array_info = [] # Empty list to append figure information to. Becomes list of lists
obj_info = [] # Empty list to append all object info to, becomes list of arrays
surf_area = [] # Empty list to append total surface area per figure to
"""Generate object dimensions and coordinates"""
for area in areas: # Cycle over cumulative surface area levels
for numerosity in numerosities: # Cycle over numerosity levels
for _ in range(num_fig): # Cycle over number of figures per combination
counter2 = 0 # Infinite while loop protections
"""Loop to assign dimensions to each object"""
while counter2 < while_limit2:
counter3 = 0 # Infinite while loop protection
while counter3 < while_limit:
res_area = area # Get variable residual area
fig_array = np.zeros((dim_fig, dim_fig)) # Make figure array to add obj_ones to
obj_array = np.zeros((numerosity, 4)) # Make object array to add dim and coordinates to:
# [x, :2] = dimensions, [x, 2:] = left upper corner. Mostly for debugging.
res_obj = numerosity
for item in range(numerosity):
res_obj = numerosity - item
obj_noise = elrandom.normal(0, noise_lev1, 1) # Create first layer of noise
obj_area = (float(res_area) / res_obj) + obj_noise # Calculate area plus first noise layer
if obj_area <= 0: # Exit for loop and restart while loop if obj area is zero to avoid error
counter3 += 1
break
obj_dim = mt.sqrt(obj_area) # Take root of area to obtain initial object dimensions
list_dim = [obj_dim] * 2 # Create list with two initial positive dimensions
"""While loop to avoid negative or zero dimensions"""
while True:
dim_noise = elrandom.normal(0, noise_lev2, 2)
# Create random noise array to add to object dimensions
dim = list_dim + dim_noise # Array 'dim' contains actual dimensions of object
dim_round = np.around(dim, 0) # Round the dimensions
"""If all dimensions are greater than zero the while loop can be exited
NOTE: CAN CAUSE A SLIGHT BIAS TOWARDS LARGER CUMULATIVE SURFACE AREAS"""
if all(x > 0 for x in dim_round):
break
obj_array[item, :2] = dim_round # Insert rounded dimensions into the object array
act_area = dim_round[0] * dim_round[1] # Calculate actual surface area
res_area -= act_area # Subtract actual object area from total area
if res_obj == 1: # Way to communicate all dimensions are assigned successfully
res_obj = 0
"""If all objects are assigned successfully in for loop above, dimensions while loop can exit.
Otherwise initiate next round of dimension assignment."""
if res_obj == 0:
break
if counter3 == while_limit: # Let's check if this ever happens with these settings
print('Failed dimension assignment.')
obj_placed = 0 # To keep track of all objects that are successfully placed
"""Now that all objects have dimensions, generate object coordinates one by one"""
for item in range(numerosity):
counter1 = 0 # Used to avoid infinite while Loop
"""Set some parameter used in this section"""
obj_width = obj_array[item, 0]
obj_height = obj_array[item, 1]
x_limit = dim_fig - obj_width
y_limit = dim_fig - obj_height
# obj_area = obj_width * obj_height # Used in debugging
while counter1 < while_limit:
# Generate random x-coordinate for left upper corner:
obj_array[item, 2] = elrandom.randint(0, (x_limit + 1))
obj_x = obj_array[item, 2]
# Generate random y-coordinate for left upper corner:
obj_array[item, 3] = elrandom.randint(0, (y_limit + 1))
obj_y = obj_array[item, 3]
# Object array is not really used for anything else after this, handy for debugging?
# Make ones array in shape of object:
obj_ones = np.ones((obj_width, obj_height))
"""Check if the assigned space in the figure array is available"""
# Determine size of pixel buffer:
# X:
if obj_x == 0 or obj_x == (dim_fig - obj_width):
x_buffer = 1 * pix_buffer
else:
x_buffer = 2 * pix_buffer
# Y:
if obj_y == 0 or obj_y == (dim_fig - obj_height):
y_buffer = 1 * pix_buffer
else:
y_buffer = 2 * pix_buffer
# Make zeros array shape of obj plus buffer, used to check availability of assigned space:
obj_zeros_width = int(obj_width + x_buffer)
obj_zeros_height = int(obj_height + y_buffer)
obj_zeros = np.zeros((obj_zeros_width, obj_zeros_height))
# Assign coordinates to zeros array (= size of area to be checked).
# Coordinates depend on location of object (whether it is right at the edges of the figure)
if obj_x == 0: # X
x_obj_zeros = obj_x
else:
x_obj_zeros = obj_x - 1
if obj_y == 0: # Y
y_obj_zeros = obj_y
else:
y_obj_zeros = obj_y - 1
# Check if the space with buffer is available:
# For better overview:
obj_z_left = int(x_obj_zeros)
obj_z_right = int(x_obj_zeros + obj_zeros_width)
obj_z_up = int(y_obj_zeros)
obj_z_down = int(y_obj_zeros + obj_zeros_height)
# Variable representing the target area in the figure array:
test_area = fig_array[obj_z_left:obj_z_right, obj_z_up:obj_z_down]
"""If space is available, insert ones and move on to next object.
If not, loop again and get new coordinates to try."""
if (obj_zeros == test_area).all():
# If so, generated coordinates can be used:
obj_array[item, 2:4] = [obj_x, obj_y] # Fill obj array with coordinates for debugging
# For better overview:
obj_left = int(obj_x)
obj_right = int(obj_x + obj_width)
obj_up = int(obj_y)
obj_down = int(obj_y + obj_height)
# Insert ones in the location of the object the figure array:
fig_array[obj_left:obj_right, obj_up:obj_down] = obj_ones
# Once valid location is found and object is inserted, record that and exit while loop:
obj_placed += 1
break
else:
"""If the space is not available, add 1 to while counter and do while loop again,
so new coordinates are generated and checked for this particular object."""
counter1 += 1 # Loop will exit automatically once limit is reached
"""If all objects are placed we can exit the while loop and store the object information"""
if obj_placed == numerosity:
new_info = [fig_counter, area, numerosity]
data_array_info.append(new_info)
obj_info.append(obj_array)
# print('Figure: %d, Area: %d, Numerosity: %d, Objects placed: %d'
# % ((fig_counter+1), area, numerosity, obj_placed))
break
"""If not, the while loop needs to be executed again to generate new coordinates for all objects
in this particular image"""
counter2 += 1 # Infinite while loop protection 2
if counter2 == while_limit2: # Used in debugging
print('Failed figure.')
print('Area = {}, numerosity = {}'.format(area, numerosity))
print('Figure index = {}, objects placed = {}'.format(fig_counter, obj_placed))
"""Add complete figures to final array, and pickle final array"""
fig_list = fig_array.flatten() # Flatten array to obtain vectorized figure
data_array[fig_counter, :] = fig_list # Add obtained vector as row to final array
surf_area.append(sum(fig_list)) # Store surface area of this figure
fig_counter += 1
# Create main dictionary with all information
return_dict = {'data_array': data_array, 'data_array_info': data_array_info, 'obj_info': obj_info,
'parameter_list': parameter_list, 'surf_area': surf_area}
"""Depending on pickle_data: pickle output file, otherwise return."""
if pickle_data:
pickle.dump(return_dict, open(data_stage, 'wb'))
else:
return return_dict
Q = 10.0*2.0**L
K = floor(n/L)-Q
p = 2.0**L
c = 0.7-0.8/L+(4.0+32.0/L)*(K**(-3.0/L))/15.0
sigma = c*sqrt(variance[int(L)]/K)
T = zeros(p)
for i in range(1,int(Q+1)):
decRep = 0.0
for j in range(int(L)):
decRep += bits[int((i-1)*L+j)]*2**(L-1-j)
T[decRep] = i
total = 0.0
for i in range(int(Q+1),int(Q+K+1)):
decRep = 0.0
for j in range(int(L)):
decRep += bits[int((i-1)*L+j)]*2**(L-1-j)
total += log(i-T[decRep],2)
T[decRep] = i
phi = total/K
arg = (phi-expected[int(L)])/sigma
p_value = erfc(abs(arg)/sqrt(2))
return p_value
if __name__ == "__main__":
bits = random.randint(0,2,4000)
print '%.2f' % (UST(bits))
def setUp(self) -> None:
seed(seed=5)
self.testData = randint(low=0, high=50, size=15)
self.testData2 = randint(low=1, high=51, size=15)
if j:
Nk[j] = Nk[j] * V(i, k - j,
t) + Nk[j - 1] * (1 - V(i, k - j + 1, t))
else:
Nk[j] = Nk[j] * V(i, k - j, t)
Nk.reverse()
return [
sum(p[j] * N for p, N in zip(self.points[k - self.m:k + 1], Nk))
for j in (0, 1)
]
if __name__ == '__main__':
control_points = tuple([(random.randint(0, 10), random.randint(0, 10))
for k in range(random.randint(4, 7))])
degree = 3
N = 100
bspline = Bspline(control_points, degree)
points = map(bspline.curve, (i / N for i in xrange(N + 1)))
x, y = ([p[j] for p in points] for j in (0, 1))
plt.plot(x, y, 'b-')
x, y = ([p[j] for p in control_points] for j in (0, 1))
plt.plot(x, y, 'ro-')
plt.grid(True)
plt.show()
def take_action_eval(self, state):
if self.eval_epsilon > npr.uniform():
return npr.randint(0, self.action_dim)
else:
action = self.policy_net.take_action(state).numpy()
return action
