Python math 模块，ceil() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用math.ceil()。
def main():
args.input_data_dir = os.path.abspath(args.input_data_dir)
if not os.path.exists(args.output_data_dir):
os.mkdir(args.output_data_dir)
for dir_path, dir_names, file_names in os.walk(args.input_data_dir):
if len(file_names) > 0:
print(dir_path)
rows = int(math.ceil(len(file_names) / 6.0))
print(rows)
fig, axes = plt.subplots(4, 12, subplot_kw={'xticks': [], 'yticks': []})
fig.subplots_adjust(hspace=0.01, wspace=0.01)
for ax, file_name in zip(axes.flat, file_names):
print(file_name)
img = imread(dir_path + '/' + file_name)
ax.imshow(img)
# ax.set_title(os.path.splitext(file_name)[0].replace('.227x227', ''))
plt.savefig(args.output_data_dir + dir_path.replace(args.input_data_dir, '') + '.pdf')
def calculateDiskSize(inputFile=None, inputFileSize=None, analysisId=None, scalingFactor=None, roundToNearestGbInterval=None):
if inputFile is not None:
fileSize = int(subprocess.check_output(["gsutil", "du", inputFile]).split(' ')[0])
elif analysisId is not None:
analysisDetail = CGHubDataUtils.getAnalysisDetail(analysisId)
if len(analysisDetail["result_set"]["results"]) > 0:
files = analysisDetail["result_set"]["results"][0]["files"]
fileSize = sum([int(x["filesize"]) for x in files])
else:
print "ERROR: no files found for analysis ID {a}!".format(a=analysisId)
exit(-1)
if scalingFactor is not None:
scalingFactor = int(scalingFactor)
else:
scalingFactor = 1
if roundToNearestGbInterval is not None:
roundTo = float(roundToNearestGbInterval) * 1000000000
return int(math.ceil(scalingFactor * fileSize/ roundTo) * roundTo) / 1000000000
def compute_dt_dist(docs, labels, tags, model, max_len, batch_size, pad_id, idxvocab, output_file):
#generate batches
num_batches = int(math.ceil(float(len(docs)) / batch_size))
dt_dist = []
t = []
combined = []
docid = 0
for i in xrange(num_batches):
x, _, _, t, s = get_batch_doc(docs, labels, tags, i, max_len, cf.tag_len, batch_size, pad_id)
attention, mean_topic = sess.run([model.attention, model.mean_topic], {model.doc: x, model.tag: t})
dt_dist.extend(attention[:s])
if debug:
for si in xrange(s):
d = x[si]
print "\n\nDoc", docid, "=", " ".join([idxvocab[item] for item in d if (item != pad_id)])
sorted_dist = matutils.argsort(attention[si], reverse=True)
for ti in sorted_dist:
print "Topic", ti, "=", attention[si][ti]
docid += 1
np.save(open(output_file, "w"), dt_dist)
def _factor_target_indices(self, Y_inds, vocab_size=None, base=2):
if vocab_size is None:
vocab_size = len(self.dp.word_index)
print >>sys.stderr, "Factoring targets of vocabulary size: %d"%(vocab_size)
num_vecs = int(math.ceil(math.log(vocab_size)/math.log(base))) + 1
base_inds = []
div_Y_inds = Y_inds
print >>sys.stderr, "Number of factors: %d"%num_vecs
for i in range(num_vecs):
new_inds = div_Y_inds % base
if i == num_vecs - 1:
if new_inds.sum() == 0:
# Most significant "digit" is a zero. Omit it.
break
base_inds.append(new_inds)
div_Y_inds = numpy.copy(div_Y_inds/base)
base_vecs = [self._make_one_hot(base_inds_i, base) for base_inds_i in base_inds]
return base_vecs
def eval_pred(dr_model, ub):
'''
evaluate dream model for predicting next basket on all training users
in batches
'''
item_embedding = dr_model.encode.weight
dr_model.eval()
dr_hidden = dr_model.init_hidden(dr_model.config.batch_size)
start_time = time()
id_u, score_u = [], [] # user's id, user's score
num_batchs = ceil(len(ub) / dr_model.config.batch_size)
for i,x in enumerate(batchify(ub, dr_model.config.batch_size)):
print(i)
baskets, lens, uids = x
_, dynamic_user, _ = dr_model(baskets, lens, dr_hidden)# shape: batch_size, max_len, embedding_size
dr_hidden = repackage_hidden(dr_hidden)
for i,l,du in zip(uids, lens, dynamic_user):
du_latest = du[l - 1].unsqueeze(0) # shape: 1, embedding_size
score_up = torch.mm(du_latest, item_embedding.t()) # shape: 1, num_item
score_u.append(score_up.cpu().data.numpy())
id_u.append(i)
elapsed = time() - start_time
print('[Predicting] Elapsed: {02.2f}'.format(elapsed))
return score_ub, id_u
def evaluate_dream():
dr_model.eval()
dr_hidden = dr_model.init_hidden(dr_config.batch_size)
total_loss = 0
start_time = time()
num_batchs = ceil(len(test_ub) / dr_config.batch_size)
for i,x in enumerate(batchify(test_ub, dr_config.batch_size)):
baskets, lens, _ = x
dynamic_user, _ = dr_model(baskets, lens, dr_hidden)
loss = bpr_loss(baskets, dynamic_user, dr_model.encode.weight, dr_config)
dr_hidden = repackage_hidden(dr_hidden)
total_loss += loss.data
# Logging
elapsed = (time() - start_time) * 1000 / num_batchs
total_loss = total_loss[0] / num_batchs
print('[Evaluation]| Epochs {:3d} | Elapsed {:02.2f} | Loss {:05.2f} |'.format(epoch, elapsed, total_loss))
return total_loss
def create_vote(self, action, player, finished_event):
new_vote = Vote()
new_vote.action = action
new_vote.requester = player
new_vote.votes_current = []
needed_votes = math.ceil(self.instance.player_manager.count_players / 2)
if needed_votes == math.floor(self.instance.player_manager.count_players / 2):
needed_votes += 1
if needed_votes > self.instance.player_manager.count_players:
needed_votes = self.instance.player_manager.count_players
new_vote.votes_required = needed_votes
new_vote.vote_added = self.vote_added
new_vote.vote_removed = self.vote_removed
new_vote.vote_finished = finished_event
asyncio.ensure_future(self.vote_reminder(new_vote))
return new_vote
def __call__(self):
total_processes = _calculate_workers()
ctxt = {
"service_name": self.service_name,
"user": self.user,
"group": self.group,
"script": self.script,
"admin_script": self.admin_script,
"public_script": self.public_script,
"processes": int(math.ceil(self.process_weight * total_processes)),
"admin_processes": int(math.ceil(self.admin_process_weight *
total_processes)),
"public_processes": int(math.ceil(self.public_process_weight *
total_processes)),
"threads": 1,
"usr_bin": git_determine_usr_bin(),
"python_path": git_determine_python_path(),
}
return ctxt
def split(args):
chunk_mem_gb = cr_utils.get_mem_gb_request_from_barcode_whitelist(args.barcode_whitelist)
whitelist_mem_gb = cr_utils.get_mem_gb_request_from_barcode_whitelist(args.barcode_whitelist, args.gem_groups, use_min=False)
# Estimate the total number of rows in the final molecule info. Worst case.
total_reads = cr_utils.get_metric_from_json(args.extract_reads_summary, 'total_reads')
mol_info_rows = total_reads
# Memory for sorting in MoleculeCounter.concatenate_sort:
# N = total number of rows
# 8*N bytes to store the sort indices
# (8+8+8)*N bytes to load, concatenate, and index into a 64-bit data column
mol_info_mem_gb = int(math.ceil((32 * mol_info_rows)/1e9))
join_mem_gb = min(MAX_MEM_GB, max(cr_constants.MIN_MEM_GB, whitelist_mem_gb + mol_info_mem_gb))
chunks = []
for chunk_input in args.inputs:
chunks.append({
'chunk_input': chunk_input,
'__mem_gb': chunk_mem_gb,
})
join = {
'__mem_gb': join_mem_gb,
}
return {'chunks': chunks, 'join': join}
def split(args):
assert len(args.read1s) == len(args.read2s)
chunks = []
# Determine the number of buckets required to achieve
# the given chunk size.
chunks_per_gem_group = {}
with open(args.reads_summary) as f:
reads_summary = json.load(f)
for gg in args.gem_groups:
readpairs = reads_summary['%d_total_reads_per_gem_group' % gg]
chunks_per_gem_group[str(gg)] = max(2,
int(math.ceil(float(readpairs) / \
args.readpairs_per_chunk)))
for fastq1, fastq2 in itertools.izip(args.read1s, args.read2s):
chunks.append({
'read1s_chunk': fastq1,
'read2s_chunk': fastq2,
'chunks_per_gem_group': chunks_per_gem_group,
})
return {'chunks': chunks}
def run(self):
c = self.client
if not c.login():
log.error('login failed')
return
symbols_list = self.split(self.symbols, self.size)
size = int(math.ceil(1. * len(symbols_list) / self.core))
child_sl = self.split(symbols_list, size)
f = open(self.out, 'ab') if self.out else None
ps, gs = [], []
for i in range(self.core):
r, w = gipc.pipe()
g = gevent.spawn(self.main_on_data, r, f)
p = gipc.start_process(target=self.spawn_watchs, args=(w, child_sl[i]))
ps.append(p)
for p in ps:
p.join()
for g in gs:
g.kill()
g.join()
def __calculate_light_brightness(self, current_time, light_policy = {}):
bright_time, dark_time = light_policy['bright_time'], light_policy['dark_time']
if current_time < min(bright_time, dark_time) or current_time > max(bright_time, dark_time):
return -1 # return -1 when current time is not within the bright_time and dark_time range
# if there is a constant brightness value, return immediately
if 'const_brightness' in light_policy:
return light_policy['const_brightness']
min_brightness, max_brightness = 0, 100
if 'min_brightness' in light_policy:
min_brightness = light_policy['min_brightness']
if 'max_brightness' in light_policy:
max_brightness = light_policy['max_brightness']
time_scale = abs(self.__get_diff_between_datetime(bright_time, dark_time))
time_passed = abs(self.__get_diff_between_datetime(current_time, bright_time))
brightness = int(math.ceil(min_brightness + float(time_passed) / float(time_scale) * float(max_brightness - min_brightness)))
brightness += min_brightness
return brightness
def build(self):
end_time = timeit.default_timer()
end_mem = memory_profiler.memory_usage()[0]
sys.stdout = self._previous_stdout
self._log.write("END RequestId: {r}\n".format(
r=self._context.aws_request_id))
duration_in_millis = int(math.ceil(1000 * (end_time - self._start_time)))
# The memory overhead of setting up the AWS Lambda environment
# (when actually run in AWS) is roughly 14 MB
max_memory_used_in_mb = (end_mem - self._start_mem) / 1048576 + 14
self._log.write(
"REPORT RequestId: {r}\tDuration: {d} ms\t"
"Max Memory Used: {m} MB\n"
.format(r=self._context.aws_request_id,
d=duration_in_millis,
m=max_memory_used_in_mb))
log = self._log.getvalue()
return LambdaCallSummary(duration_in_millis, max_memory_used_in_mb, log)
def end_of_episode(self):
'''
Summary:
Performs miscellaneous end of episode tasks (#printing out useful information, saving stuff, etc.)
'''
# self.model = self.weak_learners
self.add_new_weak_learner()
self.most_recent_episode = []
if self.markov_window > 0:
# num_sampled_trees = int(math.ceil(len(self.weak_learners) / 10.0))
# self.model = random.sample(self.weak_learners, num_sampled_trees)
self.model = self.weak_learners[-self.markov_window:]
else:
self.model = self.weak_learners
Agent.end_of_episode(self)
def _compute_walls(self, width, height):
'''
Args:
width (int)
height (int)
Returns:
(list): Contains (x,y) pairs that define wall locations.
'''
walls = []
half_width = math.ceil(width / 2.0)
half_height = math.ceil(height / 2.0)
for i in range(1, width + 1):
if i == (width + 1) / 3 or i == math.ceil(2 * (width + 1) / 3.0):
continue
walls.append((i, half_height))
for j in range(1, height + 1):
if j == (height + 1) / 3 or j == math.ceil(2 * (height + 1) / 3.0):
continue
walls.append((half_width, j))
return walls
def get_data_hash(self, data_bytes):
"""Calculate Merkle's root hash of the given data bytes"""
# Calculate tree parameters
data_len = len(data_bytes)
tree_populated_width = math.ceil(data_len / self._chunk_len)
tree_height = math.ceil(math.log2(tree_populated_width))
tree_width = int(math.pow(2, tree_height))
tree_bottom_layer = ['\x00'] * tree_width
with io.BytesIO(data_bytes) as b_data:
self._initial_hasher(
b_data,
tree_populated_width,
tree_bottom_layer
)
# Get Merkle's root hash
mrh = self._calculate_root_hash(tree_bottom_layer)
return mrh
def run(self):
while True:
if self.scan_config.RESTART:
self.scan_config.RESTART = False
if self.scan_config.ACCOUNTS_CHANGED:
self.scan_config.ACCOUNTS_CHANGED = False
num_workers = min(max(int(math.ceil(len(config['ACCOUNTS']) / 23.0)), 3), 10)
self.api.resize_workers(num_workers)
self.api.add_accounts(config['ACCOUNTS'])
ScanMetrics.NUM_THREADS = num_workers
ScanMetrics.NUM_ACCOUNTS = len(config['ACCOUNTS'])
if (not self.scan_config.SCAN_LOCATIONS or
not config.get('ACCOUNTS', None)):
time.sleep(5)
continue
ScanMetrics.STEPS_COMPLETED = 0
scan_start_time = time.time()
self.scan()
ScanMetrics.COMPLETE_SCAN_TIME = time.time() - scan_start_time
def make_pagination_headers(limit, curpage, total, link_header=True):
"""Return Link Hypermedia Header."""
lastpage = int(math.ceil(1.0 * total / limit) - 1)
headers = {'X-Total-Count': str(total), 'X-Limit': str(limit),
'X-Page-Last': str(lastpage), 'X-Page': str(curpage)}
if not link_header:
return headers
base = "{}?%s".format(request.path)
links = {}
links['first'] = base % urlencode(dict(request.args, **{PAGE_ARG: 0}))
links['last'] = base % urlencode(dict(request.args, **{PAGE_ARG: lastpage}))
if curpage:
links['prev'] = base % urlencode(dict(request.args, **{PAGE_ARG: curpage - 1}))
if curpage < lastpage:
links['next'] = base % urlencode(dict(request.args, **{PAGE_ARG: curpage + 1}))
headers['Link'] = ",".join(['<%s>; rel="%s"' % (v, n) for n, v in links.items()])
return headers
# pylama:ignore=R0201
def make_sprite(label_img, save_path):
import math
import torch
import torchvision
# this ensures the sprite image has correct dimension as described in
# https://www.tensorflow.org/get_started/embedding_viz
nrow = int(math.ceil((label_img.size(0)) ** 0.5))
# augment images so that #images equals nrow*nrow
label_img = torch.cat((label_img, torch.randn(nrow ** 2 - label_img.size(0), *label_img.size()[1:]) * 255), 0)
# Dirty fix: no pixel are appended by make_grid call in save_image (https://github.com/pytorch/vision/issues/206)
xx = torchvision.utils.make_grid(torch.Tensor(1, 3, 32, 32), padding=0)
if xx.size(2) == 33:
sprite = torchvision.utils.make_grid(label_img, nrow=nrow, padding=0)
sprite = sprite[:, 1:, 1:]
torchvision.utils.save_image(sprite, os.path.join(save_path, 'sprite.png'))
else:
torchvision.utils.save_image(label_img, os.path.join(save_path, 'sprite.png'), nrow=nrow, padding=0)
def randint(minvalue, maxvalue):
"""Returns a random integer x with minvalue <= x <= maxvalue"""
# Safety - get a lot of random data even if the range is fairly
# small
min_nbits = 32
# The range of the random numbers we need to generate
range = maxvalue - minvalue
# Which is this number of bytes
rangebytes = ceil(math.log(range, 2) / 8.)
# Convert to bits, but make sure it's always at least min_nbits*2
rangebits = max(rangebytes * 8, min_nbits * 2)
# Take a random number of bits between min_nbits and rangebits
nbits = random.randint(min_nbits, rangebits)
return (read_random_int(nbits) % range) + minvalue
def randomized_primality_testing(n, k):
"""Calculates whether n is composite (which is always correct) or
prime (which is incorrect with error probability 2**-k)
Returns False if the number if composite, and True if it's
probably prime.
"""
q = 0.5 # Property of the jacobi_witness function
# t = int(math.ceil(k / math.log(1/q, 2)))
t = ceil(k / math.log(1/q, 2))
for i in range(t+1):
x = randint(1, n-1)
if jacobi_witness(x, n): return False
return True
def getprime(nbits):
"""Returns a prime number of max. 'math.ceil(nbits/8)*8' bits. In
other words: nbits is rounded up to whole bytes.
>>> p = getprime(8)
>>> is_prime(p-1)
0
>>> is_prime(p)
1
>>> is_prime(p+1)
0
"""
while True:
integer = read_random_int(nbits)
# Make sure it's odd
integer |= 1
# Test for primeness
if is_prime(integer): break
# Retry if not prime
return integer
def combine_images(generated_images):
total, width, height, ch = generated_images.shape
cols = int(math.sqrt(total))
rows = math.ceil(float(total)/cols)
combined_image = np.zeros((height*rows, width*cols, 3),
dtype = generated_images.dtype)
for index, image in enumerate(generated_images):
i = int(index/cols)
j = index % cols
combined_image[width*i:width*(i+1), height*j:height*(j+1), :]\
= image
return combined_image
def make_grid(tensor, nrow=8, padding=2,
normalize=False, scale_each=False):
"""Code based on https://github.com/pytorch/vision/blob/master/torchvision/utils.py"""
nmaps = tensor.shape[0]
xmaps = min(nrow, nmaps)
ymaps = int(math.ceil(float(nmaps) / xmaps))
height, width = int(tensor.shape[1] + padding), int(tensor.shape[2] + padding)
grid = np.zeros([height * ymaps + 1 + padding // 2, width * xmaps + 1 + padding // 2, 3], dtype=np.uint8)
k = 0
for y in range(ymaps):
for x in range(xmaps):
if k >= nmaps:
break
h, h_width = y * height + 1 + padding // 2, height - padding
w, w_width = x * width + 1 + padding // 2, width - padding
grid[h:h+h_width, w:w+w_width] = tensor[k]
k = k + 1
return grid
def make_grid(tensor, nrow=8, padding=2,
normalize=False, scale_each=False):
"""Code based on https://github.com/pytorch/vision/blob/master/torchvision/utils.py
minor improvement, row/col was reversed"""
nmaps = tensor.shape[0]
ymaps = min(nrow, nmaps)
xmaps = int(math.ceil(float(nmaps) / ymaps))
height, width = int(tensor.shape[1] + padding), int(tensor.shape[2] + padding)
grid = np.zeros([height * ymaps + 1 + padding // 2, width * xmaps + 1 + padding // 2, 3], dtype=np.uint8)
k = 0
for y in range(ymaps):
for x in range(xmaps):
if k >= nmaps:
break
h, h_width = y * height + 1 + padding // 2, height - padding
w, w_width = x * width + 1 + padding // 2, width - padding
grid[h:h+h_width, w:w+w_width] = tensor[k]
k = k + 1
return grid
def make_grid(tensor, nrow=8, padding=2,
normalize=False, scale_each=False):
"""Code based on https://github.com/pytorch/vision/blob/master/torchvision/utils.py"""
nmaps = tensor.shape[0]
xmaps = min(nrow, nmaps)
ymaps = int(math.ceil(float(nmaps) / xmaps))
height, width = int(tensor.shape[1] + padding), int(tensor.shape[2] + padding)
grid = np.zeros([height * ymaps + 1 + padding // 2, width * xmaps + 1 + padding // 2, 3], dtype=np.uint8)
k = 0
for y in range(ymaps):
for x in range(xmaps):
if k >= nmaps:
break
h, h_width = y * height + 1 + padding // 2, height - padding
w, w_width = x * width + 1 + padding // 2, width - padding
grid[h:h+h_width, w:w+w_width] = tensor[k]
k = k + 1
return grid
def __nearest_pow_2(self,x):
"""
Find power of two nearest to x
>>> _nearest_pow_2(3)
2.0
>>> _nearest_pow_2(15)
16.0
:type x: float
:param x: Number
:rtype: Int
:return: Nearest power of 2 to x
"""
a = math.pow(2, math.ceil(np.log2(x)))
b = math.pow(2, math.floor(np.log2(x)))
if abs(a - x) < abs(b - x):
return a
else:
return b
# calculate spectrogram of signals
def _nearest_pow_2(x):
"""
Find power of two nearest to x
>>> _nearest_pow_2(3)
2.0
>>> _nearest_pow_2(15)
16.0
:type x: float
:param x: Number
:rtype: Int
:return: Nearest power of 2 to x
"""
a = M.pow(2, M.ceil(np.log2(x)))
b = M.pow(2, M.floor(np.log2(x)))
if abs(a - x) < abs(b - x):
return a
else:
return b
def __draw_pk2(self):
self.__cleanPk2()
if self.units is not None:
unique_units = np.unique(self.units)
unique_units = unique_units.tolist()
pca_1,pca_2 = self.PCAusedList.currentText().split("-")
pca_1 = np.int(pca_1)-1
pca_2 = np.int(pca_2)-1
if self.wavePCAs[0].shape[0]>2:
xs = self.wavePCAs[:,pca_1]
ys = self.wavePCAs[:,pca_2]
self.PcaScatterItem = []
seg_num = 5000
for i,ite_unit in enumerate(unique_units):
mask = self.units==ite_unit
temp_xs = xs[mask]
temp_ys = ys[mask]
segs = int(ceil(temp_xs.shape[0]/float(seg_num)))
for j in range(segs):
temp_xs_j = temp_xs[j*seg_num:(j+1)*seg_num]
temp_ys_j = temp_ys[j*seg_num:(j+1)*seg_num]
self.PcaScatterItem.append(pg.ScatterPlotItem(temp_xs_j,temp_ys_j,pen=self.colors[ite_unit],brush=self.colors[ite_unit],size=3,symbol="o"))
for i in range(len(self.PcaScatterItem)):
self.pk2.addItem(self.PcaScatterItem[i])
def __nearest_pow_2(self,x):
"""
Find power of two nearest to x
>>> _nearest_pow_2(3)
2.0
>>> _nearest_pow_2(15)
16.0
:type x: float
:param x: Number
:rtype: Int
:return: Nearest power of 2 to x
"""
a = math.pow(2, math.ceil(np.log2(x)))
b = math.pow(2, math.floor(np.log2(x)))
if abs(a - x) < abs(b - x):
return a
else:
return b
# calculate spectrogram of signals
def _nearest_pow_2(x):
"""
Find power of two nearest to x
>>> _nearest_pow_2(3)
2.0
>>> _nearest_pow_2(15)
16.0
:type x: float
:param x: Number
:rtype: Int
:return: Nearest power of 2 to x
"""
a = M.pow(2, M.ceil(np.log2(x)))
b = M.pow(2, M.floor(np.log2(x)))
if abs(a - x) < abs(b - x):
return a
else:
return b
def test_partial_send(self, *args):
c = self.make_connection()
# only write the first four bytes of the OptionsMessage
write_size = 4
c._socket.send.side_effect = None
c._socket.send.return_value = write_size
c.handle_write(None, 0)
msg_size = 9 # v3+ frame header
expected_writes = int(math.ceil(float(msg_size) / write_size))
size_mod = msg_size % write_size
last_write_size = size_mod if size_mod else write_size
self.assertFalse(c.is_defunct)
self.assertEqual(expected_writes, c._socket.send.call_count)
self.assertEqual(last_write_size, len(c._socket.send.call_args[0][0]))
def test_partial_send(self, *args):
c = self.make_connection()
# only write the first four bytes of the OptionsMessage
write_size = 4
c.socket.send.side_effect = None
c.socket.send.return_value = write_size
c.handle_write()
msg_size = 9 # v3+ frame header
expected_writes = int(math.ceil(float(msg_size) / write_size))
size_mod = msg_size % write_size
last_write_size = size_mod if size_mod else write_size
self.assertFalse(c.is_defunct)
self.assertEqual(expected_writes, c.socket.send.call_count)
self.assertEqual(last_write_size, len(c.socket.send.call_args[0][0]))
def compute_logarithmic_scale(min_, max_, min_scale, max_scale):
"""Compute an optimal scale for logarithmic"""
if max_ <= 0 or min_ <= 0:
return []
min_order = int(floor(log10(min_)))
max_order = int(ceil(log10(max_)))
positions = []
amplitude = max_order - min_order
if amplitude <= 1:
return []
detail = 10.
while amplitude * detail < min_scale * 5:
detail *= 2
while amplitude * detail > max_scale * 3:
detail /= 2
for order in range(min_order, max_order + 1):
for i in range(int(detail)):
tick = (10 * i / detail or 1) * 10 ** order
tick = round_to_scale(tick, tick)
if min_ <= tick <= max_ and tick not in positions:
positions.append(tick)
return positions
def Occlusion_exp(image,occluding_size,occluding_stride,model,preprocess,classes,groundTruth):
img = np.copy(image)
height, width,_= img.shape
output_height = int(math.ceil((height-occluding_size)/occluding_stride+1))
output_width = int(math.ceil((width-occluding_size)/occluding_stride+1))
ocludedImages=[]
for h in range(output_height):
for w in range(output_width):
#occluder region
h_start = h*occluding_stride
w_start = w*occluding_stride
h_end = min(height, h_start + occluding_size)
w_end = min(width, w_start + occluding_size)
input_image = copy.copy(img)
input_image[h_start:h_end,w_start:w_end,:] = 0
ocludedImages.append(preprocess(Image.fromarray(input_image)))
L = np.empty(output_height*output_width)
L.fill(groundTruth)
L = torch.from_numpy(L)
tensor_images = torch.stack([img for img in ocludedImages])
dataset = torch.utils.data.TensorDataset(tensor_images,L)
dataloader = torch.utils.data.DataLoader(dataset,batch_size=5,shuffle=False, num_workers=8)
heatmap=np.empty(0)
model.eval()
for data in dataloader:
images, labels = data
if use_gpu:
images, labels = (images.cuda()), (labels.cuda(async=True))
outputs = model(Variable(images))
m = nn.Softmax()
outputs=m(outputs)
if use_gpu:
outs=outputs.cpu()
heatmap = np.concatenate((heatmap,outs[0:outs.size()[0],groundTruth].data.numpy()))
return heatmap.reshape((output_height, output_width))
def percentile(N, percent, key=lambda x:x):
"""
Find the percentile of a list of values.
@parameter N - is a list of values. Note N MUST BE already sorted.
@parameter percent - a float value from 0.0 to 1.0.
@parameter key - optional key function to compute value from each element of N.
@return - the percentile of the values
"""
if not N:
return None
k = (len(N)-1) * percent
f = math.floor(k)
c = math.ceil(k)
if f == c:
return key(N[int(k)])
d0 = key(N[int(f)]) * (c-k)
d1 = key(N[int(c)]) * (k-f)
return d0+d1
# median is 50th percentile.
def gen_sieve(ceiling=None):
if ceiling is not None:
if ceiling % 2 == 0:
ceiling -= 1
highest_prime = math.ceil(math.sqrt(ceiling))
last_val = 1
found_primes = []
yield 2
while ceiling is None or ceiling > last_val:
current_val = None
while current_val is None:
current_val = last_val = last_val + 2
for prime, square in found_primes:
if current_val < square:
break
if current_val % prime == 0:
current_val = None
break
yield current_val
if ceiling is None or highest_prime > last_val:
found_primes.append((current_val, current_val ** 2))
def stop_foraging(self):
if self.last_action and self.last_action[0] == "foraging":
item = self.last_action[1]
time_spent = math.ceil(time.time() - self.last_action_time) / 60
self.last_action = None
self.last_action_time = None
item_amount = math.floor(time_spent * self.foraging_rate)
self.inventory[item] = self.inventory.get(item, 0) + item_amount
if self.inventory[item] == 0:
del self.inventory[item]
self.foraging_xp += item_amount
secondary_item = forageables[item][0]
tertiary_item = forageables[item][1]
secondary_amount = random.randint(0, item_amount)
tertiary_amount = math.floor(random.randint(0, item_amount) / 100)
self.inventory[secondary_item] = self.inventory.get(secondary_item, 0) + secondary_amount
if self.inventory[secondary_item] == 0:
del self.inventory[secondary_item]
self.inventory[tertiary_item] = self.inventory.get(tertiary_item, 0) + tertiary_amount
if self.inventory[tertiary_item] == 0:
del self.inventory[tertiary_item]
self.write_data()
return item, time_spent, item_amount, secondary_amount, tertiary_amount
else:
return False, self.last_action
def stop_woodcutting(self):
if self.last_action and self.last_action[0] == "woodcutting":
wood_type = self.last_action[1]
time_spent = math.ceil(time.time() - self.last_action_time) / 60
self.last_action = None
self.last_action = None
current_wood_lvl = wood_lvl(wood_type)
wood_amount = math.floor(time_spent * self.wood_rate(wood_type) * self.woodcutting_rate)
xp_amount = current_wood_lvl * wood_amount
self.inventory[wood_type] = self.inventory.get(wood_type, 0) + wood_amount
if self.inventory[wood_type] == 0:
del self.inventory[wood_type]
self.woodcutting_xp += xp_amount
self.write_data()
return wood_type, time_spent, wood_amount, xp_amount
else:
return False, self.last_action
def download_mutation_images(self):
# TODO: dunno if this works
import ipywidgets
import math
views = []
for g in self.reference_gempro.genes:
if g.protein.representative_structure:
view = g.protein.view_all_mutations(alignment_type='seqalign', grouped=False, structure_opacity=0.5,
opacity_range=(0.6, 1), scale_range=(.5, 5))
view._remote_call("setSize", target='Widget', args=['300px', '300px'])
view.download_image(filename='{}_{}_mutations.png'.format(g.id, g.name))
views.append(view)
hboxes = [ipywidgets.HBox(views[i * 3:i * 3 + 3])
for i in range(int(math.ceil(len(views) / 3.0)))]
vbox = ipywidgets.VBox(hboxes)
return vbox
def __call__(self):
total_processes = _calculate_workers()
ctxt = {
"service_name": self.service_name,
"user": self.user,
"group": self.group,
"script": self.script,
"admin_script": self.admin_script,
"public_script": self.public_script,
"processes": int(math.ceil(self.process_weight * total_processes)),
"admin_processes": int(math.ceil(self.admin_process_weight *
total_processes)),
"public_processes": int(math.ceil(self.public_process_weight *
total_processes)),
"threads": 1,
"usr_bin": git_determine_usr_bin(),
"python_path": git_determine_python_path(),
}
return ctxt
def __call__(self):
total_processes = _calculate_workers()
ctxt = {
"service_name": self.service_name,
"user": self.user,
"group": self.group,
"script": self.script,
"admin_script": self.admin_script,
"public_script": self.public_script,
"processes": int(math.ceil(self.process_weight * total_processes)),
"admin_processes": int(math.ceil(self.admin_process_weight *
total_processes)),
"public_processes": int(math.ceil(self.public_process_weight *
total_processes)),
"threads": 1,
"usr_bin": git_determine_usr_bin(),
"python_path": git_determine_python_path(),
}
return ctxt
def __call__(self):
total_processes = _calculate_workers()
ctxt = {
"service_name": self.service_name,
"user": self.user,
"group": self.group,
"script": self.script,
"admin_script": self.admin_script,
"public_script": self.public_script,
"processes": int(math.ceil(self.process_weight * total_processes)),
"admin_processes": int(math.ceil(self.admin_process_weight *
total_processes)),
"public_processes": int(math.ceil(self.public_process_weight *
total_processes)),
"threads": 1,
"usr_bin": git_determine_usr_bin(),
"python_path": git_determine_python_path(),
}
return ctxt
def __call__(self):
total_processes = _calculate_workers()
ctxt = {
"service_name": self.service_name,
"user": self.user,
"group": self.group,
"script": self.script,
"admin_script": self.admin_script,
"public_script": self.public_script,
"processes": int(math.ceil(self.process_weight * total_processes)),
"admin_processes": int(math.ceil(self.admin_process_weight *
total_processes)),
"public_processes": int(math.ceil(self.public_process_weight *
total_processes)),
"threads": 1,
"usr_bin": git_determine_usr_bin(),
"python_path": git_determine_python_path(),
}
return ctxt
def __call__(self):
total_processes = _calculate_workers()
ctxt = {
"service_name": self.service_name,
"user": self.user,
"group": self.group,
"script": self.script,
"admin_script": self.admin_script,
"public_script": self.public_script,
"processes": int(math.ceil(self.process_weight * total_processes)),
"admin_processes": int(math.ceil(self.admin_process_weight *
total_processes)),
"public_processes": int(math.ceil(self.public_process_weight *
total_processes)),
"threads": 1,
"usr_bin": git_determine_usr_bin(),
"python_path": git_determine_python_path(),
}
return ctxt
def save_ims(filename, ims, dpi=100, scale=0.5):
n, c, h, w = ims.shape
rows = int(math.ceil(math.sqrt(n)))
cols = int(round(math.sqrt(n)))
fig, axes = plt.subplots(rows, cols, figsize=(w*cols/dpi*scale, h*rows/dpi*scale), dpi=dpi)
for i, ax in enumerate(axes.flat):
if i < n:
ax.imshow(ims[i].transpose((1, 2, 0)))
ax.set_xticks([])
ax.set_yticks([])
ax.axis('off')
plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0.1, hspace=0.1)
plt.savefig(filename, dpi=dpi, bbox_inces='tight', transparent=True)
plt.clf()
plt.close()
def __init__(self, archivelist):
self.node_archives = archivelist
self.jobdir = os.path.dirname(archivelist[0])
self.job_id = "1"
self.end_str = "end"
self.walltime = 9751
self.nodecount = len(archivelist)
self.acct = {"end_time": 12312, "id": 1, "uid": "sdf", "user": "werqw"}
self.nodes = ["node" + str(i) for i in xrange(len(archivelist))]
self._data = {}
archive_starts = []
archive_ends = []
for archive in archivelist:
context = pmapi.pmContext(c_pmapi.PM_CONTEXT_ARCHIVE, archive)
mdata = context.pmGetArchiveLabel()
archive_starts.append(datetime.datetime.utcfromtimestamp(math.floor(mdata.start)))
archive_ends.append(datetime.datetime.utcfromtimestamp(math.ceil(context.pmGetArchiveEnd())))
self.start_datetime = min(archive_starts)
self.end_datetime = max(archive_ends)
def adjust_job_start_end(job):
""" Set the job node start and end times based on the presence of the special
job-X-begin and job-X-end archives. Do nothing if these archives are absent
"""
startarchive = "job-{0}-begin".format(job.job_id)
endarchive = "job-{0}-end".format(job.job_id)
for nodename, filepaths in job.rawarchives():
begin = None
end = None
for fname in filepaths:
filename = os.path.basename(fname)
if filename.startswith(startarchive):
context = pmapi.pmContext(c_pmapi.PM_CONTEXT_ARCHIVE, fname)
mdata = context.pmGetArchiveLabel()
begin = datetime.datetime.utcfromtimestamp(math.floor(mdata.start))
if filename.startswith(endarchive):
context = pmapi.pmContext(c_pmapi.PM_CONTEXT_ARCHIVE, fname)
end = datetime.datetime.utcfromtimestamp(math.ceil(context.pmGetArchiveEnd()))
job.setnodebeginend(nodename, begin, end)
def run_if_needed(base_file, then_file, now_file):
# Python uses doubles for mtime so it can't precisely represent linux's
# nanosecond precision. Round up to next whole second to ensure we get a
# stable timestamp that is guaranteed to be >= the timestamp of the
# compiler. This also avoids issues if the compiler is on a file system
# with high-precision timestamps, but the build directory isn't.
base_stat = os.stat(base_file)
mtime = math.ceil(base_stat.st_mtime)
atime = math.ceil(base_stat.st_atime)
if (os.path.exists(then_file)
and os.path.exists(now_file)
and os.stat(then_file).st_mtime == mtime):
return # Don't need to do anything.
createIfNeeded(now_file)
os.utime(now_file, None) # None means now
createIfNeeded(then_file)
os.utime(then_file, (atime, mtime))
def col_profile(num_cols, height):
profile = np.zeros(num_cols)
peak_width = int(math.ceil(num_cols * 0.125))
# average number of pixels should be height
for i in range(0, peak_width):
profile[i] = height
# average number of pixels should be 10% of height
for i in range(peak_width, num_cols - peak_width):
profile[i] = height * .1
# average number of pixels should be height
for i in range(num_cols - peak_width, num_cols):
profile[i] = height
# normalize to between 0 and 1
profile *= 1.0 / profile.max()
return profile