| import collections
|
| import numpy as np
|
| import torch
|
| import matplotlib.pyplot as plt
|
| import time
|
| from copy import deepcopy
|
|
|
| plt.switch_backend('agg')
|
|
|
|
|
| def load_model_compile(model, model_pth, device, strict=False):
|
| model = model.to(device)
|
| origin_dict = torch.load(model_pth, map_location=device)
|
| state_dict = collections.OrderedDict()
|
| torch2_model_prefix = '_orig_mod.'
|
| offset2 = len(torch2_model_prefix)
|
| if list(origin_dict.keys())[0].startswith(torch2_model_prefix) and \
|
| not list(model.state_dict().keys())[0].startswith(torch2_model_prefix):
|
| for key, value in origin_dict.items():
|
| state_dict[key[offset2: len(key)]] = value
|
| model.load_state_dict(state_dict, strict=strict)
|
| else:
|
| model.load_state_dict(origin_dict, strict=strict)
|
| return model
|
|
|
|
|
| def remove_state_key_prefix(origin_dict, model, prefix='_orig_mod.'):
|
| if isinstance(prefix, list):
|
| for p in prefix:
|
| origin_dict = remove_state_key_prefix(origin_dict, model, prefix=p)
|
| return origin_dict
|
|
|
| if list(origin_dict.keys())[0].startswith(prefix) and \
|
| not list(model.state_dict().keys())[0].startswith(prefix):
|
| state_dict = collections.OrderedDict()
|
| offset2 = len(prefix)
|
| for key, value in origin_dict.items():
|
| state_dict[key[offset2: len(key)]] = value
|
| return state_dict
|
| else:
|
| return origin_dict
|
|
|
|
|
| def instance_norm(ts, dim):
|
| mu = ts.mean(dim, keepdims=True)
|
| ts = ts - mu
|
| var = ((ts ** 2).mean(dim, keepdims=True) + 1e-8) ** 0.5
|
| return ts / var
|
|
|
|
|
| def adjust_learning_rate(optimizer, scheduler, epoch, args, printout=True):
|
|
|
| if args.lradj == 'type1':
|
| lr_adjust = {epoch: args.learning_rate * (0.5 ** ((epoch - 1) // 1))}
|
| elif args.lradj == 'type2':
|
| lr_adjust = {
|
| 2: 5e-5, 4: 1e-5, 6: 5e-6, 8: 1e-6,
|
| 10: 5e-7, 15: 1e-7, 20: 5e-8
|
| }
|
| elif args.lradj == 'type3':
|
| lr_adjust = {epoch: args.learning_rate if epoch < 3 else args.learning_rate * (0.9 ** ((epoch - 3) // 1))}
|
| elif args.lradj == 'type4':
|
| lr_adjust = {epoch: args.learning_rate * (0.5 ** ((epoch) // 1))}
|
| elif args.lradj == 'type5':
|
| lr_adjust = {epoch: args.learning_rate if epoch < 3 else args.learning_rate * (0.95 ** ((epoch - 3) // 1))}
|
| elif args.lradj == 'every5':
|
| lr_adjust = {epoch: args.learning_rate * (0.5 ** ((epoch - 1) // 5))}
|
| elif args.lradj == 'warmup':
|
| lr_adjust = {epoch: args.learning_rate * (0.5 ** ((min(epoch, args.warmup_epochs) - 1) // 1))}
|
| elif args.lradj == 'constant':
|
| lr_adjust = {epoch: args.learning_rate}
|
| elif args.lradj == '3':
|
| lr_adjust = {epoch: args.learning_rate if epoch < 10 else args.learning_rate*0.1}
|
| elif args.lradj == '4':
|
| lr_adjust = {epoch: args.learning_rate if epoch < 15 else args.learning_rate*0.1}
|
| elif args.lradj == '5':
|
| lr_adjust = {epoch: args.learning_rate if epoch < 25 else args.learning_rate*0.1}
|
| elif args.lradj == '6':
|
| lr_adjust = {epoch: args.learning_rate if epoch < 5 else args.learning_rate*0.1}
|
| elif args.lradj == 'TST':
|
| lr_adjust = {epoch: scheduler.get_last_lr()[0]}
|
| elif args.lradj == 'Crossformer':
|
| lr_adjust = {2: args.learning_rate * 0.5 ** 1, 4: args.learning_rate * 0.5 ** 2,
|
| 6: args.learning_rate * 0.5 ** 3, 8: args.learning_rate * 0.5 ** 4,
|
| 10: args.learning_rate * 0.5 ** 5}
|
| else:
|
| lr_adjust = {}
|
|
|
| if epoch in lr_adjust.keys():
|
| lr = lr_adjust[epoch]
|
| for param_group in optimizer.param_groups:
|
| param_group['lr'] = lr
|
| if printout: print('Updating learning rate to {}'.format(lr))
|
|
|
|
|
|
|
| class EarlyStopping:
|
| def __init__(self, patience=7, verbose=False, delta=0):
|
| self.patience = patience
|
| self.verbose = verbose
|
| self.counter = 0
|
| self.best_score = None
|
| self.early_stop = False
|
| self.val_loss_min = np.Inf
|
| self.delta = delta
|
| self.best_checkpoint = None
|
|
|
| def __call__(self, val_loss, model, path):
|
| score = -val_loss
|
| if self.best_score is None:
|
| self.best_score = score
|
| self.best_checkpoint = deepcopy(model.state_dict())
|
|
|
| elif score < self.best_score + self.delta:
|
| self.counter += 1
|
| print(f'EarlyStopping counter: {self.counter} out of {self.patience}')
|
| if self.counter >= self.patience:
|
| self.early_stop = True
|
| else:
|
| self.best_score = score
|
| self.best_checkpoint = deepcopy(model.state_dict())
|
|
|
| self.counter = 0
|
|
|
| def save_checkpoint(self, val_loss, model, path):
|
| if self.verbose:
|
| print(f'Validation loss decreased ({self.val_loss_min:.6f} --> {val_loss:.6f}). Saving model ...')
|
| torch.save(model.state_dict(), path + '/' + 'checkpoint.pth')
|
| self.val_loss_min = val_loss
|
|
|
|
|
| class dotdict(dict):
|
| """dot.notation access to dictionary attributes"""
|
| __getattr__ = dict.get
|
| __setattr__ = dict.__setitem__
|
| __delattr__ = dict.__delitem__
|
|
|
|
|
| class StandardScaler():
|
| def __init__(self, mean, std):
|
| self.mean = mean
|
| self.std = std
|
|
|
| def transform(self, data):
|
| return (data - self.mean) / self.std
|
|
|
| def inverse_transform(self, data):
|
| return (data * self.std) + self.mean
|
|
|
|
|
| def visual(true, preds=None, name='./pic/test.pdf'):
|
| """
|
| Results visualization
|
| """
|
| plt.figure()
|
| plt.plot(true, label='GroundTruth', linewidth=2)
|
| if preds is not None:
|
| plt.plot(preds, label='Prediction', linewidth=2)
|
| plt.legend()
|
| plt.savefig(name, bbox_inches='tight')
|
|
|
| def test_params_flop(model, x_shape, x=None):
|
| from thop import profile, clever_format
|
| import torch
|
|
|
|
|
| if x is None:
|
| x = torch.randn(*x_shape)
|
|
|
|
|
| flops, params = profile(model, inputs=(x,), verbose=False)
|
| flops, params = clever_format([flops, params], "%.3f")
|
|
|
| print(f'FLOPS: {flops}')
|
|
|
|
|
| model_params = sum(p.numel() for p in model.parameters())
|
| trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
|
|
|
| print(f'Model parameter count: {model_params}')
|
| print(f'Trainable parameter count: {trainable_params}')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
