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