def main():
optimize(systems)
# Display all the systems
print('Autonomous Systems:')
print()
print(
tabulate([[asys, asys.local_preference] for asys in systems],
headers=['Autonomous System', 'Local Preference'],
tablefmt='pretty'))
print()
# Display all the neighbours
for asys in systems:
print(f'Neighbours of {asys}:')
print()
print(
tabulate(asys.display_neighbour_info(),
headers=['Autonomous System', 'Weight'],
tablefmt='pretty'))
print()
# Display all the Routing Tables
for asys in systems:
print(f'Routing Table for {asys}:')
print()
print(
tabulate(
asys.display_routing_table(),
headers=['Autonomous System', 'Weight', 'Hops', 'Next Jump'],
tablefmt='pretty'))
print()
def start_intensively_optimal_construct_Q_from(P, internal=5, rounds=5):
'''
construct a init Q for further refinement
'''
lengths = q_config[0]["side_lengths"]
p0 = P[0]
p1 = P[1]
q1 = p0 + (p1 - p0) / np.linalg.norm(p1 - p0) * lengths[0]
Q = np.array([P[0], q1])
Q = kabsched_Q(Q, P[0:2])
for i in range(2, P.shape[0]):
print 'now: ', i
tmp_p = P[0:i + 1]
Q = expand_Q_from(Q, tmp_p)
for _ in range(5):
Q = expand_Q_from(Q[0:-1], tmp_p)
if i < 500:
Q = optimize(Q, tmp_p, 5)
elif i % internal == 0:
Q = optimize(Q, tmp_p, rounds)
print rmsd(Q, P)
print "lower bound: ", lower_bound(Q, P)
return Q
def source(source_file: SourceFile, args: Args) -> List[Instruction]:
code: List[Instruction] = []
errors: List[ParseError] = []
span = source_file.span()
if args.assertions:
# An assertion at the start makes the property tests happy
code.append(StartTapeAssertion(Span(source_file, 0, 0)))
for sub in _split_on(span, set(['\n'])):
try:
code += _line(sub, args)
except ParseError as err:
errors.append(err)
loops = []
for instr in code:
if instr.loop_level_change() == 1:
loops.append(instr)
elif instr.loop_level_change() == -1:
if len(loops):
loops.pop(-1)
else:
errors.append(SingleParseError('Unmatched "]"', instr.span()))
elif instr.loop_level_change() != 0:
assert False, 'Invalid value ' + str(
instr.loop_level_change()) + ' for loop level change'
for instr in loops:
errors.append(SingleParseError('Unmatched "["', instr.span()))
if errors:
raise MultiParseError(errors)
if args.optimize:
optimize.optimize(code)
return code
def initialize(dictionary, basic_vars, non_basic_vars):
m, n = np.shape(dictionary)
has_neg = any(dictionary[:-1, 0] < 0)
if not has_neg:
return dictionary, basic_vars, non_basic_vars, False
init_dict = np.vstack((np.c_[dictionary[:-1], np.ones((m - 1, 1))], np.r_[np.zeros(n), -1]))
init_non_basic_vars = np.r_[non_basic_vars, 0]
init_basic_vars = np.array(basic_vars)
entering, leaving = (len(init_non_basic_vars),
min(range(m - 1), key = lambda i: init_dict[i, 0]))
pivot.pivot_for(init_dict, init_basic_vars,
init_non_basic_vars, entering, leaving)
optimize.optimize(init_dict, init_basic_vars, init_non_basic_vars)
return init_dict, init_basic_vars, init_non_basic_vars, True
def test_train():
loss_arr = []
for preds, losses, i, epoch in optimize(content_targets,
style_target,
content_weight,
style_weight,
tv_weight,
vgg_path,
epochs=1,
print_iterations=1,
batch_size=4,
save_path='ckp_temp/fns.ckpt',
slow=False,
learning_rate=1e-3,
debug=False,
type=0,
save=False):
style_loss, content_loss, tv_loss, loss = losses
print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss))
loss_arr.append(loss)
to_print = (style_loss, content_loss, tv_loss)
print('style: %s, content:%s, tv: %s' % to_print)
if len(loss_arr) > 2:
loss_arr.remove(min(loss_arr))
loss_arr.remove(max(loss_arr))
growth = get_growth(loss_arr)
print('growth: %f' % growth)
if growth >= 0:
print('TEST TRAINING FAILED, LOSS IS NOT DECLINING.')
exit(0)
elif growth < 0:
print('TEST TRAINING SUCCESS.')
def get_clusters(path): sizes = get_sizes(os.path.join(path, "sizes.json")) mois = get_mois(path, sizes) clusters = optimize(mois) return clusters
def main():
parser = build_parser()
options = parser.parse_args()
check_opts(options)
style_target = get_img(options.style)
content_targets = list_files(options.train_path)
kwargs = {
"epochs":options.epochs,
"print_iterations":options.checkpoint_iterations,
"batch_size":options.batch_size,
"checkpoint_dir":os.path.join(options.checkpoint_dir,'fns.ckpt'),
"summary_dir":options.summary_dir,
"learning_rate":options.learning_rate
}
args = [
content_targets,
style_target,
options.content_weight,
options.style_weight,
options.tv_weight,
options.vgg_path
]
start_time = time.time()
for preds, losses, i, epoch in optimize(*args, **kwargs):
style_loss, content_loss, tv_loss, loss = losses
print('{0} ---------- Epoch: {1}, Iteration: {2}----------'.format(time.ctime(), epoch, i))
print('Total loss: {0}, Style loss: {1}, Content loss: {2}, TV loss: {3}'
.format(loss, style_loss, content_loss, tv_loss))
print("Training complete! Total training time is {0} s".format(time.time() - start_time))
def dominate(mu, cov, cost, prices, risk_tolerance):
# start date for the based portfolio to be determined ... always assign to past 6 months (ie rebalance the period)
start_date = (datetime.now() -
relativedelta(months=6)).strftime("%Y-%m-%d")
# get the number of days in the backtest period ... to determine target returns and variances later
days = business_days(start_date, datetime.now().strftime("%Y-%m-%d"))
# call backtest to get the value of the portfolio
portfolio_value = back_test(portfolio,
start_date,
end_date=None,
dollars=None)[0].sum(axis=1)
# calculate portfolio returns
portfolio_returns = (portfolio_value / portfolio_value.shift(1) -
1).dropna()
# assign the target return and variance
target_returns = (gmean(portfolio_returns + 1, axis=0) - 1) * days
target_variance = portfolio_returns.var() * days
mu_p2 = mu[0] if single_period else mu[1]
cov_p2 = cov[0] if single_period else cov[1]
soln, agg_soln = optimize(mu=(mu[0], mu_p2),
sigma=(cov[0], cov_p2),
alpha=(0.05, 0.10),
return_target=(target_returns, target_returns),
costs=cost,
prices=prices,
gamma=risk_tolerance[2])
return soln, agg_soln
def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):
w = np.zeros(X_train.shape[0]).reshape(X_train.shape[0],1)
b = 0
parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate)
w = parameters["w"]
b = parameters["b"]
Y_prediction_test = predict(w,b,X_test)
Y_prediction_train = predict(w,b,X_train)
print("train accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))
print("test accuracy: {} %".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))
d = {"costs": costs,
"Y_prediction_test": Y_prediction_test,
"Y_prediction_train" : Y_prediction_train,
"w" : w,
"b" : b,
"learning_rate" : learning_rate,
"num_iterations": num_iterations}
return d
def generate(self, content, init_image, optimizer_iterations, optimizer_checkpoint):
if not self.content_is_const:
self.content.set_value(content)
self.generated_image.set_value(init_image)
# scipy optimize requires that the parameters are of type float64
x0 = self.generated_image.get_value().astype('float64')
# our record. Start with the style and the content.
style2 = self.style[:, :, :x0.shape[2], :x0.shape[3]]
if style2.shape[2] < x0.shape[2]:
style2 = np.concatenate((style2, np.zeros((x0.shape[0], x0.shape[1], x0.shape[2] - self.style.shape[2], style2.shape[3]))), axis=2)
if style2.shape[3] < x0.shape[3]:
style2 = np.concatenate((style2, np.zeros((x0.shape[0], x0.shape[1], style2.shape[2], x0.shape[3] - self.style.shape[3]))), axis=3)
xs = [content, style2, x0]
overall_start_time = time.time()
last_loss_val = 0.
for x, i, loss_val, iter_duration in optimize.optimize(x0, self.generated_image, self.f_outputs, num_iterations=optimizer_iterations, checkpoint_iterations=optimizer_checkpoint):
if self.print_progress:
print('iteration %d' % (i,))
print('Current loss value: %f' % (loss_val,))
print('Iteration %d completed in %fs' % (i, iter_duration))
xs.append(x)
last_loss_val = loss_val
if self.print_progress:
overall_end_time = time.time()
print('Optimization completed in %fs' % (overall_end_time - overall_start_time,))
return xs, last_loss_val
def main():
"""Compiles program.scratch to a scratch project."""
parser = Lark.open("grammar.lark",
parser="lalr",
transformer=ScratchTransformer,
postlex=ScratchIndenter())
with open("program.scratch") as source_file:
source_code = source_file.read()
parsed = parser.parse(source_code)
# print(parsed)
parsed = optimize(parsed)
parsed = scratchify(parsed)
backdrop_md5 = md5sum("resources/backdrop.svg")
for i in parsed["targets"]:
i["costumes"] = [{
"assetId": backdrop_md5,
"name": "backdrop",
"md5ext": f"{backdrop_md5}.svg",
"dataFormat": "svg",
"rotationCenterX": 240,
"rotationCenterY": 180
}]
try:
with open("parsed.json", "w") as parsed_json_file:
json.dump(parsed, parsed_json_file, indent="\t")
except ValueError:
print(parsed)
create_project_files(parsed)
def main():
opts = get_opts()
style_target = read_img(opts.style)
content_targets = glob.glob('%s/*' % opts.train_path)
style_name = os.path.splitext(os.path.basename(opts.style))[0]
kwargs = {
"epochs": opts.epochs,
"print_iterations": opts.checkpoint_iterations,
"batch_size": opts.batch_size,
"save_path": os.path.join(opts.checkpoint_dir, '%s.ckpt' % style_name),
"learning_rate": opts.learning_rate
}
args = [
content_targets, style_target, opts.content_weight, opts.style_weight,
opts.tv_weight, opts.net_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 opts.output:
preds_path = '%s/%s_%s.png' % (opts.output_dir, epoch, i)
quickpaint.eval_mul_dims(opts.output, preds_path,
opts.checkpoint_dir)
cmd_text = 'python quickpaint.py --checkpoint %s ...' % opts.checkpoint_dir
print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main():
### 注意这里的引用关系，实际上是argparse.parse_args()！
parser = build_parser()
options = parser.parse_args()
check_opts(options)
###
### 这里就是用自己写的get_img去拿出参数里面的style图像！
style_target = get_img(options.style)
###
### 处理传进来的参数！
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
def model(X_train,
Y_train,
X_test,
Y_test,
num_iterations=2000,
learning_rate=0.5,
print_cost=False):
w, b = initialize_with_zeros(X_train.shape[0])
# Gradient descent ( 1 line of code)
parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations,
learning_rate, print_cost)
w = parameters["w"]
b = parameters["b"]
# Predict test/train set examples ( 2 lines of code)
Y_prediction_test = predict(w, b, X_test)
Y_prediction_train = predict(w, b, X_train)
### END CODE HERE ###
# Print train/test Errors
print("train accuracy: {} %".format(
100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))
print("test accuracy: {} %".format(
100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))
d = {
"costs": costs,
"Y_prediction_test": Y_prediction_test,
"Y_prediction_train": Y_prediction_train,
"w": w,
"b": b,
"learning_rate": learning_rate,
"num_iterations": num_iterations
}
return d
def getTimepointSlicesAt(self, slice):
"""
Sets the slice to show
"""
self.slice = slice
# if we're showing each slice of one timepoint
# instead of one slice of each timepoint, call the
# appropriate function
self.slices = []
if not self.showTimepoints:
return self.setTimepoint(self.timepoint)
count = self.dataUnit.getNumberOfTimepoints()
for tp in range(0, count):
if self.dataUnit.isProcessed():
image = self.dataUnit.doPreview(self.slice, 1, tp)
image.Update()
self.ctf = self.dataUnit.getSourceDataUnits()[0].getColorTransferFunction()
Logging.info("Using ", image, "for gallery", kw = "preview")
else:
image = self.dataUnit.getTimepoint(tp)
x, y, z = self.dataUnit.getDimensions()
image = optimize.optimize(image, updateExtent = (0, x - 1, 0, y - 1, self.slice, self.slice))
self.ctf = self.dataUnit.getColorTransferFunction()
image = lib.ImageOperations.getSlice(image, self.slice)
image.Update()
tp = vtk.vtkImageData()
tp.DeepCopy(image)
self.slices.append(tp)
self.calculateBuffer()
self.updatePreview()
def simplex(dictionary, basic_vars, non_basic_vars):
dict_, basic, non_basic = initialize_and_reconstruct(
dictionary, basic_vars, np.array(non_basic_vars))
res, _ = optimize(dict_, basic, non_basic)
if res == UNBOUNDED:
raise Infeasible()
return dict_, basic, non_basic
def main():
print("Enter main")
parser = build_parser()
options = parser.parse_args()
check_opts(options)
print("Get image target")
style_target = get_img(options.style)
if not options.slow:
with log_time_usage("get images targets"):
content_targets = _get_files(options.train_path)
elif options.test:
content_targets = [options.test]
kwargs = {
"slow": options.slow,
"debug": options.debug,
"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,
"tensorboard_dir": options.tensorboard_dir
}
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
]
print("Start training")
with log_time_usage("Training completed in"):
for preds, losses, i, epoch, time_info in optimize(*args, **kwargs):
style_loss, content_loss, tv_loss, loss = losses
print(
'Epoch %d, Iteration: %d, Loss: %s, AVG batch time: %.2f, total_time: %.2f, ETA (in h): %.2f'
% (epoch, i, loss, *time_info))
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:
# TODO: img is not defined
# save_img(preds_path, img)
pass
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():
print('ml5.js Style Transfer Training!')
print('Note: This traning will take a couple of hours.')
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
]
print('Training is starting!...')
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)
print('Converting model to ml5js')
dump_checkpoints(kwargs['save_path'], options.model_dir)
print('Done! Checkpoint saved. Visit https://ml5js.org/docs/StyleTransfer for more information')
def main():
args = docopt.docopt(__doc__)
data = read_data(args['<in>'])
score, result = solve(data)
print(score)
score2, result2 = optimize(result, data)
print(score2)
format_solution(args['<out>'], result2, prefix=str(score))
def main():
check_version()
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,
"device":options.device,
"total_iterations":options.total_iterations,
"base_model_path":options.base_model_path,
}
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)
sys.stdout.flush()
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-dir %s ...' % ckpt_dir
print("Training complete. For evaluation:\n `%s`" % cmd_text)
def do_optimization():
global _optimization_status
# last opt still running
if _optimization_status == "running":
return jsonify({"result": "error",
"reason": "last optimization still running"})
try:
# lock and do optimization
_optimization_status = "running"
kids = request.json
_sqllog.info("kids: %s", kids)
orders_by_dt = defaultdict(list)
conn = pymssql.connect(**sqlinfo) # connection
for kid in kids:
cursor = conn.cursor()
cursor.execute("""
SELECT
ov.M1 AS M1,
ov.M2 AS M2,
ov.T1 AS T1,
ov.T2 AS T2,
ov.S1 AS S1,
ov.S2 AS S2,
ov.Wire AS Wire,
ov.Require_Date as Require_Date,
ov.do_time as do_time
FROM optimization_view AS ov
WHERE ov.kid = %s
""", kid)
*parts, reqdate, do_time = cursor.fetchall()[0]
reqdate = reqdate.strftime("%Y-%m-%d")
orders_by_dt[reqdate].append(Kanban(kid, tuple(parts), do_time))
cursor = conn.cursor(as_dict=True)
cursor.execute("""
SELECT
bw.wcenter_No AS machineId,
bw.ParentWcenter_No AS pwc,
bw.RouteCode AS rc
FROM MES_BASE_WCENTER AS bw
""")
machines = cursor.fetchall()
conn.close()
# result = {reqdate: optimize(orders, machines)
# for reqdate, orders in orders_by_dt.items()}
result = [{"date": reqdate, "result": optimize(orders, machines)}
for reqdate, orders in orders_by_dt.items()]
_optimization_status = "idle"
return jsonify(result)
finally:
_optimization_status = "idle"
def model(X_train,
Y_train,
X_test,
Y_test,
num_iterations=2000,
learning_rate=0.5,
print_cost=False):
"""
Builds the logistic regression model by calling the function you've implemented previously
Arguments:
X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)
Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)
X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)
Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)
num_iterations -- hyperparameter representing the number of iterations to optimize the parameters
learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()
print_cost -- Set to true to print the cost every 100 iterations
Returns:
d -- dictionary containing information about the model.
"""
### START CODE HERE ###
# initialize parameters with zeros (≈ 1 line of code)
w, b = initialize_with_zeros(X_train.shape[0])
# Gradient descent (≈ 1 line of code)
parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations,
learning_rate, print_cost)
# Retrieve parameters w and b from dictionary "parameters"
w = parameters["w"]
b = parameters["b"]
# Predict test/train set examples (≈ 2 lines of code)
Y_prediction_test = predict(w, b, X_test)
Y_prediction_train = predict(w, b, X_train)
### END CODE HERE ###
# Print train/test Errors
print("train accuracy: {} %".format(
100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))
print("test accuracy: {} %".format(
100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))
d = {
"costs": costs,
"Y_prediction_test": Y_prediction_test,
"Y_prediction_train": Y_prediction_train,
"w": w,
"b": b,
"learning_rate": learning_rate,
"num_iterations": num_iterations
}
return d
def main(style,
test=False,
test_dir='test',
train_path=TRAIN_PATH,
slow=False,
epochs=NUM_EPOCHS,
checkpoint_iterations=CHECKPOINT_ITERATIONS,
batch_size=BATCH_SIZE,
checkpoint_dir=CHECKPOINT_DIR,
learning_rate=LEARNING_RATE,
content_weight=CONTENT_WEIGHT,
style_weight=STYLE_WEIGHT,
tv_weight=TV_WEIGHT,
vgg_path=VGG_PATH):
#parser = build_parser()
#options = parser.parse_args()
#check_opts(options)
style_target = get_img(style)
if not slow:
content_targets = _get_files(train_path)
elif test:
content_targets = [test]
kwargs = {
"slow": slow,
"epochs": epochs,
"print_iterations": checkpoint_iterations,
"batch_size": batch_size,
"save_path": checkpoint_dir,
"learning_rate": learning_rate
}
if slow:
if epochs < 10:
kwargs['epochs'] = 1000
if learning_rate < 1:
kwargs['learning_rate'] = 1e1
args = [
content_targets, style_target, content_weight, style_weight, tv_weight,
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 test:
assert test_dir != False
preds_path = '%s/%s_%s.png' % (test_dir, epoch, i)
if not slow:
ckpt_dir = os.path.dirname(checkpoint_dir)
evaluate.ffwd_to_img(test, preds_path, checkpoint_dir)
else:
save_img(preds_path, img)
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,
"device_and_number": options.device_and_number
}
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
]
import time
from datetime import datetime
start_time = time.time()
for preds, losses, i, epoch in optimize(*args, **kwargs):
style_loss, content_loss, tv_loss, loss = losses
delta_time, start_time = time.time() - start_time, time.time()
print(
'Current Time = {}; Time Elapsed = {}; Epoch = {}; Iteration = {}; Loss = {}'
.format(datetime.now().strftime("%Y %B %d, %H:%M:%S"), delta_time,
epoch, i, loss))
to_print = (style_loss, content_loss, tv_loss)
print('Loss values: style = %s; content = %s; tv = %s' % to_print)
sys.stdout.flush()
if options.test:
assert options.test_dir != False
preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i)
if not options.slow: # if uses GPU, uses RAM that it doesn't have, so it's slow here
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 Newton_hook(x0,f,df,delta,N_max,tol_f,tol_x,alpha,beta,delta_min):
k = 0
x = copy(x0)
converged = 0
diag = []
while not(converged):
if k > N_max or delta < delta_min:
break
# compute the Newton-Raphson update step
r = f(x)
res = np.linalg.norm(r,2)
J = df(x)
# linalg.solve uses LUP decomposition
dx = -np.linalg.solve(J,r)
size = np.linalg.norm(dx,2)
diag.append([k,res,size,delta])
print('Step %d, delta=%e, res=%e size of NR step=%e ...' % (k,delta,res,size))
if size < delta:
accept = try_step(x,dx,f,res) # set z <- x+dx, compute f(z), return accept = 1 iff |f(z)|< res
if accept:
# the Newton-Raphson step reduced the residual, accept it
x += dx
k += 1
print('Accepted full NR step.')
else:
# the Newton-Raphson step increased the residual, reject it and decrease delta
delta *= alpha
print('Rejected full NR step, resetting delta=%e.' %(delta))
else:
# the Newton-Raphson step lies outside the trust region
dx = optimize(x,dx,f,df,delta)
accept = try_step(x,dx,f,res)
if accept:
# the update step on the edge of the trust region gives a smaller residual, accept and increase delta
x += dx
delta *= beta
k += 1
print('Accepted constrained minimization step, resetting delta=%e.' % (delta))
else:
# the update step on the edge of the trust region gives a larger residual, reject and reduce delta
delta *= alpha
print('Rejected constrained minimization step, resetting delta=%e.' % (delta))
r = f(x)
res = np.linalg.norm(r,2)
err = np.linalg.norm(dx,2)
if res < tol_f and err < tol_x:
converged = 1
if converged == 0:
print('No convergence after %d iterations, delta = %e.' % (k,delta))
return x,np.asarray(diag)
def main():
parser = build_parser()
options = parser.parse_args()
if not os.path.exists(options.test_dir):
os.mkdir(options.test_dir)
if not os.path.exists(options.checkpoint_dir):
os.mkdir(options.checkpoint_dir)
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,
"gpu_fraction": options.gpu_fraction
}
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 generate_samples(save_path, generator, encoder, target, loss_func,
n_samples):
mean_loss = 0
for i in range(n_samples):
generated_image, _, loss = optimize(generator, encoder, target,
loss_func)
generated_image = to_pil_image(generated_image)
generated_image.save('{}_{}.png'.format(save_path, i))
mean_loss += loss / n_samples
with open('{}_metrics.json'.format(save_path), 'w') as f:
f.write(json.dumps({'mean_final_loss': mean_loss}, indent=2))
def model(X_train,
Y_train,
X_test,
Y_test,
num_iterations=2000,
learning_rate=0.5,
print_cost=False):
"""
Builds the logistic regression model by calling the function you've implemented previously
Arguments:
X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)
Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)
X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)
Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)
num_iterations -- hyperparameter representing the number of iterations to optimize the parameters
learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()
print_cost -- Set to true to print the cost every 100 iterations
Returns:
d -- dictionary containing information about the model.
"""
# 用0初始化参数
w, b = initialize_with_zeros(X_train.shape[0])
# 梯度下降
parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations,
learning_rate, print_cost)
# 从参数表中取出 w 和 b
w = parameters["w"]
b = parameters["b"]
# 预测测试集和训练集中的样本
Y_prediction_test = predict(w, b, X_test)
Y_prediction_train = predict(w, b, X_train)
print("训练集精度：{} %".format(100 -
np.mean(np.abs(Y_prediction_train - Y_train)) *
100))
print(
"测试集精度：{} %".format(100 -
np.mean(np.abs(Y_prediction_test - Y_test)) * 100))
d = {
"costs": costs,
"Y_prediction_test": Y_prediction_test,
"Y_prediction_train": Y_prediction_train,
"w": w,
"b": b,
"learning_rate": learning_rate,
"num_iterations": num_iterations
}
return d
def opt(reform):
return optimize(
input_dict,
"mean_pct_loss",
reform,
verbose=False,
seed=0,
# Reforms don't always improve upon one another with the
# default tolerance of 0.01.
tol=0.0001,
)
def model(train_X, train_Y, test_X, test_Y, num_iteration, learning_rate=0.5):
m = train_X.shape[1]
dim = train_X.shape[0]
W_ini, b_ini = initialize_with_zeros(dim)
W, b = optimize(W_ini, b_ini, train_X, train_Y, num_iteration,
learning_rate)
train_Y_hat = predict(W, b, train_X)
test_Y_hat = predict(W, b, test_X)
train_accuracy = (1 - np.mean(abs(train_Y - train_Y_hat))) * 100
test_accuracy = (1 - np.mean(abs(test_Y - test_Y_hat))) * 100
return train_accuracy, test_accuracy
def check_optimizer(f):
def check(a, b):
return f(a) > f(b)
a = optimize(f)
for i in range(len(a) - 1):
if not check(a[i], a[i + 1]):
raise ValueError("something is wrong")
if f(a[0]) - f(a[-1]) <= 5:
raise ValueError("it is a bad optimizer, Mitya luzer")
print('everything is OK, Mitya the best')
def test_optimize_multi_param(self):
print(colored("optimize test with three params four functions", 'blue'))
warnings.warn("This test contains nondeterministic code, please check the results manually!!", RuntimeWarning)
functions = get_all_f(os.path.join(cwd, "results/prism_results/multiparam_synchronous_3.txt"), "prism", True)
functions = functions[3]
print(functions)
d = [0.2, 0.3, 0.4, 0.1]
print(d)
result = optimize.optimize(functions, ["p", "q1", "q2"], [[0, 1], [0, 1], [0, 1]], d)
print("parameter point", result[0])
print("function values", result[1])
print("distance", result[2])
def test_optimize_two_param(self):
print(colored("optimize test with two params three functions", 'blue'))
warnings.warn("This test contains nondeterministic code, please check the results manually!!", RuntimeWarning)
functions = get_all_f(os.path.join(cwd, "results/prism_results/asynchronous_2.txt"), "prism", True)
functions = functions[2]
print("functions", functions)
d = pickle_load(os.path.join(data_dir, "data.p"))
print("data_point", d)
result = optimize.optimize(functions, ["p", "q"], [[0, 1], [0, 1]], d)
print("parameter point", result[0])
print("function values", result[1])
print("distance", result[2])
def aux_optim(algorithm, run_id=0, func_id=5, dim=2, pop_size=30, max_f_evals='auto', target_error=10e-8):
'''
Auxiliary function for multiprocessing.
'''
np.random.seed()
print("Run ID: ", run_id)
errorHist, fitnessHist = optimize(algorithm, func_id=func_id, dim=dim, pop_size=pop_size, max_f_evals=max_f_evals,
target_error=target_error, verbose=True)
errorHist["Run"] = np.ones(errorHist.shape[0], dtype=int)*run_id
return errorHist, fitnessHist
def updateRendering(self): """ Update the Rendering of this module """ data = self.getInput(1) x,y,z = self.dataUnit.getDimensions() data = optimize.optimize(image = data, updateExtent = (0, x-1, 0, y-1, 0, z-1)) if data.GetNumberOfScalarComponents() > 3: extract = vtk.vtkImageExtractComponents() extract.SetInput(data) extract.SetComponents(1, 1, 1) data = extract.GetOutput() if data.GetNumberOfScalarComponents() > 1: self.luminance.SetInput(data) data = self.luminance.GetOutput() z = self.parameters["Slice"] ext = (0, x - 1, 0, y - 1, z, z) voi = vtk.vtkExtractVOI() voi.SetVOI(ext) voi.SetInput(data) slice = voi.GetOutput() self.geometry.SetInput(slice) self.warp.SetInput(self.geometry.GetOutput()) self.warp.SetScaleFactor(self.parameters["Scale"]) self.merge.SetGeometry(self.warp.GetOutput()) if slice.GetNumberOfScalarComponents() == 1: maptocol = vtk.vtkImageMapToColors() ctf = self.getInputDataUnit(1).getColorTransferFunction() maptocol.SetInput(slice) maptocol.SetLookupTable(ctf) maptocol.Update() scalars = maptocol.GetOutput() else: scalars = slice self.merge.SetScalars(scalars) data = self.merge.GetOutput() if self.parameters["Normals"]: self.normals.SetInput(data) self.normals.SetFeatureAngle(self.parameters["FeatureAngle"]) print "Feature angle=", self.parameters["FeatureAngle"] data = self.normals.GetOutput() self.mapper.SetInput(data) self.mapper.Update() VisualizationModule.updateRendering(self) self.parent.Render()
def save(self):
"""
Apply a series of actions from a set of (action, arg) tuples, probably
as parsed from a URL. Each action is a code into PROCESSORS.
Then save the mogrified image.
"""
from settings import PROCESSORS
from .filesystem import makedirs
if self.im is None:
# If we got here something very strange is going on that I can't even
# predict.
return # pragma: no cover
makedirs(self.output_path)
for action, arg in self.actions:
action = PROCESSORS[action]
if self.frames:
new_frames = []
for frame in self.frames:
new_frames.append(action.process(frame, arg))
self.frames = new_frames
else:
self.im = action.process(self.im, arg)
self.im = optimize.optimize(self.im, fmt=self.format, quality=self.quality)
kwargs = {
'format': self.format,
'optimize': True,
'quality': self.quality,
}
if self.format == 'jpeg':
kwargs['progressive'] = True
if self.filename.startswith('s3://'):
import cStringIO
from filesystem import s3
output = cStringIO.StringIO()
if self.frames:
images2gif.write_gif(output, self.frames)
else:
self.im.save(output, **kwargs)
output.reset()
s3.put_file(output, self.filename)
else:
if self.frames:
images2gif.write_gif(self.filename, self.frames)
else:
self.im.save(self.filename, **kwargs)
def setTimepoint(self, timepoint, update = 1):
"""
Sets the timepoint to display
"""
if self.timepoint == timepoint and self.slices:
return
self.timepoint = timepoint
if not scripting.renderingEnabled:
return
# if we're showing one slice of each timepointh
# instead of each slice of one timepoint, call the
# appropriate function
if self.showTimepoints:
return self.getTimepointSlicesAt(self.slice)
if self.visualizer.getProcessedMode():
image = self.dataUnit.doPreview(scripting.WHOLE_DATASET_NO_ALPHA, 1, self.timepoint)
self.ctf = self.dataUnit.getSourceDataUnits()[0].getColorTransferFunction()
# Logging.info("Using ", image, "for gallery", kw = "preview")
else:
image = self.dataUnit.getTimepoint(timepoint)
self.ctf = self.dataUnit.getColorTransferFunction()
#self.imagedata = lib.ImageOperations.imageDataTo3Component(image,ctf)
self.imagedata = image
self.imagedata.SetUpdateExtent(self.imagedata.GetWholeExtent())
self.imagedata.Update()
x, y, z = self.dataUnit.getDimensions()
self.slices = []
for i in range(z):
image = optimize.optimize(image = self.imagedata, updateExtent = (0, x - 1, 0, y - 1, i, i))
image = lib.ImageOperations.getSlice(image, i)
lib.messenger.send(None, "update_progress", i / float(z), "Loading slice %d / %d for Gallery view" % (i + 1, z + 1))
self.slices.append(image)
lib.messenger.send(None, "update_progress", 1.0, "All slices loaded.")
self.calculateBuffer()
if update:
print "Updating preview"
self.updatePreview()
self.Refresh()
def updateRendering(self, input = None):
"""
Update the Rendering of this module
"""
self.updateMethod()
self.updateQuality()
self.updateInterpolation()
self.setShading(self.parameters["UseShading"])
if not input:
input = self.getInput(1)
x, y, z = self.dataUnit.getDimensions()
input = optimize.optimize(image = input, updateExtent = (0, x - 1, 0, y - 1, 0, z - 1))
ncomps = input.GetNumberOfScalarComponents()
Logging.info("Number of comps=", ncomps, kw = "rendering")
dataType = input.GetScalarType()
if (ncomps > 1 or dataType not in [3, 5]) and self.parameters["Method"] == TEXTURE_MAPPING:
self.setParameter("Method", 0)
lib.messenger.send(None, "update_module_settings")
if ncomps > 1:
self.volumeProperty.IndependentComponentsOff()
else:
self.volumeProperty.IndependentComponentsOn()
Logging.info("Rendering using, ", self.mapper.__class__, kw = "rendering")
self.mapper.SetInput(input)
if self.mapperUpdated:
self.volume.SetMapper(self.mapper)
self.mapperUpdated = False
if not self.volumeAdded:
self.parent.getRenderer().AddVolume(self.volume)
self.volumeAdded = True
VisualizationModule.updateRendering(self, input)
self.parent.Render()
if self.parameters["Method"] == TEXTURE_MAPPING_3D:
if not self.mapper.IsRenderSupported(self.volumeProperty, self.renderer):
lib.messenger.send(None, \
"show_error", \
"3D texture mapping not supported", \
"Your graphics hardware does not support 3D accelerated texture mapping. \
Please use one of the other volume rendering methods.")
def execute(self, inputs, update = 0, last = 0):
"""
Execute filter in input image and return output image
"""
if not lib.ProcessingFilter.ProcessingFilter.execute(self,inputs):
return None
self.eventDesc = "Converting image data to polygonal data"
inputImage = self.getInput(1)
inputImage.Update()
self.scalarRange = inputImage.GetScalarRange()
lib.messenger.send(self, "update_IsoValue")
x, y, z = self.dataUnit.getDimensions()
input = optimize.optimize(image = inputImage, updateExtent = (0, x - 1, 0, y - 1, 0, z - 1))
self.contour.SetInput(input)
self.contour.SetValue(0, self.parameters["IsoValue"])
polyOutput = self.contour.GetOutput()
#TODO: should decimateLevel and preserveTopology be instance variables?
decimateLevel = self.parameters["Simplify"]
preserveTopology = self.parameters["PreserveTopology"]
if decimateLevel != 0:
self.decimate.SetPreserveTopology(preserveTopology)
if not preserveTopology:
self.decimate.SplittingOn()
self.decimate.BoundaryVertexDeletionOn()
else:
self.decimate.SplittingOff()
self.decimate.BoundaryVertexDeletionOff()
self.decimate.SetTargetReduction(decimateLevel / 100.0)
Logging.info("Decimating %.2f%%, preserve topology: %s" \
% (decimateLevel, preserveTopology), kw = "visualizer")
self.decimate.SetInput(polyOutput)
polyOutput = self.decimate.GetOutput()
polyOutput.Update()
self.setPolyDataOutput(polyOutput)
return inputImage
def eval(type, index=30):
"""Executes the experiment
Parameters
----------
type : a string representing the type of covariance matrix to optimize against, either 'sample' or 'shrunk'
index : benchmark index size to use
Returns
-------
dictionary : returns a dictionary with sample statistics for the information ratio, mean excess return,
standard deviation of excess returns, and tracking error
"""
# get the portfolio parameters
port_params = params.get_portfolio_params(index=index)
# instantiate the porfolio object
port = portfolio.Portfolio(port_params, proxy={"http": "http://proxy.jpmchase.net:8443"})
# setup the periodicity
roll = 60
rollperiod = relativedelta.relativedelta(months=roll)
outsample = 60
outsampleperiod = relativedelta.relativedelta(months=outsample)
# setup
dates = port.get_trading_dates()
start = dates[0] + rollperiod
end = dates[-1]
delta = relativedelta.relativedelta(end, start)
periods = (delta.years * 12) + delta.months
portvalue = port.get_portfolio_historic_position_values()
# constant benchmark weights
#returns = port.get_portfolio_historic_returns()
active = port.get_active_returns()
bench_returns = port.get_benchmark_returns()
bench_weights = port.get_benchmark_weights()
expected_excess_returns = port.get_expected_excess_stock_returns()
e = []; te = [];
for i in xrange(roll, periods+roll+1):
# setup the dates to calculate returns for the covariance matrixes
start = dates[i-roll]
end = dates[i]
active_returns = active.ix[start:end]
# compute the sample covariance matrix, cov of active returns
cov = port.get_covariance_matrix(active_returns)
# actual realized returns
y = ((portvalue.ix[end:end].as_matrix() / portvalue.ix[dates[i-1]:dates[i-1]].as_matrix()) - 1)[0]
# alphas
# apparently, cvxopt.matrix requires the input ndarray to be F_CONTIGUOUS which i discovered reading the C source code
# F_CONTIGUOUS is found in ndarray.flags and is a boolean which ensure a Fortran-contiguous array
# np.require forces that to be the case; this took me a really long time to figure out
a0 = np.require(expected_excess_returns.ix[end:end].transpose().as_matrix(), dtype=np.float64, requirements=['F'])
a = matrix(a0)
if type == 'sample':
S = matrix(cov.as_matrix())
elif type == 'shrunk':
# compute the shrunk covariance matrix, sigma
sigma, shrinkage = port.get_shrunk_covariance_matrix(cov)
S = matrix(sigma.as_matrix())
else:
raise ValueError('Type must be either of the two strings: sample or shrunk')
# get the optimized weights
# this is horribly naive because i'm only including the constaints provided in the example
# i spent a considerable amount of time looking at the documentation, forums, and source
# code trying to become comfortable with the package to no avail
x = op.optimize(a, S)
# optimized expected active portfolio returns
e_ = (x.T * y).sum()
e.append(e_)
# weighted benchmark returns
b = (bench_returns.ix[end:end] * bench_weights.ix[end:end]).sum()
# tracking error
te.append(e_ - b)
return {
'information_ratio': port.information_ratio(np.array([e])),
'mean_excess_return': np.array([e]).mean(),
'stdev_excess_return': np.array([e]).std(),
'tracking_error': np.array([te]).std()
}
def updateRendering(self):
"""
Update the Rendering of this module
"""
self.mapper.AddObserver("ProgressEvent", lib.messenger.send)
lib.messenger.connect(self.mapper, "ProgressEvent", self.updateProgress)
dataUnit = self.getInputDataUnit(1)
inputDataUnit2 = self.getInputDataUnit(2)
settings = inputDataUnit2.getSettings()
filterList = settings.get("FilterList")
if not dataUnit:
dataUnit = self.dataUnit
self.mapper.SetLookupTable(dataUnit.getColorTransferFunction())
self.mapper.ScalarVisibilityOn()
min, max = self.data.GetScalarRange()
# if (min,max) != self.scalarRange:
self.setScalarRange(min, max)
dataUnit = self.getInputDataUnit(1)
self.mapper.ColorByArrayComponent(0, 0)
self.mapper.SetScalarRange(min, max)
self.mapper.SetColorModeToMapScalars()
self.mapper.SetLookupTable(dataUnit.getColorTransferFunction())
self.mapper.ScalarVisibilityOn()
self.updateOpacity()
# self.actor2.GetProperty().SetOpacity(opacity)
polyinput = self.getPolyDataInput(1)
if polyinput:
Logging.info("Using polydata input", kw="visualizer")
VisualizationModule.updateRendering(self, polyinput)
else:
input = self.getInput(1)
x, y, z = self.dataUnit.getDimensions()
input = optimize.optimize(image=input, updateExtent=(0, x - 1, 0, y - 1, 0, z - 1))
self.contour.SetInput(input)
polyinput = self.contour.GetOutput()
input2 = self.getInput(2)
minval, maxval = input2.GetScalarRange()
input2.Update()
self.contour2.SetInput(input2)
print "Generating", maxval - 1, "values in range", 1, maxval
self.contour2.GenerateValues(maxval - 1, 1, maxval)
n = self.contour2.GetNumberOfContours()
for i in range(0, n):
self.contour2.SetValue(i, int(self.contour2.GetValue(i)))
self.mapper2.ColorByArrayComponent(0, 0)
self.mapper2.SetScalarRange(min, max)
if not self.parameters["MarkColor"]:
self.mapper2.SetLookupTable(inputDataUnit2.getColorTransferFunction())
else:
self.setLookupTableBasedOnDistance(self.parameters["Distance"])
print "\n\n\n*** INPUT DATAUNIT2=", inputDataUnit2
self.mapper2.SetColorModeToMapScalars()
self.mapper2.ScalarVisibilityOn()
polyinput2 = self.contour2.GetOutput()
decimateLevel = self.parameters["Simplify"]
preserveTopology = self.parameters["PreserveTopology"]
if decimateLevel != 0:
self.decimate.SetPreserveTopology(preserveTopology)
if not preserveTopology:
self.decimate.SplittingOn()
self.decimate.BoundaryVertexDeletionOn()
else:
self.decimate.SplittingOff()
self.decimate.BoundaryVertexDeletionOff()
self.decimate.SetTargetReduction(decimateLevel / 100.0)
Logging.info(
"Decimating %.2f%%, preserve topology: %s" % (decimateLevel, preserveTopology), kw="visualizer"
)
self.decimate.SetInput(polyinput)
polyinput = self.decimate.GetOutput()
if self.parameters["Normals"]:
angle = self.parameters["FeatureAngle"]
Logging.info("Generating normals at angle", angle, kw="visualizer")
self.normals.SetFeatureAngle(angle)
self.normals.SetInput(polyinput)
polyinput = self.normals.GetOutput()
self.mapper.SetInput(polyinput)
self.mapper2.SetInput(polyinput2)
self.init = True
VisualizationModule.updateRendering(self, polyinput)
self.parent.Render()
#!/usr/bin/env python3
from optimize import optimize, Kanban
from pprint import pprint
optimal = optimize(
orders=[
Kanban('A01', (1, 2, 3, 4, 5, 6, 7), 7),
Kanban('A02', (1, 2, 4, 4, 5, 6, 7), 7),
Kanban('A03', (1, 2, 4, 4, 3, 6, 7), 7),
Kanban('A04', (1, 2, 4, 4, 3, 8, 7), 7),
Kanban('A05', (1, 2, 4, 6, 3, 8, 7), 7),
Kanban('A06', (1, 2, 4, 6, 3, 8, 9), 7),
Kanban('A07', (1, 2, 4, 6, 3, 5, 9), 7),
Kanban('A08', (1, 2, 4, 8, 3, 5, 9), 7),
Kanban('A09', (1, 2, 4, 8, 9, 5, 9), 7),
Kanban('A10', (1, 2, 4, 8, 9, 5, 3), 7),
],
machines=[
{'machineId': 'a1'},
{'machineId': 'a2'},
{'machineId': 'a3'},
]
)
pprint(optimal)
#!/usr/bin/python
from parse_yacc import parse
from optimize import optimize
from peep import createAssemblyCode
import sys
if __name__ == '__main__':
if len(sys.argv) < 2:
print 'Run: python %s benchmarks/assembly.s output.s' % sys.argv[0]
exit(1)
# Parsing and optimization
parsed = parse(sys.argv[1])
new = optimize(parsed, var=1)
if len(sys.argv) > 2:
# Save output assembly
file_func = open(sys.argv[2], 'w+')
file_func.write(createAssemblyCode(new))
file_func.close()
def simplex(dictionary, basic_vars, non_basic_vars):
dict_, basic, non_basic = initialize_and_reconstruct(dictionary, basic_vars, np.array(non_basic_vars))
res, _ = optimize(dict_, basic, non_basic)
if res == UNBOUNDED:
raise Infeasible()
return dict_, basic, non_basic
# There's a bug where no icon (right menu bar) is selected and we still try to process
# the variable named colorImage, which in this turn of events is None.
if colorImage == None:
Logging.info("Nothing to preview (no channel, icon, data) selected.")
return
usedUpdateExt = 0
uext = None
if self.z != -1:
x, y = self.dataDimX, self.dataDimY
usedUpdateExt = 1
uext = (0, x - 1, 0, y - 1, self.z, self.z)
t = time.time()
colorImage.ReleaseDataFlagOn()
colorImage = optimize.optimize(image = colorImage, updateExtent = uext)
t2 = time.time()
Logging.info("Executing pipeline took %f seconds" % (t2 - t), kw = "pipeline")
self.currentImage = colorImage
if colorImage:
x, y, z = colorImage.GetDimensions()
if x != self.oldx or y != self.oldy:
self.oldx = x
self.oldy = y
self.setImage(colorImage)
self.setZSlice(self.z)
z = self.z
import sys
from common import read_input, print_solution
from optimize import optimize
from opt_2 import opt_2
from greedy import greedy
from solver_greedy import solve
from or_opt import or_opt
from vortex import vortex
from kruskal import kruskal_greedy
from my_random import random_solve
from combine import optimize2, read_path
if __name__ == '__main__':
assert len(sys.argv) > 1
optimize = optimize(read_input(sys.argv[1]))
optimize2 = optimize2(read_input(sys.argv[1]), read_path(sys.argv[2]))
greedy = greedy(read_input(sys.argv[1]))
opt_2 = opt_2(read_input(sys.argv[1]))
or_opt = or_opt(read_input(sys.argv[1]))
vortex = vortex(read_input(sys.argv[1]))
kruskal = kruskal_greedy(read_input(sys.argv[1]))
print_solution(or_opt)
print_solution(or_opt)
print_solution(vortex)
print_solution(kruskal)
print_solution(greedy)
print_solution(greedy)
print_solution(optimize)
print_solution(optimize)
def doOperation(self, preview=0):
"""
Manipulationes the dataset in specified ways
"""
filterlist = self.settings.get("FilterList")
if filterlist:
modified = filterlist.getModified()
else:
modified = 0
if preview and not modified and self.cached and self.timepoint == self.cachedTimepoint:
Logging.info("--> Returning cached data, timepoint=%d, cached timepoint=%d" %
(self.timepoint, self.cachedTimepoint), kw = "pipeline")
return self.cached
else:
del self.cached
self.cached = None
Logging.info("Creating preview, filters = %s"%str(filterlist), kw="pipeline")
data = self.images
if not filterlist or type(filterlist) == types.ListType or filterlist.getCount() == 0:
Logging.info("No filters, returning original dat", kw="pipeline")
return self.images[0]
try:
enabledFilters = filterlist.getEnabledFilters()
except AttributeError:
enabledFilters = []
highestFilterIndex = len(enabledFilters)-1
lastfilter = None
wantWhole = False
polydata = None
x = 1.0/(1+len(enabledFilters))
# A very specific cache is needed, to prevent the "result" channel
# being re-processed when being merged to the "original" channel(s).
key = (self.settings.dataunit, self.timepoint)
if key in self.cacheDataUnits and self.cacheDataUnitsEnabled:
Logging.info("Returning cached dataunit", kw="pipeline")
return self.cacheDataUnits[key]
for i, currfilter in enumerate(enabledFilters):
if currfilter.requireWholeDataset:
wantWhole = True
self.currentExecutingFilter = currfilter
self.shift = x*(i+1)
self.scale = x
self.eventDesc = "Performing %s"%currfilter.name
currfilter.setExecutive(self)
if polydata:
currfilter.setPolyDataInput(polydata)
flag = (i == highestFilterIndex)
if i > 0:
currfilter.setPrevFilter(enabledFilters[i-1])
else:
currfilter.setPrevFilter(None)
if not flag:
currfilter.setNextFilter(enabledFilters[i+1])
else:
currfilter.setNextFilter(None)
Logging.info("Executing %s"%currfilter.name,kw="pipeline")
data = currfilter.execute(data, update=0, last=flag)
polydata = currfilter.getPolyDataOutput()
if not flag:
nextfilter = enabledFilters[i+1]
if not currfilter.itkFlag and nextfilter.itkFlag:
Logging.info("Executing VTK side before switching to ITK", kw="pipeline")
data = optimize.optimize(image = data, releaseData = 1)
data.Update()
elif currfilter.itkFlag and not nextfilter.itkFlag:
Logging.info("Converting from ITK side back to VTK", kw="pipeline")
data = currfilter.convertITKtoVTK(data)
lastfilter = currfilter
if not preview:
currfilter.writeOutput(self.controlUnit, self.timepoint)
data = [data]
if not data:
self.currentExecutingFilter = None
self.cached = None
return None
self.currentExecutingFilter = None
if wantWhole:
scripting.wantWholeDataset = wantWhole
Logging.info("Pipeline done",kw="pipeline")
data = data[0]
if data.__class__ != vtk.vtkImageData and type(data) != types.TupleType:
data = lastfilter.convertITKtoVTK(data)
filterlist.setModified(0)
self.setPolyDataOutput(polydata)
if self.cacheDataUnitsEnabled:
print data.GetUpdateExtent()
x0, x1, y0, y1, z0, z1 = data.GetUpdateExtent()
if z1 >= 0:
copy = vtk.vtkImageData()
copy.DeepCopy(data)
copy.Update()
key = (self.settings.dataunit, self.timepoint)
self.cacheDataUnits[key] = copy
Logging.info("Caching dataunit", kw="pipeline")
return data
def updateRendering(self):
"""
Update the Rendering of this module
"""
method = self.parameters["Method"]
self.setMethod(method)
if self.volumeModule:
self.volumeModule.function = vtk.vtkVolumeRayCastIsosurfaceFunction()
self.volumeModule.function.SetIsoValue(self.parameters["IsoValue"])
self.volumeModule.showTimepoint(self.timepoint)
return
if not self.init:
self.init = 1
self.mapper.ColorByArrayComponent(0, 0)
self.mapper.AddObserver("ProgressEvent", lib.messenger.send)
lib.messenger.connect(self.mapper, "ProgressEvent", self.updateProgress)
dataUnit = self.getInputDataUnit(1)
if not dataUnit:
dataUnit = self.dataUnit
dataCtf = dataUnit.getColorTransferFunction()
if self.parameters["SolidColor"]:
minval, maxval = dataCtf.GetRange()
ctf = vtk.vtkColorTransferFunction()
ctf.AddRGBPoint(int(minval), 0, 0, 0)
r, g, b = dataCtf.GetColor(maxval)
ctf.AddRGBPoint(int(minval) + 1, r, g, b)
ctf.AddRGBPoint(maxval, r, g, b)
else:
ctf = dataCtf
self.mapper.SetLookupTable(ctf)
self.mapper.ScalarVisibilityOn()
minVal, maxVal = self.data.GetScalarRange()
self.setScalarRange(minVal, maxVal)
self.mapper.SetScalarRange(minVal, maxVal)
self.mapper.SetColorModeToMapScalars()
opacity = self.parameters["Transparency"]
opacity = (100 - opacity) / 100.0
Logging.info("Using opacity ", opacity, kw="visualizer")
if opacity != 1:
cullers = self.parent.getRenderer().GetCullers()
cullers.InitTraversal()
culler = cullers.GetNextItem()
culler.SetSortingStyleToBackToFront()
# print cullers, culler
# self.parent.getRenderer().GetRenderWindow().SetAlphaBitPlanes(1)
# self.parent.getRenderer().GetRenderWindow().SetMultiSamples(0)
# self.parent.getRenderer().SetUseDepthPeeling(1)
# self.parent.getRenderer().SetMaximumNumberOfPeels(100)
# self.parent.getRenderer().SetOcclusionRatio(1.0)
# print self.parent.getRenderer().GetLastRenderingUsedDepthPeeling()
self.actor.GetProperty().SetOpacity(opacity)
polyinput = self.getPolyDataInput(1)
if polyinput:
Logging.info("Using polydata input", kw="visualizer")
self.mapper.SetInput(polyinput)
VisualizationModule.updateRendering(self, polyinput)
self.parent.Render()
return
x, y, z = self.dataUnit.getDimensions()
input = self.getInput(1)
input = optimize.optimize(image=input, updateExtent=(0, x - 1, 0, y - 1, 0, z - 1))
if self.parameters["Gaussian"]:
Logging.info("Doing gaussian smoothing", kw="visualizer")
if not self.smooth:
self.smooth = vtk.vtkImageGaussianSmooth()
self.smooth.SetInput(input)
input = self.smooth.GetOutput()
self.contour.SetInput(input)
input = self.contour.GetOutput()
multi = self.parameters["MultipleSurfaces"]
if not multi:
Logging.info("Using single isovalue=%d" % int(self.parameters["IsoValue"]), kw="visualizer")
self.contour.SetValue(0, self.parameters["IsoValue"])
else:
begin = self.parameters["SurfaceRangeBegin"]
end = self.parameters["SurfaceRangeEnd"]
n = self.parameters["SurfaceAmnt"]
Logging.info("Generating %d values in range %d-%d" % (n, begin, end), kw="visualizer")
self.contour.GenerateValues(n, begin, end)
n = self.contour.GetNumberOfContours()
for i in range(0, n):
self.contour.SetValue(i, int(self.contour.GetValue(i)))
# print self.contour
# TODO: should decimateLevel and preserveTopology be instance variables?
decimateLevel = self.parameters["Simplify"]
preserveTopology = self.parameters["PreserveTopology"]
if decimateLevel != 0:
self.decimate.SetPreserveTopology(preserveTopology)
if not preserveTopology:
self.decimate.SplittingOn()
self.decimate.BoundaryVertexDeletionOn()
else:
self.decimate.SplittingOff()
self.decimate.BoundaryVertexDeletionOff()
self.decimate.SetTargetReduction(decimateLevel / 100.0)
Logging.info(
"Decimating %.2f%%, preserve topology: %s" % (decimateLevel, preserveTopology), kw="visualizer"
)
self.decimate.SetInput(input)
input = self.decimate.GetOutput()
if self.parameters["Normals"]:
angle = self.parameters["FeatureAngle"]
Logging.info("Generating normals at angle", angle, kw="visualizer")
self.normals.SetFeatureAngle(angle)
self.normals.SetInput(input)
input = self.normals.GetOutput()
self.mapper.SetInput(input)
VisualizationModule.updateRendering(self, input)
self.parent.Render()
def main_program():
#
# convert file to pic format
#
if not os.path.exists(Gerber_name.get()):
get_input_filename()
if not os.path.exists(Gerber_name.get()):
tkMessageBox.showerror("G2G_GUI ERROR", "The path provided for the input Gerber file is invalid.")
return
head, tail = os.path.split(Gerber_name.get())
if os.name=='nt':
temp_pdf = os.path.normpath("%s\_tmp_gerber.pdf" % (head))
temp_pic = os.path.normpath("%s\_tmp_gerber.pic" % (head))
temp_bat = os.path.normpath("%s\_tmp_gerber.bat" % (head))
else:
temp_pdf = "_tmp_gerber.pdf"
temp_pic = "_tmp_gerber.pic"
if os.name=='nt':
if not os.path.exists(gerbv_path.get()):
tkMessageBox.showerror("G2G_GUI ERROR", "The path provided for gerbv is invalid.")
return
if not os.path.exists(pstoedit_path.get()):
tkMessageBox.showerror("G2G_GUI ERROR", "The path provided for pstoedit is invalid.")
return
if os.name=='nt':
os.system("echo \"%s\" --export=pdf --output=%s --border=0 \"%s\" > \"%s\"" % (os.path.normpath(gerbv_path.get()),temp_pdf,os.path.normpath(Gerber_name.get()),temp_bat))
os.system("echo \"%s\" -q -f pic \"%s\" \"%s\" >> \"%s\"" % (os.path.normpath(pstoedit_path.get()),temp_pdf,temp_pic, temp_bat))
os.system("\"%s\"" % temp_bat)
else:
os.system("%s --export=pdf --output=%s --border=0 \"%s\"" % (os.path.normpath(gerbv_path.get()),temp_pdf,os.path.normpath(Gerber_name.get())))
os.system("%s -q -f pic \"%s\" \"%s\"" % (os.path.normpath(pstoedit_path.get()),temp_pdf,temp_pic))
original_stdout = sys.stdout # keep a reference to STDOUT
if Output_name.get():
sys.stdout = open(Output_name.get(), 'w')
if not offset_str.get():
default_offset_str()
if not border_str.get():
default_border_str()
if not matrix_str.get():
default_matrix_str()
if not speed_str.get():
default_speed_str()
if not force_str.get():
default_force_str()
if not cut_mode_str.get():
default_cut_mode_str()
offset = floats(offset_str.get())
border = floats(border_str.get())
matrix = floats(matrix_str.get())
speed = floats(speed_str.get())
force = floats(force_str.get())
cut_mode = int(cut_mode_str.get())
#
# main program
#
import graphtec
import pic
import optimize
g = graphtec.graphtec()
g.start()
g.set(offset=(offset[0]+border[0]+0.5,offset[1]+border[1]+0.5), matrix=matrix)
strokes = pic.read_pic(temp_pic)
max_x,max_y = optimize.max_extent(strokes)
tx,ty = 0.5,0.5
border_path = [
(-border[0], -border[1]),
(max_x+border[0], -border[1]),
(max_x+border[0], max_y+border[1]),
(-border[0], max_y+border[1])
]
if cut_mode==0:
lines = optimize.optimize(strokes, border)
for (s,f) in zip(speed,force):
g.set(speed=s, force=f)
for x in lines:
g.line(*x)
g.closed_path(border_path)
else:
for (s,f) in zip(speed,force):
g.set(speed=s, force=f)
for s in strokes:
g.closed_path(s)
g.closed_path(border_path)
g.end()
if Output_name.get():
sys.stdout = original_stdout # restore STDOUT back to its original value
tkMessageBox.showinfo("G2G_GUI Message", "File '%s' created" % (Output_name.get()) )
def doProcessing(self, bxdFile, **kws):
"""
Executes the module's operation using the current settings
Parameters:
bxdFile The name of the created .bxdfile
Keywords:
settings_only If this parameter is set, then only the
settings will be written out and not the VTI
files.
timepoints The timepoints that should be processed
"""
if not self.module:
Logging.error("No module set", "No module was set for the dataunit to do processing with")
callback = None
settings_only = kws.get("settings_only", 0)
callback = kws.get("callback", None)
timepoints = kws.get("timepoints", range(self.getNumberOfTimepoints()))
writebxd = kws.get("writebxd", True)
# We create the vtidatasource with the name of the dataunit file
# so it knows where to store the vtkImageData objects
numberOfDatasets = self.module.getNumberOfOutputs()
bxdWriters = []
dataWriters = []
if not settings_only:
if numberOfDatasets > 1:
for i in range(numberOfDatasets):
channelBXDFile = bxdFile
if bxdFile[-4:] == ".bxd":
channelBXDFile = bxdFile[:-4] + "_" + self.sourceunits[i].getName() + ".bxd"
bxdwriter = BXDDataWriter(channelBXDFile)
bxdWriters.append(bxdwriter)
bxcFile = bxdwriter.getBXCFileName(channelBXDFile)
dataWriter = BXCDataWriter(bxcFile)
dataWriters.append(dataWriter)
bxdwriter.addChannelWriter(dataWriter)
else:
bxdwriter = BXDDataWriter(bxdFile)
bxcFile = bxdwriter.getBXCFileName(bxdFile)
bxdWriters.append(bxdwriter)
dataWriter = BXCDataWriter(bxcFile)
dataWriters.append(dataWriter)
bxdwriter.addChannelWriter(dataWriter)
else:
bxcFile = bxdFile
bxdwriter = None
bxcFile = bxcFile[:-1] + "p"
bxdWriters.append(bxdwriter)
dataWriter = BXCDataWriter(bxcFile)
dataWriters.append(dataWriter)
self.outputDirectory = os.path.dirname(bxcFile)
#self.dataWriter = BXCDataWriter(bxcFile)
#if bxdwriter:
# bxdwriter.addChannelWriter(self.dataWriter)
n = 1
self.guicallback = callback
self.module.setControlDataUnit(self)
if not settings_only:
for timePoint in timepoints:
# First we reset the module, so that we can start the operation
# from clean slate
scripting.processingTimepoint = timePoint
self.module.reset()
# We get the processed timepoint from each of the source data
# units
#self.module.setSettings(self.settings)
self.module.setTimepoint(timePoint)
for dataunit in self.sourceunits:
image = dataunit.getTimepoint(timePoint)
self.module.addInput(dataunit, image)
# Get the vtkImageData containing the results of the operation
# for this time point
imageDatas = self.module.doOperation()
polydatas = self.module.getPolyDataOutput()
# Convert output to tuples if aren't already
if type(imageDatas) is not types.TupleType:
imageDatas = (imageDatas,)
if type(polydatas) is not types.TupleType and polydatas is not None:
polydatas = (polydatas,)
Logging.info("Executing with optimizations",kw="processing")
for i, imageData in enumerate(imageDatas):
imageData = optimize.optimize(image = imageData)
Logging.info("Processing done",kw="processing")
lib.messenger.send(None, "update_processing_progress", timePoint, n, len(timepoints) * len(imageDatas))
n += 1
# Write the image data to disk
Logging.info("Writing timepoint %d"%timePoint,kw="processing")
dataWriters[i].addImageData(imageData)
if polydatas is not None and i < len(polydatas):
dataWriters[i].addPolyData(polydatas[i])
dataWriters[i].sync()
dims = dataWriters[i].getOutputDimensions()
self.settings.set("Dimensions", str(dims))
scripting.processingTimepoint = -1
if settings_only:
self.settings.set("SettingsOnly", "True")
else:
self.settings.set("SettingsOnly", "False")
# Check if we have multiple outputs
# If we do, make sure ctf is correct
updateCTF = 0
origCTF = self.settings.get("ColorTransferFunction")
if len(dataWriters) > 1:
updateCTF = 1
for i, dataWriter in enumerate(dataWriters):
if updateCTF:
self.settings.set("ColorTransferFunction", self.sourceunits[i].getColorTransferFunction())
self.createDataUnitFile(dataWriter)
self.settings.set("ColorTransferFunction", origCTF)
if not settings_only:
for bxdwriter in bxdWriters:
bxdwriter.write()
# Write references to channels in BXD file
if writebxd:
try:
fp = open(bxdFile, "w")
print "Writing output to",bxdFile
for bxdwriter in bxdWriters:
channelBXCFile = bxdwriter.getBXCFileName(bxdwriter.getFilename())
pathParts = channelBXCFile.split(os.sep)
channelBXCFile = pathParts[-2] + os.sep + pathParts[-1]
fp.write("%s\n"%channelBXCFile)
except IOError, ex:
Logging.error("Failed to write settings", "CombinedDataUnit failed to open .bxd file %s for writing settings (%s)"%(bxdFile, str(ex)))
fp.close()
return bxdFile
else:
return bxdWriters[0].getFilename()
