def get_img_gen(data, split_index, G, iepoch, out_path):
old_split_index = data.split_index
data.set_split_index(split_index)
data_loader = torch.utils.data.DataLoader(data, batch_size=1, shuffle=False)
data_batch = next(iter(data_loader))
with torch.no_grad():
recipe_ids, recipe_embs, img_ids, imgs, classes = data_batch
batch_size, recipe_embs, imgs, classes, classes_one_hot = util.get_variables(recipe_ids, recipe_embs, img_ids, imgs, classes, data.num_classes())
imgs_gen = G(recipe_embs, classes_one_hot)
save_img(imgs_gen[0], iepoch, out_path, split_index, recipe_ids[0], img_ids[0])
data.set_split_index(old_split_index)
def remove_dead_variables(code):
variables = get_variables(code)
blocks = get_blocks(code)
for variable in variables:
v = variables[variable]
if "def_site" not in v:
for use in v["uses"]:
b, s = blocks[use["block"]], use["statement"]
statement = code["blocks"][b]["code"][s]
for u in [u for u in statement if u.startswith("src") and statement[u] == variable]:
del statement[u]
def do_pure_literal_elimination(
formula: List[Clause]) -> (List[Clause], Mapping[int, bool]):
known_mapping: Mapping[int, bool] = {}
new_formula = deepcopy(formula)
variables = get_variables(formula)
for variable in variables:
# Check variable purity on original formula because variables might get removed during purging. Purity does not
# change across purges, so we're safe to use the original formula.
variable_purity = get_variable_purity(variable, formula)
if variable_purity is not None:
new_formula = purge_clauses_with_literal(
Literal(variable, variable_purity), new_formula)
known_mapping[variable] = variable_purity
return new_formula, known_mapping
def main():
# Load the data
data = GANstronomyDataset(opts.DATA_PATH, split=opts.TVT_SPLIT)
data.set_split_index(0)
data_loader = torch.utils.data.DataLoader(data,
batch_size=opts.BATCH_SIZE,
shuffle=True)
num_classes = data.num_classes()
# Make the output directory
util.create_dir(opts.RUN_PATH)
util.create_dir(opts.IMG_OUT_PATH)
util.create_dir(opts.MODEL_OUT_PATH)
# Copy opts.py and model.py to opts.RUN_PATH as a record
shutil.copy2('opts.py', opts.RUN_PATH)
shutil.copy2('model.py', opts.RUN_PATH)
shutil.copy2('train.py', opts.RUN_PATH)
# Instantiate the models
G = Generator(opts.EMBED_SIZE, num_classes).to(opts.DEVICE)
G_optimizer = torch.optim.Adam(G.parameters(),
lr=opts.ADAM_LR,
betas=opts.ADAM_B)
D = Discriminator(num_classes).to(opts.DEVICE)
D_optimizer = torch.optim.Adam(D.parameters(),
lr=opts.ADAM_LR,
betas=opts.ADAM_B)
if opts.MODEL_PATH is None:
start_iepoch, start_ibatch = 0, 0
else:
print('Attempting to resume training using model in %s...' %
opts.MODEL_PATH)
start_iepoch, start_ibatch = load_state_dicts(opts.MODEL_PATH, G,
G_optimizer, D,
D_optimizer)
for iepoch in range(opts.NUM_EPOCHS):
for ibatch, data_batch in enumerate(data_loader):
# To try to resume training, just continue if iepoch and ibatch are less than their starts
if iepoch < start_iepoch or (iepoch == start_iepoch
and ibatch < start_ibatch):
if iepoch % opts.INTV_PRINT_LOSS == 0 and not ibatch:
print('Skipping epoch %d...' % iepoch)
continue
recipe_ids, recipe_embs, img_ids, imgs, classes, noisy_real, noisy_fake = data_batch
# Make sure we're not training on validation or test data!
if opts.SAFETY_MODE:
for recipe_id in recipe_ids:
assert data.get_recipe_split_index(recipe_id) == 0
batch_size, recipe_embs, imgs, classes, classes_one_hot = util.get_variables(
recipe_ids, recipe_embs, img_ids, imgs, classes, num_classes)
noisy_real, noisy_fake = util.get_variables2(
noisy_real, noisy_fake)
# Adversarial ground truths
all_real = Variable(FloatTensor(batch_size, 1).fill_(1.0),
requires_grad=False).to(opts.DEVICE)
all_fake = Variable(FloatTensor(batch_size, 1).fill_(0.0),
requires_grad=False).to(opts.DEVICE)
# Train Generator
for _ in range(opts.NUM_UPDATE_G):
G_optimizer.zero_grad()
imgs_gen = G(recipe_embs, classes_one_hot)
fake_probs = D(imgs_gen, classes_one_hot)
G_BCE_loss = BCELoss(fake_probs, all_real)
G_MSE_loss = MSELoss(imgs_gen, imgs)
G_loss = opts.A_BCE * G_BCE_loss + opts.A_MSE * G_MSE_loss
G_loss.backward()
G_optimizer.step()
# Train Discriminator
for _ in range(opts.NUM_UPDATE_D):
D_optimizer.zero_grad()
fake_probs = D(imgs_gen.detach(), classes_one_hot)
real_probs = D(imgs, classes_one_hot)
D_loss = (
BCELoss(fake_probs,
noisy_fake if opts.NOISY_LABELS else all_fake) +
BCELoss(real_probs,
noisy_real if opts.NOISY_LABELS else all_real)) / 2
D_loss.backward()
D_optimizer.step()
if iepoch % opts.INTV_PRINT_LOSS == 0 and not ibatch:
print_loss(G_BCE_loss, G_MSE_loss, D_loss, iepoch)
if iepoch % opts.INTV_SAVE_IMG == 0 and not ibatch:
# Save a training image
get_img_gen(data, 0, G, iepoch, opts.IMG_OUT_PATH)
# Save a validation image
get_img_gen(data, 1, G, iepoch, opts.IMG_OUT_PATH)
if iepoch % opts.INTV_SAVE_MODEL == 0 and not ibatch:
print('Saving model...')
save_model(G, G_optimizer, D, D_optimizer, iepoch,
opts.MODEL_OUT_PATH)
save_model(G, G_optimizer, D, D_optimizer, 'FINAL', opts.MODEL_OUT_PATH)
print('\a') # Ring the bell to alert the human
def conditional_propagation(code):
worklist = []
blocks = get_blocks(code)
global variables
variables = get_variables(code)
for v in variables:
# Variables with no definition must be input to the program
if variables[v].has_key("def_site"):
variables[v]["evidence"] = "never"
else:
variables[v]["evidence"] = "over"
for block in code["blocks"]:
block["delete"] = True
#Entry block is always executable
if block["name"] == code["starting_block"][0]:
add_block_to_worklist(block, worklist)
block["delete"] = False
branch = "nil"
while len(worklist):
s = worklist.pop(0)
# Executable Blocks with only 1 successor, that block must also be executable
if len(get_block(s, code, blocks)["next_block"]) >= 1:
if get_next_block(code, blocks, s, 0)["delete"] and len(get_block(s, code, blocks)["next_block"]) == 1:
get_next_block(code, blocks, s, 0)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 0), worklist)
if "dest" in s:
#any overloaded variable cannot chance state
if variables[s["dest"]]["evidence"] != "over":
#Any executable statement v := x op y with x and y constant and exectuable , set v to constant x op y
#Any executable statement v := x op y with x or y is overloaded and exectuable, set v overloaded
if is_executable (code, s["src1"], variables):
if s["op"] == "MOV":
if is_constant_val(s["src1"], variables):
if get_value (variables, s["dest"]) == "never":
variables [s["dest"]]["evidence"] = get_value (variables, s["src1"])
update_worklist(code, worklist, s)
elif get_value (variables, s["dest"]) != get_value (variables, s["dest"]):
variables [s["dest"]]["evidence"] = "over"
update_worklist(code, worklist, s)
else:
variables [s["dest"]]["evidence"] = "over"
update_worklist(code, worklist, s)
if s["op"] in FOLDABLE_OPS:
if is_executable (code, s["src2"], variables):
if is_constant_val(s["src1"], variables) and is_constant_val(s["src2"], variables):
try:
val1 = int(get_value(variables, s["src1"])[1:])
val2 = int(get_value(variables, s["src2"])[1:])
except ValueError:
return
const = "#" + str(_do_op(s["op"], val1, val2))
if get_value (variables, s["dest"]) == "never":
variables [s["dest"]]["evidence"] = const
update_worklist(code, worklist, s)
elif get_value (variables, s["dest"]) != const:
variables [s["dest"]]["evidence"] = "over"
update_worklist(code, worklist, s)
else:
variables [s["dest"]]["evidence"] = "over"
update_worklist(code, worklist, s)
# If v assigned from phi op, and if all srcs that are constant and executable are the same and there are no variables that have seen evidence of use, assign constant value to v.
# If v assigned from phi op, and at least 2 srcs are different constants and are executable, v is a overloaded
# If v assigned from phi op, and at least 1 srcs is overloaded and is executable, v is overloaded
if s["op"] == "phi":
operands = [s[x] for x in s if x.startswith("src")]
for o in operands:
if is_executable (code, o, variables):
if is_constant_val(o, variables):
if get_value (variables, s["dest"]) == "never":
variables [s["dest"]]["evidence"] = get_value (variables, o)
update_worklist(code, worklist, s)
elif get_value (variables, s["dest"]) != get_value (variables, o):
variables [s["dest"]]["evidence"] = "over"
update_worklist(code, worklist, s)
else:
variables [s["dest"]]["evidence"] = "over"
update_worklist(code, worklist, s)
# If value loaded from memory, evidence of overloading
if s["op"] in MEMORY_OPS:
variables[s["dest"]]["evidence"] = "over"
update_worklist(code, worklist, s)
if s["op"] == "CMP":
# if branch instruction, if either src is a overloaded, then both paths may be executed and should be added to the worklist to be marked as such and their statements analysed.
if is_var(s["src1"], variables) or is_var(s["src2"], variables):
add_block_to_worklist(get_next_block(code, blocks, s, 0) , worklist)
get_next_block(code, blocks, s, 0)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 1) , worklist)
get_next_block(code, blocks, s, 1)["delete"] = False
#If a branch and both srcs are constant, add appropriate path to work path.
else:
val1 = int(get_value(variables,s["src1"])[1:])
val2 = int(get_value(variables,s["src2"])[1:])
if val1 > val2 :
branch = "gt"
elif val1 < val2 :
branch = "lt"
else:
branch = "eq"
#Note - these do not take in to account all possible instructions in the arm instruction set, such as any operation being conditional
if branch != "nil":
if s["op"] == "BEQ":
if branch == "eq":
get_next_block(code, blocks, s, 0)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 0) , worklist)
else:
get_next_block(code, blocks, s, 1)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 1) , worklist)
if s["op"] == "BNE":
if branch != "eq":
get_next_block(code, blocks, s, 0)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 0) , worklist)
else:
get_next_block(code, blocks, s, 1)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 1) , worklist)
if s["op"] == "BLT":
if branch == "lt":
get_next_block(code, blocks, s, 0)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 0) , worklist)
else:
get_next_block(code, blocks, s, 1)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 1) , worklist)
if s["op"] == "BLE":
if branch == "eq" or branch == "lt" :
get_next_block(code, blocks, s, 0)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 0) , worklist)
else:
get_next_block(code, blocks, s, 1)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 1) , worklist)
if s["op"] == "BGT":
if branch == "gt":
get_next_block(code, blocks, s, 0)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 0) , worklist)
else:
get_next_block(code, blocks, s, 1)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 1) , worklist)
if s["op"] == "BGE":
if branch == "eq" or branch == "gt" :
get_next_block(code, blocks, s, 0)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 0) , worklist)
else:
get_next_block(code, blocks, s, 1)["delete"] = False
add_block_to_worklist(get_next_block(code, blocks, s, 1) , worklist)
# Delete any block that is not executed
for block in code["blocks"]:
i = 0
#delete references to deleted blocks
while i < len(block["next_block"]):
if code["blocks"][blocks[block["next_block"][i]]]["delete"]:
del block["next_block"][i]
else:
i += 1
for block in code["blocks"]:
if not block["delete"]:
del block["delete"]
i = 0
while i < len(code["blocks"]):
if "delete" in code["blocks"][i]:
del code["blocks"][i]
else:
i += 1
worklistfix = []
for block in code["blocks"]:
for statement in block["code"]:
worklistfix.append(statement)
while len(worklistfix):
s = worklistfix.pop(0)
#propogate constants
if "dest" in s:
if variables[s["dest"]]["evidence"].startswith('#'):
_propagate_constant(code, s, variables[s["dest"]]["evidence"])
#remove any branch ops that are constant
if s["op"] == "CMP":
if is_constant_val(s["src1"], variables) and is_constant_val(s["src2"], variables):
remove_statement(code, s)
if s["op"] in CONDITIONAL_BRANCH:
block = get_block(s, code, blocks)["code"]
if not any(statement["op"] == "CMP" for statement in block):
remove_statement(code, s)
if s["block"]:
del s["block"]
