def load(self,args): if args.model_dir != "": loadedparams = torch.load(args.model_dir,map_location=self.device) self.agent = agent.Agent(args,chkpoint=loadedparams) #self.agent = agent.Agent(args) else: self.agent = agent.Agent(args) self.SRmodels = [] self.SRoptimizers = [] self.schedulers = [] for i in range(args.action_space): #CREATE THE ARCH if args.model == 'basic': model = arch.RRDBNet(3,3,32,args.d,gc=8) elif args.model == 'ESRGAN': model = arch.RRDBNet(3,3,64,23,gc=32) elif args.model == 'RCAN': torch.manual_seed(args.seed) checkpoint = utility.checkpoint(args) if checkpoint.ok: module = import_module('model.rcan') model = module.make_model(args).to(self.device) kwargs = {} else: print('error loading RCAN model. QUITING'); quit(); #LOAD THE WEIGHTS if args.model_dir != "": model.load_state_dict(loadedparams["sisr"+str(i)]) print('continuing training') elif args.random: print('random init') model.apply(init_weights) elif args.model == 'ESRGAN': model.load_state_dict(torch.load(args.ESRGAN_PATH),strict=True) elif args.model == 'RCAN': print('RCAN loaded!') model.load_state_dict(torch.load(args.pre_train,**kwargs),strict=True) elif args.model == 'basic': if args.d == 1: model.load_state_dict(torch.load(args.basicpath_d1),strict=True) elif args.d == 2: model.load_state_dict(torch.load(args.basicpath_d2),strict=True) elif args.d == 4: model.load_state_dict(torch.load(args.basicpath_d4),strict=True) elif args.d == 8: model.load_state_dict(torch.load(args.basicpath_d8),strict=True) else: print('no pretrained model available. Random initialization of basic block') self.SRmodels.append(model) self.SRmodels[-1].to(self.device) #self.SRoptimizers.append(torch.optim.Adam(model.parameters(),lr=1e-5)) self.SRoptimizers.append(torch.optim.Adam(model.parameters(),lr=1e-5)) scheduler = torch.optim.lr_scheduler.StepLR(self.SRoptimizers[-1],1000,gamma=0.5) self.schedulers.append(scheduler)
def load(self, args): if args.model_dir != "": loadedparams = torch.load(args.model_dir, map_location=self.device) self.agent = agent.Agent(args, chkpoint=loadedparams) else: self.agent = agent.Agent(args) self.SRmodels = [] self.SRoptimizers = [] self.schedulers = [] for i in range(args.action_space): #CREATE THE ARCH if args.model == 'ESRGAN': model = arch.RRDBNet(3, 3, 64, 23, gc=32) elif args.model == 'RCAN' or args.model == 'random': torch.manual_seed(args.seed) checkpoint = utility.checkpoint(args) if checkpoint.ok: module = import_module('model.rcan') model = module.make_model(args).to(self.device) kwargs = {} else: print('error loading RCAN model. QUITING') quit() #LOAD THE WEIGHTS if args.model_dir != "": model.load_state_dict(loadedparams["sisr" + str(i)]) print('continuing training') elif args.random: model.apply(init_weights) elif args.model == 'ESRGAN': model.load_state_dict(torch.load(args.ESRGAN_PATH), strict=True) elif args.model == 'RCAN': model.load_state_dict(torch.load(args.pre_train, **kwargs), strict=True) self.SRmodels.append(model) self.SRmodels[-1].to(self.device) self.SRoptimizers.append( torch.optim.Adam(model.parameters(), lr=1e-4)) self.schedulers.append( torch.optim.lr_scheduler.StepLR(self.SRoptimizers[-1], 500, gamma=0.1)) #INCREMENT SCHEDULES TO THE CORRECT LOCATION for i in range(args.step): [s.step() for s in self.schedulers]
def simulate(model, envname, num_rollouts=20, max_timesteps=None, render=False): env = gym.make(envname) max_steps = max_timesteps or env.spec.timestep_limit returns = [] observations = [] actions = [] for i in range(num_rollouts): # print('iter', i) obs = env.reset() done = False totalr = 0. steps = 0 while not done: action = model.apply(obs.reshape(1, -1)) observations.append(obs) actions.append(action) obs, r, done, _ = env.step(action) totalr += r steps += 1 if render: env.render() # if steps % 100 == 0: print("%i/%i"%(steps, max_steps)) if steps >= max_steps: break returns.append(totalr) print('returns', returns) print('mean return', np.mean(returns)) print('std of return', np.std(returns)) return np.mean(returns)
def load(self, args): if args.model == 'ESRGAN': model = arch.RRDBNet(3, 3, 64, 23, gc=32) model.load_state_dict(torch.load(self.SRMODEL_PATH), strict=True) elif args.model == 'random': model = arch.RRDBNet(3, 3, 64, 23, gc=32) model.apply(self.init_weights) elif args.model == 'RCAN': torch.manual_seed(args.seed) checkpoint = utility.checkpoint(args) if checkpoint.ok: module = import_module('model.' + args.model.lower()) model = module.make_model(args).to(self.device) kwargs = {} model.load_state_dict(torch.load(args.pre_train, **kwargs), strict=False) else: print('error loading RCAN model. QUITING') quit() return model
def task6(): pass """ 1. ??????????? ????????? 2. ?????????? ????????? ??????? (????? > 1), ?????? ??????? ? ?? - ?? ???????? ?????? - ??? ?????? ?????????????... - ?????????? ?? ? 0-1 ????? ???????????? ?? ? ??? ?????????? - ?????????? ????? ???????? ?????? ? ?? ???????????? :return: """ img = IO.read_image("image2.jpg", r".\data") img = to_one_chanel(img) print(img.shape) LD = m.luminance_distribution(img) img2 = m.apply(img, LD) IO.show_images([img, img2], ["image", "image vs luminance distribution"]) bLD1 = m.back_luminance_distribution(LD) bLD2 = m.luminance_distribution(img2) IO.plot_functions([(None, LD)]) IO.plot_functions([(None, LD), (None, bLD1)])
def summary(model, x, *args, **kwargs): """Summarize the given input model. Summarized information are 1) output shape, 2) kernel shape, 3) number of the parameters and 4) operations (Mult-Adds) Args: model (Module): Model to summarize x (Tensor): Input tensor of the model with [N, C, H, W] shape dtype and device have to match to the model args, kwargs: Other argument used in `model.forward` function """ def register_hook(module): def hook(module, inputs, outputs): cls_name = str(module.__class__).split(".")[-1].split("'")[0] module_idx = len(summary) # Lookup name in a dict that includes parents for name, item in module_names.items(): if item == module: key = "{}_{}".format(module_idx, name) info = OrderedDict() info["id"] = id(module) if isinstance(outputs, (list, tuple)): try: info["out"] = list(outputs[0].size()) except AttributeError: # pack_padded_seq and pad_packed_seq store feature into data attribute info["out"] = list(outputs[0].data.size()) else: info["out"] = list(outputs.size()) info["ksize"] = "-" info["inner"] = OrderedDict() info["params_nt"], info["params"], info["macs"] = 0, 0, 0 for name, param in module.named_parameters(): info["params"] += param.nelement() * param.requires_grad info["params_nt"] += param.nelement() * (not param.requires_grad) if name == "weight": ksize = list(param.size()) # to make [in_shape, out_shape, ksize, ksize] if len(ksize) > 1: ksize[0], ksize[1] = ksize[1], ksize[0] info["ksize"] = ksize # ignore N, C when calculate Mult-Adds in ConvNd if "Conv" in cls_name: info["macs"] += int(param.nelement() * np.prod(info["out"][2:])) else: info["macs"] += param.nelement() # RNN modules have inner weights such as weight_ih_l0 elif "weight" in name: info["inner"][name] = list(param.size()) info["macs"] += param.nelement() # if the current module is already-used, mark as "(recursive)" # check if this module has params if list(module.named_parameters()): for v in summary.values(): if info["id"] == v["id"]: info["params"] = "(recursive)" if info["params"] == 0: info["params"], info["macs"] = "-", "-" summary[key] = info # ignore Sequential and ModuleList if not module._modules: hooks.append(module.register_forward_hook(hook)) module_names = get_names_dict(model) hooks = [] summary = OrderedDict() model.apply(register_hook) try: with torch.no_grad(): model(x) if not (kwargs or args) else model(x, *args, **kwargs) finally: for hook in hooks: hook.remove() # Use pandas to align the columns df = pd.DataFrame(summary).T df["Mult-Adds"] = pd.to_numeric(df["macs"], errors="coerce") df["Params"] = pd.to_numeric(df["params"], errors="coerce") df["Non-trainable params"] = pd.to_numeric(df["params_nt"], errors="coerce") df = df.rename(columns=dict( ksize="Kernel Shape", out="Output Shape", )) df_sum = df.sum() df.index.name = "Layer" df = df[["Kernel Shape", "Output Shape", "Params", "Mult-Adds"]] max_repr_width = max([len(row) for row in df.to_string().split("\n")]) # option = pd.option_context( # "display.max_rows", 600, # "display.max_columns", 10, # "display.float_format", pd.io.formats.format.EngFormatter(use_eng_prefix=True) # ) # with option: # # print("="*max_repr_width) # # print(df.replace(np.nan, "-")) # # print("-"*max_repr_width) # # df_total = pd.DataFrame( # # {"Total params": (df_sum["Params"] + df_sum["params_nt"]), # # "Trainable params": df_sum["Params"], # # "Non-trainable params": df_sum["params_nt"], # # "Mult-Adds": df_sum["Mult-Adds"] # # }, # # index=['Totals'] # # ).T # # print(df_total) # # print("="*max_repr_width) return df, df_sum
else: device = torch.device("cpu") print("Rodando na CPU") #Creating the model model = model.SqueezeNet().to(device) # print(model) #Função utilizada para realizar a inicialização dos pesos da camadas #convolucionais seguindo distribuição normal com média 0 def _initialize_weights(net): for m in net.modules(): if isinstance(m, nn.Conv2d): m.weight.data.normal_(mean=0, std=0.02) model.apply(_initialize_weights) model.cuda() summary(model, (3, 512, 512)) #Setting the optimizer and loss optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE) loss_function = nn.BCELoss() #Spliting features and labels. Creating DataLoaders train_X = training_set[0] train_y = training_set[1] dataloader_train_X = torch.utils.data.DataLoader(train_X, batch_size=BATCH_SIZE) dataloader_train_y = torch.utils.data.DataLoader(train_y, batch_size=BATCH_SIZE)
def __init__(self, args=args): #RANDOM MODEL INITIALIZATION FUNCTION def init_weights(m): if isinstance(m, torch.nn.Linear) or isinstance( m, torch.nn.Conv2d): torch.nn.init.xavier_uniform_(m.weight.data) #INITIALIZE VARIABLES self.SR_COUNT = args.action_space SRMODEL_PATH = args.srmodel_path self.batch_size = args.batch_size self.TRAINING_LRPATH = glob.glob( os.path.join(args.training_lrpath, "*")) self.TRAINING_HRPATH = glob.glob( os.path.join(args.training_hrpath, "*")) self.TRAINING_LRPATH.sort() self.TRAINING_HRPATH.sort() self.PATCH_SIZE = args.patchsize self.patchinfo_dir = args.patchinfo self.TESTING_PATH = glob.glob(os.path.join(args.testing_path, "*")) self.LR = args.learning_rate self.UPSIZE = args.upsize self.step = 0 self.name = args.name if args.name != 'none': self.logger = logger.Logger( args.name) #create our logger for tensorboard in log directory else: self.logger = None self.device = torch.device(args.device) #determine cpu/gpu #DEFAULT START OR START ON PREVIOUSLY TRAINED EPOCH if args.model_dir != "": self.load(args) print('continue training for model: ' + args.model_dir) else: self.SRmodels = [] self.SRoptimizers = [] self.schedulers = [] #LOAD A COPY OF THE MODEL N TIMES for i in range(self.SR_COUNT): if args.model == 'ESRGAN': model = arch.RRDBNet(3, 3, 64, 23, gc=32) model.load_state_dict(torch.load(args.ESRGAN_PATH), strict=True) print('ESRGAN loaded') elif args.model == 'random': model = arch.RRDBNet(3, 3, 64, 23, gc=32) model.apply(init_weights) print('Model RRDB Loaded with random weights...') elif args.model == 'RCAN': torch.manual_seed(args.seed) checkpoint = utility.checkpoint(args) if checkpoint.ok: module = import_module('model.' + args.model.lower()) model = module.make_model(args).to(self.device) kwargs = {} model.load_state_dict(torch.load( args.pre_train, **kwargs), strict=False) else: print('error') self.SRmodels.append(model) self.SRmodels[-1].to(self.device) self.SRoptimizers.append( torch.optim.Adam(model.parameters(), lr=1e-4)) self.schedulers.append( torch.optim.lr_scheduler.StepLR(self.SRoptimizers[-1], 10000, gamma=0.1)) #self.patchinfo = np.load(self.patchinfo_dir) self.agent = agent.Agent(args)
DEC_EMB_DIM = 256 HID_DIM = 512 N_LAYERS = 2 ENC_DROPOUT = 0.5 DEC_DROPOUT = 0.5 enc = model.Encoder(INPUT_DIM, ENC_EMB_DIM, HID_DIM, N_LAYERS, ENC_DROPOUT) dec = model.Decoder(OUTPUT_DIM, DEC_EMB_DIM, HID_DIM, N_LAYERS, DEC_DROPOUT) model = model.Seq2Seq(enc, dec, device).to(device) def init_weights(m): for name, param in m.named_parameters(): nn.init.uniform_(param.data, -0.08, 0.08) model.apply(init_weights) def count_parameters(model): return sum(p.numel() for p in model.parameters() if p.requires_grad) print(f'The model has {count_parameters(model):,} trainable parameters') optimizer = optim.Adam(model.parameters()) PAD_IDX = TRG.vocab.stoi['<pad>'] criterion = nn.CrossEntropyLoss(ignore_index = PAD_IDX) def train(model, iterator, optimizer, criterion, clip): model.train()
def param_summary(model, input_size, batch_size=-1, device=torch.device('cuda:0'), dtypes=None): if dtypes == None: dtypes = [torch.FloatTensor] * len(input_size) # summary_str = '' def register_hook(module): def hook(module, input, output): class_name = str(module.__class__).split(".")[-1].split("'")[0] module_idx = len(summary) m_key = "%s-%i" % (class_name, module_idx + 1) summary[m_key] = OrderedDict() summary[m_key]["input_shape"] = list(input[0].size()) summary[m_key]["input_shape"][0] = batch_size if isinstance(output, (list, tuple)): summary[m_key]["output_shape"] = [[-1] + list(o.size())[1:] for o in output] else: summary[m_key]["output_shape"] = list(output.size()) summary[m_key]["output_shape"][0] = batch_size params = 0 if hasattr(module, "weight") and hasattr(module.weight, "size"): params += torch.prod( torch.LongTensor(list(module.weight.size()))) summary[m_key]["trainable"] = module.weight.requires_grad if hasattr(module, "bias") and hasattr(module.bias, "size"): params += torch.prod(torch.LongTensor(list( module.bias.size()))) summary[m_key]["nb_params"] = params if (not isinstance(module, nn.Sequential) and not isinstance(module, nn.ModuleList)): hooks.append(module.register_forward_hook(hook)) # multiple inputs to the network if isinstance(input_size, tuple): input_size = [input_size] # batch_size of 2 for batchnorm x = [ torch.rand(2, *in_size).type(dtype).to(device=device) for in_size, dtype in zip(input_size, dtypes) ] # create properties summary = OrderedDict() hooks = [] # register hook model.apply(register_hook) # make a forward pass # print(x.shape) model(*x) # remove these hooks for h in hooks: h.remove() # summary_str += "----------------------------------------------------------------" + "\n" # line_new = "{:>20} {:>25} {:>15}".format( # "Layer (type)", "Output Shape", "Param #") # summary_str += line_new + "\n" # summary_str += "================================================================" + "\n" total_params = 0 total_output = 0 trainable_params = 0 for layer in summary: # input_shape, output_shape, trainable, nb_params # line_new = "{:>20} {:>25} {:>15}".format( # layer, # str(summary[layer]["output_shape"]), # "{0:,}".format(summary[layer]["nb_params"]), # ) total_params += summary[layer]["nb_params"] print(str(layer)) if (str(layer).find('Flatten')) == -1 and ((str(layer).find('ReLU'))): total_output += np.prod( summary[layer]["output_shape"]) // batch_size if "trainable" in summary[layer]: if summary[layer]["trainable"] == True: trainable_params += summary[layer]["nb_params"] # summary_str += line_new + "\n" # assume 4 bytes/number (float on cuda). total_input_size = abs( np.prod(sum(input_size, ())) * batch_size * 4. / (1024**2.)) total_output_size = abs(2. * total_output * 4. / (1024**2.)) # x2 for gradients total_params_size = abs(total_params * 4. / (1024**2.)) total_size = total_params_size + total_output_size + total_input_size # summary_str += "================================================================" + "\n" # summary_str += "Total params: {0:,}".format(total_params) + "\n" # summary_str += "Trainable params: {0:,}".format(trainable_params) + "\n" # summary_str += "Non-trainable params: {0:,}".format(total_params - # trainable_params) + "\n" # summary_str += "----------------------------------------------------------------" + "\n" # summary_str += "Input size (MB): %0.2f" % total_input_size + "\n" # summary_str += "Forward/backward pass size (MB): %0.2f" % total_output_size + "\n" # summary_str += "Params size (MB): %0.2f" % total_params_size + "\n" # summary_str += "Estimated Total Size (MB): %0.2f" % total_size + "\n" # summary_str += "----------------------------------------------------------------" + "\n" # return summary return total_output, (total_params.item(), trainable_params.item())
def predict(): ''' For rendering results on HTML GUI ''' feature = [] for x in request.form.values(): feature.append(x) pickle_out = open("feature.pickle", "wb") pickle.dump(feature, pickle_out) pickle_out.close() #final_features = [np.array(int_features)] #prediction = model.predict(final_features) import model model.apply() pickle_in = open("model_output.pickle", "rb") output = pickle.load(pickle_in) avail = str(output[0]) high = str(output[1]) rec = str(output[2]) low = str(output[3]) day = str(output[4]) month = int(output[5]) if (month == 1): month = "January." elif (month == 2): month = "February." elif (month == 3): month = "March." elif (month == 4): month = "April." elif (month == 5): month = "May." elif (month == 6): month = "June." elif (month == 7): month = "July." elif (month == 8): month = "August." elif (month == 9): month = "September." elif (month == 10): month = "October." elif (month == 11): month = "November." else: month = "December." day = day + ', ' + month loc = str(output[6]) avail = avail.translate({ord(i): None for i in "{}''"}) high = high.translate({ord(i): None for i in "[]''"}) rec = rec.translate({ord(i): None for i in "[]''"}) low = low.translate({ord(i): None for i in "[]''"}) #return render_template('index.html', Avail='AC: {}'.format(output[0]), High ='H: {}'.format(output[1]), avg ='A: {}'.format(output[2], low ='N: {}'.format(output[3]))) return render_template('index.html', Avail=avail, Low=low, High=high, Rec=rec, Day=day, Loc=loc)
def predictions(params, x): logits = model.apply(params, x) return jnp.argmax(logits, axis=-1)
def mean_cross_entropy(params, x, y_true): logits = model.apply(params, x) return jnp.mean(softmax_cross_entropy(logits, y_true))