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"]