def main():
banner()
start = timer()
dork = 'inurl:"/component/tags/"'
file_string = '######## By MakMan ########\n'
final_result = []
count = 0
print( '[+] Starting dork scanner for : ' + dork)
sys.stdout.flush()
#Calling dork_scanner from makman.py for 6 pages and 6 parallel processes
search_result = dork_scanner( dork, '6', '6' )
print( '[+] Total URLs found : ' + str( len( search_result ) ) )
with open( 'urls.txt', 'a', encoding = 'utf-8' ) as ufile:
ufile.write( '\n'.join( search_result ) )
print( '[+] URLs written to urls.txt' )
print( '\n[+] Trying Joomla SQL Injection exploit on ' + str( len( search_result ) ) + ' urls' )
sys.stdout.flush()
#Running 8 parallel processes for the exploitation
with Pool(8) as p:
final_result.extend( p.map( inject, search_result ) )
for i in final_result:
if not 'Not Vulnerable' in i and not 'Bad Response' in i:
count += 1
file_string = file_string + i.split('~:')[0] + '\n' + i.split('~:')[1] + '\n' + i.split('~:')[2] + '\n' + i.split('~:')[3] + '\n' + i.split('~:')[4] + '\n' + i.split('~:')[5] + '\n' + i.split('~:')[6] + '\n\n\n'
#Writing vulnerable URLs in a file makman.txt
with open( 'makman.txt', 'a', encoding = 'utf-8' ) as rfile:
rfile.write( file_string )
print( 'Total URLs Scanned : ' + str( len( search_result ) ) )
print( 'Vulnerable URLs Found : ' + str( count ) )
print( 'Script Execution Time : ' + str ( timer() - start ) + ' seconds' )
def main():
# ********************************************************************
# read and test input parameters
# ********************************************************************
print('Parallel Research Kernels version ') #, PRKVERSION
print('Python Dense matrix-matrix multiplication: C = A x B')
if len(sys.argv) != 3:
print('argument count = ', len(sys.argv))
sys.exit("Usage: ./transpose <# iterations> <matrix order>")
iterations = int(sys.argv[1])
if iterations < 1:
sys.exit("ERROR: iterations must be >= 1")
order = int(sys.argv[2])
if order < 1:
sys.exit("ERROR: order must be >= 1")
print('Number of iterations = ', iterations)
print('Matrix order = ', order)
# ********************************************************************
# ** Allocate space for the input and transpose matrix
# ********************************************************************
A = numpy.fromfunction(lambda i,j: j, (order,order), dtype=float)
B = numpy.fromfunction(lambda i,j: j, (order,order), dtype=float)
C = numpy.zeros((order,order))
for k in range(0,iterations+1):
if k<1: t0 = timer()
#C += numpy.matmul(A,B) # requires Numpy 1.10 or later
C += numpy.dot(A,B)
t1 = timer()
dgemm_time = t1 - t0
# ********************************************************************
# ** Analyze and output results.
# ********************************************************************
checksum = numpy.linalg.norm(numpy.reshape(C,order*order),ord=1)
ref_checksum = 0.25*order*order*order*(order-1.0)*(order-1.0)
ref_checksum *= (iterations+1)
epsilon=1.e-8
if abs((checksum - ref_checksum)/ref_checksum) < epsilon:
print('Solution validates')
avgtime = dgemm_time/iterations
nflops = 2.0*order*order*order
print('Rate (MF/s): ',1.e-6*nflops/avgtime, ' Avg time (s): ', avgtime)
else:
print('ERROR: Checksum = ', checksum,', Reference checksum = ', ref_checksum,'\n')
sys.exit("ERROR: solution did not validate")
def main():
start = timer()
# Calling dork_scanner from makman.py for 15 pages and 4 parallel processes
search_result = dork_scanner('intext:Developed by : iNET inurl:photogallery.php', '15', '4')
file_string = '######## By MakMan ########\n'
final_result = []
count = 0
# Running 8 parallel processes for the exploitation
with Pool(8) as p:
final_result.extend(p.map(inject, search_result))
for i in final_result:
if not 'Not Vulnerable' in i and not 'Bad Response' in i:
count += 1
print('------------------------------------------------\n')
print('Url : http:' + i.split(':')[1])
print('User : '******':')[2])
print('Version : ' + i.split(':')[3])
print('------------------------------------------------\n')
file_string = file_string + 'http:' + i.split(':')[1] + '\n' + i.split(':')[2] + '\n' + i.split(':')[3] + '\n\n\n'
# Writing vulnerable URLs in a file makman.txt
with open('makman.txt', 'a', encoding='utf-8') as file:
file.write(file_string)
print('Total URLs Scanned : %s' % len(search_result))
print('Vulnerable URLs Found : %s' % count)
print('Script Execution Time : %s' % (timer() - start,))
def trycontext(n=100000):
while True:
from time import perf_counter as timer
i = iter(range(n))
t1 = timer()
while True:
try:
next(i)
except StopIteration:
break
t2 = timer()
# print("small try", t2 - t1)
i = iter(range(n))
t3 = timer()
try:
while True:
next(i)
except StopIteration:
pass
t4 = timer()
tsmall = D(t2) - D(t1)
tbig = D(t4) - D(t3)
fastest = "Small Try" if tsmall < tbig else "Big Try"
# noinspection PyStringFormat
print("small try %.8f" % tsmall, "big try %.8f" % tbig, "fastest:", fastest,
"%%%.1f" % ((tsmall - tbig) / tsmall * 100))
def simulator():
res_slow = []
res_fast = []
clusters = []
for size in range(2, 201):
clusters.append(gen_random_clusters(size))
# slow
for clist in clusters:
slow_start = timer()
slow(clist)
slow_end = timer()
res_slow.append(slow_end - slow_start)
# fast
for clist in clusters:
fast_start = timer()
fast(clist)
fast_end = timer()
res_fast.append(fast_end - fast_start)
x_axis = [num for num in range(2, 201)]
plt.title('Comparison of efficiency in desktop python environment')
plt.xlabel('size of random clusters')
plt.ylabel('running time (seconds)')
plt.plot(x_axis, res_slow, '-b', label='slow_closest_pair', linewidth=2)
plt.plot(x_axis, res_fast, '-r', label='fast_closest_pair', linewidth=2)
plt.legend(loc='upper left')
plt.show()
def main():
print (Style.BRIGHT)
banner()
count = 0
start = timer()
file_string = ''
final_result = []
# Make sure urls.txt is in the same directory
try:
with open( 'urls.txt' ) as f:
search_result = f.read().splitlines()
except:
print( 'urls.txt not found in the current directory. Create your own or download from here. http://makman.tk/vb/urls.txt\n' )
sys.exit(0)
search_result = list( set( search_result ) )
print (' [+] Executing Exploit for ' + Fore.RED + str( len( search_result ) ) + Fore.WHITE + ' Urls.\n')
with Pool(8) as p:
final_result.extend( p.map( inject, search_result ) )
for i in final_result:
if not 'Not Vulnerable' in i and not 'Bad Response' in i:
count += 1
file_string = file_string + i.split( ':::' )[0].strip() + '\n' + i.split( ':::' )[1].strip() + '\n' + i.split( ':::' )[2].strip() + '\n' + i.split( ':::' )[3].strip()
file_string = file_string + '\n------------------------------------------\n'
# Writing Result in a file makman.txt
with open( 'makman.txt', 'a', encoding = 'utf-8' ) as rfile:
rfile.write( file_string )
print( 'Total URLs Scanned : ' + str( len( search_result ) ) )
print( 'Vulnerable URLs Found : ' + str( count ) )
print( 'Script Execution Time : ' + str ( timer() - start ) + ' seconds' )
def time_test(container, key_count, key_range, randrange=randrange, timer=timer):
t1 = timer()
for _i in range(key_count):
keys = test_key % randrange(key_range)
container[keys]
t2 = timer()
return t2 - t1
def _get_fps(self, frame):
elapsed = int()
start = timer()
preprocessed = self.framework.preprocess(frame)
feed_dict = {self.inp: [preprocessed]}
net_out = self.sess.run(self.out, feed_dict)[0]
processed = self.framework.postprocess(net_out, frame, False)
return timer() - start
def do_parse_test(times, func=quick_strptime):
t1 = timer()
stripped = map(str.strip, times)
raw = list(takewhile(bool, stripped))
fmt = ParseDateFormat(raw[0])
list(func(date, fmt) for date in raw)
t2 = timer()
return t2 - t1
def test_map(times, mock=quick_strptime, repeat=repeat):
t1 = timer()
stripped = map(str.strip, times)
raw = list(takewhile(bool, stripped))
fmt = ParseDateFormat(raw[0])
list(map(mock, raw, repeat(fmt)))
t2 = timer()
return t2 - t1
def test( *args ):
start = timer()
result = [ url for url in sitemap( *args )]
elapsed = timer() - start
print( 'Result: ', end ='' )
for r in result:
print( GET_DUMMY. search( r ). group(), end= ' ' )
print()
print( 'Elapsed:', elapsed * 1000, 'miliseconds' )
def do_superfast_test(times, special_map=special_handler_map):
t1 = timer()
stripped = map(str.strip, times)
raw = list(takewhile(bool, stripped))
fmt = ParseDateFormat(raw[0])
func = special_map[fmt]
list(map(func, raw))
t2 = timer()
return t2 - t1
def main(argv):
# Read Config
starttime = timer()
iniFile = "input/halo_makeDerivs.ini"
Config = ConfigParser.SafeConfigParser()
Config.optionxform = str
Config.read(iniFile)
paramList = []
fparams = {}
cosmo = {}
stepSizes = {}
fparams['hmf_model'] = Config.get('general','hmf_model')
fparams['exp_name'] = Config.get('general','exp_name')
for (key, val) in Config.items('hmf'):
if ',' in val:
param, step = val.split(',')
paramList.append(key)
fparams[key] = float(param)
stepSizes[key] = float(step)
else:
fparams[key] = float(val)
# Make a separate list for cosmology to add to massfunction
for (key, val) in Config.items('cosmo'):
if ',' in val:
param, step = val.split(',')
paramList.append(key)
cosmo[key] = float(param)
stepSizes[key] = float(step)
else:
cosmo[key] = float(val)
fparams['cosmo'] = cosmo
for paramName in paramList:
#Make range for each parameter
#First test: x2 the range, x0.01 the stepsize
if paramName in cosmo:
start = fparams['cosmo'][paramName] - stepSizes[paramName]
end = fparams['cosmo'][paramName] + stepSizes[paramName]
else:
start = fparams[paramName] - stepSizes[paramName]
end = fparams[paramName] + stepSizes[paramName]
width = stepSizes[paramName]*0.01
paramRange = np.arange(start,end+width,width)
for paramVal in paramRange:
if paramName in cosmo:
params = fparams.copy()
params['cosmo'][paramName] = paramVal
else:
params = fparams.copy()
params[paramName] = paramVal
print paramName,paramVal
N = clusterNum(params)
np.savetxt("output/step/"+fparams['exp_name']+'_'+fparams['hmf_model']+"_"+paramName+"_"+str(paramVal)+".csv",N,delimiter=",")
#----------------------------
endtime = timer()
print "Time elapsed: ",endtime-starttime
def run(cmd, timeout_sec):
start = timer()
with Popen(cmd, shell=True, stdout=PIPE, preexec_fn=os.setsid) as process:
try:
output = process.communicate(timeout=timeout_sec)[0]
except TimeoutExpired:
os.killpg(process.pid, signal.SIGINT) # send signal to the process group
output = process.communicate()[0]
print("DEBUG: process timed out: "+cmd)
print('DEBUG: Elapsed seconds: {:.2f}'.format(timer() - start))
def timing_middleware(next, root, info, **args):
start = timer()
return_value = next(root, info, **args)
duration = timer() - start
logger.debug("{parent_type}.{field_name}: {duration} ms".format(
parent_type=root._meta.name if root and hasattr(root, '_meta') else '',
field_name=info.field_name,
duration=round(duration * 1000, 2)
))
return return_value
def search(identity, num_of_imgs):
start = timer()
#inizialize the queue for multithreading
queue = Queue.Queue(maxsize=0)
#create query
query = identity['name'].replace('_', ' ')
query = query.split()
query = '+'.join(query)
#build a dictionary with search info
data = {
'query': query,
'label': identity['label'],
'num_of_imgs': num_of_imgs,
'header': {'User-Agent': 'Mozilla/5.0'}
}
#start threads
threads = []
if use_bing == 'true':
bing_search = Thread(target=fetcher, args=(queue, 'bing', data))
threads.append(bing_search)
if use_aol == 'true':
aol_search_1 = Thread(target=fetcher, args=(queue, 'aol1', data))
aol_search_2 = Thread(target=fetcher, args=(queue, 'aol2', data))
threads.append(aol_search_1)
threads.append(aol_search_2)
if use_yahoo == 'true':
yahoo_search = Thread(target=fetcher, args=(queue, 'yahoo', data))
threads.append(yahoo_search)
for t in threads:
t.start()
for t in threads:
t.join()
#if queue is not empty, save urls to db (status = OK), else end script (STATUS = ERR_F)
if not queue.empty():
queue_size = queue.qsize()
insert_urls(queue, identity, queue_size)
print 'Collector terminated for identity: ' + identity['name'] + ' - Number of images: ' \
+ str(queue_size) + ' - Elapsed time: ' + str((timer() - start))
else:
update_identity_status(identity, 'ERR_F')
print 'Collector terminated for identity: ' + identity['name'] + ' - Elapsed time: ' + str((timer() - start))
def benchmark(client, fn, num_transactions=200, num_workers=10, *args, **kwargs):
start = timer()
total_latency = 0
with concurrent.futures.ThreadPoolExecutor(max_workers=num_workers) as executor:
futures = [executor.submit(time_transaction(fn), client, *args, **kwargs) for _ in range(num_transactions)]
latencies = [f.result() for f in concurrent.futures.as_completed(futures)]
total_throughput = num_transactions / (timer() - start)
return (latencies, total_throughput)
def inplace_speed():
from time import perf_counter as timer
_map = map
n = D(1)
i = D(1)
incr = i.__add__
loops = 100000 * 100
test_data = tuple(D(1) for _ in range(loops))
t1 = timer()
for n in test_data:
n = incr(n)
t2 = timer()
t3 = timer()
for n in test_data:
n += i
t4 = timer()
t5 = timer()
for num in _map(incr, test_data):
a = num
t6 = timer()
t7 = timer()
for num in test_data:
a = num + i
t8 = timer()
print("Incr:", t2 - t1, "normal:", t4 - t3, 'map:', t6 - t5, "comp", t8 - t7)
def get_result(worker_name, uuid, timeout=None, sg_url=SG_URL):
"""
Wait for processing results and return RAW data structure.
:param timeout: How many seconds to wait for a result.
:param worker_name: name of the worker
:param uuid: UUID of the task
:param sg_url: URL of the service gateway
"""
logger = getLogger(__name__)
status = None
logger.info("Getting result of processing request %s for %s",
uuid, worker_name)
status_url = urljoin(sg_url, "{}/status".format(worker_name))
logger.debug("Status URL is %s", status_url)
starttime = timer()
logger.debug("Started at %s", starttime)
if timeout:
timeout = int(timeout)
logger.info("Using %s as timeout value", timeout)
while status != 'SUCCESS':
logger.info("Waiting for success state")
sleep(SUCCESS_WAIT_ITER_TIME)
r_val = requests.get(status_url, params={'uuid': uuid})
if r_val.status_code != 502: # Ignore Bad gateway return codes...
r_val.raise_for_status()
else:
logger.warning("BAD gateway response: %s", r_val)
status = r_val.json()['status']
logger.debug(r_val.text)
logger.info("Status is %s", status)
if status == "FAILURE":
raise ServerError("Error: Remote server says: {}".
format(r_val.json()['result']['message']))
elif status == "PROGRESS":
progress = r_val.json()['result']['current']
logger.info("Progress stated at %s%%", progress)
elif status in ['EXPIRED', 'REVOKED']:
raise ServerError("Error with task status: Contact administrator")
latency = int(timer() - starttime)
logger.info("Current latency is %s", latency)
if latency > timeout:
raise TimeOutError("Process did not succeed in required time")
status_result = r_val.json()
logger.debug("Result string is %s", status_result)
return status_result
def main():
start = timer()
# Empty List to store the Urls
result = []
arguments = docopt(__doc__, version='Google scraper')
search = arguments['<search>']
pages = arguments['<pages>']
# Calling the function [pages] times.
for page in range(0, int(pages)):
# Getting the URLs in the list
result.extend(get_urls(search, str(page * 10)))
# Removing Duplicate URLs
result = list(set(result))
print(*result, sep='\n')
print('\nTotal URLs Scraped : %s ' % str(len(result)))
print('Script Execution Time : %s ' % (timer() - start,))
def wrapped(client, retry=False, *args, **kwargs):
start = timer()
success = False
while success == False:
try:
txn = client.transaction()
fn(txn, *args, **kwargs)
txn.commit()
success = True
except TransactionFailureException:
if not retry:
break
else:
continue
latency = timer() - start
return latency
def main():
parser = ArgumentParser()
parser.add_argument(
'-s', '--host', default='http://127.0.0.1', help='tracker host')
parser.add_argument(
'-p', '--port', default=6000, help='tracker host port', type=int)
parser.add_argument(
'-n', '--users', default=1, help='how many users to create', type=int)
options = parser.parse_args()
urlbase = '{}:{}/'.format(options.host, options.port)
session = requests.Session()
for user in range(options.users):
# username is just a random number
new_username = str(random.randint(1e6, 1e7))
# all new users have one password for simple debug
new_password = '******'
resp = session.post(urljoin(urlbase, 'auth/signup'),
json={'username': new_username,
'password': new_password})
resp.raise_for_status()
token = resp.json()['access_token']
session.auth = TrackerAuth(token)
fake_data = create_fake_data()
ts = timer()
resp = session.post(
urljoin(urlbase, 'events'),
headers={'Content-Type': 'application/json'},
data=json.dumps(fake_data, default=default))
delta = timer() - ts
resp.raise_for_status()
print('{} events in {:.2f}s @ {:.2f} rps'
.format(len(fake_data), delta, len(fake_data) / delta))
def main():
start = timer()
result = []
arguments = docopt(__doc__, version='MakMan Google Scrapper & Mass Exploiter')
search = arguments['<search>']
pages = arguments['<pages>']
processes = int(arguments['<processes>'])
####Changes for Multi-Processing####
make_request = partial(get_urls, search)
pagelist = [str(x * 10) for x in range(0, int(pages))]
with Pool(processes) as p:
tmp = p.map(make_request, pagelist)
for x in tmp:
result.extend(x)
####Changes for Multi-Processing####
result = list(set(result))
print(*result, sep='\n')
print('\nTotal URLs Scraped : %s ' % str(len(result)))
print('Script Execution Time : %s ' % (timer() - start,))
def search(grid, type, line):
begin_search = timer()
start, goal = get_start_and_goal(line, grid)
# start, goal = [line, 0], [line + 20, 3320]
if type == 'A':
print 'A*..'
a = astar.Astar(grid)
path, map = a.pathfind(start, goal)
elif type == 'jps':
print 'A* + JPS...'
j = jps.Jps(grid)
path, map = j.pathfind(start, goal)
print ' => path found in ' + str(timer() - begin_search) + ' s'
return path, map
def repeat(function, kwargs, title, count, verbose=True):
t0 = timer()
id_list = []
while len(id_list) < count:
func = deepcopy(function)
kw = deepcopy(kwargs)
id_list.append(func(**kw))
t1 = timer()
if verbose:
print('%s inits of %s in %s secs' % (count, title, (t1 - t0)))
rand_int = randomlab.random_integer(0, (count - 1))
rand_item = id_list[rand_int]
try:
rand_str = str(rand_item)
if verbose:
print('Value of item[%s] of %s performance test is: %s' % (rand_int, title, rand_str))
except:
if verbose:
print('Value returned by %s cannot be coerced into a string.' % title)
return rand_item
def downloader(identity, DATA_DIR):
start = timer()
# take image urls for an identity from db
images = select_urls(identity)
# start multithreading
queue = Queue.Queue(maxsize=0)
download_master(images, queue, identity)
# if queue is not empty, save images to disk (status = DONE), else end script (STATUS = ERR_D)
if not queue.empty():
queue_size = queue.qsize()
print identity["name"] + " - Saving to disk.."
save(queue, identity, DATA_DIR)
print "Donwload terminated for identity: " + identity["name"] + " Number of images saved: " + str(
queue_size
) + " - Elapsed time: " + str((timer() - start))
else:
update_identity_status(identity, "ERR_D")
print "Donwload failed for identity: " + identity["name"] + " - Elapsed time: " + str((timer() - start))
def execute_size_euler(size, ws, nr, results):
euler_graph = create_euler(size, 30)
start = timer()
euler(euler_graph, 0, [])
time = timer()-start
results[0].append(time)
#ws["B"+str(nr)] = time
euler_graph = create_euler(size, 50)
start = timer()
euler(euler_graph, 0, [])
time = timer()-start
results[1].append(time)
#ws["C"+str(nr)] = time
euler_graph = create_euler(size, 70)
start = timer()
euler(euler_graph, 0, [])
time = timer()-start
results[2].append(time)
def execute_size_hamilton(size, ws, nr, results):
hamilton_graph = create_hamilton(size, 30)
start = timer()
result = hamilton(hamilton_graph, 0, 1, [1] + [0]*(len(hamilton_graph)-1))
if result=="False":
print "LOL"
time = timer()-start
results[3].append(time)
#ws["G"+str(nr)] = time
hamilton_graph = create_hamilton(size, 50)
start = timer()
hamilton(hamilton_graph, 0, 1, [1] + [0]*(len(hamilton_graph)-1))
time = timer()-start
results[4].append(time)
#ws["H"+str(nr)] = time
hamilton_graph = create_hamilton(size, 70)
start = timer()
hamilton(hamilton_graph, 0, 1, [1] + [0]*(len(hamilton_graph)-1))
time = timer()-start
results[5].append(time)
def generate_model_exons():
tic = timer()
cur = _con.cursor()
genes = get_all_genes(cur)
gene_count = 0
ex_count = 0
# delete old model exons/transcript if they exist
cur.execute('''
DELETE FROM exon
WHERE transcript_id IN (
SELECT id
FROM transcript
WHERE is_model=true
);
''')
cur.execute(
'''
DELETE FROM transcript WHERE is_model=true;
''', )
for (gene_name, chrom, strand), gene_id in genes.items():
cur.execute(
'''
SELECT chrom_start, chrom_end
FROM exon
WHERE transcript_id IN (
SELECT id
FROM transcript
WHERE gene_id=%s AND is_model=false
);
''', (gene_id, ))
exon_coords = cur.fetchall()
new_coords = interval_union(exon_coords)
start_pos = min(i[0] for i in new_coords)
end_pos = max(i[1] for i in new_coords)
if strand == '-':
new_coords.reverse()
# insert transcript
transcript_id = insert_transcript(
{
'start': start_pos,
'end': end_pos,
'attributes': {}
},
gene_id,
None,
cur,
is_model=True)
# insert exons
for i, (start, end) in enumerate(new_coords, 1):
insert_exon(
{
'start': start,
'end': end,
'attributes': {
'exon_number': i
}
}, transcript_id, cur)
ex_count += 1
gene_count += 1
_con.commit()
cur.close()
toc = timer()
print(f'generated\n\t{ex_count} exons\nacross\n\t{gene_count} genes')
print(f'in {toc-tic} seconds')
def join_words_builder(words: List[str]) -> str:
"""Joins words using a StringBuilder"""
builder = StringBuilder()
for word in words:
builder.append(word)
return builder.to_string()
def join_words_join(words: List[str]) -> str:
"""Joins words using str.join"""
return ''.join(words)
test_words = ['hehe', 'haha', 'hoho', 'hawhaw', 'ehehe', 'muahahahahhaha'
] * 10000000
start = timer()
joined = join_words_cat(test_words)
stop = timer()
print(f'Runtime of join_words_cat was {stop - start:0.4f} seconds')
start = timer()
joined = join_words_builder(test_words)
stop = timer()
print(f'Runtime of join_words_builder was {stop - start:0.4f} seconds')
start = timer()
joined = join_words_join(test_words)
stop = timer()
print(f'Runtime of join_words_join was {stop - start:0.4f} seconds')
def get_magnitude_keys(self):
return [
'TICv8_Bmag', 'TICv8_e_Bmag', 'TICv8_Vmag', 'TICv8_e_Vmag',
'TICv8_umag', 'TICv8_e_umag', 'TICv8_gmag', 'TICv8_e_gmag',
'TICv8_rmag', 'TICv8_e_rmag', 'TICv8_imag', 'TICv8_e_imag',
'TICv8_zmag', 'TICv8_e_zmag', 'TICv8_Jmag', 'TICv8_e_Jmag',
'TICv8_Hmag', 'TICv8_e_Hmag', 'TICv8_Kmag', 'TICv8_e_Kmag',
'TICv8_TWOMflag', 'TICv8_prox', 'TICv8_w1mag', 'TICv8_e_w1mag',
'TICv8_w2mag', 'TICv8_e_w2mag', 'TICv8_w3mag', 'TICv8_e_w3mag',
'TICv8_w4mag', 'TICv8_e_w4mag', 'TICv8_GAIAmag', 'TICv8_e_GAIAmag',
'TICv8_Tmag', 'TICv8_e_Tmag'
]
if __name__ == '__main__':
t0 = timer()
cat = catalog()
t1 = timer()
print('took', t1 - t0, 's')
print(cat.data)
# def load(tic_id=None, sector=None, keys=None):
# f = '/Users/mx/Dropbox (Personal)/Science/TESS/TESS_SC_target_lists/unique_targets_S001-S023_obs_tic_gaia_banyan.csv.gz'
# df = pd.read_csv(f, dtype=str, usecols=keys)
# #::: filter by tic_id(s), select only requested rows
# if tic_id is not None:
# tic_id = [str(int(t)) for t in np.atleast_1d(tic_id)]
# df = df.loc[df['TIC_ID'].isin(list(tic_id))]
# #::: filter by sector(s), select only requested rows
from pygame import *
from random import *
from time import time as timer
win_widh = 1000
win_hight = 400
win = display.set_mode((win_widh, win_hight))
display.set_caption('Plants')
ImegHero = 'Woodman.png'
ImeBack = 'Forest.png'
ImeAnemi = 'BigCliz.png'
img_bullet = 'Ball.png'
TimeNow = timer()
TimeHit = timer()
# clock = time.Clock()
class GameSprite(sprite.Sprite):
def __init__(self, PLimage, playX, playY, sizeX, sizeY, speed):
sprite.Sprite.__init__(self)
self.image = transform.scale(image.load(PLimage), (sizeX, sizeY))
self.speed = speed
self.rect = self.image.get_rect()
self.rect.x = playX
self.rect.y = playY
existences[0] = tm.initial_cardinality
ids = np.zeros((nsamples, nobjects), dtype=bool)
tracker_structure = (samples, existences, ids)
new_samples = np.empty(samples.shape)
new_exist = np.empty(existences.shape)
new_ids = np.empty(ids.shape, dtype=bool)
new_tracker_structure = (new_samples, new_exist, new_ids)
# unique labels, because id columns will be reused
# assigned at first time object is recognized
unique_ids = np.zeros((nobjects, ), dtype=int)
unique_id_count = 0
worst_time = 0.
first_time = timer()
for time in range(0, maxtime, skip):
starttime = timer()
measurements = data[times[time]:times[time + 1]]
n_measurements = len(measurements)
# predict
tm.predict(samples)
existences *= tm.survival(samples)
#tm.debug(samples[existences > 1e-10])
# entry
# so this is hacky... but given the limited number of components
# and the fact that they aren't easily merged, it is better to not
# include entry components every single time
def timed_callback(self, name):
s = timer()
yield
self.add(name, timer() - s)
def gui_loop(device):
global prev_gbu_counter_change_time
do_print = True
print_time = 0.0
time = timer()
handle_time = timer()
write_time_capture = timer()
prev_gbu_counter_change_time = timer()
gbu_counter_change_time = timer()
skip_write = 0
prev_counter = 0
send_stream_request_command_once = 1
# cnt = None
# prev_cnt = None
# value = None
global special_cmd
# global print_flag
while True:
# Reset the counter
if (do_print):
print_time = timer()
# Write to the device
# if send_stream_request_command_once == 1:
# send_stream_request_command_once = 0
# if PRODUCT_ID == PRODUCT_ID_LAP_NEW_CAMERA:
# print("enforce streaming of data with command 0x82"
# if device is attached enforce streaming of data.
# device.write(WRITE_DATA_CMD_START)
if special_cmd == 'I':
if PRODUCT_ID == PRODUCT_ID_STATION:
WRITE_DATA = WRITE_DATA_CMD_START_0x304
else:
WRITE_DATA = WRITE_DATA_CMD_START
device.write(WRITE_DATA)
print("special_cmd Start")
special_cmd = 0
# elif special_cmd == 'S':
# WRITE_DATA = WRITE_DATA_CMD_GET_BOARD_TYPE
# device.write(WRITE_DATA)
# print("special_cmd CMD_GET_BOARD_TYPE")
# # print_flag = 1
# special_cmd = 0
# elif special_cmd == 'A':
# WRITE_DATA = WRITE_DATA_CMD_A
# print("special_cmd A -> keep Alive + fast BLE update (every 20 msec)")
# special_cmd = 0
# elif special_cmd == 'M':
# WRITE_DATA = WRITE_DATA_CMD_M
# print("special_cmd M -> moderate BLE update rate every 50 mSec")
# special_cmd = 0
# elif special_cmd == 'B':
# WRITE_DATA = WRITE_DATA_CMD_B
# device.write(WRITE_DATA)
# print("special_cmd B -> set_BSL_mode --- this will stop HID communication with this GUI")
# special_cmd = 0
# else:
# WRITE_DATA = DEFAULT_WRITE_DATA
cycle_time = timer() - time
# print("cycle timer: %.10f" % cycle_time)
# If not enough time has passed, sleep for SLEEP_AMOUNT seconds
sleep_time = SLEEP_AMOUNT - (cycle_time)
# Measure the time
time = timer()
# print(" ")
# Read the packet from the device
value = device.read(READ_SIZE, timeout=READ_TIMEOUT)
# Update the GUI
if len(value) >= READ_SIZE:
# save into file:
analog = [(int(value[i + 1]) << 8) + int(value[i])
for i in LAP_ANALOG_INDEX_LIST]
channel_0 = analog[0]
channel_1 = analog[1]
channel_2 = analog[2]
channel_3 = analog[3]
channel_4 = analog[4]
counter = (int(value[COUNTER_INDEX + 1]) << 8) + int(
value[COUNTER_INDEX])
count_dif = counter - prev_counter
GBU_COUNTER_INDEX = 2 + 51 # need to add 2 since we have two bytes of lengths.
gbu_counter = (int(value[GBU_COUNTER_INDEX + 1]) << 8) + int(
value[GBU_COUNTER_INDEX])
gbu_counter2 = (int(value[GBU_COUNTER_INDEX]) << 8) + int(
value[GBU_COUNTER_INDEX + 1])
global file1
global prev_gbu_counter
# global prev_gbu_counter_change_time
#if count_dif > 1 :
# L = [ str(counter),", ", str(clicker_analog), ", " , str(count_dif), " <<<<<--- " ,"\n" ]
#else:
# L = [ str(counter),", ", str(clicker_analog), ", " , str(count_dif), "\n" ]
L = [
str(channel_0), ", ",
str(channel_1), ", ",
str(channel_2), ", ",
str(channel_3), ", ",
str(channel_4), "\n"
]
# file1.writelines(L)
# handler(value, do_print=do_print)
# print("Received data: %s" % hexlify(value))
Handler_Called = (timer() - handle_time)
if Handler_Called > 0.002:
# if Handler_Called > 0.02 :
#print("handler called: %.6f" % Handler_Called)
global print_every
# if gbu_counter2 != prev_gbu_counter:
# # check for 0x3f35ff0f then the rest
# if value[0] == 0x3f and value[1] == 0x35 and value[2] == 0xff and value[3] == 0x0f:
# print_every = 200
# delta_time = timer() - prev_gbu_counter_change_time
# gbu_counter_change_time = timer()
# print_every = print_every + 1
if print_every >= 200:
pass
# print_every = 0
# print("delta_time: %.1f" % delta_time, end="")
# L1 = [str(delta_time), "\n"]
# delta_time_str = "%.1f" %delta_time # save only 1 digit after decimal point
# event_time = get_time()
# L1 = [delta_time_str, " ",event_time, "\n"]
# # global FILE1_PATH
# # file1 = open(FILE1_PATH,"w")
# file1.writelines(L1)
# # file1.close()
# # print(" Received data: %s" % str(gbu_counter))
# # print(" Received data: %06x" % gbu_counter)
# # print(" Received data: %06x " % gbu_counter2 + "%f" %v)
# print(" Received data: %06d" % gbu_counter2 + " time: %s" %event_time)
# print(" Received data: %s" % hexlify(value))
# 10 20 30 40
# 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
#Received data: b'3f2e64006400640064006400640064006400640064006400640064006400010101010101010101010101000000010101761dbd7fcabf5a0fafe1f3cb94ace35f'
if value[0] == 0x3f and value[1] == 0x2e and value[
30] == 0x01 and value[31] == 0x01:
pass
# prev_gbu_counter = gbu_counter2
# prev_gbu_counter_change_time = gbu_counter_change_time
for n in range(30, 41):
if value[n] != 0x01:
st = get_date_time_milisec()
print(st, end=" ")
print(" pressed: ", n)
L1 = [st, " pressed: ", str(n), "\n"]
file1.writelines(L1)
# print("time: %.6f" % time)
handle_time = timer()
prev_counter = counter
# Update the do_print flag
do_print = (timer() - print_time) >= PRINT_TIME
# Create optimizer object.
opt = SANelderMead(prob.f, debug=0, maxiter=100000)
# Install custom reporter plugin. Print dot for 500 evaluations.
opt.installPlugin(
MyReporter(prob.name, 1000, concise=True, printImprovement=False))
# If problem has a custom initial simplex, set it.
if len(probdef) == 1:
opt.reset(prob.initial)
else:
# Custom simplex (for McKinnon)
opt.reset(probdef[1])
# Start timing, run, measure time.
dt = timer()
opt.run()
dt = timer() - dt
# Write number of function evaluations.
print(" %d evaluations" % opt.niter)
# Calculate initial and final gradient
gini = prob.g(prob.initial)
gend = prob.g(opt.x)
# Store results for this problem.
result = {
'i': opt.niter,
'x': opt.x,
'f': opt.f,
def timed_Module(self, name):
s = timer()
yield
self.add(name, timer() - s)
state = row[1]
city2 = row[2]
state2 = row[3]
origin_city = city + "," + state
destination_city = city2 + "," + state2
urls.append("https://maps.googleapis.com/maps/api/distancematrix/json" \
"?origins=%s&destinations=%s&units=imperial&key=%s" % (origin_city, destination_city, gkey))
counter = counter + 1
#make api requests
def dist_matrix(url):
try:
response = requests.get(url).json()
return url, response["rows"][0]["elements"][0]["duration"]["text"]
except Exception as e:
return url, None, e
#if url list is built, start pooling and calling function
if counter >= 950:
start = timer()
print("Timer started")
results = ThreadPool(20).imap_unordered(dist_matrix, urls)
for url, time in enumerate(results):
print(url, time)
print("Elapsed Time: %s" % (timer() - start, ))
else:
print(counter)
def menu():
while True:
print('01. Listar Cidades')
print('02. Listar Pontos Turísticos')
print('03. Distancia entre cidade e ponto turístico')
print('04. Mostrar Lista de Adjacencias')
print('05. Comparar Dijkstra e Bellman-Ford')
print('06. Encerrar')
print(
'\nA função 3 foi modificada para incluir o algoritmo de Bellman-Ford'
)
print(
'A função 5 compara Bellman-Ford e Dijkstra em todos os nós de forma geral\n'
)
func = int(input('Selecione uma função(1~6): '))
if func == 1:
print(' ')
for cidade in nodes:
print('[{}]: {}'.format(cidade, nodes[cidade]))
if cidade == 11:
break
print(' ')
elif func == 2:
print(' ')
for x in range(13, 30):
print('[{}]: {}'.format(x, nodes[x]))
print(' ')
elif func == 3:
partida = int(input('Selecione a cidade de partida(1 - 11): '))
destino = int(
input('Selecione o ponto turistico de destino(12 - 28): '))
print(' ')
print('Dijkstra:')
t0 = timer()
dijkstra(partida, destino)
t1 = timer()
print(' ({:.10f} s)'.format(t1 - t0))
print('Bellman Ford:')
t2 = timer()
bellmanFord(partida, destino, False)
t3 = timer()
print(dist[destino], 'km', end=' ')
print('({:.10f} s)'.format(t3 - t2))
print(" ")
elif func == 4:
print(" ")
printGrafo(grafo)
print(" ")
elif func == 5:
print('\nLista de distancias do ponto 1:\n')
t0 = timer()
for i in nodes:
dijkstra(1, i, False)
t1 = timer()
print(dijDist)
print('Dijkstra: {:.10f} segundos\n'.format(t1 - t0))
t2 = timer()
bellmanFord(1)
t3 = timer()
print(dist[1:])
print('Bellman-Ford: {:.10f} segundos\n'.format(t3 - t2))
elif func == 6:
return
else:
print('Função não definida!\n')
def acceptor_epoch(sess,
acceptor,
data_generator,
rnn_structure,
input_length,
y_dim,
x_dim,
t_timer,
stateful=True,
training=True):
"""
One epoch for either training or validation
:param sess: TensorFlow session
:param acceptor: acceptor instance
:param data_generator: iterator for generating batches
:param input_length: number of look back steps used for future prediction
:param y_dim: targets dismension
:param x_dim: inputs dimension
:param t_timer: in case running time is too long
:param training: boolean. true is training, false is validation or prediction
:return: averaged_loss for the epoch
"""
# one epoch for either training or prediction
num_layers = len(rnn_structure)
total_loss = 0
total_samples = 0
# Batch Generator returns a tuple of (data, sequence length, keys, current size)
# data: np 3-D array [record, time, feature]
# sequence length: np 1-D array [record]
# keys: np 1-D array [record]
# current size: scalar number of samples in current batch
for batch, seqlen, keys, current_size in data_generator:
if timer() - t_timer > timeLimit:
timeout = True
print("Training timeout during batching at epoch:", epoch)
break
init_state = np.zeros((num_layers, 2, current_size,
max(i[0] for i in rnn_structure)))
# initialize data slicer, iterator for slicing each batch to fit the acceptor network
data_slicer = DataSlicer(batch,
seqlen,
input_length,
y_dim,
x_dim,
random=random_slice)
# steps within a batch
for x, y, x_length in data_slicer:
if timer() - t_timer > time_limit:
timeout = True
print("Training timeout during slicing at epoch:", epoch)
break
num_effective_sample = (x_length > 0).sum()
total_samples += num_effective_sample
# take one step and calculate loss
preds, loss, final_state = acceptor_step(sess=sess,
acceptor=acceptor,
x=x,
y=y,
seqlen=x_length,
init_state=init_state,
training=training)
# accumulate training loss
if training:
total_loss += loss * num_effective_sample
else:
total_loss += loss
# initial state for the next GD update step
init_state = np.zeros((num_layers, 2, current_size,
max(i[0] for i in rnn_structure)))
# if the rnn is stateful the initial state for the next training step should be the final state of the current training step
if stateful:
for i in range(len(final_state)):
c = final_state[i][0] # LSTM cell state
h = final_state[i][1] # LSTM hidden state
n_row, n_col = c.shape
init_state[i][0][:nrow, :ncol] = c
init_state[i][1][:nrow, :ncol] = h
# if training is stopped due to timeout
if timeout:
# TODO: raise timeout exception
raise Exception("Timeout!")
return total_loss, total_samples
def acceptor_train(sess,
acceptor,
data_generator,
num_epochs,
rnn_structure,
input_length,
y_dim,
x_dim,
valid_data_generator=None,
verbose=True,
time_limit=float("Inf"),
stateful=True,
random_slice=True):
"""
Train the acceptor
:param sess: TensorFlow session
:param acceptor: acceptor instance
:param data_generator: iterator for generating batches
:param data_slicer: iterator for slicing each batch to fit the acceptor network
:param num_epochs: number of epochs to run for training the network
:param rnn_structure: define the structure of the acceptor. list of state tuples. Each tuple is a combinator of state size and drop out keep rate.[(9, .9), (20, .7)] means two stacked layers of 9 hidden units in first layer with 0.9 dropout KEEP rate and 20 units in second layer of 0.7 dropout KEEP rate.
:param input_length: number of look back steps used for future prediction
:param y_dim: targets dismension
:param x_dim: inputs dimension
:param valid_data_generator: iterator for generating validation batches
:param verbose: for debug and monitor purpose
:param time_limit: in case running time is too long
:param stateful: boolean indicating a stateful acceptor or not
:param random_slice: boolean indication random slice the batches or not
:return: training_losses, validation_losses
"""
# training statistics
training_losses = []
validation_losses = []
# initilize the timer, in case the training time is too long
t_timer = timer()
timeout = False
# start training
epoch = 0
# extract the number of RNN layers from rnn_structure
num_layers = len(self.rnn_structure)
while epoch <= num_epochs:
if timer() - t > timeLimit:
timeout = True
print("Training timeout at beginning of epoch:", epoch)
break
# take one epoch
averaged_loss = acceptor_epoch(sess=sess,
acceptor=acceptor,
data_generator=data_generator,
rnn_structure=rnn_structure,
t_timer=t_timer,
stateful=stateful,
training=True)
# training statistics
training_losses.append(averaged_loss)
# when one epoch is done, print training loss, test with validation
if verbose:
print("Average training loss for Epoch{}, loss:{}".format(
epoch, averaged_loss))
# if there are data for validation
if valid_data_generator:
averaged_valid_loss = acceptor_epoch(
sess=sess,
acceptor=acceptor,
data_generator=valid_data_generator,
rnn_structure=rnn_structure,
t_timer=t_timer,
stateful=stateful,
training=False)
# training statistics
validation_losses.append(averaged_valid_loss)
print("Average validation loss for Epoch{}, loss:{}".format(
epoch, averaged_valid_loss))
# next epoch
epoch += 1
return training_losses, validation_losses
def camera(self):
file = self.FLAGS.demo
SaveVideo = self.FLAGS.saveVideo
if self.FLAGS.track:
if self.FLAGS.tracker == "deep_sort":
from deep_sort import generate_detections
from deep_sort.deep_sort import nn_matching
from deep_sort.deep_sort.tracker import Tracker
metric = nn_matching.NearestNeighborDistanceMetric(
"cosine", 0.2, 100)
tracker = Tracker(metric)
encoder = generate_detections.create_box_encoder(
os.path.abspath(
"deep_sort/resources/networks/mars-small128.ckpt-68577"))
elif self.FLAGS.tracker == "sort":
from sort.sort import Sort
encoder = None
tracker = Sort()
if self.FLAGS.BK_MOG and self.FLAGS.track:
fgbg = cv2.bgsegm.createBackgroundSubtractorMOG()
if file == 'camera':
file = 0
else:
assert os.path.isfile(file), \
'file {} does not exist'.format(file)
camera = skvideo.io.VideoCapture(file)
if file == 0:
self.say('Press [ESC] to quit video')
assert camera.isOpened(), \
'Cannot capture source'
if self.FLAGS.csv:
f = open('{}.csv'.format(file), 'w')
writer = csv.writer(f, delimiter=',')
writer.writerow(['frame_id', 'track_id', 'x', 'y', 'w', 'h'])
f.flush()
else:
f = None
writer = None
if file == 0: #camera window
cv2.namedWindow('', 0)
_, frame = camera.read()
height, width, _ = frame.shape
cv2.resizeWindow('', width, height)
else:
_, frame = camera.read()
height, width, _ = frame.shape
if SaveVideo:
if file == 0: #camera window
fps = 1 / self._get_fps(frame)
if fps < 1:
fps = 1
else:
fps = get_fps_rate(file)
output_file = 'output_{}'.format(file)
if os.path.exists(output_file):
os.remove(output_file)
videoWriter = skvideo.io.VideoWriter(output_file,
fps=fps,
frameSize=(width, height))
videoWriter.open()
# buffers for demo in batch
buffer_inp = list()
buffer_pre = list()
elapsed = 0
start = timer()
self.say('Press [ESC] to quit demo')
#postprocessed = []
# Loop through frames
n = 0
while camera.isOpened():
elapsed += 1
_, frame = camera.read()
if frame is None:
print('\nEnd of Video')
break
if self.FLAGS.skip != n:
n += 1
continue
n = 0
if self.FLAGS.BK_MOG and self.FLAGS.track:
fgmask = fgbg.apply(frame)
else:
fgmask = None
preprocessed = self.framework.preprocess(frame)
buffer_inp.append(frame)
buffer_pre.append(preprocessed)
# Only process and imshow when queue is full
if elapsed % self.FLAGS.queue == 0:
feed_dict = {self.inp: buffer_pre}
net_out = self.sess.run(self.out, feed_dict)
for img, single_out in zip(buffer_inp, net_out):
if not self.FLAGS.track:
postprocessed = self.framework.postprocess(single_out,
img,
save=False)
else:
postprocessed = self.framework.postprocess(
single_out,
img,
frame_id=elapsed,
csv_file=f,
csv=writer,
mask=fgmask,
encoder=encoder,
tracker=tracker,
save=False)
if SaveVideo:
videoWriter.write(postprocessed)
# Clear Buffers
buffer_inp = list()
buffer_pre = list()
if elapsed % 5 == 0:
sys.stdout.write('\r')
sys.stdout.write('{0:3.3f} FPS'.format(elapsed /
(timer() - start)))
sys.stdout.flush()
sys.stdout.write('\n')
if SaveVideo:
videoWriter.release()
if self.FLAGS.csv:
f.close()
camera.release()
def ns_fit(datadir):
#::: init
config.init(datadir)
#::: show initial guess
show_initial_guess()
#::: settings
nlive = config.BASEMENT.settings[
'ns_nlive'] # (default 500) number of live points
bound = config.BASEMENT.settings[
'ns_bound'] # (default 'single') use MutliNest algorithm for bounds
ndim = config.BASEMENT.ndim # number of parameters
sample = config.BASEMENT.settings[
'ns_sample'] # (default 'auto') random walk sampling
tol = config.BASEMENT.settings[
'ns_tol'] # (defualt 0.01) the stopping criterion
#::: run
if config.BASEMENT.settings['ns_modus'] == 'static':
logprint('\nRunning Static Nested Sampler...')
logprint('--------------------------')
t0 = timer()
if config.BASEMENT.settings['multiprocess']:
with closing(
Pool(processes=(config.BASEMENT.
settings['multiprocess_cores']))) as pool:
logprint('\nRunning on',
config.BASEMENT.settings['multiprocess_cores'],
'CPUs.')
sampler = dynesty.NestedSampler(
ns_lnlike,
ns_prior_transform,
ndim,
pool=pool,
queue_size=config.BASEMENT.settings['multiprocess_cores'],
bound=bound,
sample=sample,
nlive=nlive)
sampler.run_nested(dlogz=tol, print_progress=True)
else:
sampler = dynesty.NestedSampler(ns_lnlike,
ns_prior_transform,
ndim,
bound=bound,
sample=sample,
nlive=nlive)
sampler.run_nested(dlogz=tol, print_progress=True)
t1 = timer()
timedynesty = (t1 - t0)
logprint("\nTime taken to run 'dynesty' (in static mode) is {} hours".
format(int(timedynesty / 60. / 60.)))
elif config.BASEMENT.settings['ns_modus'] == 'dynamic':
logprint('\nRunning Dynamic Nested Sampler...')
logprint('--------------------------')
t0 = timer()
if config.BASEMENT.settings['multiprocess']:
with closing(
Pool(processes=config.BASEMENT.
settings['multiprocess_cores'])) as pool:
logprint('\nRunning on',
config.BASEMENT.settings['multiprocess_cores'],
'CPUs.')
sampler = dynesty.DynamicNestedSampler(
ns_lnlike,
ns_prior_transform,
ndim,
pool=pool,
queue_size=config.BASEMENT.settings['multiprocess_cores'],
bound=bound,
sample=sample)
sampler.run_nested(nlive_init=nlive,
dlogz_init=tol,
print_progress=True)
else:
sampler = dynesty.DynamicNestedSampler(ns_lnlike,
ns_prior_transform,
ndim,
bound=bound,
sample=sample)
sampler.run_nested(nlive_init=nlive, print_progress=True)
t1 = timer()
timedynestydynamic = (t1 - t0)
logprint("\nTime taken to run 'dynesty' (in dynamic mode) is {} hours".
format(int(timedynestydynamic / 60. / 60.)))
#::: pickle-save the 'results' class
results = sampler.results
with open(os.path.join(config.BASEMENT.outdir, 'save_ns.pickle'),
'wb') as f:
pickle.dump(results, f)
def __init__(self, summarize_every=5, disabled=False):
self.last_tick = timer()
self.logs = OrderedDict()
self.summarize_every = summarize_every
self.disabled = disabled
def camera(self):
global current_count
file = self.FLAGS.demo
SaveVideo = self.FLAGS.saveVideo
if file == 'camera':
file = 0
else:
assert os.path.isfile(file), \
'file {} does not exist'.format(file)
camera = cv2.VideoCapture(file)
if file == 0:
self.say('Press [ESC] to quit demo')
assert camera.isOpened(), \
'Cannot capture source'
if file == 0: # camera window
cv2.namedWindow('', 0)
_, frame = camera.read()
height, width, _ = frame.shape
cv2.resizeWindow('', width, height)
else:
_, frame = camera.read()
height, width, _ = frame.shape
if SaveVideo:
fourcc = cv2.VideoWriter_fourcc(*'XVID')
if file == 0: # camera window
fps = 1 / self._get_fps(frame)
if fps < 1:
fps = 1
else:
fps = round(camera.get(cv2.CAP_PROP_FPS))
videoWriter = cv2.VideoWriter('video.avi', fourcc, fps,
(width, height))
# buffers for demo in batch
buffer_inp = list()
buffer_pre = list()
elapsed = int()
start = timer()
self.say('Press [ESC] to quit demo')
# Loop through frames
i = 0
count = 0
while camera.isOpened():
elapsed += 1
_, frame = camera.read()
i += 1
if frame is None:
print('\nEnd of Video')
break
if i % 20 == 0:
preprocessed = self.framework.preprocess(frame)
buffer_inp.append(frame)
buffer_pre.append(preprocessed)
# Only process and imshow when queue is full
if elapsed % self.FLAGS.queue == 0:
feed_dict = {self.inp: buffer_pre}
net_out = self.sess.run(self.out, feed_dict)
for img, single_out in zip(buffer_inp, net_out):
postprocessed, count = self.framework.postprocess(
single_out, img, False)
current_count = count
if SaveVideo:
videoWriter.write(postprocessed)
# if file == 0: # camera window
# cv2.imshow('', postprocessed)
# Clear Buffers
buffer_inp = list()
buffer_pre = list()
if elapsed % 5 == 0:
sys.stdout.write('\r')
sys.stdout.write('{0:3.3f} FPS\n'.format(elapsed /
(timer() - start)))
sys.stdout.flush()
if file == 0: # camera window
choice = cv2.waitKey(1)
if choice == 27: break
# else:
# cv2.imshow('', frame)
# cv2.waitKey(1)
sys.stdout.write('\n')
if SaveVideo:
videoWriter.release()
camera.release()
if file == 0: # camera window
cv2.destroyAllWindows()
# Create optimizer object.
opt=SANelderMead(prob.f, debug=0, maxiter=100000)
# Install custom reporter plugin. Print dot for 500 evaluations.
opt.installPlugin(MyReporter(prob.name, 1000, concise=True, printImprovement=False))
# If problem has a custom initial simplex, set it.
if len(probdef)==1:
opt.reset(prob.initial)
else:
# Custom simplex (for McKinnon)
opt.reset(probdef[1])
# Start timing, run, measure time.
dt=timer()
opt.run()
dt=timer()-dt
# Write number of function evaluations.
print(" %d evaluations" % opt.niter)
# Calculate initial and final gradient
gini=prob.g(prob.initial)
gend=prob.g(opt.x)
# Store results for this problem.
result={
'i': opt.niter,
'x': opt.x,
'f': opt.f,
clock = time.Clock()
FPS = 60
pl1 = Player("yes1.png",30,200,4,25,100)
pl2 = Player("yes2.png",520,200,4,25,100)
ball = Gamesprite("мячик.png",240,200,4,100,75)
x = 3
y = 3
cccc = 0
ccc = 0
cc = randint(1,2)
c = 0
if cc == 2:
x *=-1
else :
x *=1
last_time = timer()
score1 = font.render(str(s1),True,(2,4,5))
score2 = font.render(str(s2),True,(6,7,8))
while game:
for e in event.get():
if e.type == QUIT:
game = False
if finish != True:
def verify(self):
if abs(self.time - timer()) > self.MaxVideoTime:
self.imagespath, self.videopath, self.time = self.path_saves()
self.videoWriter = self.video_partition()
self.time = timer()
def initSetConfig(self):
"""Reset the timer before setting configuration (tyically at startup)"""
self.timeStart = timer()
def total_timer(msg):
""" A context which add the time spent inside to TotalTimer. """
start = timer()
yield
t = timer() - start
_TOTAL_TIMER_DATA[msg].feed(t)
def reset_timer(self):
self.last_tick = timer()
def main():
# client = Client(processes = False) # threads ?
client = Client()
size = 10000000
# size = 20
# shards = 20
# shards = 6
# shards = 1
shards = 12
shape = [size]
lat = np.random.rand(size) * 180.0 - 90.0
lon = np.random.rand(size) * 360.0 - 180.0
resolution_ = 8
resolution = np.full(shape, resolution_, dtype=np.int64)
# print('lat shape: ',lat.shape)
print('')
serial_start = timer()
s_sids = ps.from_latlon(lat, lon, resolution_)
s_sidsstr = [hex16(s_sids[i]) for i in range(len(s_sids))]
serial_end = timer()
# print('0 s_sids: ',s_sids)
print('time s_sids: ', serial_end - serial_start)
def w_from_latlon(llr):
# print('')
# print('llr: ',llr)
sids = ps.from_latlon(llr[0], llr[1], int(llr[2][0]))
# print('sids: ',sids)
# print('')
return sids
# def w_from_latlon1(lat,lon,res):
# return ps.from_latlon(np.array([lat],dtype=np.double)\
# ,np.array([lon],dtype=np.double)\
# ,int(res))
# sid = ps.from_latlon(lat,lon,resolution)
# sid = client.map(w_from_latlon1,lat,lon,resolution) # futures
dask_start = timer()
shard_size = int(size / shards)
shard_bins = np.arange(shards + 1) * shard_size
shard_bins[-1] = size
# print('---')
# print('shards: ',shards)
# print('shard_size: ',shard_size)
# print('shard_bins: ',shard_bins)
# print('---')
lat_shards = [lat[shard_bins[i]:shard_bins[i + 1]] for i in range(shards)]
lon_shards = [lon[shard_bins[i]:shard_bins[i + 1]] for i in range(shards)]
res_shards = [
resolution[shard_bins[i]:shard_bins[i + 1]] for i in range(shards)
]
llr_shards = []
for i in range(shards):
llr_shards.append([lat_shards[i], lon_shards[i], res_shards[i]])
# print('llr_shards len: ',len(llr_shards))
# print('llr_shards: ',llr_shards)
## future = client.submit(func, big_data) # bad
##
## big_future = client.scatter(big_data) # good
## future = client.submit(func, big_future) # good
# sid = client.map(w_from_latlon,llr_shards) # futures
big_future = client.scatter(llr_shards)
sid = client.map(w_from_latlon, big_future) # futures
# print('0 sid: ',sid)
# print('9 len(sid): ',len(sid))
# for i in range(shards):
# print(i, ' 10 sid: ',sid[i])
# print(i, ' 11 sid: ',sid[i].result())
# print('15 sid: ',[type(i) for i in sid])
sid_cat = np.concatenate([i.result() for i in sid])
sidsstr = [hex16(sid_cat[i]) for i in range(len(sid_cat))]
dask_end = timer()
# print('2 sids: ',sids)
sids = sid_cat
print('')
# for i in range(size-20,size):
for i in np.array(np.random.rand(20) * size, dtype=np.int64):
print("%09i" % i, sidsstr[i], s_sidsstr[i], ' ', sids[i] - s_sids[i])
print('')
print('dask total threads: ', sum(client.nthreads().values()))
print('size: ', size)
print('shards: ', shards)
print('')
print('time sids: ', dask_end - dask_start)
print('time s_sids: ', serial_end - serial_start)
print('parallel speed up: ',
(serial_end - serial_start) / (dask_end - dask_start))
client.close()
#Let's keep the format from bridge_played_hands:
#name of the folder = first three digits of the lin files
for directory in [str(s) for s in range(423,534+1)]:
if not os.path.exists(directory):
os.makedirs(directory)
def fetch_lin_file(url):
#name of the folder = first three digits of the lin files
filename = url[-5:-2]+"/"+url[-5:]
try:
response = urlopen(url)
f=open(filename+'.lin', 'w')
f.write(response.read())
f.close()
return url, None
except Exception as e:
return url, e
#download them in parallel
#based on https://stackoverflow.com/questions/16181121/a-very-simple-multithreading-parallel-url-fetching-without-queue
start = timer()
results = ThreadPool(20).imap_unordered(fetch_lin_file, urls)#20 requests at a time
for url, error in results:
if error is None:
print("%r fetched in %ss" % (url[-5:], timer() - start))
else:
print("Error fetching %r: %s" % (url, error))
print("Elapsed Time: %s" % (timer() - start,))
# ===============================================
# Preparing files for network
# Drop indices for neutral reviews
to_drop = [2]
data_validation = data_validation[~data_validation['Polarity'].isin(to_drop)]
data_test = data_test[~data_test['airline_sentiment'].isin(to_drop)]
# Tweets corresponding to training, validation and test set
tweets_training = data_training['Tweet']
tweets_validation = data_validation['Tweet']
tweets_test = data_test['text']
# Create vocabulary from reduced tweets and dump it for easy read out.
# It takes ~2 s for creating a vocabulary for 1.6M reduced tweets.
t_start = timer()
flat_list = [word for tweet in tweets_training for word in tweet.split()
] # Equivalent of looping over different terms
# vocab = [*set(flat_list), ] # Using set and converting to a list
vocab = Counter()
vocab.update(flat_list)
t_stop = timer()
print("Time to create vocabulary for %d Tweets is %0.5f s" %
(len(tweets_training), t_stop - t_start))
# Output in terminal
# Time to create vocabulary for 1000 Tweets is 0.00122 s
# Time to create vocabulary for 1600000 Tweets is 1.76170 s
# Reducing limits with heapq package
t_start = timer()
red_word = 10000 # Number of reduced words in the vocabulary
def reset(self):
self.start = timer()
def stop_timer_for(self, i, score):
self.measurements[i][TIME] = timer() - self.t0
self.measurements[i][R1] = score[0]
self.measurements[i][R2] = score[1]
self.measurements[i][R4] = score[2]
os.makedirs(this)
requiredDirectories = [FLAGS.imgdir, FLAGS.binary,
FLAGS.backup, os.path.join(FLAGS.imgdir, 'out')]
if FLAGS.summary:
requiredDirectories.append(FLAGS.summary)
_get_dir(requiredDirectories)
tfnet = TFNet(FLAGS)
model = masknet.create_model()
model.summary()
model.load_weights("weights.hdf5")
elapsed = int()
start = timer()
tfnet.say('Press [ESC] to quit demo')
preprocessed = tfnet.framework.preprocess(frame)
buffer_inp.append(frame)
buffer_pre.append(preprocessed)
# Only process and imshow when queue is full
if elapsed % FLAGS.queue == 0:
feed_dict = {tfnet.inp: buffer_pre}
net_out = tfnet.sess.run(
[tfnet.out, tfnet.my_c2, tfnet.my_c3, tfnet.my_c4, tfnet.my_c5], feed_dict)
my_c2 = net_out[1]
my_c3 = net_out[2]
my_c4 = net_out[3]
my_c5 = net_out[4]
data_validation = data_validation[~data_validation['Polarity'].isin(to_drop)]
data_test = data_test[~data_test['airline_sentiment'].isin(to_drop)]
# Tweets corresponding to training, validation and test set
tweets_training = data_training['Tweet']
tweets_validation = data_validation['Tweet']
tweets_test = data_test['text']
# ===============================
# Preparing for inputs for embedding model
# Some Constants
VocLen = 10000 # Number of words to keep in dictionary in dictionary
MaxLen = 24
time_step = 50 # Same as vector dimension of GloVe Embedding
t_start = timer() # Clock start
tokenizer = Tokenizer(num_words=VocLen)
tokenizer.fit_on_texts(tweets_training)
# Save token for future use
with open('models/tokenizer_10k.pickle', 'wb') as handle:
pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)
# # Load tokenizer
# # Will be used in fast loading this routine.
# with open('models/tokenizer_10k.pickle', 'rb') as handle:
# tokenizer = pickle.load(handle)
# Converting sequences of tweets
X_train_seq = tokenizer.texts_to_sequences(tweets_training)
def timed_callback(self, name):
s = timer()
yield
self.add(name, timer() - s)
def main():
# ********************************************************************
# read and test input parameters
# ********************************************************************
print('Parallel Research Kernels version ') #, PRKVERSION
print('Python Sparse matrix-vector multiplication')
if len(sys.argv) < 3:
print('argument count = ', len(sys.argv))
sys.exit(
"Usage: ./sparse.py <# iterations> <2log grid size> <stencil radius>"
)
iterations = int(sys.argv[1])
if iterations < 1:
sys.exit("ERROR: iterations must be >= 1")
lsize = int(sys.argv[2])
if lsize < 0:
sys.exit("ERROR: lsize must be >= 0")
size = 2**lsize
size2 = size**2
radius = int(sys.argv[3])
if radius < 1:
sys.exit("ERROR: Stencil radius should be positive")
if size < (2 * radius + 1):
sys.exit("ERROR: Stencil radius exceeds grid size")
stencil_size = 4 * radius + 1
sparsity = (4. * radius + 1.) / size2
nent = size2 * stencil_size
print('Number of iterations = ', iterations)
print('Matrix order = ', size2)
print('Stencil diameter = ', 2 * radius + 1)
print('Sparsity = ', sparsity)
# ********************************************************************
# Initialize data and perform computation
# ********************************************************************
matrix = numpy.zeros(nent, dtype=float)
colIndex = numpy.zeros(nent, dtype=int)
vector = numpy.zeros(size2, dtype=float)
result = numpy.zeros(size2, dtype=float)
for row in range(size2):
i = int(row % size)
j = int(row / size)
elm = row * stencil_size
colIndex[elm] = offset(i, j, lsize)
for r in range(1, radius + 1):
colIndex[elm + 1] = offset((i + r) % size, j, lsize)
colIndex[elm + 2] = offset((i - r + size) % size, j, lsize)
colIndex[elm + 3] = offset(i, (j + r) % size, lsize)
colIndex[elm + 4] = offset(i, (j - r + size) % size, lsize)
elm += 4
# sort colIndex to make sure the compressed row accesses vector elements in increasing order
colIndex[row * stencil_size:(row + 1) * stencil_size] = sorted(
colIndex[row * stencil_size:(row + 1) * stencil_size])
for k in range(0, stencil_size):
elm = row * stencil_size + k
matrix[elm] = 1.0 / (colIndex[elm] + 1)
for k in range(iterations + 1):
if k < 1: t0 = timer()
# fill vector
vector += numpy.fromfunction(lambda i: i + 1.0, (size2, ))
# do the actual matrix-vector multiplication
for row in range(0, size2):
result[row] += numpy.dot(
matrix[stencil_size * row:stencil_size * (row + 1)],
vector[colIndex[stencil_size * row:stencil_size * (row + 1)]])
t1 = timer()
sparse_time = t1 - t0
#******************************************************************************
#* Analyze and output results.
#******************************************************************************
reference_sum = 0.5 * nent * (iterations + 1) * (iterations + 2)
vector_sum = numpy.linalg.norm(result, ord=1)
epsilon = 1.e-8
# verify correctness
if abs(vector_sum - reference_sum) < epsilon:
print('Solution validates')
flops = 2 * nent
avgtime = sparse_time / iterations
print('Rate (MFlops/s): ', 1.e-6 * flops / avgtime, ' Avg time (s): ',
avgtime)
else:
print('ERROR: Vector sum = ', vector_sum, ', Reference vector sum = ',
reference_sum)
sys.exit()
