def __init__(self):
self.best_step = sys.maxsize
self.sols = {}
self.solsSum = {}
self.hidden_size = 50
self.lr = 0.01
self.activation_hidden = 'relu6'
self.activation_output = 'sigmoid'
self.activations = {
'sigmoid': nn.Sigmoid(),
'relu': nn.ReLU(),
'relu6': nn.ReLU6(),
'rrelu0103': nn.RReLU(0.1, 0.3),
'rrelu0205': nn.RReLU(0.2, 0.5),
'htang1': nn.Hardtanh(-1, 1),
'htang2': nn.Hardtanh(-2, 2),
'htang3': nn.Hardtanh(-3, 3),
'tanh': nn.Tanh(),
'elu': nn.ELU(),
'selu': nn.SELU(),
'hardshrink': nn.Hardshrink(),
'leakyrelu01': nn.LeakyReLU(0.1),
'leakyrelu001': nn.LeakyReLU(0.01),
'logsigmoid': nn.LogSigmoid(),
'prelu': nn.PReLU(),
}
self.hidden_size_grid = [16, 20, 26, 32, 36, 40, 45, 50, 54]
self.lr_grid = [0.0001, 0.001, 0.005, 0.01, 0.1, 1]
# self.lr_grid = [0.1, .5, 1, 1.5, 2, 3, 5, 10]
# self.activation_hidden_grid = list(self.activations.keys())
# self.activation_output_grid = list(self.activations.keys())
self.grid_search = GridSearch(self)
self.grid_search.set_enabled(False)
def __init__(self):
self = self
self.best_step = 1000
self.activations = {
'sigmoid': nn.Sigmoid(),
'relu': nn.ReLU(),
'rrelu0103': nn.RReLU(0.1, 0.3),
'elu': nn.ELU(),
'selu': nn.SELU(),
'leakyrelu01': nn.LeakyReLU(0.1)
}
self.learning_rate = 0.003
self.momentum = 0.8
self.layers_number = 5
self.hidden_size = 50
self.activation_hidden = 'relu'
self.activation_output = 'sigmoid'
self.do_batch_norm = True
self.sols = {}
self.solsSum = {}
self.random = 0
#self.do_batch_norm_grid = [False, True]
self.random_grid = [_ for _ in range(10)]
#self.layers_number_grid = [3, 4, 5, 6, 7, 8, 9, 10]
#self.hidden_size_grid = [10, 20, 30, 40, 50]
self.momentum_grid = [0.0, 0.3, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
#self.learning_rate_grid = [0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009, 0.01]
#self.activation_hidden_grid = self.activations.keys()
#self.activation_output_grid = self.activations.keys()
self.grid_search = GridSearch(self)
self.grid_search.set_enabled(False)
def __init__(self):
self.value_fun = np.load(os.path.join(os.path.dirname(__file__), "mdp_value_without_5.npy"))
self.gamma = 0.95 # 每份时间的折现率
self.alpha1 = 0.5 # value_fun权重
self.BASETIME = 946670400 # 2020.1.1 04:00:00
self.dispatch_frequency_gap = 300 # 以5分钟为时间间隔
self.grid_search = GridSearch()
def grid_search_xgboost(param, tuning_param, X_train, X_test, y_train, y_test):
xgb_model = xgb.XGBRegressor()
xgb_model.set_params(**param)
gs = GridSearch(xgb_model, tuning_param, verbose=1)
gs.fit(X_train, X_test, y_train, y_test)
return gs
def grid_search_xgboost(param, tuning_param, X_train, X_test, y_train, y_test):
xgb_model = xgb.XGBRegressor()
xgb_model.set_params(**param)
gs = GridSearch(xgb_model, tuning_param, verbose=1)
gs.fit(X_train, X_test, y_train, y_test)
return gs
class Solution():
def __init__(self):
self.lr = 1.2
self.lr_grid = [0.01, 0.1, 1.0, 10.0, 100.0]
self.hidden_size = 16
self.hidden_size_grid = [1, 2, 3, 5, 7, 9, 11, 13, 15, 17, 19]
self.grid_search = GridSearch(self).set_enabled(False)
def create_model(self, input_size, output_size):
return SolutionModel(input_size, output_size, self.hidden_size)
# Return number of steps used
def train_model(self, model, train_data, train_target, context):
step = 0
# Put model in train mode
model.train()
while True:
time_left = context.get_timer().get_time_left()
# No more time left, stop training
if time_left < 0.1:
break
sm.SolutionManager.print_hint(
"Hint[2]: Learning rate is too small", step)
optimizer = optim.SGD(model.parameters(), lr=self.lr)
data = train_data
target = train_target
# model.parameters()...gradient set to zero
optimizer.zero_grad()
# evaluate model => model.forward(data)
output = model(data)
# if x < 0.5 predict 0 else predict 1
predict = output.round()
# Number of correct predictions
correct = predict.eq(target.view_as(predict)).long().sum().item()
# Total number of needed predictions
total = target.view(-1).size(0)
if correct == total:
break
# calculate loss
loss = ((output - target)**2).sum()
self.grid_search.log_step_value('loss', loss.item(), step)
# calculate deriviative of model.forward() and put it in model.parameters()...gradient
loss.backward()
# print progress of the learning
self.print_stats(step, loss, correct, total)
# update model: model.parameters() -= lr * gradient
optimizer.step()
step += 1
return step
def print_stats(self, step, loss, correct, total):
if step % 1000 == 0:
print("Step = {} Prediction = {}/{} Error = {}".format(
step, correct, total, loss.item()))
def __init__(self,ncfile,xpt=None,ypt=None,Npt=100,klayer=[-99],**kwargs):
self.Npt=Npt
Spatial.__init__(self,ncfile,klayer=klayer,**kwargs)
# Load the grid as a hybridgrid
self.grd = GridSearch(self.xp,self.yp,self.cells,nfaces=self.nfaces,\
edges=self.edges,mark=self.mark,grad=self.grad,neigh=self.neigh,\
xv=self.xv,yv=self.yv)
# Find the edge indices along the line
self.update_xy(xpt,ypt)
def __init__(self):
# best so far - lr 1.5, hs 15, layers 3
self = self
self.layers_number = 3
self.lr = 1.5
self.hidden_size = 15
self.momentum = 0.8
self.activation_hidden = 'relu6'
self.activation_output = 'sigmoid'
self.do_batch_norm = True
self.lr_grid = [1.25,1.27, 1.29, 1.3,1.31, 1.32, 1.34]
self.hidden_size_grid = [12,13,14,15,16,17]
#self.momentum_grid = [0.0, 0.3, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
self.activations = {
'sigmoid': nn.Sigmoid(),
'relu': nn.ReLU(),
'relu6': nn.ReLU6(),
'rrelu0103': nn.RReLU(0.1, 0.3),
'elu': nn.ELU(),
'selu': nn.SELU(),
'leakyrelu01': nn.LeakyReLU(0.1)
}
#self.do_batch_norm_grid = [False, True]
#self.activation_hidden_grid = self.activations.keys()
#self.activation_output_grid = self.activations.keys()
self.grid_search = GridSearch(self).set_enabled(DoGridSearch)
def __init__(self):
self.lr = 0.08
#self.lr_grid = [0.6,0.65,0.7,0.75,1.0,2.0, 5, 10]
self.lr_grid = [0.05, 0.07, 0.08, 0.09, 0.1, 0.11, 0.12, 0.13, 0.14]
self.hidden_size = 39
#self.hidden_size_grid = [40,50,55,58,60,61,62,63,64,65]
self.hidden_size_grid = [28, 32, 34, 35, 36, 37, 38, 39, 45, 50]
self.grid_search = GridSearch(self).set_enabled(False)
def __call__(self,X,Y,Z,data,update=True):
if update:
# The Update the cell index using GridSearch class
if not self.__dict__.has_key('cellind'):
GridSearch.__call__(self,X,Y)
else:
if np.sum(np.abs(X-self.xpt))>0+1e-8:
self.updatexy(X,Y)
# Return the nearest data point (... for now)
if self.method == 'nearest':
dataout = data[self.cellind]
#if self.method == 'linear':
# dataout = self.lininterp(X,Y,Z,data,kind)
# Mask bogey points
dataout[self.cellind==-1]=0.0
return dataout
def __init__(self):
# best so far - lr 5(1), hs 32(25), layers 3 5/32
self = self
self.lr = 5
self.hidden_size = 64
self.momentum = 0.5
self.init_type = 'uniform'
self.do_batch_init = False
self.do_batch_norm = True
self.batch_size = 256
self.lr_grid = [0.01, 1, 5, 10, 12]
self.hidden_size_grid = [50, 64, 72, 100, 128]
#self.momentum_grid = [0.0, 0.3, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
self.grid_search = GridSearch(self).set_enabled(DoGridSearch)
def __init__(self,x,y,z,cells,nfaces,mask,method='nearest',grdfile=None):
self.method=method
# Initialise the trisearch array
GridSearch.__init__(self,x,y,cells,nfaces=nfaces,force_inside=True)
if self.method == 'linear':
Grid.__init__(self,grdfile)
self.datatmp = np.zeros(mask.shape,dtype=np.double)
self.z = np.sort(z)
self.z[-1]=10.0 # Set the surface layer to large
self.Nkmax = z.size-1
self.mask3d = mask
self.maskindex = -1*np.ones(self.mask3d.shape,dtype=np.int32)
rr=0
for ii in range(self.mask3d.shape[0]):
for jj in range(self.mask3d.shape[1]):
if self.mask3d[ii,jj]:
self.maskindex[ii,jj]=rr
rr+=1
def __call__(self,X,Y,Z,data,update=True):
if update:
# The Update the cell index using TriSearch class
if not self.__dict__.has_key('cellind'):
#print ' Finding initial particle index...'
GridSearch.__call__(self,X,Y)
else:
if np.sum(np.abs(X-self.xpt))>0+1e-8:
#print ' updating location index...'
self.updatexy(X,Y)
# Find the k-index
kind=self.z.searchsorted(Z)
kind = self.Nkmax - kind
kind[kind>=self.Nkmax-1] = self.Nkmax-1
ind = self.maskindex[kind,self.cellind]
#maskpts = self.mask3d[kind,self.cellind]
#if np.sum(maskpts==False)>10:
# pdb.set_trace()
#
#ind[maskpts == False] = 0
# Return the nearest data point (... for now)
if self.method == 'nearest':
dataout = data[ind]
if self.method == 'linear':
dataout = self.lininterp(X,Y,Z,data,kind)
# Mask bogey points
#dataout[maskpts==False]=0.0
dataout[ind==-1]=0 # these are the masked points
dataout[self.cellind==-1]=0.0
return dataout
def __init__(self):
self.best_step = 1000
self.activations = {
'sigmoid': nn.Sigmoid(),
'custom': self.custom,
'relu': nn.ReLU(),
'relu6': nn.ReLU6(),
'rrelu0103': nn.RReLU(0.1, 0.3),
'rrelu0205': nn.RReLU(0.2, 0.5),
'htang1': nn.Hardtanh(-1, 1),
'htang2': nn.Hardtanh(-2, 2),
'htang3': nn.Hardtanh(-3, 3),
'tanh': nn.Tanh(),
'elu': nn.ELU(),
'selu': nn.SELU(),
'hardshrink': nn.Hardshrink(),
'leakyrelu01': nn.LeakyReLU(0.1),
'leakyrelu001': nn.LeakyReLU(0.01),
'logsigmoid': nn.LogSigmoid(),
'prelu': nn.PReLU(),
}
self.learning_rate = 1.0
self.hidden_size = 11
self.activation_hidden = 'relu'
self.activation_output = 'sigmoid'
self.sols = {}
self.solsSum = {}
self.random = 0
self.random_grid = [_ for _ in range(10)]
self.hidden_size_grid = [3, 5, 7, 11]
self.learning_rate_grid = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]
#self.learning_rate_grid = [1.0 + i/100.0 for i in range(10)]
self.activation_hidden_grid = self.activations.keys()
#self.activation_output_grid = self.activations.keys()
self.grid_search = GridSearch(self)
self.grid_search.set_enabled(True)
def __init__(self):
self.learning_rate = 0.2
self.momentum = 0.8
self.signal_count = 3
self.batch_size = 128
self.init_type = 'uniform'
self.rand_function_hidden_size = 28
self.rand_function_layers_count = 5
self.compare_hidden_size = 28
self.compare_layers_count = 1
self.clip_grad_limit = 100.0
self.rand_seed = 1
self.rand_seed_grid = [i for i in range(10)]
self.grid_search = GridSearch(self).set_enabled(False)
Debug.set_enabled(False)
def main(argv=None):
tstart = time.time()
# Arguments
parser = argparse.ArgumentParser(
description=
'FACIL - Framework for Analysis of Class Incremental Learning')
# miscellaneous args
parser.add_argument('--gpu',
type=int,
default=0,
help='GPU (default=%(default)s)')
parser.add_argument('--results-path',
type=str,
default='../results',
help='Results path (default=%(default)s)')
parser.add_argument('--exp-name',
default=None,
type=str,
help='Experiment name (default=%(default)s)')
parser.add_argument('--seed',
type=int,
default=0,
help='Random seed (default=%(default)s)')
parser.add_argument(
'--log',
default=['disk'],
type=str,
choices=['disk', 'tensorboard'],
help='Loggers used (disk, tensorboard) (default=%(default)s)',
nargs='*',
metavar="LOGGER")
parser.add_argument('--save-models',
action='store_true',
help='Save trained models (default=%(default)s)')
parser.add_argument('--last-layer-analysis',
action='store_true',
help='Plot last layer analysis (default=%(default)s)')
parser.add_argument(
'--no-cudnn-deterministic',
action='store_true',
help='Disable CUDNN deterministic (default=%(default)s)')
# dataset args
parser.add_argument('--datasets',
default=['cifar100'],
type=str,
choices=list(dataset_config.keys()),
help='Dataset or datasets used (default=%(default)s)',
nargs='+',
metavar="DATASET")
parser.add_argument(
'--num-workers',
default=4,
type=int,
required=False,
help=
'Number of subprocesses to use for dataloader (default=%(default)s)')
parser.add_argument(
'--pin-memory',
default=False,
type=bool,
required=False,
help=
'Copy Tensors into CUDA pinned memory before returning them (default=%(default)s)'
)
parser.add_argument(
'--batch-size',
default=64,
type=int,
required=False,
help='Number of samples per batch to load (default=%(default)s)')
parser.add_argument(
'--num-tasks',
default=4,
type=int,
required=False,
help='Number of tasks per dataset (default=%(default)s)')
parser.add_argument(
'--nc-first-task',
default=None,
type=int,
required=False,
help='Number of classes of the first task (default=%(default)s)')
parser.add_argument(
'--use-valid-only',
action='store_true',
help='Use validation split instead of test (default=%(default)s)')
parser.add_argument(
'--stop-at-task',
default=0,
type=int,
required=False,
help='Stop training after specified task (default=%(default)s)')
# model args
parser.add_argument('--network',
default='resnet32',
type=str,
choices=allmodels,
help='Network architecture used (default=%(default)s)',
metavar="NETWORK")
parser.add_argument(
'--keep-existing-head',
action='store_true',
help='Disable removing classifier last layer (default=%(default)s)')
parser.add_argument('--pretrained',
action='store_true',
help='Use pretrained backbone (default=%(default)s)')
# training args
parser.add_argument('--approach',
default='finetuning',
type=str,
choices=approach.__all__,
help='Learning approach used (default=%(default)s)',
metavar="APPROACH")
parser.add_argument(
'--nepochs',
default=200,
type=int,
required=False,
help='Number of epochs per training session (default=%(default)s)')
parser.add_argument('--lr',
default=0.1,
type=float,
required=False,
help='Starting learning rate (default=%(default)s)')
parser.add_argument('--lr-min',
default=1e-4,
type=float,
required=False,
help='Minimum learning rate (default=%(default)s)')
parser.add_argument(
'--lr-factor',
default=3,
type=float,
required=False,
help='Learning rate decreasing factor (default=%(default)s)')
parser.add_argument(
'--lr-patience',
default=5,
type=int,
required=False,
help=
'Maximum patience to wait before decreasing learning rate (default=%(default)s)'
)
parser.add_argument('--clipping',
default=10000,
type=float,
required=False,
help='Clip gradient norm (default=%(default)s)')
parser.add_argument('--momentum',
default=0.0,
type=float,
required=False,
help='Momentum factor (default=%(default)s)')
parser.add_argument('--weight-decay',
default=0.0,
type=float,
required=False,
help='Weight decay (L2 penalty) (default=%(default)s)')
parser.add_argument('--warmup-nepochs',
default=0,
type=int,
required=False,
help='Number of warm-up epochs (default=%(default)s)')
parser.add_argument(
'--warmup-lr-factor',
default=1.0,
type=float,
required=False,
help='Warm-up learning rate factor (default=%(default)s)')
parser.add_argument(
'--multi-softmax',
action='store_true',
help='Apply separate softmax for each task (default=%(default)s)')
parser.add_argument(
'--fix-bn',
action='store_true',
help='Fix batch normalization after first task (default=%(default)s)')
parser.add_argument(
'--eval-on-train',
action='store_true',
help='Show train loss and accuracy (default=%(default)s)')
# gridsearch args
parser.add_argument(
'--gridsearch-tasks',
default=-1,
type=int,
help=
'Number of tasks to apply GridSearch (-1: all tasks) (default=%(default)s)'
)
# Args -- Incremental Learning Framework
args, extra_args = parser.parse_known_args(argv)
args.results_path = os.path.expanduser(args.results_path)
base_kwargs = dict(nepochs=args.nepochs,
lr=args.lr,
lr_min=args.lr_min,
lr_factor=args.lr_factor,
lr_patience=args.lr_patience,
clipgrad=args.clipping,
momentum=args.momentum,
wd=args.weight_decay,
multi_softmax=args.multi_softmax,
wu_nepochs=args.warmup_nepochs,
wu_lr_factor=args.warmup_lr_factor,
fix_bn=args.fix_bn,
eval_on_train=args.eval_on_train)
if args.no_cudnn_deterministic:
print('WARNING: CUDNN Deterministic will be disabled.')
utils.cudnn_deterministic = False
utils.seed_everything(seed=args.seed)
print('=' * 108)
print('Arguments =')
for arg in np.sort(list(vars(args).keys())):
print('\t' + arg + ':', getattr(args, arg))
print('=' * 108)
# Args -- CUDA
if torch.cuda.is_available():
torch.cuda.set_device(args.gpu)
device = 'cuda'
else:
print('WARNING: [CUDA unavailable] Using CPU instead!')
device = 'cpu'
# Multiple gpus
# if torch.cuda.device_count() > 1:
# self.C = torch.nn.DataParallel(C)
# self.C.to(self.device)
####################################################################################################################
# Args -- Network
from networks.network import LLL_Net
if args.network in tvmodels: # torchvision models
tvnet = getattr(importlib.import_module(name='torchvision.models'),
args.network)
if args.network == 'googlenet':
init_model = tvnet(pretrained=args.pretrained, aux_logits=False)
else:
init_model = tvnet(pretrained=args.pretrained)
set_tvmodel_head_var(init_model)
else: # other models declared in networks package's init
net = getattr(importlib.import_module(name='networks'), args.network)
# WARNING: fixed to pretrained False for other model (non-torchvision)
init_model = net(pretrained=False)
# Args -- Continual Learning Approach
from approach.incremental_learning import Inc_Learning_Appr
Appr = getattr(importlib.import_module(name='approach.' + args.approach),
'Appr')
assert issubclass(Appr, Inc_Learning_Appr)
appr_args, extra_args = Appr.extra_parser(extra_args)
print('Approach arguments =')
for arg in np.sort(list(vars(appr_args).keys())):
print('\t' + arg + ':', getattr(appr_args, arg))
print('=' * 108)
# Args -- Exemplars Management
from datasets.exemplars_dataset import ExemplarsDataset
Appr_ExemplarsDataset = Appr.exemplars_dataset_class()
if Appr_ExemplarsDataset:
assert issubclass(Appr_ExemplarsDataset, ExemplarsDataset)
appr_exemplars_dataset_args, extra_args = Appr_ExemplarsDataset.extra_parser(
extra_args)
print('Exemplars dataset arguments =')
for arg in np.sort(list(vars(appr_exemplars_dataset_args).keys())):
print('\t' + arg + ':', getattr(appr_exemplars_dataset_args, arg))
print('=' * 108)
else:
appr_exemplars_dataset_args = argparse.Namespace()
# Args -- GridSearch
if args.gridsearch_tasks > 0:
from gridsearch import GridSearch
gs_args, extra_args = GridSearch.extra_parser(extra_args)
Appr_finetuning = getattr(
importlib.import_module(name='approach.finetuning'), 'Appr')
assert issubclass(Appr_finetuning, Inc_Learning_Appr)
GridSearch_ExemplarsDataset = Appr.exemplars_dataset_class()
print('GridSearch arguments =')
for arg in np.sort(list(vars(gs_args).keys())):
print('\t' + arg + ':', getattr(gs_args, arg))
print('=' * 108)
assert len(extra_args) == 0, "Unused args: {}".format(' '.join(extra_args))
####################################################################################################################
# Log all arguments
full_exp_name = reduce(
(lambda x, y: x[0] + y[0]),
args.datasets) if len(args.datasets) > 0 else args.datasets[0]
full_exp_name += '_' + args.approach
if args.exp_name is not None:
full_exp_name += '_' + args.exp_name
logger = MultiLogger(args.results_path,
full_exp_name,
loggers=args.log,
save_models=args.save_models)
logger.log_args(
argparse.Namespace(**args.__dict__, **appr_args.__dict__,
**appr_exemplars_dataset_args.__dict__))
# Loaders
utils.seed_everything(seed=args.seed)
trn_loader, val_loader, tst_loader, taskcla = get_loaders(
args.datasets,
args.num_tasks,
args.nc_first_task,
args.batch_size,
num_workers=args.num_workers,
pin_memory=args.pin_memory)
# Apply arguments for loaders
if args.use_valid_only:
tst_loader = val_loader
max_task = len(taskcla) if args.stop_at_task == 0 else args.stop_at_task
# Network and Approach instances
utils.seed_everything(seed=args.seed)
net = LLL_Net(init_model, remove_existing_head=not args.keep_existing_head)
utils.seed_everything(seed=args.seed)
# taking transformations and class indices from first train dataset
first_train_ds = trn_loader[0].dataset
transform, class_indices = first_train_ds.transform, first_train_ds.class_indices
appr_kwargs = {**base_kwargs, **dict(logger=logger, **appr_args.__dict__)}
if Appr_ExemplarsDataset:
appr_kwargs['exemplars_dataset'] = Appr_ExemplarsDataset(
transform, class_indices, **appr_exemplars_dataset_args.__dict__)
utils.seed_everything(seed=args.seed)
appr = Appr(net, device, **appr_kwargs)
# GridSearch
if args.gridsearch_tasks > 0:
ft_kwargs = {
**base_kwargs,
**dict(logger=logger,
exemplars_dataset=GridSearch_ExemplarsDataset(
transform, class_indices))
}
appr_ft = Appr_finetuning(net, device, **ft_kwargs)
gridsearch = GridSearch(appr_ft, args.seed, gs_args.gridsearch_config,
gs_args.gridsearch_acc_drop_thr,
gs_args.gridsearch_hparam_decay,
gs_args.gridsearch_max_num_searches)
# Loop tasks
print(taskcla)
acc_taw = np.zeros((max_task, max_task))
acc_tag = np.zeros((max_task, max_task))
forg_taw = np.zeros((max_task, max_task))
forg_tag = np.zeros((max_task, max_task))
for t, (_, ncla) in enumerate(taskcla):
# Early stop tasks if flag
if t >= max_task:
continue
print('*' * 108)
print('Task {:2d}'.format(t))
print('*' * 108)
# Add head for current task
net.add_head(taskcla[t][1])
net.to(device)
# GridSearch
if t < args.gridsearch_tasks:
# Search for best finetuning learning rate -- Maximal Plasticity Search
print('LR GridSearch')
best_ft_acc, best_ft_lr = gridsearch.search_lr(
appr.model, t, trn_loader[t], val_loader[t])
# Apply to approach
appr.lr = best_ft_lr
gen_params = gridsearch.gs_config.get_params('general')
for k, v in gen_params.items():
if not isinstance(v, list):
setattr(appr, k, v)
# Search for best forgetting/intransigence tradeoff -- Stability Decay
print('Trade-off GridSearch')
best_tradeoff, tradeoff_name = gridsearch.search_tradeoff(
args.approach, appr, t, trn_loader[t], val_loader[t],
best_ft_acc)
# Apply to approach
if tradeoff_name is not None:
setattr(appr, tradeoff_name, best_tradeoff)
print('-' * 108)
# Train
appr.train(t, trn_loader[t], val_loader[t])
print('-' * 108)
# Test
for u in range(t + 1):
test_loss, acc_taw[t, u], acc_tag[t,
u] = appr.eval(u, tst_loader[u])
if u < t:
forg_taw[t, u] = acc_taw[:t, u].max(0) - acc_taw[t, u]
forg_tag[t, u] = acc_tag[:t, u].max(0) - acc_tag[t, u]
print(
'>>> Test on task {:2d} : loss={:.3f} | TAw acc={:5.1f}%, forg={:5.1f}%'
'| TAg acc={:5.1f}%, forg={:5.1f}% <<<'.format(
u, test_loss, 100 * acc_taw[t, u], 100 * forg_taw[t, u],
100 * acc_tag[t, u], 100 * forg_tag[t, u]))
logger.log_scalar(task=t,
iter=u,
name='loss',
group='test',
value=test_loss)
logger.log_scalar(task=t,
iter=u,
name='acc_taw',
group='test',
value=100 * acc_taw[t, u])
logger.log_scalar(task=t,
iter=u,
name='acc_tag',
group='test',
value=100 * acc_tag[t, u])
logger.log_scalar(task=t,
iter=u,
name='forg_taw',
group='test',
value=100 * forg_taw[t, u])
logger.log_scalar(task=t,
iter=u,
name='forg_tag',
group='test',
value=100 * forg_tag[t, u])
# Save
print('Save at ' + os.path.join(args.results_path, full_exp_name))
logger.log_result(acc_taw, name="acc_taw", step=t)
logger.log_result(acc_tag, name="acc_tag", step=t)
logger.log_result(forg_taw, name="forg_taw", step=t)
logger.log_result(forg_tag, name="forg_tag", step=t)
logger.save_model(net.state_dict(), task=t)
logger.log_result(acc_taw.sum(1) /
np.tril(np.ones(acc_taw.shape[0])).sum(1),
name="avg_accs_taw",
step=t)
logger.log_result(acc_tag.sum(1) /
np.tril(np.ones(acc_tag.shape[0])).sum(1),
name="avg_accs_tag",
step=t)
aux = np.tril(
np.repeat([[tdata[1] for tdata in taskcla[:max_task]]],
max_task,
axis=0))
logger.log_result((acc_taw * aux).sum(1) / aux.sum(1),
name="wavg_accs_taw",
step=t)
logger.log_result((acc_tag * aux).sum(1) / aux.sum(1),
name="wavg_accs_tag",
step=t)
# Last layer analysis
if args.last_layer_analysis:
weights, biases = last_layer_analysis(net.heads,
t,
taskcla,
y_lim=True)
logger.log_figure(name='weights', iter=t, figure=weights)
logger.log_figure(name='bias', iter=t, figure=biases)
# Output sorted weights and biases
weights, biases = last_layer_analysis(net.heads,
t,
taskcla,
y_lim=True,
sort_weights=True)
logger.log_figure(name='weights', iter=t, figure=weights)
logger.log_figure(name='bias', iter=t, figure=biases)
# Print Summary
utils.print_summary(acc_taw, acc_tag, forg_taw, forg_tag)
print('[Elapsed time = {:.1f} h]'.format(
(time.time() - tstart) / (60 * 60)))
print('Done!')
return acc_taw, acc_tag, forg_taw, forg_tag, logger.exp_path
class Solution():
def htanh02(self, x):
return nn.Hardtanh(-0.2, 0.2)(x)
def custom(self, x):
return self.htanh02(0.72 * x) + self.htanh02(0.27 * x) + self.htanh02(
0.2 * x) + self.htanh02(0.2 * x) + self.htanh02(0.1 * x) + 0.2 * x
def __init__(self):
self.best_step = 1000
self.activations = {
'sigmoid': nn.Sigmoid(),
'custom': self.custom,
'relu': nn.ReLU(),
'relu6': nn.ReLU6(),
'rrelu0103': nn.RReLU(0.1, 0.3),
'rrelu0205': nn.RReLU(0.2, 0.5),
'htang1': nn.Hardtanh(-1, 1),
'htang2': nn.Hardtanh(-2, 2),
'htang3': nn.Hardtanh(-3, 3),
'tanh': nn.Tanh(),
'elu': nn.ELU(),
'selu': nn.SELU(),
'hardshrink': nn.Hardshrink(),
'leakyrelu01': nn.LeakyReLU(0.1),
'leakyrelu001': nn.LeakyReLU(0.01),
'logsigmoid': nn.LogSigmoid(),
'prelu': nn.PReLU(),
}
self.learning_rate = 1.0
self.hidden_size = 11
self.activation_hidden = 'relu'
self.activation_output = 'sigmoid'
self.sols = {}
self.solsSum = {}
self.random = 0
self.random_grid = [_ for _ in range(10)]
self.hidden_size_grid = [3, 5, 7, 11]
self.learning_rate_grid = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]
#self.learning_rate_grid = [1.0 + i/100.0 for i in range(10)]
self.activation_hidden_grid = self.activations.keys()
#self.activation_output_grid = self.activations.keys()
self.grid_search = GridSearch(self)
self.grid_search.set_enabled(True)
def create_model(self, input_size, output_size):
return SolutionModel(input_size, output_size, self)
# Return number of steps used
def train_model(self, model, train_data, train_target, context):
step = 0
# Put model in train mode
model.train()
while True:
time_left = context.get_timer().get_time_left()
# No more time left, stop training
key = "{}_{}_{}_{}".format(self.learning_rate, self.hidden_size,
self.activation_hidden,
self.activation_output)
# Speed up search
if time_left < 0.1 or (self.grid_search.enabled and step > 40):
if not key in self.sols:
self.sols[key] = 0
self.solsSum[key] = 0
self.sols[key] += 1
self.solsSum[key] += step
self.sols[key] = -1
break
if key in self.sols and self.sols[key] == -1:
break
optimizer = optim.SGD(model.parameters(), lr=self.learning_rate)
data = train_data
target = train_target
# model.parameters()...gradient set to zero
optimizer.zero_grad()
# evaluate model => model.forward(data)
output = model(data)
# if x < 0.5 predict 0 else predict 1
predict = output.round()
# Number of correct predictions
correct = predict.eq(target.view_as(predict)).long().sum().item()
# Total number of needed predictions
total = target.view(-1).size(0)
if correct == total:
if not key in self.sols:
self.sols[key] = 0
self.solsSum[key] = 0
self.sols[key] += 1
self.solsSum[key] += step
#if self.sols[key] > 1:
# print("Key = {} Avg = {:.2f} Ins = {}".format(key, float(self.solsSum[key])/self.sols[key], self.sols[key]))
if self.sols[key] == len(self.random_grid):
#self.best_step = step
print(
"Learning rate = {} Hidden size = {} Activation hidden = {} Activation output = {} Steps = {}"
.format(self.learning_rate, self.hidden_size,
self.activation_hidden, self.activation_output,
step))
print("{:.4f}".format(
float(self.solsSum[key]) / self.sols[key]))
break
# calculate loss
loss = ((output - target)**2).sum()
# calculate deriviative of model.forward() and put it in model.parameters()...gradient
loss.backward()
# print progress of the learning
#self.print_stats(step, loss, correct, total)
# update model: model.parameters() -= lr * gradient
optimizer.step()
step += 1
return step
def print_stats(self, step, loss, correct, total):
if step % 1000 == 0:
print("Step = {} Prediction = {}/{} Error = {}".format(
step, correct, total, loss.item()))
parameters['hidden_nodes'] = [10,12,14,16,18,20,22,24] parameters['learning_rate'] = [0.01, 0.04, 0.03, 0.02, 0.05, 0.005, 0.001] parameters['dropout'] = [0,.1, .2, .3, .4, .5] parameters['iters'] = [200,1000,2000,3000,4000,5000] # In[132]: parameters # In[133]: g = GridSearch(NeuralNetwork, MSE, train_features, train_targets, val_features, val_targets) g.run(parameters) # In[134]: g.final_parameters # In[136]: import sys ### Set the hyperparameters here ###
def __init__(self):
self.lr = 1.2
self.lr_grid = [0.01, 0.1, 1.0, 10.0, 100.0]
self.hidden_size = 16
self.hidden_size_grid = [1, 2, 3, 5, 7, 9, 11, 13, 15, 17, 19]
self.grid_search = GridSearch(self).set_enabled(False)
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 1 15:53:46 2019
@author: rrameshbabu6
"""
from gridsearch import GridSearch
from prepare_data import scale_data
from prepare_sensor_data import load_data, scale_sensor_data
import pickle as p
# load dataset
roboBoat_gridsearch = GridSearch(n_epochs=[100],
n_nodes=[100, 150, 250, 500, 750, 1000],
n_hidden_layers=[1],
n_input=[3],
dropout=[1],
time_series=True,
n_batch=[100])
train_file = 'train.json'
test_file = 'test.json'
train_samples = load_data(train_file)
test_samples = load_data(test_file)
train_samples = train_samples[0:15000, :]
test_samples = test_samples[0:5000, :]
# transform the scale of the data
scaler, train_scaled, test_scaled = scale_sensor_data(train_samples,
class Solution():
def __init__(self):
self.best_step = sys.maxsize
self.sols = {}
self.solsSum = {}
self.hidden_size = 50
self.lr = 0.01
self.activation_hidden = 'relu6'
self.activation_output = 'sigmoid'
self.activations = {
'sigmoid': nn.Sigmoid(),
'relu': nn.ReLU(),
'relu6': nn.ReLU6(),
'rrelu0103': nn.RReLU(0.1, 0.3),
'rrelu0205': nn.RReLU(0.2, 0.5),
'htang1': nn.Hardtanh(-1, 1),
'htang2': nn.Hardtanh(-2, 2),
'htang3': nn.Hardtanh(-3, 3),
'tanh': nn.Tanh(),
'elu': nn.ELU(),
'selu': nn.SELU(),
'hardshrink': nn.Hardshrink(),
'leakyrelu01': nn.LeakyReLU(0.1),
'leakyrelu001': nn.LeakyReLU(0.01),
'logsigmoid': nn.LogSigmoid(),
'prelu': nn.PReLU(),
}
self.hidden_size_grid = [16, 20, 26, 32, 36, 40, 45, 50, 54]
self.lr_grid = [0.0001, 0.001, 0.005, 0.01, 0.1, 1]
# self.lr_grid = [0.1, .5, 1, 1.5, 2, 3, 5, 10]
# self.activation_hidden_grid = list(self.activations.keys())
# self.activation_output_grid = list(self.activations.keys())
self.grid_search = GridSearch(self)
self.grid_search.set_enabled(False)
def create_model(self, input_size, output_size):
return SolutionModel(input_size, output_size, self)
# Return number of steps used
def train_model(self, model, train_data, train_target, context):
step = 0
# Put model in train mode
model.train()
criterion = F.binary_cross_entropy
# optimizer = optim.SGD(model.parameters(), lr=model.lr, momentum=0.9)
optimizer = optim.Adam(model.parameters(), lr=model.lr)
while True:
time_left = context.get_timer().get_time_left()
key = "{}_{}_{}_{}".format(self.lr, self.hidden_size, self.activation_hidden, self.activation_output)
# No more time left, stop training
if time_left < 0.1 or (model.solution.grid_search.enabled and step > 100):
if not key in self.sols:
self.sols[key] = 0
self.solsSum[key] = 0
self.sols[key] += 1
self.solsSum[key] += step
self.sols[key] = -1
break
if key in self.sols and self.sols[key] == -1:
break
data = train_data
target = train_target
# model.parameters()...gradient set to zero
optimizer.zero_grad()
# evaluate model => model.forward(data)
output = model(data)
# if x < 0.5 predict 0 else predict 1
predict = output.round()
# Number of correct predictions
correct = predict.eq(target.view_as(predict)).long().sum().item()
# Total number of needed predictions
total = target.view(-1).size(0)
if total == correct:
if not key in self.sols:
self.sols[key] = 0
self.solsSum[key] = 0
self.sols[key] += 1
self.solsSum[key] += step
if step < 21:
self.best_step = step
loss = criterion(output, target)
self.print_stats(step, loss, correct, total, model)
print("{:.4f}".format(float(self.solsSum[key])/self.sols[key]))
return step
# calculate loss
loss = criterion(output, target)
# calculate deriviative of model.forward() and put it in model.parameters()...gradient
loss.backward()
# update model: model.parameters() -= lr * gradient
optimizer.step()
step += 1
return step
def print_stats(self, step, loss, correct, total, model):
print("LR={}, HS={}, ActivHidden={}, ActivOut={}, Step = {} Prediction = {}/{} Error = {}".format(model.lr,
model.hidden_size, model.activation_hidden, model.activation_output, step, correct, total, loss.item()))
class SliceEdge(Slice):
"""
Slice suntans edge-based data at all edges near a line
Used for e.g. flux calculations along a profile
"""
edgemethod=1
def __init__(self,ncfile,xpt=None,ypt=None,Npt=100,klayer=[-99],**kwargs):
self.Npt=Npt
Spatial.__init__(self,ncfile,klayer=klayer,**kwargs)
# Load the grid as a hybridgrid
self.grd = GridSearch(self.xp,self.yp,self.cells,nfaces=self.nfaces,\
edges=self.edges,mark=self.mark,grad=self.grad,neigh=self.neigh,\
xv=self.xv,yv=self.yv)
# Find the edge indices along the line
self.update_xy(xpt,ypt)
def update_xy(self,xpt,ypt):
"""
Updates the x and y coordinate info in the object
"""
if xpt == None or ypt == None:
self._getXYgraphically()
else:
self.xpt=xpt
self.ypt=ypt
self._getSliceCoords(kind='linear')
# List of the edge indices
self.j,self.nodelist =\
self.get_edgeindices(self.xslice,self.yslice,method=self.edgemethod)
self.nslice = len(self.j)
# Update the x and y axis of the slice
self.xslice=self.xp[self.nodelist]
self.yslice=self.yp[self.nodelist]
self._getDistCoords()
self.edgexy()
# The x and y arrys need to be resized
self.xslice = 0.5*(self.xslice[1:]+self.xslice[0:-1])
self.yslice = 0.5*(self.yslice[1:]+self.yslice[0:-1])
self.distslice = 0.5*(self.distslice[1:]+self.distslice[0:-1])
# Get the mask
self.calc_mask()
# Calculate the area
self.area = self.calc_area()
# Calculate the normnal
self.ne1, self.ne2, self.enormal = self.calc_normal(self.nodelist,self.j)
# Get the bathymetry along the slice
de = self.get_edgevar(self.dv)
self.hslice = -de[self.j]
def loadData(self,variable=None,setunits=True,method='mean'):
"""
Load the specified suntans variable data as a vector
Overloaded method for edge slicing - it is quicker to load time step by
time step in a loop.
method: edge interpolation method - 'mean', 'max'
"""
nc = self.nc
if variable==None:
variable=self.variable
if setunits:
try:
self.long_name = nc.variables[variable].long_name
self.units= nc.variables[variable].units
except:
self.long_name = ''
self.units=''
j=self.j
# Check if cell-centered variable
is3D=True
isCell=False
if self.hasDim(variable,self.griddims['Ne']):
isCell=False
elif self.hasDim(variable,self.griddims['Nc']):
isCell=True
nc1 = self.grad[j,0].copy()
nc2 = self.grad[j,1].copy()
# check for edges (use logical indexing)
ind1 = nc1==-1
nc1[ind1]=nc2[ind1]
ind2 = nc2==-1
nc2[ind2]=nc1[ind2]
# Check if 3D
if self.hasDim(variable,self.griddims['Nk']): # 3D
is3D=True
else:
is3D=False
klayer,Nkmax = self.get_klayer()
def ncload(nc,variable,tt):
if variable=='agemean':
ac = nc.variables['agec'][tt,klayer,:]
aa = nc.variables['agealpha'][tt,klayer,:]
tmp = aa/ac
tmp[ac<1e-12]=0.
return tmp/86400.
if variable=='area':
eta = nc.variables['eta'][tt,:]
dzf = self.getdzf(eta)
dzf = Spatial.getdzf(self,eta)
return self.df*dzf
else:
if self.hasDim(variable,self.griddims['Nk']): # 3D
return nc.variables[variable][tt,klayer,:]
else:
return nc.variables[variable][tt,:]
# For loop where the data is extracted
nt = len(self.tstep)
ne = len(self.j)
if is3D==True:
self.data = np.zeros((nt,Nkmax,ne))
else:
self.data = np.zeros((nt,ne))
for ii,tt in enumerate(self.tstep):
#tmp=nc.variables[variable][tt,:,:]
tmp = ncload(nc,variable,tt)
# Return the mean for cell-based variables
if isCell:
if method == 'mean':
self.data[ii,...] = 0.5*(tmp[...,nc1]+tmp[...,nc2])
elif method == 'max':
tmp2 = np.dstack((tmp[...,nc1], tmp[...,nc2]))
self.data[ii,...] =tmp2.max(axis=-1)
else:
self.data[ii,...]=tmp[...,self.j]
# Mask 3D data
if is3D:
maskval=0
self.data[ii,self.maskslice]=maskval
#fillval = 999999.0
#self.mask = self.data==fillval
#self.data[self.mask]=0.
self.data[self.data==self._FillValue]=0.
self.data = self.data.squeeze()
return self.data
def edgexy(self):
"""
Nx2 vectors outlining each cell in the edge slice
"""
def closePoly(xp,node,k):
return np.array([ [xp[node],\
xp[node+1],xp[node+1], xp[node],xp[node]],\
[-self.z_w[k],-self.z_w[k],-self.z_w[k+1],-self.z_w[k+1],-self.z_w[k]],\
]).T
self.xye = [closePoly(self.distslice,jj,kk) for kk in range(self.Nkmax) \
for jj in range(len(self.j)) ]
def calc_normal(self,nodelist,j):
"""
Calculate the edge normal
"""
# Calculate the unit normal along the edge
P1 = GPoint(self.xp[nodelist][0:-1],self.yp[nodelist][0:-1])
P2 = GPoint(self.xp[nodelist][1:],self.yp[nodelist][1:])
L = Line(P1,P2)
ne1,ne2 = L.unitnormal()
# Compute the unique normal of the dot product
enormal = np.round(self.n1[j]*ne1 +\
self.n2[j]*ne2)
return ne1,ne2,enormal
def mean(self,phi,axis='time'):
"""
Calculate the mean of the sliced data along an axis
axis: time, depth, area
time : returns the time mean. size= (Nk, Nj)
depth: returns the time and spatial mean. Size = (Nk)
area: returns the area mean. Size = (Nt)
"""
if axis=='time':
return np.mean(phi,axis=0)
elif axis=='area':
area_norm = self.area / self.area.sum()
return np.sum( np.sum(phi*area_norm,axis=-1),axis=-1)
elif axis=='depth':
dx = self.df[self.j]
dx_norm = dx / dx.sum()
return np.sum( self.mean(phi,axis='time')*dx_norm,axis=-1)
def plot(self,z,titlestr=None,**kwargs):
"""
Pcolor plot of the slice
"""
if self.clim==None:
self.clim=[]
self.clim.append(np.min(z))
self.clim.append(np.max(z))
# Set the xy limits
xlims=[self.distslice.min(),self.distslice.max()]
ylims=[-self.z_w.max(),-self.z_w.min()]
self.fig,self.ax,self.patches,self.cb=unsurf(self.xye,z.ravel(),xlim=xlims,ylim=ylims,\
clim=self.clim,**kwargs)
self.ax.set_aspect('auto')
def plotedges(self,color='m',**kwargs):
"""
plot for testing
"""
self.plotmesh()
#plt.plot(self.edgeline.xy,'r')
for ee in self.j:
plt.plot([self.xp[self.edges[ee,0]],self.xp[self.edges[ee,1]]],\
[self.yp[self.edges[ee,0]],self.yp[self.edges[ee,1]]],color=color,\
**kwargs)
def calc_area(self,eta=None):
"""
Calculate thee cross-sectional area of each face
"""
if eta==None:
eta = np.zeros((self.nslice,)) # Assumes the free-surface is zero
dzf = self.getdzf(eta)
area = dzf * self.df[self.j]
area[self.maskslice]=0
return area
def getdzf(self,eta):
""" Get the cell thickness along each edge of the slice"""
dzf = Spatial.getdzf(self,eta,j=self.j)
dzf[self.maskslice]=0
return dzf
def get_width(self):
"""
Calculate the width of each edge as a 2d array
Missing cells are masked
"""
df = self.df[self.j]
width = np.ones((self.Nkmax,1)) * df[np.newaxis,:]
width[self.maskslice]=0
return width
def calc_mask(self):
""" Construct the mask array"""
klayer,Nkmax=self.get_klayer()
self.maskslice = np.zeros((Nkmax,len(self.j)),dtype=np.bool)
for k,kk in enumerate(klayer):
for ii,j in enumerate(self.j):
if kk >= self.Nke[j]:
self.maskslice[k,ii]=True
def get_edgeindices(self,xpt,ypt,method=1):
"""
Return the indices of the edges (in order) along the line
method - method for line finding algorithm
0 - closest point to line
1 - closest point without doing a u-turn
"""
# Load the line as a shapely object
#edgeline = asLineString([self.xslice,self.yslice])
Npt = xpt.shape[0]
xyline = [(xpt[ii],ypt[ii]) for ii in range(Npt)]
self.edgeline = LineString(xyline)
# Find the nearest grid Node to the start and end of the line
xy_1 = np.vstack((xpt[0],ypt[0])).T
node0 = self.grd.findnearest(xy_1)
xy_2 = np.vstack((xpt[-1],ypt[-1])).T
endnode = self.grd.findnearest(xy_2)
# This is the list containing all edge nodes
nodelist = [node0[0]]
def connecting_nodes(node,nodelist):
""" finds the nodes connecting to the node"""
edges = self.grd.pnt2edges(node)
cnodes = []
for ee in edges:
for nn in self.grd.edges[ee]:
if nn not in nodelist:
cnodes.append(nn)
return cnodes
def min_dist(nodes,line):
"""Returns the index of the node with the minimum distance
to the line"""
# Convert all nodes to a point object
points = [Point((self.xp[nn],self.yp[nn])) for nn in nodes]
# Calculate the distance
dist = [line.distance(pp) for pp in points]
for ii,dd in enumerate(dist):
if dd == min(dist):
return nodes[ii]
def min_dist_line(cnode,nodes,line):
"""Returns the index of the node with the minimum distance
to the line"""
# Convert all nodes to a point object
points = [Point((0.5*(self.xp[nn]+self.xp[cnode]),\
0.5*(self.yp[nn]+self.yp[cnode]))) for nn in nodes]
#lines = [LineString([(self.xp[cnode],self.yp[cnode]),\
# (self.xp[nn],self.yp[nn])]) for nn in nodes]
# Calculate the distance
dist = [line.distance(pp) for pp in points]
for ii,dd in enumerate(dist):
if dd == min(dist):
return nodes[ii]
def min_dist_angle(cnode,nodes,line):
"""Returns the index of the node with the minimum distance
to the line"""
# Convert all nodes to a point object
points = [Point((0.5*(self.xp[nn]+self.xp[cnode]),\
0.5*(self.yp[nn]+self.yp[cnode]))) for nn in nodes]
# Calculate the distance
dist = [line.distance(pp) for pp in points]
dist = np.array(dist)
# Calculate the angle along the line of the new coordinate
def calc_ang(x1,x2,y1,y2):
return np.arctan2( (y2-y1),(x2-x1) )
angle1 = [calc_ang(self.xp[cnode],self.xp[nn],\
self.yp[cnode],self.yp[nn]) for nn in nodes]
# Calculate the heading of the line near the two points
def calc_heading(P1,P2,L):
d1 = L.project(P1)
d2 = L.project(P2)
if d1 <= d2:
P3 = L.interpolate(d1)
P4 = L.interpolate(d2)
else:
P3 = L.interpolate(d2)
P4 = L.interpolate(d1)
return calc_ang(P3.xy[0][0],P4.xy[0][0],P3.xy[1][0],P4.xy[1][0])
P1 = Point((self.xp[cnode],self.yp[cnode]))
angle2 = [calc_heading(P1,Point( (self.xp[nn],self.yp[nn]) ),line) \
for nn in nodes]
angdiff = np.array(angle2) - np.array(angle1)
# Use the minimum distance unless the point is a u-turn
rank = np.argsort(dist)
for nn in range(dist.shape[0]):
if np.abs(angdiff[rank[nn]]) <= np.pi/2:
return nodes[rank[nn]]
# if they all u-turn return the min dist
return nodes[rank[0]]
# Loop through and find all of the closest points to the line
MAXITER=10000
for ii in range(MAXITER):
cnodes = connecting_nodes(nodelist[-1],nodelist)
#if method==0:
# newnode = min_dist(cnodes,self.edgeline)
if method==0:
newnode = min_dist_line(nodelist[-1],cnodes,self.edgeline)
elif method==1:
newnode = min_dist_angle(nodelist[-1],cnodes,self.edgeline)
#print 'Found new node: %d...'%newnode
if newnode==None:
break
if ii>1:
if self.mark[self.grd.find_edge([newnode,nodelist[-1]])] not in [0,5]:
print 'Warning: reached a boundary cell. Aborting edge finding routine'
break
nodelist.append(newnode)
if newnode == endnode:
#print 'Reached end node.'
break
# Return the list of edges connecting all of the nodes
return [self.grd.find_edge([nodelist[ii],nodelist[ii+1]]) for ii in\
range(len(nodelist)-1)], nodelist
def __init__(self,x,y,cells,nfaces,method='nearest',grdfile=None):
self.method=method
# Initialise the trisearch array
GridSearch.__init__(self,x,y,cells,nfaces=nfaces,force_inside=True)
class Agent(object):
"""Agent for dispatching and reposition"""
def __init__(self):
self.value_fun = np.load(os.path.join(os.path.dirname(__file__), "mdp_value_without_5.npy"))
self.gamma = 0.95 # 每份时间的折现率
self.alpha1 = 0.5 # value_fun权重
self.BASETIME = 946670400 # 2020.1.1 04:00:00
self.dispatch_frequency_gap = 300 # 以5分钟为时间间隔
self.grid_search = GridSearch()
# self.gridsearch = GridSearch()
def dispatch(self, dispatch_observ):
""" Compute the assignment between drivers and passengers at each time step
:param dispatch_observ: a list of dict, the key in the dict includes:
order_id, int
driver_id, int
order_driver_distance, float
order_start_location, a list as [lng, lat], float
order_finish_location, a list as [lng, lat], float
driver_location, a list as [lng, lat], float
timestamp, int
order_finish_timestamp, int
day_of_week, int
reward_units, float
pick_up_eta, float
:return: a list of dict, the key in the dict includes:
order_id and driver_id, the pair indicating the assignment
"""
driver_id_refresh_dict, result = self.process(dispatch_observ)
dispatch_action = []
row_ind, col_ind = linear_sum_assignment(result)
for idx, oid in enumerate(row_ind):
dispatch_action.append(dict(order_id=oid, driver_id=driver_id_refresh_dict[col_ind[idx]]))
return dispatch_action
def reposition(self, repo_observ):
""" Compute the reposition action for the given drivers
:param repo_observ: a dict, the key in the dict includes:
timestamp: int
driver_info: a list of dict, the key in the dict includes:
driver_id: driver_id of the idle driver in the treatment group, int
grid_id: id of the grid the driver is located at, str
day_of_week: int
:return: a list of dict, the key in the dict includes:
driver_id: corresponding to the driver_id in the od_list
destination: id of the grid the driver is repositioned to, str
"""
repo_action = []
for driver in repo_observ['driver_info']:
# the default reposition is to let drivers stay where they are
repo_action.append({'driver_id': driver['driver_id'], 'destination': driver['grid_id']})
return repo_action
def process(self, dispatch_observ):
order_ids = set()
driver_ids = set()
for od in dispatch_observ:
order_ids.add(od["order_id"])
driver_ids.add(od["driver_id"])
driver_id_dict = dict(zip(driver_ids, range(len(driver_ids))))
driver_id_refresh_dict = dict(zip(range(len(driver_ids)), driver_ids))
result = np.zeros([len(order_ids), len(driver_ids)])
for od in dispatch_observ:
oid, did, fts, lts = od["order_id"], driver_id_dict[od["driver_id"]], od["timestamp"], od["order_finish_timestamp"] + od["pick_up_eta"]
fgrid, lgrid = self.grid_search.cal_loc_grid([od["driver_location"], od["order_finish_location"]])
ftid = int(((fts - self.BASETIME)//self.dispatch_frequency_gap) % (24*3600//self.dispatch_frequency_gap))
ltid = int(((lts - self.BASETIME)//self.dispatch_frequency_gap) % (24*3600//self.dispatch_frequency_gap))
tid_period = ltid - ftid
if tid_period == 0:
result[oid, did] = od["reward_units"] + self.value_fun[ltid, lgrid] - self.value_fun[ftid, fgrid]
else:
discount_rate = pow(self.gamma, tid_period)
result[oid, did] = (od["reward_units"]*(1-pow(self.gamma, tid_period)))/(tid_period*(1-self.gamma)) + self.alpha1*(discount_rate * self.value_fun[ltid, lgrid] - self.value_fun[ftid, fgrid])
return driver_id_refresh_dict, result
def GridParticles(grdfile,dx,dy,nz,xypoly=None,splitvec=1):
"""
Returns the locations of particles on a regular grid inside of suntans grid
Inputs:
grdfile - netcdf filename containing the suntans grid
dx,dy - resolution in x and y component respectively.
nz - number of particles in the vertical. Particles are arranged in sigma layers.
xypoly - [optional] coordinates of an additional bounding polygon [Nx2 array]
"""
# Load the suntans grid
sun = Grid(grdfile)
# Load a trisearch object
tri = GridSearch(sun.xp,sun.yp,sun.cells,nfaces=sun.nfaces,verbose=False)
if xypoly == None:
xlims = [sun.xlims[0],sun.xlims[1]]
ylims = [sun.ylims[0],sun.ylims[1]]
else:
xlims = [xypoly[:,0].min(),xypoly[:,0].max()]
ylims = [xypoly[:,1].min(),xypoly[:,1].max()]
# Construct a 2D mesh of particles
x = np.arange(xlims[0],xlims[1],dx)
y = np.arange(ylims[0],ylims[1],dy)
X,Y = np.meshgrid(x,y)
X=X.ravel()
Y=Y.ravel()
# Check which particles are inside the grid
cellind = tri(X,Y)
mask = cellind!=-1
# Check which particles are also inside of the polygon
if not xypoly == None:
inpoly = inpolygon(np.vstack((X,Y)).T,xypoly)
mask = operator.and_(mask,inpoly)
xout = X[mask]
yout = Y[mask]
nx = xout.shape[0]
# Construct the 3D mesh
xout = np.repeat(xout.reshape((nx,1)),nz,axis=1)
yout = np.repeat(yout.reshape((nx,1)),nz,axis=1)
zout = np.linspace(0.05,0.95,nz)
zout = np.repeat(zout.reshape((nz,1)),nx,axis=1)
zout *= -sun.dv[cellind[mask]]
zout = zout.T
xout = xout.ravel()
yout = yout.ravel()
zout = zout.ravel()
# Rearrange the vectors to avoid clustering (this helps even the MPI workload)
#xout_split=[]
#yout_split=[]
#zout_split=[]
#for start in range(splitvec):
# xout_split.append(xout[start::splitvec])
# yout_split.append(yout[start::splitvec])
# zout_split.append(zout[start::splitvec])
#xout = np.hstack(xout_split)
#yout = np.hstack(yout_split)
#zout = np.hstack(zout_split)
return xout, yout, zout
class Solution():
def __init__(self):
self = self
self.best_step = 1000
self.activations = {
'sigmoid': nn.Sigmoid(),
'relu': nn.ReLU(),
'rrelu0103': nn.RReLU(0.1, 0.3),
'elu': nn.ELU(),
'selu': nn.SELU(),
'leakyrelu01': nn.LeakyReLU(0.1)
}
self.learning_rate = 0.003
self.momentum = 0.8
self.layers_number = 5
self.hidden_size = 50
self.activation_hidden = 'relu'
self.activation_output = 'sigmoid'
self.do_batch_norm = True
self.sols = {}
self.solsSum = {}
self.random = 0
#self.do_batch_norm_grid = [False, True]
self.random_grid = [_ for _ in range(10)]
#self.layers_number_grid = [3, 4, 5, 6, 7, 8, 9, 10]
#self.hidden_size_grid = [10, 20, 30, 40, 50]
self.momentum_grid = [0.0, 0.3, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
#self.learning_rate_grid = [0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009, 0.01]
#self.activation_hidden_grid = self.activations.keys()
#self.activation_output_grid = self.activations.keys()
self.grid_search = GridSearch(self)
self.grid_search.set_enabled(False)
def create_model(self, input_size, output_size):
return SolutionModel(input_size, output_size, self)
def get_key(self):
return "{}_{}_{}_{}_{}_{}_{}".format(self.learning_rate, self.momentum, self.hidden_size, self.activation_hidden, self.activation_output, self.do_batch_norm, "{0:03d}".format(self.layers_number));
# Return number of steps used
def train_model(self, model, train_data, train_target, context):
key = self.get_key()
if key in self.sols and self.sols[key] == -1:
return
step = 0
# Put model in train mode
model.train()
# Note: we need to move this out of circle, since we need to save state for momentum to work
optimizer = optim.SGD(model.parameters(), lr=self.learning_rate, momentum=self.momentum)
while True:
time_left = context.get_timer().get_time_left()
data = train_data
target = train_target
# model.parameters()...gradient set to zero
optimizer.zero_grad()
# evaluate model => model.forward(data)
output = model(data)
# if x < 0.5 predict 0 else predict 1
predict = output.round()
# Number of correct predictions
correct = predict.eq(target.view_as(predict)).long().sum().item()
# Total number of needed predictions
total = target.view(-1).size(0)
if correct == total or time_left < 0.1 or (self.grid_search.enabled and step > 100):
if not key in self.sols:
self.sols[key] = 0
self.solsSum[key] = 0
self.sols[key] += 1
self.solsSum[key] += step
if self.sols[key] == len(self.random_grid):
print("{} {:.4f}".format(key, float(self.solsSum[key])/self.sols[key]))
break
# calculate loss
loss = ((output-target)**2).sum()
# calculate deriviative of model.forward() and put it in model.parameters()...gradient
loss.backward()
# print progress of the learning
#self.print_stats(step, loss, correct, total)
# update model: model.parameters() -= lr * gradient
optimizer.step()
step += 1
return step
def print_stats(self, step, loss, correct, total):
if step % 1000 == 0:
print("Step = {} Prediction = {}/{} Error = {}".format(step, correct, total, loss.item()))
def __init__(self):
self.lr = 0.9
self.lr_grid = [0.005, 0.01, 0.05, 0.1]
self.hidden_size = 14
self.hidden_size_grid = [2, 3, 4, 5, 6, 7]
self.grid_search = GridSearch(self).set_enabled(False)
