def run_dt_solver(traces, subsetSize=config.DT_SUBSET_SIZE, txtFile="treeRepresentation.txt", strategy=config.DT_SAMPLING_STRATEGY, decreaseRate=config.DT_DECREASE_RATE,\
repetitionsInsideSampling=config.DT_REPETITIONS_INSIDE_SAMPLING, restartsOfSampling=config.DT_RESTARTS_OF_SAMPLING, q = None, encoder=DagSATEncoding,):
#try:
config.encoder = encoder
if q != None:
separateProcess = True
else:
separateProcess = False
ab = AtomBuilder()
ab.getExamplesFromTraces(traces)
#samplingStrategy = config.DT_SAMPLING_STRATEGY
samplingStrategy = strategy
#decreaseRate = config.DT_DECREASE_RATE
decreaseRate = decreaseRate
t = TicToc()
t.tic()
(atoms, atomTraceEvaluation) = ab.buildAtoms(sizeOfPSubset=subsetSize, strategy = samplingStrategy, sizeOfNSubset=subsetSize, probabilityDecreaseRate=decreaseRate,\
numRepetitionsInsideSampling=repetitionsInsideSampling, numRestartsOfSampling = restartsOfSampling)
fb = DTFormulaBuilder(features=ab.atoms,
data=ab.getMatrixRepresentation(),
labels=ab.getLabels())
fb.createASeparatingFormula()
timePassed = t.tocvalue()
atomsFile = "atoms.txt"
treeTxtFile = txtFile
ab.writeAtomsIntoFile(atomsFile)
numberOfUsedPrimitives = fb.numberOfNodes()
fb.tree_to_text_file(treeTxtFile)
# return (timePassed, len(atoms), numberOfUsedPrimitives)
if separateProcess == True:
q.put([timePassed, len(atoms), numberOfUsedPrimitives])
else:
return [timePassed, len(atoms), numberOfUsedPrimitives]
def run_single():
tictoc = TicToc()
tictoc.tic()
result = [eval(rs) for rs in range(CYCLES)]
ellapsed = tictoc.tocvalue()
print("Single: {}".format(ellapsed))
return result
def _throw(self):
dice = None
if self.method == 1: # insert from keyboard
flag = True
while flag:
padding = " " * (len(str(self.max_ind)) - len(str(self.ind)))
str_input = "throw " + padding + str(self.ind) + "/" + str(self.max_ind) + ", result: "
inp = input(str_input)
if all(c in "0123456789" for c in inp) and inp != "":
dice = int(inp) - 1
if dice in range(self.base):
flag = False
else:
print("invalid result, insert again")
else:
print("invalid result, insert again")
if self.method == 2: # dice result always 2
dice = 1
padding = " " * (len(str(self.max_ind)) - len(str(self.ind)))
print("throw " + padding + str(self.ind) + "/" + str(self.max_ind) + ", result: " + str(dice + 1))
if self.method == 3: # throw pressing keyboard
t = TicToc()
t.tic()
input("Press enter to throw")
dice = int(t.tocvalue() * 10**8) % self.base
padding = " " * (len(str(self.max_ind)) - len(str(self.ind)))
print("throw " + padding + str(self.ind) + "/" + str(self.max_ind) + ", result: " + str(dice + 1))
return dice
def _throw(self):
dice = None
if self.method == 1: # insert from keyboard
flag = True
while flag:
padding = " " * (len(str(self.max_ind)) - len(str(self.ind)))
str_input = "throw " + padding + str(self.ind) + "/" + str(
self.max_ind) + ", result: "
inp = input(str_input)
if all(c in "0123456789" for c in inp) and inp != "":
dice = int(inp) - 1
if dice in range(self.base):
flag = False
else:
print("invalid result, insert again")
else:
print("invalid result, insert again")
if self.method == 2: # dice result always 2
dice = 1
padding = " " * (len(str(self.max_ind)) - len(str(self.ind)))
print("throw " + padding + str(self.ind) + "/" +
str(self.max_ind) + ", result: " + str(dice + 1))
if self.method == 3: # throw pressing keyboard
t = TicToc()
t.tic()
input("Press enter to throw")
dice = int(t.tocvalue() * 10**8) % self.base
padding = " " * (len(str(self.max_ind)) - len(str(self.ind)))
print("throw " + padding + str(self.ind) + "/" +
str(self.max_ind) + ", result: " + str(dice + 1))
return dice
def __merge_knnr_data(self, knnsr_data):
if self.verbosity == 2:
print("Combining KNNSR data")
self.views = {}
ptids = self.data.get_ptids()
tictoc = TicToc()
tictoc.tic()
self.valid_ptids = []
for m in self.data.get_modalities():
self.views[m] = {}
for t in knnsr_data[m].keys():
xy_measurement = self.data.getXY(
ptids, m, target=t, split=False, impute_ptids=self.train_ptids
)
modality_ts = knnsr_data[m][t]
if not isinstance(modality_ts, self.data.backend.DataFrame):
modality_ts = self.data.backend.DataFrame(modality_ts)
view = self.merge_view(xy_measurement, modality_ts)
self.views[m][t] = view
self.valid_ptids += view[TADPOLEData.PTID].values.tolist()
if self.verbosity == 2:
print("Mergin KNNSR data took %f" % tictoc.tocvalue())
self.valid_ptids = list(set(self.valid_ptids))
if self.verbosity == 2:
print("%i patients in set" % len(self.valid_ptids))
def train_epoch(self, epoch, X_iter, verbose=0):
t = TicToc()
start = t.tic()
epoch_loss = 0.0
num_batches = 5
for idx, inputs in enumerate(X_iter):
inputs = inputs['input']
batch_size = inputs.shape[0]
# Convert to tensors and move to device
inputs = torch.tensor(inputs).to(self.device)
# Train batch and get batch loss
batch_loss = self.train_batch(inputs)
# Update epoch loss given als batch loss
epoch_loss += batch_loss
if verbose != 0:
print(
'[{}] Epoch: {} #batches {}/{}, loss: {:.8f}, learning rates: {:.6f}/{:.6f}'
.format(datetime.timedelta(seconds=int(t.toc() - start)),
epoch + 1, idx + 1, num_batches,
(batch_loss / ((idx + 1) * batch_size)),
self.encoder_lr, self.decoder_lr),
end='\r')
return epoch_loss
def poll_for_valid_message(consumer,
expected_file_identifier=b"f142",
timeout=15.0):
"""
Polls the subscribed topics by the consumer and checks the buffer is not empty or malformed.
Skips connection status messages.
:param consumer: The consumer object
:param expected_file_identifier: The schema id we expect to find in the message
:param timeout: give up if we haven't found a message with expected_file_identifier after this length of time
:return: Tuple of the message payload and the key
"""
timer = TicToc()
timer.tic()
while timer.tocvalue() < timeout:
msg = consumer.poll(timeout=1.0)
assert msg is not None
if msg.error():
raise MsgErrorException("Consumer error when polling: {}".format(
msg.error()))
if expected_file_identifier is None:
return msg.value(), msg.key()
elif expected_file_identifier is not None:
message_file_id = msg.value()[4:8]
assert (
expected_file_identifier == message_file_id
or message_file_id == b"ep00"
), f"Expected message to have schema id of {expected_file_identifier}, but it has {message_file_id}"
if message_file_id == b"f142":
return LogData.LogData.GetRootAsLogData(msg.value(),
0), msg.key()
def run_parallel():
tictoc = TicToc()
tictoc.tic()
result = Parallel(n_jobs=JOBS,
prefer=None)(delayed(eval)(rs) for rs in range(CYCLES))
ellapsed = tictoc.tocvalue()
print("Parallel: {}".format(ellapsed))
return result
def print_time_operation_took(function):
"""
Print the time it took to complete a given function
:param function: the function to run
"""
t = TicToc()
function()
t.toc()
def rxn_csv(format, name, dataset_dir):
"""
Load SBML, interpret as reaction graph, set features from csv.
:param format:
:param name:
:param dataset_dir:
:return:
"""
if cfg.dataset.interpretation != 'reaction_graph' or cfg.dataset.format != 'SBML' \
or cfg.dataset.node_attr_file is None:
return None
nw = Network.from_sbml(name)
t = TicToc()
t.tic()
if cfg.dataset.max_node_degree is not None:
nw = nw.limit_node_degrees(cfg.dataset.max_node_degree)
if cfg.dataset.max_edge_degree is not None:
nw = nw.limit_edge_degrees(cfg.dataset.max_edge_degree)
nw = nw.limit_to_largest_component() # returns igraph.Graph instead of
# biomodels.Network
nw = nw.bipartite_projection(which=Network.hyperedge_t)
import csv
csv_path = files('data').joinpath(cfg.dataset.node_attr_file)
attrs: dict
attrs = {}
with open(csv_path) as csvDataFile:
csvReader = csv.reader(csvDataFile)
# number of features is number of columns minus one for rxn id
for row in csvReader:
floats = [float(v) for v in row[1:len(row)]]
# row[0] is rxn id, all others are considered features
attrs[row[0]] = floats
for node in nw.vs:
node['node_label'] = 0 # TODO GG breaks if no node_label is set
if node['name'] in attrs:
node['has_feature'] = True
# for comparison experiments, consider the same subgraph but without node
# features
if cfg.dataset.use_node_feature is False:
node['node_feature'] = torch.tensor([0]).to(torch.float)
else:
node['node_feature'] = torch.tensor(attrs[node['name']]).to(
torch.float)
# consider the induced subgraph of those reactions with non-zero features
# TODO select only nodes which have features set,
# or simply save their ids in the loop above
nw_sub = nw.induced_subgraph(
nw.vs.select(has_feature=True)) # list of node ids
# nw_sub = nw
dsG = deepsnap.graph.Graph(nw_sub.to_networkx())
return [dsG]
def wrapper(*args, **kwargs):
setup_logging()
load_dotenv(find_dotenv())
logger.info("Loaded environment variables")
logger.info(f"Starting {main.__name__}() in {sys.argv[0]}")
t = TicToc()
t.tic()
main(*args, **kwargs)
logger.info(f"Finished {main.__name__}() in "
f"{timedelta(seconds=np.ceil(t.tocvalue()))}")
class ElapsedTime(object):
"""Measure the elapsed time between Tic and Toc"""
def __init__(self):
self.t = TicToc()
self.t.tic()
def elapsed(self):
_elapsed = self.t.tocvalue()
d = timedelta(seconds=_elapsed)
logger.debug('< {} >'.format(d))
def perform_cv(args):
splitter = KFold(args.folds, random_state=0, shuffle=True)
data = TADPOLEData(
data=args.modality_path + args.data_file,
modality_path=args.modality_path,
modality_k=args.modality_k,
)
# Split the ptids into n folds
ptids = data.get_ptids(min_time_points=2, target=args.target)
print("Total patients in CV: %i" % len(ptids))
t = TicToc()
print("CV mode %s" % args.mode)
sys.stdout.flush()
predictions = []
modality_ranks = []
for fold, (train_index, test_index) in enumerate(splitter.split(ptids)):
print("Fold %i/%i" % (fold, args.folds - 1))
sys.stdout.flush()
train_ptids = [ptids[i] for i in train_index]
test_ptids = [ptids[i] for i in test_index]
aug_data = AugmentedTADPOLEData(
data, args.precomputed_path + "merged_%i.p" % fold, train_ptids)
model = SMNSR(aug_data,
n_jobs=args.cpus,
forecast=False,
mode=args.mode)
print("Fitting model")
t.tic()
model.fit(train_ptids)
print("Trainig took %s seconds" % t.tocvalue())
print("Performing forecasting")
sys.stdout.flush()
# Fetch known target values for the patients
y = aug_data.getY(test_ptids, target=args.target)
prediction_definition = y[[TADPOLEData.PTID, TADPOLEData.C_MONTH]]
print("Patients with more than one measurement in fold %i: %i" %
(fold, y[TADPOLEData.PTID].unique().shape[0]))
y_hat = model.predict(prediction_definition, target=args.target)
prediction = y.merge(
y_hat,
left_on=[TADPOLEData.PTID, TADPOLEData.C_MONTH],
right_on=[TADPOLEData.PTID, TO],
)
predictions.append((prediction))
modality_ranks.append(model.ranked_modalities)
fold += 1
predictions = pd.concat(predictions, ignore_index=True)
with open(args.output_path + args.result_file_name, "wb") as file:
pickle.dump(prediction, file)
evaluate_predictions(predictions, data)
return prediction
def compute(p, listCouples, distanceMin, listOfExclusion=[]):
"""
compute computes the distances between all Links provided, and return them
:param p: the pybullet library engine
:param listCouples: the list of the couples [[bodyA,LinkX],[bodyB, linkY] between which the computation shall be
done
:param distanceMin: distance over which there is no computation
:param listOfExclusion:
Format = [ [["BodyA", "LinkA"],["BodyB", "LinkB"]] , ...]
:return: a tuple containing the couple between which the distance was computed, the points (World coordinates)
between which the distance was computed, and the distance computed
"""
if listOfExclusion is not None and len(listOfExclusion) > 0:
raise NotImplementedError
t_forLoop = TicToc()
distCouples = []
lineCouples = []
# [[[1, 0], [2, 0]]]
t_forLoop.tic()
for couple in listCouples:
bodyA = couple[0][0]
linkIndexA = couple[0][1]
bodyB = couple[1][0]
linkIndexB = couple[1][1]
closestPointsVec = p.getClosestPoints(bodyA=bodyA,
bodyB=bodyB,
distance=distanceMin,
linkIndexA=linkIndexA,
linkIndexB=linkIndexB)
#distTemp = 99999
distTemp = 99999
fromTemp = (0, 0, 0)
toTemp = (0, 0, 0)
if len(closestPointsVec) > 0:
for c in closestPointsVec:
#distCur = round(c[8]*1000)
distCur = round(c[8])
if distCur < distanceMin:
distTemp = distCur
fromTemp = c[5]
toTemp = c[6]
distCouples.append(distTemp)
lineCouples.append([fromTemp, toTemp])
#t_forLoop.toc("TICTOC -> Time elapsed for computing (For-loop) => ")
assert len(listCouples) is len(
distCouples), "The lengths of vectors are not equal"
assert len(listCouples) is len(
lineCouples), "The lengths of vectors are not equal"
return [listCouples, lineCouples, distCouples]
def upload_dcm_files(workers, accession_number=None):
global R, instance_manifest, compress
pool = Pool(processes=workers)
initial_size = orthanc.size()
instance_manifest = orthanc.do_get('instances')
initial_count = len(instance_manifest)
logging.info("-----------------------------------")
logging.info("DCM Pre-Index File Uploader")
logging.info("-----------------------------------")
logging.info(" Workers: {}".format(workers))
if compress:
logging.info(" J2K Compress: ON")
t = TicToc()
t.tic()
if accession_number:
# Upload single accession
fps = Q.sget(accession_number)
logging.info(" Upload: Accession {}".format(accession_number))
else:
# Upload _all_
fps = R.keys()
logging.info(" Upload: All data")
pool.map(upload_dcm_file, fps, 20)
toc_ = float(t.tocvalue())
final_size = orthanc.size()
instance_manifest = orthanc.do_get('instances')
final_count = len(instance_manifest)
count = final_count - initial_count
upload_mb = final_size - initial_size
n_per_sec = float(count) / toc_
time40m = 40000000.0 / (n_per_sec or 1) / 60 / 60
mb_per_sec = float(upload_mb) / toc_
time15t = 15000000.0 / (mb_per_sec or 1) / 60 / 60
logging.info(" Time: {} sec".format(toc_))
logging.info(" Num uploaded: {}".format(count))
logging.info(" Num/sec: {}".format(n_per_sec))
logging.info(" Hrs for 40M: {}".format(time40m))
logging.info(" MB uploaded: {}".format(upload_mb))
logging.info(" MB/sec: {}".format(mb_per_sec))
logging.info(" Hrs for 15TB: {}".format(time15t))
logging.info("-----------------------------------")
def get_finite_witness(f,
trace_length=5,
operators=[
encodingConstants.G, encodingConstants.F,
encodingConstants.LAND, encodingConstants.LOR,
encodingConstants.ENDS, encodingConstants.LNOT,
encodingConstants.BEFORE,
encodingConstants.STRICTLY_BEFORE,
encodingConstants.UNTIL
],
wall_locations=[],
water_locations=None,
robot_position=None,
items_locations=None,
testing=False):
t = TicToc()
solvingTic = TicToc()
t.tic()
all_variables = [str(v) for v in f.getAllVariables()]
fg = SATOfLTLEncoding(f,
trace_length,
0,
operators=None,
literals=all_variables,
wall_positions=wall_locations,
water_locations=water_locations,
robot_position=robot_position,
items_locations=items_locations,
testing=testing)
fg.encodeFormula()
stats_log.debug("creation time was {}".format(t.tocvalue()))
solvingTic.tic()
solverRes = fg.solver.check()
stats_log.debug("solving time was {}".format(solvingTic.tocvalue()))
if solverRes == sat:
solverModel = fg.solver.model()
(cex_trace, init_world, path) = fg.reconstructWitnessTrace(solverModel)
return (cex_trace, init_world, path)
elif solverRes == unknown:
return constants.UNKNOWN_SOLVER_RES
else:
# logging.debug(solverRes)
# pdb.set_trace()
if constants.DEBUG_UNSAT_CORE is True:
filename = "debug_files/unsatCore"
os.makedirs(os.path.dirname(filename), exist_ok=True)
with open(filename, "w") as unsat_core_file:
unsat_core_file.write(str(fg.solver.unsat_core()))
return "unsat"
def __init__(
self,
all_cities,
initial,
goal=None
): # initial = (0), goal = some state that its first and last values are 0
""" Define goal state and initialize a problem """
super().__init__(initial, goal)
self.cities_matrix = init_distance_matrix(all_cities)
self.cities_identifiers = set(all_cities.keys())
self.cities_amount = len(self.cities_identifiers)
self.trees_evaluation_hash = {}
self.t = TicToc()
self.t.tic()
def test_fit_generator():
from pytictoc import TicToc
np.random.seed(42)
print("Max workers:", os.cpu_count())
train_gen = create_generator(batch_size=128, h=28, w=28, augmenter=False)
val_gen = create_generator(batch_size=128, h=28, w=28, augmenter=False)
model = create_sequential_model(shape=(28, 28, 1))
# model = create_conv_model()
model.compile(loss="categorical_crossentropy",
metrics=["accuracy"],
optimizer="rmsprop")
with TicToc():
model.fit_generator(
train_gen,
validation_data=val_gen,
workers=os.cpu_count(),
use_multiprocessing=True,
verbose=1,
epochs=1,
)
assert True
def run_solver(
*,
q=None,
encoder=DagSATEncoding,
**solver_args,
):
separate_process = q is not None
t = TicToc()
t.tic()
results = get_models(encoder=encoder, **solver_args)
time_passed = t.tocvalue()
if separate_process == True:
q.put([results, time_passed])
else:
return [results, time_passed]
def __init__(self,
random_seed=0,
reduction_dimension=128,
reduction_iterations=30):
"""
Constructor of DataLoader
:param random_seed: random seed
:param reduction_dimension: input feature dimension (SVD)
:param reduction_iterations: number of iterations required by SVD
"""
self.random_seed = random_seed
np.random.seed(self.random_seed)
self.reduction_dimension = reduction_dimension
self.reduction_iterations = reduction_iterations
self.timer = TicToc()
def test_fuzzy_partition(D: np.array, K, m, T, err):
"""
Calculate the fuzzy partition for a given input, measures the time and
saves the results
"""
t = TicToc()
mvf = MVFuzzy()
print("---------------------------------------------")
print("Calculating fuzzy partition...", end="", flush=True)
t.tic()
mvf.run(D, K, m, T, err)
elapsed = t.tocvalue()
print("done!")
print_formatted("Last Iteration:", mvf.lastIteration, suffix=False)
print_formatted("Last J_t:", mvf.lastAdequacy, suffix=False)
print_formatted("Elapsed time:", elapsed)
np.save("G_medoids", mvf.bestMedoidVectors)
np.save("W_weights", mvf.bestWeightVectors)
np.save("U_membership", mvf.bestMembershipVectors)
def wrapper(*args, **kwargs):
message = '%s(%s | %s)' % (func.__name__, args, kwargs)
with TicToc(
): # TODO: log all execution times into a single file for profiling: out/performance.csv
logger.info(' ⬆ %s | LAUNCHED: %s.' %
(datetime.datetime.now(), message))
result = func(*args, **kwargs)
logger.info(' ⬇ %s | COMPLETED: %s in' %
(datetime.datetime.now(), message))
return result
def run_rec_dt(
*,
traces,
q=None,
encoder=DagSATEncoding,
**solver_args,
):
separate_process = q is not None
t = TicToc()
t.tic()
result = get_rec_dt(traces=traces, encoder=encoder, **solver_args)
time_passed = t.tocvalue()
result.writeDotFile("recdt.dot", traces=traces)
if separate_process == True:
q.put([result, time_passed])
else:
return [result, time_passed]
def poll_for_connection_status_message(consumer, timeout=15.0):
"""
Polls the subscribed topics by the consumer and checks the buffer is not empty or malformed.
Skips connection status messages.
:param consumer: The consumer object
:param timeout: give up if we haven't found a connection status message after this length of time
:return: The LogData flatbuffer from the message payload
"""
timer = TicToc()
timer.tic()
while timer.tocvalue() < timeout:
msg = consumer.poll(timeout=1.0)
assert msg is not None
if msg.error():
raise MsgErrorException("Consumer error when polling: {}".format(
msg.error()))
message_file_id = msg.value()[4:8]
if message_file_id == b"ep00":
return EpicsConnectionInfo.EpicsConnectionInfo.GetRootAsEpicsConnectionInfo(
msg.value(), 0)
def main():
t = TicToc()
t.tic()
with open("/home/ubuntu/sbmd/station", "rb") as f:
fileobj = pickle.load(f)
statit = fileobj[2][int(sys.argv[1])]
statit = np.flip(statit)
credfile = "/home/ubuntu/sbmd/dwh.cfg"
config = configparser.ConfigParser()
config.read(credfile)
s3k = config['AWS']['KEY']
s3ks = config['AWS']['SECRET']
pool = mp.Pool(mp.cpu_count())
[pool.apply(load_trains_all, args=(co, s3k, s3ks)) for co in statit]
ind = sys.argv[1]
logging.info(f"Gathered conn data succesfully with index {ind}")
t.toc()
def run_tsp(difficulty, file_name):
t = TicToc()
all_cities = my_utils.generate_cities_dict(difficulty)
cities_map = cities_visualitation.CitiesMap(all_cities)
tsp = TravelingSalesmanProblem(all_cities, (0, ), ())
t.tic()
best_known_solution_value = 0.0
if difficulty == 'big':
best_known_solution_value = params.big_best_known_solution
elif difficulty == 'medium':
best_known_solution_value = params.medium_best_known_solution
elif difficulty == 'small':
best_known_solution_value = params.small_best_known_solution
tsp_result, msg = search.astar_search(tsp,
best_known_solution_value,
display=True)
print(msg)
t.toc()
cities_list = cities_visualitation.get_normalized_cities_identification(
tsp_result.state)
cities_list_evaluation = (-1) * tsp.value(tsp_result.state)
cities_map.show_map(list(tsp_result.state))
cities_map.save_plot(file_name)
my_utils.save_results(file_name, cities_list_evaluation, cities_list, msg)
def main(individuals_number):
global individuals
individuals = individuals_number
print_variable_info()
t = TicToc()
t.tic()
# Initialize a population
population = initialize()
population = [
(calculate_fitness(i), i) for i in population
] # Calculates the fitness of each individual, and stores it in pairs ordered in the form (5 , [1,2,1,1,1,4,1,8,9,4,1])
initial_population = sorted(population, key=lambda x: x[0])
# Evolves the population
for i in range(generations):
print("→→", i)
population = selection_and_reproduction(population)
print("←←")
# Print the results
print_results(initial_population, population)
t.toc()
def process_file(audio_fname, speakers_number, config_dict, is_remote_file,
gt_fname):
prepare_outdir(RESULTS_PATH)
remote_path = ""
if is_remote_file:
print("Remote file selected")
remote_path = config_dict['bucket_url'] + "/" + audio_fname
else:
# local file, upload to bucket and set "remote_path" variable
print("Local file selected, will upload before processing...")
print("----------------------------------------")
file_path = Path(audio_fname)
remote_path = config_dict['bucket_url'] + "/" + config_dict[
'bucket_new_dir'] + "/" + file_path.name
upload_to_bucket(file_path, remote_path)
print("----------------------------------------\n")
print("Waiting for transcription...")
t = TicToc()
t.tic()
transcribed_str = request_transcription(remote_path, speakers_number,
config_dict)
elapsed_time = t.tocvalue()
print("Time to transcribe: {:.2f} minutes ({:.2f} seconds)".format(
elapsed_time / 60, elapsed_time))
out_transcribed_fname = Path(audio_fname).stem + "_transcribed.txt"
str_to_file(RESULTS_PATH / out_transcribed_fname, transcribed_str)
print("Transcription completed, saved to '{}'".format(
RESULTS_PATH / out_transcribed_fname))
if (gt_fname):
print(
"\nGT file provided, will evaluate results with several metrics..."
)
eval_result_str = evaluate_transcription(transcribed_str, gt_fname)
print(eval_result_str)
out_eval_fname = Path(audio_fname).stem + "_eval.txt"
str_to_file(RESULTS_PATH / out_eval_fname, eval_result_str)
print("Results saved to '{}'".format(RESULTS_PATH / out_eval_fname))
async def oneloop(dut):
"""perf oneloop test"""
t = TicToc()
tb = settings()
await reset(dut)
clkobj = Clock(dut.clk, tb.period, 'us')
cocotb.fork(clkobj.start())
t.tic()
k = 0
for cycle in range(tb.dinArate * tb.npoints):
await (RisingEdge(dut.clk))
if (cycle % tb.dinArate) == 0:
k = k + 1
dut.dinA <= 1
if (k % 100 == 0):
dut._log.info("Sim progress...{} %".format(
int(100 * float(k) / tb.npoints)))
else:
dut.dinA <= 0
if (cycle % tb.dinBrate) == 0:
dut.dinB <= 1
else:
dut.dinB <= 0
t.toc()
print(t.elapsed)
def accuracyCalculator(dataSetLoader, crrNeuralNet):
'''
Calculate and return accuracy on the given data set using current trained Neural Net
Args:
dataSetLoader: given data set loader
crrNeuralNet: given current trained neural net.
Returns:
accuracyForCurrentNet: current accuracy on the given data set by trained net at current epoch
'''
numOfCorrectPrediction = 0
numOfTotalDataPoints = 0
timerObj = TicToc()
timerObj.tic()
with torch.no_grad():
for crrData in dataSetLoader:
crrInputData, crrLabels = crrData
predictedOutputs = crrNeuralNet.feedForward(crrInputData)
_, predictedLabels = torch.max(predictedOutputs.data, 1)
numOfTotalDataPoints += crrLabels.size(0)
numOfCorrectPrediction += (
predictedLabels == crrLabels).sum().item()
accuracyForCurrentNet = numOfCorrectPrediction / numOfTotalDataPoints
print('Accuracy of the network on the images(train or test): %d %%' %
(100 * numOfCorrectPrediction / numOfTotalDataPoints))
timerObj.toc()
return accuracyForCurrentNet
def derotate_image_forloop(startNum,stopNum,dateString):
for f in range(startNum,stopNum+1): # loop over filenames
print('----------------------------------------')
print('Derotating image '+str("{:0>5d}".format(f))+'...')
t = TicToc() # create instance of timer
t.tic() # start timer
# retrieve image
image, header = fits.getdata(calibrated_trapezium_data_stem+
'step02_dewarped/'+
'lm_'+dateString+'_'+
str("{:0>5d}".format(f))+
'.fits',
0,
header=True)
# find PA from header
pa = header['LBT_PARA']
# derotate
image_derot = rot(image, -pa, [1024,1024], order=3, pivot=False) # axis coord here is just a dummy
# save
fits.writeto(calibrated_trapezium_data_stem+
'step03_derotate/'+
'lm_'+dateString+'_'+
str("{:0>5d}".format(f))+
'.fits',
image_derot, header, overwrite=False)
t.toc()
print('------------------------------')
