def generate_score():
"""This is /generate-score page. It renders score.html.
Query string format:
/generate-score?verilog=[verilog_file]&input=[input_file]&output=[output_file]&ucf=[ucf_file]
Returns:
score.html
"""
args = request.args
inp = args['input']
output = args['output']
ucf = args['ucf']
verilog = args['verilog']
print(verilog, inp, output, ucf)
# run optimizaiton and create a modifled file under "modified" directory
data = optimize(inp)
# calculate score
score = calc_score(verilog, inp, output, ucf)
modified_file = f'{inp}.input.json'
return render_template('score.html',
score=score,
file=modified_file,
data=data)
def main():
instruments_list = parse(sys.argv[1])
initial_assignment = assignment_original(instruments_list, 1)
optimized = optimize(initial_assignment, instruments_list, 1)
for player in optimized:
print(player)
print()
def main():
parser = build_parser()
options = parser.parse_args()
check_opts(options)
style_target = get_img(options.style)
if not options.slow:
content_targets = _get_files(options.train_path)
elif options.test:
content_targets = [options.test]
kwargs = {
"slow": options.slow,
"epochs": options.epochs,
"print_iterations": options.checkpoint_iterations,
"batch_size": options.batch_size,
"save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'),
"learning_rate": options.learning_rate
}
if options.slow:
if options.epochs < 10:
kwargs['epochs'] = 1000
if options.learning_rate < 1:
kwargs['learning_rate'] = 1e1
args = [
content_targets, style_target, options.content_weight,
options.style_weight, options.tv_weight, options.vgg_path
]
for preds, losses, i, epoch in optimize(*args, **kwargs):
style_loss, content_loss, tv_loss, loss = losses
print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss))
to_print = (style_loss, content_loss, tv_loss)
print('style: %s, content:%s, tv: %s' % to_print)
if options.test:
assert options.test_dir != False
preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i)
if not options.slow:
ckpt_dir = os.path.dirname(options.checkpoint_dir)
evaluate.ffwd_to_img(options.test, preds_path,
options.checkpoint_dir)
else:
save_img(preds_path, img)
ckpt_dir = options.checkpoint_dir
cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir
print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main():
args = parseCommandLineArguments()
level = INFO
if args.debug: level = 0
elif args.verbose: level = DEBUG
elif args.quiet: level = WARNING
initializeLog(level)
inputFile, reductionFile, chemkinFile, spcDict = args.requiredFiles[-4:]
for f in [inputFile, reductionFile, chemkinFile, spcDict]:
assert os.path.isfile(f), 'Could not find {}'.format(f)
inputDirectory = os.path.abspath(os.path.dirname(inputFile))
output_directory = inputDirectory
rmg, targets, error = load(inputFile, reductionFile, chemkinFile, spcDict)
logger.info('Allowed error in target observables: {0:.0f}%'.format(error *
100))
reactionModel = rmg.reactionModel
initialize(rmg.outputDirectory, reactionModel.core.reactions)
atol, rtol = rmg.absoluteTolerance, rmg.relativeTolerance
index = 0
reactionSystem = rmg.reactionSystems[index]
#compute original target observables
observables = computeObservables(targets, reactionModel, reactionSystem, \
rmg.absoluteTolerance, rmg.relativeTolerance)
logger.info('Observables of original model:')
for target, observable in zip(targets, observables):
logger.info('{}: {:.2f}%'.format(target, observable * 100))
# optimize reduction tolerance
tol, importantReactions = optimize(targets, reactionModel, rmg, index,
error, observables)
logger.info('Optimized tolerance: {:.0E}'.format(10**tol))
logger.info('Number of reactions in optimized reduced model : {}'.format(
len(importantReactions)))
# plug the important reactions into the RMG object and write:
rmg.reactionModel.core.reactions = importantReactions
writeModel(rmg)
def main():
args = parseCommandLineArguments()
level = INFO
if args.debug: level = 0
elif args.verbose: level = DEBUG
elif args.quiet: level = WARNING
initializeLog(level)
inputFile, reductionFile, chemkinFile, spcDict = args.requiredFiles[-4:]
for f in [inputFile, reductionFile, chemkinFile, spcDict]:
assert os.path.isfile(f), 'Could not find {}'.format(f)
inputDirectory = os.path.abspath(os.path.dirname(inputFile))
output_directory = inputDirectory
rmg, targets, error = load(inputFile, reductionFile, chemkinFile, spcDict)
logger.info('Allowed error in target observables: {0:.0f}%'.format(error * 100))
reactionModel = rmg.reactionModel
initialize(rmg.outputDirectory, reactionModel.core.reactions)
atol, rtol = rmg.absoluteTolerance, rmg.relativeTolerance
index = 0
reactionSystem = rmg.reactionSystems[index]
#compute original target observables
observables = computeObservables(targets, reactionModel, reactionSystem, \
rmg.absoluteTolerance, rmg.relativeTolerance)
logger.info('Observables of original model:')
for target, observable in zip(targets, observables):
logger.info('{}: {:.2f}%'.format(target, observable * 100))
# optimize reduction tolerance
tol, importantReactions = optimize(targets, reactionModel, rmg, index, error, observables)
logger.info('Optimized tolerance: {:.0E}'.format(10**tol))
logger.info('Number of reactions in optimized reduced model : {}'.format(len(importantReactions)))
# plug the important reactions into the RMG object and write:
rmg.reactionModel.core.reactions = importantReactions
writeModel(rmg)
def main(args):
"""Main function of cellanneal."""
if (args.start_temp is not None
or args.end_temp is not None) and args.auto_temp == 1:
raise Exception(
"when auto_temp is set to 1(default value), starting temperature or ending temperature should not be set manually"
)
if not args.no_parallel:
import dask
from dask.distributed import Client, LocalCluster
if not args.cluster:
cluster = LocalCluster(
n_workers=args.workers,
local_dir="/tmp/CellUniverse/dask-worker-space")
else:
cluster = args.cluster
client = Client(cluster)
else:
client = None
lineagefile = None
start = time.time()
try:
if args.debug:
debugmode = True
config = load_config(args.config)
celltype = config['global.cellType'].lower()
# setup the colony from a file with the initial properties
lineageframes = LineageFrames()
colony = lineageframes.forward()
load_colony(colony, args.initial, config)
# open the lineage file for writing
lineagefile = open(args.output / 'lineage.csv', 'w')
header = ['file', 'name']
if celltype == 'bacilli':
header.extend(['x', 'y', 'width', 'length', 'rotation'])
print(','.join(header), file=lineagefile)
if args.global_optimization:
import global_optimization
global_optimization.optimize(get_inputfiles(args), lineageframes,
lineagefile, args, config)
return 0
if args.auto_temp == 1:
temperature, end_temperature = auto_temp_schedule(
get_inputfiles(args)[0], lineageframes.forward(), args, config)
setattr(args, 'start_temp', temperature)
setattr(args, 'end_temp', end_temperature)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp,
"ending temperature is ", args.end_temp)
for imagefile in get_inputfiles(args):
colony = optimize(imagefile, lineageframes, args, config, client)
# flatten modifications and save cell properties
colony.flatten()
for cellnode in colony:
properties = [imagefile.name, cellnode.cell.name]
if celltype == 'bacilli':
properties.extend([
str(cellnode.cell.x),
str(cellnode.cell.y),
str(cellnode.cell.width),
str(cellnode.cell.length),
str(cellnode.cell.rotation)
])
print(','.join(properties), file=lineagefile)
except KeyboardInterrupt as error:
raise error
finally:
if lineagefile:
lineagefile.close()
print(f'{time.time() - start} seconds')
return 0
num_assets = len(input_returns.columns)
turnover_counter = 0
for date in dtindex[rebalancing_period - 1:]:
today = date
all_assets_returns = input_returns.loc[:today, :]
last = all_assets_returns.index[-2]
if today in rebalancing_dates: # re-optimize and get new weights
print(today)
# Select available assets
returns, available_assets = dp.returns_cleaning(
input_returns, df0, rolling_window, today)
weights.loc[today, :] = [0] * num_assets
weights.loc[today, available_assets] = op.optimize(
returns, risk_aversion, HMM_parameters)
if today == rebalancing_dates[0]:
turnover.loc[today] = 1
else:
turnover.loc[today] = sum(abs(weights.loc[today]-weights.loc[last, :] * (1 + all_assets_returns.loc[today, :]) \
/ (1 + (weights.loc[last, :] * all_assets_returns.loc[today, :]).sum())))
turnover_counter += turnover.loc[today]
else: # no re-optimization, re-balance the weights
weights.loc[today, :] = weights.loc[last, :] * (1 + all_assets_returns.loc[today, :]) \
/ (1 + (weights.loc[last, :] * all_assets_returns.loc[today, :]).sum())
turnover.loc[today] = sum(abs(weights.loc[today]-weights.loc[last, :] * (1 + all_assets_returns.loc[today, :]) \
/ (1 + (weights.loc[last, :] * all_assets_returns.loc[today, :]).sum()))) # it's just zero
# Create TC and No TC total returns series
def main(args):
"""Main function of cellanneal."""
if (args.start_temp is not None
or args.end_temp is not None) and args.auto_temp == 1:
raise Exception(
"when auto_temp is set to 1(default value), starting temperature or ending temperature should not be set manually"
)
# if not args.no_parallel:
# import dask
# from dask.distributed import Client, LocalCluster
# if not args.cluster:
# cluster = LocalCluster(
# n_workers=args.workers,local_dir="/tmp/CellUniverse/dask-worker-space"
# )
# else:
# cluster = args.cluster
#
# client = Client(cluster)
# else:
client = None
lineagefile = None
start = time.time()
try:
config = load_config(args.config)
simulation_config = config["simulation"]
#Maybe better to store the image type in the config file in the first place, instead of using cmd?
if args.graySynthetic == True:
simulation_config["image.type"] = "graySynthetic"
elif args.phaseContrast == True:
simulation_config["image.type"] = "phaseContrastImage"
elif args.binary == True:
simulation_config["image.type"] = "binary"
else:
raise ValueError(
"Invalid Command: Synthetic image type must be specified")
if args.debug:
debugmode = True
celltype = config['global.cellType'].lower()
# setup the colony from a file with the initial properties
lineageframes = LineageFrames()
colony = lineageframes.forward()
load_colony(colony, args.initial, config)
cost_diff = (-1, -1)
# open the lineage file for writing
lineagefile = open(args.output / 'lineage.csv', 'w')
header = ['file', 'name']
if celltype == 'bacilli':
header.extend(['x', 'y', 'width', 'length', 'rotation'])
print(','.join(header), file=lineagefile)
#optimze configuration
config["simulation"] = find_optimal_simulation_conf(
config["simulation"], load_image(get_inputfiles(args)[0]),
list(colony))
if args.global_optimization:
import global_optimization
if args.auto_temp == 1:
print("auto temperature schedule started")
args.start_temp, args.end_temp = \
global_optimization.auto_temp_schedule(get_inputfiles(args), lineageframes, lineagefile, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp,
"ending temperature is ", args.end_temp)
global_optimization.optimize(get_inputfiles(args), lineageframes,
lineagefile, args, config)
return 0
if args.auto_temp == 1:
print("auto temperature schedule started")
args.start_temp, args.end_temp = auto_temp_schedule(
get_inputfiles(args)[0], lineageframes.forward(), args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp,
"ending temperature is ", args.end_temp)
frame_num = 0
prev_cell_num = len(colony)
for imagefile in get_inputfiles(
args): # Recomputing temperature when needed
frame_num += 1
if args.auto_meth == "frame":
if auto_temp_schedule_frame(frame_num, 8):
print("auto temperature schedule started (recomputed)")
args.start_temp, args.end_temp = auto_temp_schedule(
imagefile, colony, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp,
"ending temperature is ", args.end_temp)
elif args.auto_meth == "factor":
if auto_temp_schedule_factor(len(colony), prev_cell_num, 1.1):
print("auto temperature schedule started (recomputed)")
args.start_temp, args.end_temp = auto_temp_schedule(
imagefile, colony, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp,
"ending temperature is ", args.end_temp)
prev_cell_num = len(colony)
elif args.auto_meth == "const":
if auto_temp_schedule_const(len(colony), prev_cell_num, 10):
print("auto temperature schedule started (recomputed)")
args.start_temp, args.end_temp = auto_temp_schedule(
imagefile, colony, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp,
"ending temperature is ", args.end_temp)
prev_cell_num = len(colony)
elif args.auto_meth == "cost":
print(cost_diff, frame_num, auto_temp_shcedule_cost(cost_diff))
if frame_num >= 2 and auto_temp_shcedule_cost(cost_diff):
print(
"auto temperature schedule started cost_diff (recomputed)"
)
args.start_temp, args.end_temp = auto_temp_schedule(
imagefile, colony, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp,
"ending temperature is ", args.end_temp)
colony = optimize(imagefile, lineageframes, args, config, client)
cost_diff = update_cost_diff(colony, cost_diff)
# flatten modifications and save cell properties
colony.flatten()
for cellnode in colony:
properties = [imagefile.name, cellnode.cell.name]
if celltype == 'bacilli':
properties.extend([
str(cellnode.cell.x),
str(cellnode.cell.y),
str(cellnode.cell.width),
str(cellnode.cell.length),
str(cellnode.cell.rotation)
])
print(','.join(properties), file=lineagefile)
except KeyboardInterrupt as error:
raise error
finally:
if lineagefile:
lineagefile.close()
print(f'{time.time() - start} seconds')
return 0
# Params
N_CLs = 11
TR = 1.0
AR = 12.0
N = 80
N_sweeps = 20
CLs = np.linspace(0.1, 0.5, N_CLs)
sweep_dists = np.zeros((N_CLs, N_sweeps))
color_range = np.linspace(0, 155, N_CLs)
colors = [
"#" + "".join([hex(int(x)).replace('0x', '')] * 3) for x in color_range
]
for i, CL in enumerate(CLs):
_, _, sweep_dists[i] = optimize(np.zeros(N_sweeps), TR, AR, CL, N,
'L-BFGS-B')
# Plot sweep distribution
spans = np.linspace(0.0, 1.0, N_sweeps)
plt.figure(figsize=(5, 5))
for i, CL in enumerate(CLs):
plt.plot(spans,
sweep_dists[i],
label=str(round(CL, 3)),
color=colors[i])
plt.xlabel("Span Fraction")
plt.ylabel("Local Sweep Angle [deg]")
plt.legend(title="$C_L$")
plt.show()
def run_experiment(settings_dict):
experiment_settings = ExperimentSettings(settings_dict)
# localize to the current computer as required
experiment_settings.localize()
# create an empty experiment object, with the correct parametrizations
experiment_settings.check_stored("parametrization_settings")
experiment_state = ExperimentState.create(
experiment_settings.get('parametrization_settings'))
experiment_settings.save("parametrization_settings")
# create the data adapter
experiment_settings.check_stored("data_settings")
data_adapter = DataAdapterFactory(
experiment_settings.get('data_settings')['data_type'])(
experiment_settings.get('local_data_settings'))
if not experiment_settings.get('data_settings')['lazy_image_loading']:
device = torch.device(general_settings.device_name)
image_tensors = [
observation.get_image()
for observation in tqdm(data_adapter.images,
desc="Preloading training images")
]
# now compact all observations into a few big tensors and remove the old tensors
# this makes for much faster access/operations
data_adapter.compound_image_tensors = {}
data_adapter.compound_image_tensor_sizes = {}
training_indices_batches, _ = data_adapter.get_training_info()
testing_indices_batches, _ = data_adapter.get_testing_info()
for batch in itertools.chain(training_indices_batches,
testing_indices_batches):
compound_H = max([image_tensors[i].shape[-2] for i in batch])
compound_W = max([image_tensors[i].shape[-1] for i in batch])
C = len(batch)
compound_images = torch.zeros(C,
3,
compound_H,
compound_W,
dtype=torch.float,
device=device)
compound_sizes = torch.zeros(C, 2, dtype=torch.long, device=device)
for idx, image_idx in enumerate(batch):
src_tensor = image_tensors[image_idx]
compound_images[idx, :, :src_tensor.shape[-2], :src_tensor.
shape[-1]] = src_tensor
compound_sizes[idx, 0] = src_tensor.shape[-1]
compound_sizes[idx, 1] = src_tensor.shape[-2]
del data_adapter.images[image_idx]._image
data_adapter.compound_image_tensors[batch] = compound_images
data_adapter.compound_image_tensor_sizes[batch] = compound_sizes
del image_tensors
experiment_settings.save("data_settings")
# initialize the parametrizations with the requested values, if the initialization is not available on disk
initialization_state_folder = experiment_settings.get_state_folder(
"initialization")
if experiment_settings.check_stored("initialization_settings"):
experiment_state.load(initialization_state_folder)
else:
experiment_state.initialize(
data_adapter,
experiment_settings.get('local_initialization_settings'))
experiment_state.save(initialization_state_folder)
experiment_settings.save("initialization_settings")
# evaluate_state("initialization",
# experiment_settings.get('data_settings')['object_name'],
# experiment_settings.get('local_data_settings')['gt_scan_folder'],
# experiment_state)
experiment_state.visualize_statics(experiment_settings.get_output_path(),
data_adapter)
if experiment_settings.get("higo_baseline") is not None:
higo_state_folder = experiment_settings.get_state_folder("higo")
if not experiment_settings.check_stored("higo_baseline"):
higo_experiment_state = higo_baseline(
experiment_state, data_adapter, higo_state_folder,
experiment_settings.get('higo_baseline'))
higo_experiment_state.visualize(
experiment_settings.get_output_path(),
"higo_baseline",
data_adapter,
losses=[],
shadows_occlusions=False)
higo_experiment_state.save(higo_state_folder)
experiment_settings.save("higo_baseline")
else:
higo_experiment_state = ExperimentState.copy(experiment_state)
higo_experiment_state.load(higo_state_folder)
evaluate_state(
"higo baseline",
experiment_settings.get('data_settings')['object_name'],
experiment_settings.get('local_data_settings')['gt_scan_folder'],
higo_experiment_state)
optimization_step_settings = experiment_settings.get(
'default_optimization_settings')
experiment_settings.check_stored("default_optimization_settings")
experiment_settings.save("default_optimization_settings")
for step_index in range(len(
experiment_settings.get('optimization_steps'))):
step_state_folder = experiment_settings.get_state_folder(
"optimization_steps", step_index)
optimization_settings = experiment_settings.get(
"optimization_steps", step_index)
shorthand = experiment_settings.get_shorthand("optimization_steps",
step_index)
set_name = "%02d_%s" % (step_index, shorthand)
if optimization_settings['visualize_initial']:
experiment_state.visualize(experiment_settings.get_output_path(),
"%02d__initial" % step_index,
data_adapter,
optimization_settings['losses'])
if experiment_settings.check_stored("optimization_steps", step_index):
experiment_state.load(step_state_folder)
else:
optimize(experiment_state,
data_adapter,
optimization_settings,
output_path_structure=os.path.join(
experiment_settings.get_output_path(),
"evolution_%%s_%s.png" % set_name))
experiment_state.save(step_state_folder)
experiment_settings.save("optimization_steps", step_index)
if optimization_settings['visualize_results']:
experiment_state.visualize(experiment_settings.get_output_path(),
set_name, data_adapter,
optimization_settings['losses'])
evaluate_state(
experiment_settings.get('data_settings').get('output_path_suffix',
'proposed'),
experiment_settings.get('data_settings')['object_name'],
experiment_settings.get('local_data_settings')['gt_scan_folder'],
experiment_state)
import optimization
from constants import *
try:
optimization.optimize(Works.normal_precision, 3, 4, Lights.B_40_Watts, 2.5,
[(1, 1),
(2, 2)], 2.3, 1.2, [(0.5, 1)], [], [], [1.5])
except Exception as error:
print(error)
filepath = os.path.join(path, f)
inFile = TFile.Open(filepath, "READ")
print " Reading from", f
tree = inFile.Get("treeA")
n = name_to_number(f)
# print n
no_events[0] = n
# print no_events[0]
Ncount = np.squeeze(tree.AsMatrix(columns=["Ncount"], dtype="int"))
Npos = np.squeeze(tree.AsMatrix(columns=["fNtrackPos"], dtype="int"))
Nneg = np.squeeze(tree.AsMatrix(columns=["fNtrackNeg"], dtype="int"))
Sum = Npos + Nneg
Diff = abs(Npos - Nneg)
inFile.Close()
events = Ncount.size
N_cmin[0], Ncount_opt_wid[0], c = optimize(Ncount, events)
Npos_cmin[0], Npos_opt_wid[0], c = optimize(Npos, events)
# print Npos_cmin[0],Npos_opt_wid[0]
Nneg_cmin[0], Nneg_opt_wid[0], c = optimize(Nneg, events)
# print Nneg_cmin[0],Nneg_opt_wid[0]
Sum_cmin[0], Sum_opt_wid[0], c = optimize(Sum, events)
# print Sum_cmin[0],Sum_opt_wid[0]
Diff_cmin[0], Diff_opt_wid[0], c = optimize(Diff, events)
# print Diff_cmin[0],Diff_opt_wid[0]
treec.Fill()
treew.Fill()
# break;
cwfile.Write()
print "--------------------Done-------------------------"
###########################################################################
############ E = ∑||Gt(pi+τ(pi))−Gs(pi)||^2################################
###########################################################################
cofficients_g = []
bbss = []
for i in range(sample_vertices_or.shape[0]):
bb = grad2[i]*sample_vertices_or[i] + src_warp_gradient[sample_vertices_or[i,1],sample_vertices_or[i,0]] - dst_warp_gradient[sample_vertices_or[i,1],sample_vertices_or[i,0]]
bbss.append(bb)
for w in weight[i]:
cofficient_g = [w*grad2[i,0],w*grad2[i,1]]
cofficients_g.append(cofficient_g)
cofficients_g = np.array(cofficients_g)
cofficients_g = cofficients_g.reshape(-1,4,2)
bbss = np.array(bbss)
# todo three constant parameter means optical,line,vertices keeping respectively
c = optimization.optimize(triangles, triangle_coefficient, cofficients, location, bs, mesh_boxes_src,
cofficients_g, bbss, 0.25,1,2, weight_lines, location_lines)
c = c.astype(np.int)
c = c.reshape(dst_y_num,dst_x_num,2)
"""the offset of texture_mapping bring"""
offset_x = abs(min(np.min(c[:,:,0]),0))
offset_y = abs(min(np.min(c[:,:,1]),0))
# todo get the image after warping
final_result = texture_mapping.texture_mapping(mesh_boxes_src.astype(np.int), c.astype(np.int),
src_warp)
final_result = final_result.astype(np.uint8)
cv2.imshow("final_result" + str(iter), final_result)
parser.add_argument('--load', help='Load listings from the supplied xml.', action='store_true')
args = parser.parse_args()
if args.buy is True and args.cart is None:
print('Error, specify --cart')
exit(1)
if args.load is True and args.parts is None:
print('Error, specify --parts')
exit(1)
if args.load:
parts, stores, listings = get_listings(args.parts, args.exclude)
pickle.dump({'parts': parts, 'stores': stores, 'listings': listings}, open('cache/loaded.p', 'wb'))
elif args.optimize:
loaded = pickle.load(open('cache/loaded.p', 'rb'))
parts = loaded['parts']
stores = loaded['stores']
listings = loaded['listings']
if args.optimize:
parts, listings, stores = pre_optimize(parts, listings, stores, args.min_parts_per_store)
optimal_listings = optimize(parts, listings, stores, args.shipping_costs)
pickle.dump({'optimal_listings': optimal_listings}, open('cache/optimized.p', 'wb'))
elif args.buy:
optimized = pickle.load(open('cache/optimized.p', 'rb'))
optimal_listings = optimized['optimal_listings']
if args.buy:
insert_in_cart(optimal_listings, args.cart)
import desugaring
import c_generation
import normalization
import optimization
import parsing
import tokenization
source_path = sys.argv[1]
with open(source_path, 'r') as f:
source = f.read()
tokens = tokenization.tokenize(source)
parsed = parsing.parse(tokens)
desugared = desugaring.desugar(parsed)
normalized = normalization.normalize(desugared)
converted = conversion.convert(normalized)
crossplatform_ir = crossplatform_ir_generation.generate(converted)
optimized = optimization.optimize(crossplatform_ir)
outputted = crossplatform_ir_generation.output(optimized)
print(outputted)
generated = c_generation.generate(optimized)
assert source_path.endswith('.fur')
destination_path = source_path + '.c'
with open(destination_path, 'w') as f:
f.write(generated)
def getBestSchedule (classes, option):
global junk1
global junk2
(potentialSchedules, junk1, junk2) = generateAll(classes)
schedule = optimize(potentialSchedules, heuristicDict[option])
return schedule
global junk1
global junk2
(potentialSchedules, junk1, junk2) = generateAll(classes)
schedule = optimize(potentialSchedules, heuristicDict[option])
return schedule
# Example of how to use optimize
if __name__ == '__main__':
# from user
classes = ["15210", "15281", "84380", "21355", "11411"]
# then generate the potentialSchedules
(potentialSchedules, junk1, junk2) = generateAll(classes)
# from user
chosenHeuristic = 'fridayOff'
schedule = optimize(potentialSchedules, heuristicDict[chosenHeuristic])
chosenHeuristic = 'noRemote'
schedule2 = optimize(potentialSchedules, heuristicDict[chosenHeuristic])
chosenHeuristic = 'latestTime'
schedule3 = optimize(potentialSchedules, heuristicDict[chosenHeuristic])
chosenHeuristic = 'earliestTime'
schedule4 = optimize(potentialSchedules, heuristicDict[chosenHeuristic])
chosenHeuristic = 'shortestTime'
schedule5 = optimize(potentialSchedules, heuristicDict[chosenHeuristic])
infoPrint(schedule)
infoPrint(schedule2)
infoPrint(schedule3)
infoPrint(schedule4)
infoPrint(schedule5)
# TACS
def build_tac_input(filename, x):
'''
sets up the yaml to feed into the java model to have ITQs running and trading
:param filename: the name of the yaml to output
:param x: the numpy array with the parameters. I just expect 2: quota for first and quota for second species
:return: nothing
'''
with open("base.yaml", 'r') as infile:
data = yaml.load(infile)
data["Prototype"]["fishers"] = 100
# change regulations
data["Prototype"]["regulation"] = dict()
data["Prototype"]["regulation"]["Multi-TAC"] = {
"firstSpeciesQuota": float(x[0]),
"otherSpeciesQuota": float(x[1])
}
# you also need to activate the predictors
data['Prototype']['usePredictors'] = "true"
with open(filename, 'w') as outfile:
outfile.write(yaml.dump(data, default_flow_style=True))
title = "mixed_tac_100"
bounds = [(0,2000000),(0,2000000)]
optimization.optimize(title,build_tac_input,bounds)
# cofficients_g = cofficients_g*0
# bbss = bbss*0
print(">>>>>>>>>>>>>>>>>>>>>>>>>")
print(triangles.shape)
print(triangle_coefficient.shape)
print(cofficients.shape)
print(location.shape)
print(bs.shape)
print(mesh_boxes_src.shape)
print(cofficients_g.shape)
print(bbss.shape)
# cofficients_g = cofficients_g*0
# bbss = bbss*0
# triangle_coefficient = triangle_coefficient*0
c = optimization.optimize(triangles, triangle_coefficient, cofficients,
location, bs, mesh_boxes_src, cofficients_g,
bbss, 0.16)
c = c.astype(np.int)
c = c.reshape(dst_y_num, dst_x_num, 2)
# c = c[:,:,(1,0)]
# ccc = copy.deepcopy(c)
# ccc = ccc.reshape(-1,2)
# for i in range(ccc.shape[0]):
# ccc[i] = ccc[i]+[112,114]
"""the offset of texture_mapping bring"""
offset_x = abs(min(np.min(c[:, :, 0]), 0))
offset_y = abs(min(np.min(c[:, :, 1]), 0))
# todo get the image after warping
final_result = texture_mapping.texture_mapping(
mesh_boxes_src.astype(np.int), c.astype(np.int), src_warp)
def trial(**kwargs):
# program tracker vars
simtime = 0
opttime = 0
btime = 0
condtime = 0
itercount = 0
final = dict()
# problem specific vars/function related
init_x = .5
init_a = 0
init_b = 1
constraint = 3
y0 = 65
y1 = 97
# bayesian discrete probability structure
pdf = [0] * (y1 + 1)
for i in range(y0, y1 + 1):
pdf[i] = 1./(y1 - y0 + 1)
# bisection search history data structure
biobs = list()
# golden search history data structure
obs = dict() # maps Point objects to a list of observations at that Point
# THE FOLLOWING ARE ALL HYPERPARAMETERS
# in common:
sim_n = 100
sim_n = kwargs['sim_n']
# golden search
# these work for good precision
alpha = .9
alpha = kwargs['alpha']
gs_epsilon = .001
gs_epsilon = kwargs['gs_epsilon']
delta = .01
delta = kwargs['delta']
# gradient
sim_grad_n = 5000
sim_grad_n = kwargs['sim_grad_n']
grad_epsilon = .01
grad_epsilon = kwargs['grad_epsilon']
stepsize = .1
stepsize = kwargs['stepsize']
# bisect
b_error = .1
b_error = kwargs['b_error']
# bayesian
oracle = .6
oracle = kwargs['oracle']
certainty = .99
certainty = kwargs['certainty']
# control logic vars
u_method = 'golden'
u_method = 'gradient'
u_method = kwargs['u_method']
b_method = 'bayes'
b_method = 'bisect'
b_method = kwargs['b_method']
# END HYPERPARAMETERS
# initializing vars
outer_stop = False
left = y0
right = y1
error = b_error
cpustart = timeit.default_timer()
itercount = 0
old_y = 0
bayescount = 0
while not outer_stop:
if b_method is 'bayes':
y = find_median(y0, y1, pdf)
if y == old_y:
bayescount += 1
else:
bayescount = 0
old_y = y
if b_method is 'bisect':
alpha = 1 - error
y = (left + right)/2
x = init_x
a = init_a
b = init_b
stop = False
while not stop:
itercount += 1
if u_method is 'gradient':
optresult = optimize(u_method=u_method,
obs=obs,
stepsize=stepsize,
constraint=constraint,
x=x,
y=y,
sim_n=sim_n,
sim_grad_n=sim_grad_n)
x = optresult['x']
cond = checkCond(u_method=u_method,
constraint=constraint,
epsilon=grad_epsilon,
f=optresult['f'],
gradient=optresult['gradient'])
opttime += optresult['opttime']
simtime += optresult['simtime']
if u_method is 'golden':
optresult = optimize(u_method=u_method,
obs=obs,
alpha=alpha,
epsilon=gs_epsilon,
sim_n=sim_n,
a=a,
b=b,
y=y)
a = optresult['a']
b = optresult['b']
f_c = optresult['f_c']
f_d = optresult['f_d']
opttime += optresult['opttime']
simtime += optresult['simtime']
cond = checkCond(u_method=u_method,
a=a,
b=b,
delta=delta,
constraint=constraint,
f_c=f_c,
f_d=f_d)
stop = cond['stop']
condtime += cond['time']
if u_method is 'golden':
print str(y) + ": " + str(f_c) + " " + str(f_d) + " " + str(a) + " " + str(b)
if u_method is 'gradient':
print str(y) + ": " + str(optresult['f']) + " " + str(x)
print cond['result']
# ***
if b_method is 'bayes':
# update priors
if cond['result']:
for i in range(y0, y):
pdf[i] *= (1 - oracle)
for i in range(y, y1 + 1):
pdf[i] *= oracle
else:
for i in range(y0, y + 1):
pdf[i] *= oracle
for i in range(y + 1, y1 + 1):
pdf[i] *= (1-oracle)
# rescale
scalefactor = 1./sum(pdf)
for i in range(y0, y1 + 1):
pdf[i] *= scalefactor
# print max(pdf)
if max(pdf) > certainty or bayescount > 25:
outer_stop = True
final['y'] = pdf.index(max(pdf))
# ***
if b_method is 'bisect':
biobs.append(dict(left=left, y=y, right=right, result=cond['result'], error=error))
# check for backtracking here
# 1. identify the current T/F streak length
streaklen = 0
for i in range(1, len(biobs) + 1):
if biobs[-i]['result'] == cond['result']:
streaklen += 1
else:
break
root = max(0, len(biobs) - streaklen) # possible mistake index
# 2. compare pcs/confidence for this streak with the undo probability
backtrack = biobs[root]['error'] > ((.5 ** (streaklen - 1)) * b_error)
# print "backtrack: " + str(backtrack)
if backtrack:
left = biobs[root]['left']
right = biobs[root]['right']
error = biobs[root]['error'] / 2
# prune the list back to before the mistake; drop the items
# GS values are still cached in the obs data structure
for i in range(len(biobs) - root):
del biobs[-1]
else:
error = b_error
if cond['result']:
# discard left
left = y
else:
right = y
if right - left == 1:
outer_stop = True
final['y'] = left
btime = timeit.default_timer() - cpustart
btime = btime - simtime - opttime - condtime
final['itercount'] = itercount
final['simtime'] = simtime
final['optime'] = opttime
final['condtime'] = condtime
final['btime'] = btime
return final
def main(args):
"""Main function of cellanneal."""
if (args.start_temp is not None or args.end_temp is not None) and args.auto_temp == 1:
raise Exception("when auto_temp is set to 1(default value), starting temperature or ending temperature should not be set manually")
# if not args.no_parallel:
# import dask
# from dask.distributed import Client, LocalCluster
# if not args.cluster:
# cluster = LocalCluster(
# n_workers=args.workers,local_dir="/tmp/CellUniverse/dask-worker-space"
# )
# else:
# cluster = args.cluster
#
# client = Client(cluster)
# else:
client = None
lineagefile = None
start = time.time()
try:
config = load_config(args.config)
simulation_config = config["simulation"]
#Maybe better to store the image type in the config file in the first place, instead of using cmd?
if args.graySynthetic == True:
simulation_config["image.type"] = "graySynthetic"
elif args.phaseContrast == True:
simulation_config["image.type"] = "phaseContrastImage"
elif args.binary == True:
simulation_config["image.type"] = "binary"
else:
raise ValueError("Invalid Command: Synthetic image type must be specified")
if not args.output.is_dir():
args.output.mkdir()
if not args.bestfit.is_dir():
args.bestfit.mkdir()
if args.residual and not args.residual.is_dir():
args.residual.mkdir()
seed = int(start * 1000) % (2**32)
if args.seed != None:
seed = args.seed
np.random.seed(seed)
print("Seed: {}".format(seed))
celltype = config['global.cellType'].lower()
# setup the colony from a file with the initial properties
lineageframes = LineageFrames()
colony = lineageframes.forward()
imagefiles = get_inputfiles(args)
if args.lineage_file:
load_colony(colony, args.lineage_file, config, initial_frame = imagefiles[0].name)
else:
load_colony(colony, args.initial, config)
cost_diff = (-1, -1)
# open the lineage file for writing
lineagefile = open(args.output/'lineage.csv', 'w')
header = ['file', 'name']
if celltype == 'bacilli':
header.extend(['x', 'y', 'width', 'length', 'rotation', "split_alpha", "opacity"])
print(','.join(header), file=lineagefile)
if args.debug:
with open(args.debug/'debug.csv', 'w') as debugfile:
print(','.join(['window_start', 'window_end', 'pbad_total', 'bad_count', 'temperature', 'total_cost_diff', 'current_iteration', 'total_iterations']), file=debugfile)
if args.global_optimization:
global useDistanceObjective
useDistanceObjective = args.dist
realimages = [optimization.load_image(imagefile) for imagefile in imagefiles]
window = config["global_optimizer.window_size"]
if args.lineage_file:
lineage = global_optimization.build_initial_lineage(imagefiles, args.lineage_file, args.continue_from, config["simulation"])
else:
lineage = global_optimization.build_initial_lineage(imagefiles, args.initial, args.continue_from, config["simulation"])
lineage = global_optimization.find_optimal_simulation_confs(imagefiles, lineage, realimages, args.continue_from)
sim_start = args.continue_from - args.frame_first
print(sim_start)
shape = realimages[0].shape
synthimages = []
cellmaps = []
distmaps = []
iteration_per_cell = config["iteration_per_cell"]
if not useDistanceObjective:
distmaps = [None] * len(realimages)
for window_start in range(1 - window, len(realimages)):
window_end = window_start + window
print(window_start, window_end)
if window_end <= len(realimages):
# get initial estimate
if window_start >= sim_start:
if window_end > 1:
lineage.copy_forward()
realimage = realimages[window_end - 1]
synthimage, cellmap = optimization.generate_synthetic_image(lineage.frames[window_end - 1].nodes, shape, lineage.frames[window_end - 1].simulation_config)
synthimages.append(synthimage)
cellmaps.append(cellmap)
if useDistanceObjective:
distmap = distance_transform_edt(realimage < .5)
distmap /= config[f'{config["global.cellType"].lower()}.distanceCostDivisor'] * config[
'global.pixelsPerMicron']
distmap += 1
distmaps.append(distmap)
if args.auto_temp == 1 and window_end == 1:
print("auto temperature schedule started")
args.start_temp, args.end_temp = \
global_optimization.auto_temp_schedule(imagefiles, lineage, realimages, synthimages, cellmaps, distmaps, 0, 1, lineagefile, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp, "ending temperature is ", args.end_temp)
if args.auto_meth == "frame" and optimization.auto_temp_schedule_frame(window_end, 3):
print("auto temperature schedule restarted")
args.start_temp, args.end_temp = \
global_optimization.auto_temp_schedule(imagefiles, lineage, realimages, synthimages, cellmaps, distmaps, window_start, window_end, lineagefile, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp, "ending temperature is ", args.end_temp)
if window_start >= sim_start:
if useDistanceObjective:
global_optimization.totalCostDiff = optimization.dist_objective(realimage, synthimage, distmap, cellmap, config["overlap.cost"])
else:
global_optimization.totalCostDiff = optimization.objective(realimage, synthimage, cellmap, config["overlap.cost"], config["cell.importance"])
global_optimization.optimize(imagefiles, lineage, realimages, synthimages, cellmaps, distmaps, window_start, window_end, lineagefile, args, config, iteration_per_cell)
if window_start >= 0:
global_optimization.save_lineage(imagefiles[window_start].name, lineage.frames[window_start].nodes, lineagefile)
global_optimization.save_output(imagefiles[window_start].name, synthimages[window_start], realimages[window_start], lineage.frames[window_start].nodes, args, config)
return 0
config["simulation"] = optimization.find_optimal_simulation_conf(config["simulation"], optimization.load_image(imagefiles[0]), list(colony))
if args.auto_temp == 1:
print("auto temperature schedule started")
args.start_temp, args.end_temp = optimization.auto_temp_schedule(imagefiles[0], lineageframes.forward(), args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp, "ending temperature is ", args.end_temp)
frame_num = 0
prev_cell_num = len(colony)
for imagefile in imagefiles: # Recomputing temperature when needed
frame_num += 1
if args.auto_meth == "frame":
if optimization.auto_temp_schedule_frame(frame_num, 8):
print("auto temperature schedule started (recomputed)")
args.start_temp, args.end_temp = optimization.auto_temp_schedule(imagefile, colony, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp, "ending temperature is ", args.end_temp)
elif args.auto_meth == "factor":
if optimization.auto_temp_schedule_factor(len(colony), prev_cell_num, 1.1):
print("auto temperature schedule started (recomputed)")
args.start_temp, args.end_temp = optimization.auto_temp_schedule(imagefile, colony, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp, "ending temperature is ", args.end_temp)
prev_cell_num = len(colony)
elif args.auto_meth == "const":
if optimization.auto_temp_schedule_const(len(colony), prev_cell_num, 10):
print("auto temperature schedule started (recomputed)")
args.start_temp, args.end_temp = optimization.auto_temp_schedule(imagefile, colony, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp, "ending temperature is ", args.end_temp)
prev_cell_num = len(colony)
elif args.auto_meth == "cost":
print(cost_diff, frame_num, optimization.auto_temp_shcedule_cost(cost_diff))
if frame_num >= 2 and optimization.auto_temp_shcedule_cost(cost_diff):
print("auto temperature schedule started cost_diff (recomputed)")
args.start_temp, args.end_temp = optimization.auto_temp_schedule(imagefile, colony, args, config)
print("auto temperature schedule finished")
print("starting temperature is ", args.start_temp, "ending temperature is ", args.end_temp)
colony = optimize(imagefile, lineageframes, args, config, client)
cost_diff = optimization.update_cost_diff(colony, cost_diff)
# flatten modifications and save cell properties
colony.flatten()
for cellnode in colony:
properties = [imagefile.name, cellnode.cell.name]
if celltype == 'bacilli':
properties.extend([
str(cellnode.cell.x),
str(cellnode.cell.y),
str(cellnode.cell.width),
str(cellnode.cell.length),
str(cellnode.cell.rotation)])
print(','.join(properties), file=lineagefile)
except KeyboardInterrupt as error:
raise error
finally:
if lineagefile:
lineagefile.close()
print(f'{time.time() - start} seconds')
return 0
def main(args):
"""Main function of cellanneal."""
import dask
from dask.distributed import Client, LocalCluster
if not args.cluster:
cluster = LocalCluster(n_workers=args.workers, )
else:
cluster = args.cluster
client = Client(cluster)
lineagefile = None
start = time.time()
try:
if args.debug:
debugmode = True
config = load_config(args.config)
celltype = config['global.cellType'].lower()
# setup the colony from a file with the initial properties
lineageframes = LineageFrames()
colony = lineageframes.forward()
load_colony(colony, args.initial, config)
# open the lineage file for writing
lineagefile = open(args.output / 'lineage.csv', 'w')
header = ['file', 'name']
if celltype == 'bacilli':
header.extend(['x', 'y', 'width', 'length', 'rotation'])
print(','.join(header), file=lineagefile)
for imagefile in get_inputfiles(args):
colony = optimize(imagefile, lineageframes, args, config, client)
# flatten modifications and save cell properties
colony.flatten()
for cellnode in colony:
properties = [imagefile.name, cellnode.cell.name]
if celltype == 'bacilli':
properties.extend([
str(cellnode.cell.x),
str(cellnode.cell.y),
str(cellnode.cell.width),
str(cellnode.cell.length),
str(cellnode.cell.rotation)
])
print(','.join(properties), file=lineagefile)
except KeyboardInterrupt as error:
raise error
finally:
if lineagefile:
lineagefile.close()
print(f'{time.time() - start} seconds')
return 0
