def do(searcher, problem):
if sys.stdin.isatty():
raw_input('Press Enter to run %s on %s' %
(name(searcher), name(problem)))
else:
print('Running %s on %s' % (name(searcher), name(problem)))
p = InstrumentedProblem(problem)
start = time.time()
solution = searcher(p)
elapsed = time.time() - start
print('Elapsed time:', elapsed, 'seconds')
if isinstance(solution, Node):
path = solution.path()
print('**************** Solution:')
if len(path) < 50:
path.reverse()
print(path)
else:
print('len(path)=', len(path), 'too long, print suppressed')
p.solution_cost = solution.path_cost
print()
else: # search failed, return a negative value
p.solution_cost = -1
print('Search failed')
return p
def cutExpressionElements(tree):
for node in PreOrderIter(tree):
if name(node) == 'expressao' and len(node.children) > 0 and name(
node.children[0]) == 'expressao_logica':
for n in PreOrderIter(node):
if name(n) == 'expressao_aditiva':
n.parent = node
node.children[0].parent = None
def _get_name(self, con, current):
cur = self._dbh.execute(con, "SELECT name FROM domains WHERE id=%s",
utils.name(current))
result = cur.fetchall()
if len(result) != 1:
raise utils.NoSuchObject
return result[0][0]
def compare_searchers(problems,
header,
searchers=[
breadth_first_tree_search,
breadth_first_graph_search, depth_first_graph_search,
iterative_deepening_search, depth_limited_search,
astar_search
]):
def do(searcher, problem):
if sys.stdin.isatty():
raw_input('Press Enter to run %s on %s' %
(name(searcher), name(problem)))
else:
print('Running %s on %s' % (name(searcher), name(problem)))
p = InstrumentedProblem(problem)
start = time.time()
solution = searcher(p)
elapsed = time.time() - start
print('Elapsed time:', elapsed, 'seconds')
if isinstance(solution, Node):
path = solution.path()
print('**************** Solution:')
if len(path) < 50:
path.reverse()
print(path)
else:
print('len(path)=', len(path), 'too long, print suppressed')
p.solution_cost = solution.path_cost
print()
else: # search failed, return a negative value
p.solution_cost = -1
print('Search failed')
return p
# table = [[name(s)] + [do(s, p) for p in problems] for s in searchers]
# print_table(table, header, sep='|')
results = {(p, s): do(s, p) for p in problems for s in searchers}
for p in problems:
print('Problem:', name(p))
for s in searchers:
print('Searcher:%30s' % name(s), results[(p, s)])
print('#exp: number of expanded nodes')
print('#gt: number of goal tests')
print('#st: number of generated states')
# Exercise: compute and compare penetrance and effective branching factor
def clearAll(self, con, current):
cur = self._dbh.execute(
con, "DELETE FROM records WHERE domain_id=%s AND type!='SOA'",
utils.name(current))
if cur.rowcount == 0:
# no records were deleted. maybe such domain doesn't exist?
self._check_existance(con, current)
con.commit()
def addRecords(self, con, rs, current):
domain = self._get_name(con, current)
if len(rs) < 1:
return
zone_id = utils.name(current)
rgen = (self._unpack_record(r, zone_id, domain) for r in rs)
self._dbh.execute_many(con, self._add_record_query, rgen)
con.commit()
def addRecord(self, con, record, current):
domain = self._get_name(con, current)
zone_id = utils.name(current)
cur = self._dbh.execute(con, self._add_record_query,
*self._unpack_record(record, zone_id, domain))
if cur.rowcount != 1:
raise utils.NoSuchObject
con.commit()
def setSOA(self, con, soar, current):
cur = self._dbh.execute(
con, "UPDATE records SET content=%s "
"WHERE type='SOA' and domain_id=%s", utils.soar2str(soar),
utils.name(current))
if cur.rowcount != 1:
raise self._dbh.NoSuchObject
con.commit()
def getSOA(self, con, current):
cur = self._dbh.execute(
con, "SELECT content FROM records "
"WHERE type='SOA' and domain_id=%s", utils.name(current))
res = cur.fetchall()
if len(res) != 1:
raise utils.NoSuchObject
return I.SOARecord(*utils.str2soar(res[0][0]))
def countRecords(self, con, current):
cur = self._dbh.execute(
con, "SELECT count(*) FROM records "
"WHERE domain_id=%s AND type!='SOA'", utils.name(current))
result = cur.fetchone()[0]
if result == 0:
self._check_existance(con, current)
return long(result)
def getRecords(self, con, limit, offset, current):
cur = self._dbh.execute_limited(
con, limit, offset, "SELECT name, type, content, ttl, prio "
"FROM records WHERE domain_id=%s AND type != 'SOA'",
utils.name(current))
res = cur.fetchall()
if len(res) < 1:
#maybe there is no such zone?
self._check_existance(con, current)
return self._pack_records(res)
def compare_searchers(problems,
header,
searchers=[astar_search, depth_first_tree_search]):
def do(searcher, problem):
p = InstrumentedProblem(problem)
searcher(p)
return p
table = [[name(s)] + [do(s, p) for p in problems] for s in searchers]
print_table(table, header)
def cutRepeatedElements(tree):
for node in PostOrderIter(tree):
no = node.parent # pai no atual
if node.parent != None:
father = name(node.parent) # nome pai no atual
# Elimina um pai e leva seus filhos para o vô
if name(node) == father: # no autal == pai
node.parent = no.parent # meu novo pai e meu vo
if len(no.children) > 0:
for item in no.children:
item.parent = node
# if len(no.children) > 0: # tamanho peu pai antigo
# i = 0
# while i < len(no.children): # varios filhos meu pai antigo
# no.children[i].parent = node ## os filhos do meu pai antigo vem para mim
# i += 1
no.parent = None ## pai antigo retirado
def OSserver():
user = ""
password = ""
ua = "kodi_%s_v%s" % (name().lower(), version())
if boolsetting('OScustomuser'):
if setting('OSuser') != '' or setting('OSpassword') != '':
user = setting('OSuser')
password = setting('OSpassword')
else:
user = "******"
password = "******"
return OpenSubtitles.LogIn(user, password, 'en', ua)
def compare_searchers(problems, header,
searchers=[breadth_first_tree_search,
breadth_first_search, depth_first_graph_search,
iterative_deepening_search,
depth_limited_search,
recursive_best_first_search]):
def do(searcher, problem):
p = InstrumentedProblem(problem)
searcher(p)
return p
table = [[name(s)] + [do(s, p) for p in problems] for s in searchers]
print_table(table, header)
def dropRecord(self, con, record, current):
if record.name.endswith('.'):
record.name = record.name[:-1]
cur = self._dbh.execute(
con, "DELETE FROM records "
"WHERE domain_id=%s AND name=%s AND type=%s AND content=%s",
utils.name(current), record.name, str(record.type), record.data)
if cur.rowcount == 0:
self._check_existance(con, current)
#no exception raised - zone exists, but no such record
raise ICore.NotFoundError("No such record.")
con.commit()
def compare_searchers(problems, header,
searchers=[breadth_first_tree_search,
breadth_first_search,
depth_first_graph_search,
iterative_deepening_search,
depth_limited_search,
recursive_best_first_search]):
def do(searcher, problem):
p = InstrumentedProblem(problem)
searcher(p)
return p
table = [[name(s)] + [do(s, p) for p in problems] for s in searchers]
print_table(table, header)
def findRecords(self, con, phrase, limit, current):
phrase = (phrase.replace('\\', '\\\\').replace('%', '\\%').replace(
'_', '\\_') + '%')
cur = self._dbh.execute_limited(
con, limit, 0,
"SELECT name, type, content, ttl, prio FROM records "
"WHERE domain_id=%s AND type!='SOA' AND name LIKE %s",
utils.name(current), phrase)
res = cur.fetchall()
if len(res) < 1:
#maybe there is no such zone?
self._check_existance(con, current)
return self._pack_records(res)
def atribution(node, builder):
elem = None
for n in PreOrderIter(node):
pai = n.parent
if n.is_leaf and ut.name(pai) == 'var' and ut.name(
pai.parent) == 'atribuicao':
nome = ut.name(n)
if nome in locais.keys():
elem = locais[nome]
if nome in globais.keys():
elem = globais[nome]
resultado = expression(node.children[1], builder)
if str(resultado.type) not in str(elem.type):
if str(elem.type) == "i32*":
resultado = builder.fptoui(resultado, ir.IntType(32))
else:
resultado = builder.uitofp(resultado, ir.DoubleType())
builder.store(resultado, elem)
def verifyCallFunc(tree):
content = walkTable()
funcsTable = []
funcsTree = []
for item in content:
if 'categoria' in item and item['categoria'] == 'funcao':
funcsTable.append(item['lexema'])
for e in PreOrderIter(tree):
if name(e) == 'chamada_funcao':
funcsTree.append(name(e.children[0]))
for func in funcsTree:
if func not in funcsTable:
linha = getLine(func)
showErrors(linha, 'err', func, 10)
exit(0)
for func in funcsTable:
if func not in funcsTree and func != 'principal':
linha = getLine(func)
showErrors(linha, 'warn', func, 8)
def compare_searchers(problems, header,
searchers=[breadth_first_tree_search,
breadth_first_search,
depth_first_graph_search,
iterative_deepening_search,
depth_limited_search,
recursive_best_first_search]):
def do(searcher, problem):
p = InstrumentedProblem(problem)
start_time = time.perf_counter_ns()
searcher(p)
end_time = time.perf_counter_ns()
return (p, str((end_time-start_time)/1000000000))
table = [[name(s)] + [do(s, p) for p in problems] for s in searchers]
print_table(table, header)
def replaceRecord(self, con, oldr, newr, current):
domain = self._get_name(con, current)
if oldr.name.endswith('.'):
oldr.name = oldr.name[:-1]
args = self._unpack_record(newr, None, domain)[1:]
args += (utils.name(current), oldr.name, str(oldr.type), oldr.data)
cur = self._dbh.execute(
con, "UPDATE records SET "
"name=%s, type=%s, content=%s, ttl=%s, prio=%s "
"WHERE domain_id=%s AND name=%s AND type=%s AND content=%s", *args)
if cur.rowcount != 1:
# domain already exists, so there is no such record
raise ICore.NotFoundError("Failed to replace record",
"Record not found")
con.commit()
def walkingTree(tree, builder):
for node in PreOrderIter(tree):
node_name = ut.name(node)
if node_name == 'chamada_funcao':
callFunc(node, builder)
if node_name == 'atribuicao':
atribution(node, builder)
if node_name == 'se':
conditional(node, builder)
if node_name == 'repita':
loop(node, builder)
if node_name == 'retorna':
returnFunc(node, builder)
if node_name == 'leia':
printFunc(node, builder)
if node_name == 'escreva':
readFunc(node, builder)
def callFunc(node, builder):
nome_func = ut.name(node.children[0])
lista = []
for i in PreOrderIter(node.children[1]):
if i.is_leaf:
lista.append(expression(i, builder))
salvaFunc = None
for f in funcoes:
if nome_func == f.name:
salvaFunc = f
for i, (param1, param2) in enumerate(zip(lista, salvaFunc.args)):
if str(param1.type) not in str(param2.type):
if "double" in str(param2.type):
f = builder.uitofp(param1, ir.DoubleType())
lista[i] = f
elif "i32" in str(param2.type):
f = builder.fptoui(param1, ir.IntType(32))
lista[i] = f
return builder.call(salvaFunc, lista)
def resume_extracts(text):
"""
Takes the text format of the resume and returns all the values
text: text format of the resume
"""
conts = {}
# Preprocessing the document
text = utils.preprocess(text)
# Extracting name
conts['name'] = utils.name(text)
# Extracting Address
conts['address'] = utils.address(text)
# Extracting mobile number
conts['mobile'] = utils.mobile_number(text)
# Extracting Email
conts['email'] = utils.email(text)
# Extracting github
conts['github'] = utils.github(text)
# Extracting linkedin
conts['linkedin'] = utils.linkedin(text)
# Provides the expertise list match
conts['expertise'] = utils.expertise_match(text)
# Provides the resume to job description simiarity
conts['similarity_score'] = utils.jobdes_rsm_similarity(text)
return conts
# searchers=searchList
players=playerList)
except:
traceback.print_exc()
sys.exit(1)
allScores = newScores()
maxScores = {}
for batch in gradeInfo:
print('Scores for: %s' % batch)
maxScores[batch] = {}
for pLabel in gradeInfo[batch]:
table = []
maxScores[batch][pLabel] = newScores()
for searcher in gradeInfo[batch][pLabel]:
sLabel = utils.name(searcher)
info = gradeInfo[batch][pLabel][searcher]
scoreSet = info['score']
table.append(['%s, %s:' % (sLabel, pLabel), scoreList(scoreSet)])
for label in scoreSet:
accumulator = accuMethods[label]
maxScores[batch][pLabel][label] = accumulator(
maxScores[batch][pLabel][label], scoreSet[label])
if len(table) > 1:
table.append([
'%s summary:' % (pLabel),
scoreList(maxScores[batch][pLabel])
])
print_table(table)
if len(table) > 1:
print()
def vid_img(opt):
output_dir = (opt.output_dir + "/" + name(opt.input.content) + "_" +
"_".join([name(s) for s in opt.input.style.split(",")]))
flow_model = flow.get_flow_model(opt)
frames = load.process_content_video(flow_model, opt)
content_size = np.array(load.preprocess(frames[0]).size()[-2:])
style_images_big = load.process_style_images(opt)
for size_n, (current_size,
num_iters) in enumerate(zip(*determine_scaling(opt.param))):
print("\nCurrent size {}px".format(current_size))
os.makedirs(output_dir + "/" + str(current_size), exist_ok=True)
content_scale = current_size / max(*content_size)
if current_size <= 1024:
opt.model.gpu = 0
opt.model.multidevice = False
else:
opt.model.gpu = "0,1"
opt.model.multidevice = True
opt.param.tv_weight = 0
net = models.load_model(opt.model, opt.param)
net.set_style_targets(style_images_big, content_scale * content_size,
opt)
for pass_n in range(opt.param.passes_per_scale):
init_image = None
for (prev_frame, this_frame) in zip(frames,
frames[1:] + frames[:1]):
# TODO add update_style() function to support changing styles per frame
opt.output = "%s/%s/%s_%s.png" % (output_dir, current_size,
pass_n + 1, name(this_frame))
if os.path.isfile(opt.output):
print(
"Skipping pass: %s, frame: %s. File already exists." %
(pass_n + 1, name(this_frame)))
continue
print("Optimizing... size: %s, pass: %s, frame: %s" %
(current_size, pass_n + 1, name(this_frame)))
content_frames = [
F.interpolate(load.preprocess(prev_frame),
scale_factor=content_scale,
mode="bilinear",
align_corners=False),
F.interpolate(load.preprocess(this_frame),
scale_factor=content_scale,
mode="bilinear",
align_corners=False),
]
content_frames = [
match_histogram(frame, style_images_big[0])
for frame in content_frames
]
net.set_content_targets(content_frames[1], opt)
# Initialize the image
# TODO make sure initialization correct even when continuing half way through video stylization
if size_n == 0 and pass_n == 0:
if opt.input.init == "random":
init_image = th.randn(
content_frames[1].size()).mul(0.001)
elif opt.input.init == "prev_warp":
flo_file = "%s/flow/forward_%s_%s.flo" % (
output_dir, name(prev_frame), name(this_frame))
flow_map = load.flow_warp_map(flo_file)
if init_image is None:
init_image = content_frames[0]
init_image = F.grid_sample(init_image,
flow_map,
padding_mode="border")
else:
init_image = content_frames[1].clone()
else:
if pass_n == 0:
# load images from last pass of previous size
if init_image is None:
ifile = "%s/%s/%s_%s.png" % (
output_dir,
prev_size,
opt.param.passes_per_scale,
name(prev_frame),
)
init_image = load.preprocess(ifile)
init_image = F.interpolate(
init_image,
size=content_frames[0].size()[2:],
mode="bilinear",
align_corners=False)
bfile = "%s/%s/%s_%s.png" % (
output_dir,
prev_size,
opt.param.passes_per_scale,
name(this_frame),
)
blend_image = load.preprocess(bfile)
blend_image = F.interpolate(
blend_image,
size=content_frames[0].size()[2:],
mode="bilinear",
align_corners=False)
else:
# load images from previous pass of current size
if init_image is None:
ifile = "%s/%s/%s_%s.png" % (output_dir,
current_size, pass_n,
name(prev_frame))
init_image = load.preprocess(ifile)
bfile = "%s/%s/%s_%s.png" % (output_dir, current_size,
pass_n, name(this_frame))
blend_image = load.preprocess(bfile)
direction = "forward" if pass_n % 2 == 0 else "backward"
flo_file = f"{output_dir}/flow/{direction}_{name(prev_frame)}_{name(this_frame)}.flo"
flow_map = load.flow_warp_map(flo_file)
flow_map = F.interpolate(flow_map.permute(0, 3, 1, 2),
size=init_image.size()[2:],
mode="bilinear").permute(
0, 2, 3, 1)
warp_image = F.grid_sample(init_image,
flow_map,
padding_mode="border")
flow_weight_file = f"{output_dir}/flow/{direction}_{name(prev_frame)}_{name(this_frame)}.png"
reliable_flow = load.reliable_flow_weighting(
flow_weight_file)
reliable_flow = F.interpolate(reliable_flow,
size=init_image.size()[2:],
mode="bilinear",
align_corners=False)
net.set_temporal_targets(warp_image,
warp_weights=reliable_flow,
opt=opt)
blend_init_image = (
1 - opt.param.blend_weight
) * blend_image + opt.param.blend_weight * init_image
warp_blend_init_image = F.grid_sample(
blend_init_image, flow_map, padding_mode="border")
init_image = warp_blend_init_image
output_image = style.optimize(
content_frames, style_images_big, init_image,
num_iters // opt.param.passes_per_scale, opt)
init_image = match_histogram(output_image.detach().cpu(),
style_images_big[0])
disp = load.deprocess(init_image.clone())
if opt.param.original_colors == 1:
disp = load.original_colors(
load.deprocess(content_frames[1].clone()), disp)
disp.save(str(opt.output))
# clean up / prepare for next pass
frames = frames[7:] + frames[:7] # rotate frames
frames = list(reversed(frames))
ffmpeg.input(output_dir + "/" + str(current_size) + "/" + str(pass_n) +
"_%05d.png").output(
"%s/%s_%s.mp4" %
(output_dir, name(output_dir), current_size),
**opt.ffmpeg).overwrite_output().run()
prev_size = current_size
del net
th.cuda.empty_cache()
ffmpeg.input("{output_dir}/{current_size}/{pass_n}_%05d.png").output(
opt.output, **opt.ffmpeg).overwrite_output().run()
def expression(node, builder):
exp = []
elem1 = None
for f in PreOrderIter(node):
if ut.name(f) == 'chamada_funcao':
return callFunc(f, builder)
for f in PreOrderIter(node):
if f.is_leaf:
exp.append(ut.name(f))
if len(exp) == 3:
if exp[1] == "+":
if isinstance(exp[0], float) or isinstance(exp[2], float):
return builder.fadd(retFloat(exp[0]),
retFloat(exp[2]),
name="addFloat")
else:
return builder.add(retInt(exp[0]),
retInt(exp[2]),
name="addInt")
if exp[1] == "-":
return builder.sub(retInt(exp[0]), retInt(exp[2]), name="sub")
if exp[1] == "*":
if isinstance(exp[0], float):
return builder.fmul(retFloat(exp[0]),
retFloat(exp[2]),
name="mulFloat")
else:
return builder.mul(retInt(exp[0]),
retInt(exp[2]),
name="mulInt")
if exp[1] == "/":
if isinstance(exp[0], float):
return builder.fdiv(retFloat(exp[0]),
retFloat(exp[2]),
name="divFloat")
else:
return builder.udiv(retInt(exp[0]),
retInt(exp[2]),
name="divInt")
if exp[1] in [">", "<", ">=", "<="]:
return builder.icmp_signed(exp[1],
retInt(exp[0]),
retInt(exp[2]),
name="maiorMenor")
if exp[1] == "<>":
return builder.icmp_signed("!=",
retInt(exp[0]),
retInt(exp[2]),
name="dif")
if exp[1] == "=":
return builder.icmp_signed("==",
retInt(exp[0]),
retInt(exp[2]),
name="igual")
elif len(exp) == 1:
if not isnumber(exp[0]) and '.' not in exp[0]:
if exp[0] in locais.keys():
elem1 = locais[exp[0]]
if exp[0] in globais.keys():
elem1 = globais[exp[0]]
print(exp)
return builder.load(elem1)
else:
if isnumber(exp[0]):
return retInt(int(exp[0]))
else:
return retFloat(float(exp[0]))
def vid_img(args):
output_dir = args.output_dir + "/" + name(args.content) + "_" + "_".join(
[name(s) for s in args.style])
flow_model = flow.get_flow_model(args)
frames = load.process_content_video(flow_model, args)
content_size = np.array(load.preprocess(frames[0]).size()[-2:])
style_images_big = load.process_style_images(args)
for size_n, (current_size,
num_iters) in enumerate(zip(args.image_sizes,
args.num_iters)):
if len(
glob.glob("%s/%s/*.png" % (output_dir, args.image_sizes[min(
len(args.image_sizes) - 1, size_n + 1)]))) == len(frames):
print("Skipping size: %s, already done." % current_size)
prev_size = current_size
continue
print("\nCurrent size {}px".format(current_size))
os.makedirs(output_dir + "/" + str(current_size), exist_ok=True)
content_scale = current_size / max(*content_size)
# scale style images
style_images = []
content_area = content_scale**2 * content_size[0] * content_size[1]
for img in style_images_big:
style_scale = math.sqrt(
content_area / (img.size(3) * img.size(2))) * args.style_scale
style_images.append(
F.interpolate(th.clone(img),
scale_factor=style_scale,
mode="bilinear",
align_corners=False))
optim.set_model_args(args, current_size)
net, losses = models.load_model(args)
# optim.set_style_targets(net, style_images, args)
for pass_n in range(args.passes_per_scale):
pastiche = None
if args.loop:
start_idx = random.randrange(0, len(frames) - 1)
frames = frames[
start_idx:] + frames[:start_idx] # rotate frames
if len(
glob.glob("%s/%s/%s_*.png" % (output_dir, current_size,
pass_n + 2))) == len(frames):
print(f"Skipping pass: {pass_n + 1}, already done.")
frames = list(reversed(frames))
continue
for n, (prev_frame, this_frame) in enumerate(
zip(frames + frames[:11 if args.loop else 1],
frames[1:] + frames[:10 if args.loop else 1])):
# TODO add update_style() function to support changing styles per frame
args.output = "%s/%s/%s_%s.png" % (
output_dir, current_size, pass_n + 1, name(this_frame))
if os.path.isfile(args.output) and not n >= len(frames):
print(
"Skipping pass: %s, frame: %s. File already exists." %
(pass_n + 1, name(this_frame)))
continue
print("Optimizing... size: %s, pass: %s, frame: %s" %
(current_size, pass_n + 1, name(this_frame)))
content_frames = [
F.interpolate(load.preprocess(prev_frame),
scale_factor=content_scale,
mode="bilinear",
align_corners=False),
F.interpolate(load.preprocess(this_frame),
scale_factor=content_scale,
mode="bilinear",
align_corners=False),
]
content_frames = [
match_histogram(frame,
style_images_big[0],
mode=args.match_histograms)
for frame in content_frames
]
flow_direction = "forward" if pass_n % 2 == 0 else "backward"
# optim.set_content_targets(net, content_frames[1], args)
# Initialize the image
# TODO make sure initialization correct even when continuing half way through video stylization
if size_n == 0 and pass_n == 0:
if args.init == "random":
pastiche = th.randn(
content_frames[1].size()).mul(0.001)
elif args.init == "prev_warp":
if pastiche is None:
pastiche = content_frames[0]
flo_file = f"{output_dir}/flow/{flow_direction}_{name(prev_frame)}_{name(this_frame)}.flo"
flow_map = load.flow_warp_map(flo_file,
pastiche.shape[2:])
pastiche = F.grid_sample(pastiche,
flow_map,
padding_mode="border")
else:
pastiche = content_frames[1].clone()
else:
if pass_n == 0:
# load images from last pass of previous size
if pastiche is None:
ifile = "%s/%s/%s_%s.png" % (
output_dir,
prev_size
if n <= len(frames) else current_size,
args.passes_per_scale
if n <= len(frames) else pass_n + 1,
name(prev_frame),
)
pastiche = load.preprocess(ifile)
pastiche = F.interpolate(
pastiche,
size=content_frames[0].size()[2:],
mode="bilinear",
align_corners=False)
bfile = "%s/%s/%s_%s.png" % (
output_dir,
prev_size if n <= len(frames) else current_size,
args.passes_per_scale
if n <= len(frames) else pass_n + 1,
name(this_frame),
)
blend_image = load.preprocess(bfile)
blend_image = F.interpolate(
blend_image,
size=content_frames[0].size()[2:],
mode="bilinear",
align_corners=False)
else:
# load images from previous pass of current size
if pastiche is None:
ifile = "%s/%s/%s_%s.png" % (
output_dir,
current_size,
pass_n if n <= len(frames) else pass_n + 1,
name(prev_frame),
)
pastiche = load.preprocess(ifile)
bfile = "%s/%s/%s_%s.png" % (
output_dir,
current_size,
pass_n if n <= len(frames) else pass_n + 1,
name(this_frame),
)
blend_image = load.preprocess(bfile)
flo_file = f"{output_dir}/flow/{flow_direction}_{name(prev_frame)}_{name(this_frame)}.flo"
flow_map = load.flow_warp_map(flo_file, pastiche.shape[2:])
warp_image = F.grid_sample(pastiche,
flow_map,
padding_mode="border")
flow_weight_file = f"{output_dir}/flow/{flow_direction}_{name(prev_frame)}_{name(this_frame)}.png"
reliable_flow = load.reliable_flow_weighting(
flow_weight_file)
reliable_flow = F.interpolate(reliable_flow,
size=pastiche.size()[2:],
mode="bilinear",
align_corners=False)
optim.set_temporal_targets(net,
warp_image,
warp_weights=reliable_flow,
args=args)
pastiche = (
1 - args.temporal_blend
) * blend_image + args.temporal_blend * pastiche
output_image = optim.optimize(
content_frames[1], style_images, pastiche,
num_iters // args.passes_per_scale, args, net, losses)
pastiche = match_histogram(output_image.detach().cpu(),
style_images_big[0],
mode=args.match_histograms)
disp = load.deprocess(pastiche.clone())
if args.original_colors == 1:
disp = load.original_colors(
load.deprocess(content_frames[1].clone()), disp)
disp.save(str(args.output))
# reverse frames for next pass
frames = list(reversed(frames))
ffmpeg.input(output_dir + "/" + str(current_size) + "/" + str(pass_n) +
"_%05d.png").output(
"%s/%s_%s.mp4" %
(output_dir, name(output_dir), current_size),
**args.ffmpeg).overwrite_output().run()
prev_size = current_size
del net
th.cuda.empty_cache()
def cutUselessElements(tree):
for node in PostOrderIter(tree):
if (name(node) == ':' or name(node) == ',' or name(node) == '('
or name(node) == ')' or name(node) == '[' or name(node) == ']'
or name(node) == ':='):
node.parent = None
import config
import flow
import load
from utils import match_histogram, name
torch.backends.cudnn.benchmark = True
args = config.get_args()
if args.seed >= 0:
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
if args.backend == "cudnn":
torch.backends.cudnn.deterministic = True
output_dir = args.output_dir + "/" + name(args.content) + "_" + "_".join(
[name(s) for s in args.style])
flow_model = flow.get_flow_model(args)
frames = load.process_content_video(flow_model, args)
content_size = np.array(load.preprocess(frames[0]).size()[-2:])
style_images_big = load.process_style_images(args)
for size_n, (current_size,
num_iters) in enumerate(zip(args.image_sizes, args.num_iters)):
if len(
glob("%s/%s/*.png" % (output_dir, args.image_sizes[min(
len(args.image_sizes) - 1, size_n + 1)]))) == len(frames):
print("Skipping size: %s, already done." % current_size)
