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))
