def log_validation_results(trainer): # evaluate test(validation) set evaluator.run(test_loader) metrics = evaluator.state.metrics logger.info( "Validation Results - Epoch: {} Avg-loss: {:.3f}\n Pix-acc: {}\n IoU: {}\n F1: {}\n" .format(trainer.state.epoch, metrics['loss'], str(metrics['pix-acc']), str(metrics['iou']), str(metrics['f1']))) # update scheduler lr_scheduler.step(metrics['loss']) # update and save state update_state(weight=model.state_dict(), train_loss=state['train_loss'], val_loss=metrics['loss'], val_pix_acc=metrics['pix-acc'], val_iou=metrics['iou'], val_f1=metrics['f1']) path = ckpt_path.format(network=networks, optimizer=optimizer, lr=lr, epoch=trainer.state.epoch) save_ckpt_file(path, state)
def log_training_results(trainer): # evaluate on training set evaluator.run(train_loader) metrics = evaluator.state.metrics logger.info("Training Results - Epoch: {} Avg-loss: {:.3f}\n Pix-acc: {}\n IoU: {}\n F1: {}\n".format( trainer.state.epoch, metrics['loss'], str(metrics['pix-acc']), str(metrics['iou']), str(metrics['f1']))) # update state update_state(weight=model.state_dict(), train_loss=metrics['loss'], val_loss=state['val_loss'], val_pix_acc=state['val_pix_acc'], val_iou=state['val_iou'], val_f1=state['val_f1'])
def webhook_handler(): signature = request.headers["X-Line-Signature"] # get request body as text body = request.get_data(as_text=True) # app.logger.info(f"Request body: {body}") # parse webhook body try: events = parser.parse(body, signature) except InvalidSignatureError: abort(400) # if event is MessageEvent and message is TextMessage, then echo text for event in events: if event.source.user_id not in machine: machine[event.source.user_id] = TocMachine( states=machine_diagram_states, transitions=machine_diagram_transitions, initial="user", auto_transitions=False, show_conditions=True, ) if not isinstance(event, MessageEvent) and not isinstance( event, PostbackEvent): continue # if not isinstance(event.message, TextMessage): # continue # if not isinstance(event.message.text, str): # continue # print(f"\nFSM STATE: {machine.state}") machine[event.source.user_id].state = read_state(event.source.user_id) response = machine[event.source.user_id].advance(event) if not response: send_text_message(event.reply_token, "Not Entering any State") else: update_state(event.source.user_id, machine[event.source.user_id].state) return "OK"
def run_episode(self): """ Game loop """ # reset obs = self.env.reset() s = init_state(obs) R = 0 # total reward this episode self.debug_log = [] while True: time.sleep(self.config['THREAD_DELAY']) # yield if self.render: self.env.render() a = self.agent.act(s) obs, r, done, info = self.env.step(a) sp = update_state(s, obs) if done: # terminal state sp = None self.agent.train(s, a, r, sp) if self.debug: self.debug_log.append([s, a, r, sp, done]) s = sp R += r if done or self.stop_signal: Environment.scores.append(R) self.episode_number += 1 # Static purge for now Environment.scores = Environment.scores[-100:] if self.debug: # Save logs # TODO: folder restructure save_pickle( self.debug_log, os.path.join( 'debug_logs', "ENV{}_EPISODE{}".format(self.id, self.episode_number))) if self.render: # Demo mode print("ENV_{} INFO: total reward this episode: {}".format( self.id, R)) break
def train_with_ignite(networks, dataset, data_dir, batch_size, img_size, epochs, lr, momentum, num_workers, optimizer, logger): from ignite.engine import Events, create_supervised_trainer, create_supervised_evaluator from ignite.metrics import Loss from utils.metrics import MultiThresholdMeasures, Accuracy, IoU, F1score # device device = 'cuda' if torch.cuda.is_available() else 'cpu' # build model model = get_network(networks) # log model summary input_size = (3, img_size, img_size) summarize_model(model.to(device), input_size, logger, batch_size, device) # build loss loss = torch.nn.BCEWithLogitsLoss() # build optimizer and scheduler model_optimizer = get_optimizer(optimizer, model, lr, momentum) lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(model_optimizer) # transforms on both image and mask train_joint_transforms = jnt_trnsf.Compose([ jnt_trnsf.RandomCrop(img_size), jnt_trnsf.RandomRotate(5), jnt_trnsf.RandomHorizontallyFlip() ]) # transforms only on images train_image_transforms = std_trnsf.Compose([ std_trnsf.ColorJitter(0.05, 0.05, 0.05, 0.05), std_trnsf.ToTensor(), std_trnsf.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) test_joint_transforms = jnt_trnsf.Compose([jnt_trnsf.Safe32Padding()]) test_image_transforms = std_trnsf.Compose([ std_trnsf.ToTensor(), std_trnsf.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) # transforms only on mask mask_transforms = std_trnsf.Compose([std_trnsf.ToTensor()]) # build train / test loader train_loader = get_loader(dataset=dataset, data_dir=data_dir, train=True, joint_transforms=train_joint_transforms, image_transforms=train_image_transforms, mask_transforms=mask_transforms, batch_size=batch_size, shuffle=False, num_workers=num_workers) test_loader = get_loader(dataset=dataset, data_dir=data_dir, train=False, joint_transforms=test_joint_transforms, image_transforms=test_image_transforms, mask_transforms=mask_transforms, batch_size=1, shuffle=False, num_workers=num_workers) # build trainer / evaluator with ignite trainer = create_supervised_trainer(model, model_optimizer, loss, device=device) measure = MultiThresholdMeasures() evaluator = create_supervised_evaluator(model, metrics={ '': measure, 'pix-acc': Accuracy(measure), 'iou': IoU(measure), 'loss': Loss(loss), 'f1': F1score(measure), }, device=device) # initialize state variable for checkpoint state = update_state(model.state_dict(), 0, 0, 0, 0, 0) # make ckpt path ckpt_root = './ckpt/' filename = '{network}_{optimizer}_lr_{lr}_epoch_{epoch}.pth' ckpt_path = os.path.join(ckpt_root, filename) # execution after every training iteration @trainer.on(Events.ITERATION_COMPLETED) def log_training_loss(trainer): num_iter = (trainer.state.iteration - 1) % len(train_loader) + 1 if num_iter % 20 == 0: logger.info("Epoch[{}] Iter[{:03d}] Loss: {:.2f}".format( trainer.state.epoch, num_iter, trainer.state.output)) # execution after every training epoch @trainer.on(Events.EPOCH_COMPLETED) def log_training_results(trainer): # evaluate on training set evaluator.run(train_loader) metrics = evaluator.state.metrics logger.info( "Training Results - Epoch: {} Avg-loss: {:.3f}\n Pix-acc: {}\n IoU: {}\n F1: {}\n" .format(trainer.state.epoch, metrics['loss'], str(metrics['pix-acc']), str(metrics['iou']), str(metrics['f1']))) # update state update_state(weight=model.state_dict(), train_loss=metrics['loss'], val_loss=state['val_loss'], val_pix_acc=state['val_pix_acc'], val_iou=state['val_iou'], val_f1=state['val_f1']) # execution after every epoch @trainer.on(Events.EPOCH_COMPLETED) def log_validation_results(trainer): # evaluate test(validation) set evaluator.run(test_loader) metrics = evaluator.state.metrics logger.info( "Validation Results - Epoch: {} Avg-loss: {:.3f}\n Pix-acc: {}\n IoU: {}\n F1: {}\n" .format(trainer.state.epoch, metrics['loss'], str(metrics['pix-acc']), str(metrics['iou']), str(metrics['f1']))) # update scheduler lr_scheduler.step(metrics['loss']) # update and save state update_state(weight=model.state_dict(), train_loss=state['train_loss'], val_loss=metrics['loss'], val_pix_acc=metrics['pix-acc'], val_iou=metrics['iou'], val_f1=metrics['f1']) path = ckpt_path.format(network=networks, optimizer=optimizer, lr=lr, epoch=trainer.state.epoch) save_ckpt_file(path, state) trainer.run(train_loader, max_epochs=epochs)
def validate(model, parser, dev_batched, dataset, device, batch_size_eval, pad_action, opt): batch_del_label = None graph_emb = None n_batchs = len(dev_batched) dependencies_total = [] pbar = tqdm(total=n_batchs) for batch in range(n_batchs): ################################## preparing the data ################################## batch_buffer_ind, batch_buffer, batch_buffer_pos, mask_buffer = dev_batched[ batch] batch_buffer = batch_buffer.to(device) batch_buffer_ind = batch_buffer_ind.to(device) batch_buffer_pos = batch_buffer_pos.to(device) mask_buffer = mask_buffer.to(device) batch_size = batch_buffer.size()[0] if opt.graphinput: batch_delete = batch_buffer.clone() batch_delete_pos = batch_buffer_pos.clone() graph_emb = torch.zeros((batch_size, batch_buffer.size()[1] + 2, batch_buffer.size()[1])).long().to(device) graph_input = torch.zeros( (batch_size, 3 * batch_buffer.size()[1] + 4, 3 * batch_buffer.size()[1] + 4)).long().to(device) #### build attention mask mask_stack = torch.zeros( (batch_size, batch_buffer.size()[1] + 1)).byte().to(device) mask_stack[:, -1] = 1 #### build stack word batch_stack = torch.zeros( (batch_size, batch_buffer.size()[1] + 1)).long().to(device) batch_stack[:, -1] = parser.ROOT batch_stack_ind = (torch.ones( (batch_size, batch_buffer.size()[1] + 1)) * (batch_buffer.size()[1] + 1)).long().to(device) batch_stack_ind[:, -1] = 0 #### build stack POS batch_stack_pos = torch.zeros( (batch_size, batch_buffer.size()[1] + 1)).long().to(device) batch_stack_pos[:, -1] = parser.P_ROOT #### build dep batch_dep = torch.ones_like(batch_stack) * parser.NULL batch_dep_pos = torch.ones_like(batch_stack_pos) * parser.P_NULL batch_dep_label = torch.ones_like(batch_stack_pos) * parser.L_NULL batch_dep_buffer = torch.ones_like(batch_stack[:, :-1]) * parser.NULL batch_dep_pos_buffer = torch.ones_like( batch_stack_pos[:, :-1]) * parser.P_NULL batch_dep_label_buffer = torch.ones_like( batch_stack_pos[:, :-1]) * parser.L_NULL ### token_type_ids if opt.graphinput: token_type_ids = torch.zeros( (batch_size, 3 * batch_buffer.size()[1] + 4)).long().to(device) token_type_ids[:, :batch_buffer.size()[1] + 2] = 2 token_type_ids[:, batch_buffer.size()[1] + 2:2 * batch_buffer.size()[1] + 3] = 1 else: token_type_ids = torch.zeros( (batch_size, 2 * batch_buffer.size()[1] + 4)).long().to(device) token_type_ids[:, :batch_buffer.size()[1] + 3] = 1 if opt.seppoint: sep_point = batch_buffer.size()[1] + 1 else: sep_point = 0 ### build the dependency set dependencies = [] for _ in range(batch_size): dependencies.append([]) ###### do the initialization of model batch_size = len(batch_buffer) mask_cls = torch.ones((batch_size, 1)).byte().to(device) mask_sep = torch.ones((batch_size, 1)).byte().to(device) step_i = 0 ## clip cls and sep ones = (torch.ones((batch_size, 1))).long().to(device) batch_temp = batch_dep[:, :-1].clone() batch_pos_temp = batch_dep_pos[:, :-1].clone() batch_label_temp = batch_dep_label[:, :-1].clone() if opt.graphinput: batch_del_label = batch_label_temp.clone() update = torch.zeros(batch_size).long().to(device) action_state = None action_cell = None transitions = None labels = None while True: if len(torch.nonzero(update)) == batch_size: break if opt.graphinput: mask_delete, graph_in = prepare_graph(graph_emb, batch_stack_ind, batch_buffer_ind, batch_size, graph_input, device, parser.NULL) input_ids_x, pos_ids_x, batch_dep_input, batch_dep_pos_input,batch_dep_label_input,\ batch_graph_label_input, attention_mask = prepare_data(ones,opt.graphinput,parser, batch_stack,batch_buffer,batch_stack_pos,batch_buffer_pos, batch_dep,batch_temp,batch_dep_pos,batch_pos_temp,batch_dep_label,batch_label_temp, mask_cls, mask_stack,mask_sep,mask_buffer,batch_dep_buffer,batch_dep_pos_buffer,batch_dep_label_buffer, mask_delete,batch_del_label,batch_delete,batch_delete_pos) transitions, labels, action_state, action_cell = model( 1, sep_point, input_ids_x, pos_ids_x, batch_dep_input, batch_dep_pos_input, batch_dep_label_input, batch_graph_label_input, attention_mask, update, token_type_ids, mask_stack, mask_buffer, batch_stack_ind, transitions, labels, action_state, action_cell, graph_in) else: input_ids_x, pos_ids_x, batch_dep_input, batch_dep_pos_input,batch_dep_label_input,attention_mask =\ prepare_data(ones,opt.graphinput,parser,batch_stack,batch_buffer,batch_stack_pos,batch_buffer_pos, batch_dep,batch_temp,batch_dep_pos,batch_pos_temp,batch_dep_label,batch_label_temp, mask_cls,mask_stack,mask_sep,mask_buffer,batch_dep_buffer,batch_dep_pos_buffer, batch_dep_label_buffer) transitions, labels, action_state, action_cell = model( 1, sep_point, input_ids_x, pos_ids_x, batch_dep_input, batch_dep_pos_input, batch_dep_label_input, None, attention_mask, update, token_type_ids, mask_stack, mask_buffer, batch_stack_ind, transitions, labels, action_state, action_cell) ####### update stack and buffer ############################## batch_stack_ind,batch_stack,batch_buffer_ind,batch_buffer,batch_stack_pos,batch_buffer_pos,\ batch_dep,batch_dep_pos,mask_buffer,mask_stack, batch_dep_label, graph_emb,batch_del_label,\ batch_dep_buffer,batch_dep_pos_buffer,batch_dep_label_buffer,\ dependencies = update_state(1,opt,batch_stack_ind, batch_stack, batch_buffer_ind, batch_buffer, batch_stack_pos,batch_buffer_pos,batch_dep,batch_dep_pos,mask_buffer, mask_stack, transitions, batch_dep_label,labels,parser.NULL,parser.P_NULL,parser.L_NULL, batch_dep_buffer,batch_dep_pos_buffer,batch_dep_label_buffer, graph_emb,batch_del_label,dependencies=dependencies) update = ((mask_buffer.sum(dim=1) == 0) * (mask_stack.sum(dim=1) == 1) * pad_action * 1.0).long() del input_ids_x, pos_ids_x, batch_dep_input,\ batch_dep_pos_input,batch_dep_label_input,attention_mask if opt.graphinput: del mask_delete, graph_in ###################################################################################### step_i += 1 pbar.update(1) del batch_buffer_ind, batch_buffer, batch_buffer_pos,mask_buffer, \ batch_stack_ind, batch_stack, batch_stack_pos, token_type_ids, batch_dep, batch_dep_pos,ones,\ batch_label_temp,batch_dep_label,batch_dep_buffer,batch_dep_pos_buffer,batch_dep_label_buffer if opt.graphinput: del batch_delete, graph_emb, graph_input, batch_del_label, batch_delete_pos dependencies_total.extend(dependencies) with open(opt.mainpath + '/dependency/' + str(opt.outputname) + '.pkl', 'wb') as f: pickle.dump(dependencies_total, f, pickle.HIGHEST_PROTOCOL) UAS = all_tokens = 0.0 LAS = 0.0 with tqdm(total=len(dataset)) as prog: for i, ex in enumerate(dataset): head = [-1] * len(ex['word']) label = [-1] * len(ex['word']) for h, t, l in dependencies_total[i]: head[t] = h label[t] = l for pred_h, pred_l, gold_h, gold_l, pos in zip( head[1:], label[1:], ex['head'][1:], ex['label'][1:], ex['pos'][1:]): assert parser.id2tok[pos].startswith(P_PREFIX) pos_str = parser.id2tok[pos][len(P_PREFIX):] UAS += 1.0 if pred_h == gold_h else 0.0 if pred_h == gold_h and pred_l == gold_l: LAS += 1.0 all_tokens += 1 prog.update(i + 1) UAS /= all_tokens LAS /= all_tokens del dependencies_total return UAS, LAS
def train(model, parser, train_batched, train_data, dev_batched, dev_data_total, output_path, device, max_seq_length, mean_seq_length, emb_size, opt, pad_action): pad_action = pad_action['P'] best_dev_LAS = 0 n_batchs = len(train_batched) if opt.mean_seq: num_train_optimization_steps = opt.nepochs * mean_seq_length * n_batchs else: num_train_optimization_steps = opt.nepochs * max_seq_length * n_batchs print('number of steps') print(num_train_optimization_steps) ## define the optimizer if opt.Bertoptim: if opt.use_two_opts: print("use two optimizers") model_nonbert = [] model_bert = [] layernorm_params = [ 'LayerNormKeys', 'dp_relation_k', 'dp_relation_v', 'compose', 'label_emb', 'pooler.dense', 'pooler.dense_label' ] for name, param in model.named_parameters(): if 'bertmodel' in name and not any(nd in name for nd in layernorm_params): model_bert.append(param) else: model_nonbert.append(param) optimizer = BertAdam(model_bert, lr=opt.lr, warmup=opt.warmupproportion, t_total=num_train_optimization_steps) optimizer_nonbert = BertAdam(model_nonbert, lr=opt.lr_nonbert, warmup=opt.warmupproportion, t_total=num_train_optimization_steps) else: optimizer = BertAdam(model.parameters(), lr=opt.lr, warmup=opt.warmupproportion, t_total=num_train_optimization_steps) else: optimizer = optim.Adam(model.parameters(), lr=opt.lr) ## load optimizer state from a checkpoint if opt.pretrained: state_dict = torch.load(opt.mainpath + '/output/' + str(opt.modelpath) + "model.weights" + "pretrained") optimizer.load_state_dict(state_dict['optimizer']) del state_dict loss_func = nn.CrossEntropyLoss() loss_func_label = nn.CrossEntropyLoss() batch_del_label = None graph_emb = None n_epochs = opt.nepochs - opt.real_epoch for n_epoch in range(n_epochs): print("Epoch {:} out of {:}".format(n_epoch + 1, opt.nepochs)) model.train() if not opt.Bertoptim: adjust_learning_rate(opt.lr, opt.updatelr, optimizer, n_epoch) loss_meter = AverageMeter() iters = np.arange(n_batchs) if opt.shuffle: print('Do shuffling') random.shuffle(iters) loss = 0. pbar = tqdm(total=n_batchs) for it in iters: ################################## preparing the data ################################# batch_buffer_ind,batch_buffer, batch_buffer_pos, mask_buffer ,\ actions_batch, actions_mask_batch, batch_labels, mask_labels = train_batched[it] actions_batch = actions_batch.to(device) actions_mask_batch = actions_mask_batch.to(device) batch_labels = batch_labels.to(device) mask_labels = mask_labels.to(device) batch_buffer = batch_buffer.to(device) batch_buffer_ind = batch_buffer_ind.to(device) batch_buffer_pos = batch_buffer_pos.to(device) mask_buffer = mask_buffer.to(device) batch_size = len(batch_buffer) if opt.graphinput: batch_delete = batch_buffer.clone() batch_delete_pos = batch_buffer_pos.clone() graph_emb = torch.zeros( (batch_size, batch_buffer.size()[1] + 2, batch_buffer.size()[1])).long().to(device) graph_input = torch.zeros( (batch_size, 3 * batch_buffer.size()[1] + 4, 3 * batch_buffer.size()[1] + 4)).long().to(device) #### build attention mask mask_stack = torch.zeros( (batch_size, batch_buffer.size()[1] + 1)).byte().to(device) mask_stack[:, -1] = 1 #### build stack word batch_stack = torch.zeros( (batch_size, batch_buffer.size()[1] + 1)).long().to(device) batch_stack[:, -1] = parser.ROOT batch_stack_ind = (torch.ones( (batch_size, batch_buffer.size()[1] + 1)) * (batch_buffer.size()[1] + 1)).long().to(device) batch_stack_ind[:, -1] = 0 #### build stack POS batch_stack_pos = torch.zeros( (batch_size, batch_buffer.size()[1] + 1)).long().to(device) batch_stack_pos[:, -1] = parser.P_ROOT #### build dep batch_dep = torch.ones_like(batch_stack) * parser.NULL batch_dep_pos = torch.ones_like(batch_stack_pos) * parser.P_NULL batch_dep_label = torch.ones_like(batch_stack_pos) * parser.L_NULL batch_dep_buffer = torch.ones_like( batch_stack[:, :-1]) * parser.NULL batch_dep_pos_buffer = torch.ones_like( batch_stack_pos[:, :-1]) * parser.P_NULL batch_dep_label_buffer = torch.ones_like( batch_stack_pos[:, :-1]) * parser.L_NULL ### token_type_ids if opt.graphinput: token_type_ids = torch.zeros( (batch_size, 3 * batch_buffer.size()[1] + 4)).long().to(device) token_type_ids[:, :batch_buffer.size()[1] + 2] = 2 token_type_ids[:, batch_buffer.size()[1] + 2:2 * batch_buffer.size()[1] + 3] = 1 else: token_type_ids = torch.zeros( (batch_size, 2 * batch_buffer.size()[1] + 4)).long().to(device) token_type_ids[:, :batch_buffer.size()[1] + 3] = 1 if opt.seppoint: sep_point = batch_buffer.size()[1] + 1 else: sep_point = 0 mask_cls = torch.ones((batch_size, 1)).byte().to(device) mask_sep = torch.ones((batch_size, 1)).byte().to(device) # main loop if actions_batch is None: step_length = opt.maxsteplength else: step_length = actions_batch.size()[1] step_i = 0 ## clip cls and sep ones = (torch.ones((batch_size, 1))).long().to(device) batch_temp = batch_dep[:, :-1].clone() batch_pos_temp = batch_dep_pos[:, :-1].clone() batch_label_temp = batch_dep_label[:, :-1].clone() if opt.graphinput: batch_del_label = batch_label_temp.clone() update = torch.zeros(batch_size).long().to(device) action_state = None action_cell = None mode = 0 while True: if step_i == step_length - 1: mode = 1 if len(torch.nonzero(update)) == batch_size: break if step_i == 0: prev_transitions = None else: prev_transitions = actions_batch[:, step_i - 1] if step_i == 0: prev_labels = None else: prev_labels = batch_labels[:, step_i - 1] transitions = actions_batch[:, step_i] steps = batch_labels[:, step_i] if opt.graphinput: ## build graoh input matrix mask_delete, graph_in = prepare_graph( graph_emb, batch_stack_ind, batch_buffer_ind, batch_size, graph_input, device, parser.NULL) ## prepare data for transformer input_ids_x, pos_ids_x, batch_dep_input, batch_dep_pos_input,batch_dep_label_input,\ batch_graph_label_input,attention_mask =prepare_data(ones,opt.graphinput,parser,batch_stack, batch_buffer,batch_stack_pos,batch_buffer_pos,batch_dep,batch_temp,batch_dep_pos, batch_pos_temp,batch_dep_label,batch_label_temp, mask_cls,mask_stack,mask_sep,mask_buffer, batch_dep_buffer,batch_dep_pos_buffer,batch_dep_label_buffer,mask_delete,batch_del_label ,batch_delete,batch_delete_pos) output_batch, output_label, action_state, action_cell = model( 0, sep_point, input_ids_x, pos_ids_x, batch_dep_input, batch_dep_pos_input, batch_dep_label_input, batch_graph_label_input, attention_mask, update, token_type_ids, mask_stack, mask_buffer, batch_stack_ind, prev_transitions, prev_labels, action_state, action_cell, graph_in) else: input_ids_x, pos_ids_x, batch_dep_input, batch_dep_pos_input,batch_dep_label_input,attention_mask =\ prepare_data(ones,opt.graphinput,parser,batch_stack,batch_buffer,batch_stack_pos,batch_buffer_pos, batch_dep,batch_temp,batch_dep_pos,batch_pos_temp,batch_dep_label,batch_label_temp, mask_cls,mask_stack,mask_sep,mask_buffer,batch_dep_buffer,batch_dep_pos_buffer, batch_dep_label_buffer) output_batch, output_label, action_state, action_cell = model( 0, sep_point, input_ids_x, pos_ids_x, batch_dep_input, batch_dep_pos_input, batch_dep_label_input, None, attention_mask, update, token_type_ids, mask_stack, mask_buffer, batch_stack_ind, prev_transitions, prev_labels, action_state, action_cell) ##################### mask the output batch ####################################### action_batch = actions_batch[:, step_i] action_mask_batch = actions_mask_batch[:, step_i] action_batch = action_batch.masked_select(action_mask_batch) output_batch = output_batch.masked_select( action_mask_batch.unsqueeze(0).t()).view(-1, opt.nclass) ############################ mask the output label batch ########################### batch_label = batch_labels[:, step_i] mask_label = mask_labels[:, step_i] batch_label = batch_label.masked_select(mask_label) output_label = output_label.masked_select( mask_label.unsqueeze(0).t()).view(-1, parser.n_transit - 1) if output_label.nelement(): loss = loss_func(output_batch, action_batch) + loss_func_label( output_label, batch_label) else: loss = loss_func(output_batch, action_batch) ## back propagation if opt.use_two_opts: optimizer_nonbert.zero_grad() optimizer.zero_grad() else: optimizer.zero_grad() if mode: loss.backward() else: loss.backward(retain_graph=True) if opt.use_two_opts: optimizer.step() optimizer_nonbert.step() else: optimizer.step() loss_meter.update(loss.item()) del output_batch,output_label,input_ids_x, pos_ids_x, batch_dep_input,\ batch_dep_pos_input,batch_dep_label_input,attention_mask if opt.graphinput: del mask_delete, graph_in ############################## update stack and buffer ############################## batch_stack_ind,batch_stack,batch_buffer_ind,batch_buffer,batch_stack_pos,batch_buffer_pos,\ batch_dep,batch_dep_pos,mask_buffer,mask_stack, batch_dep_label, graph_emb,batch_del_label,\ batch_dep_buffer,batch_dep_pos_buffer,batch_dep_label_buffer = update_state(0,opt,batch_stack_ind, batch_stack, batch_buffer_ind, batch_buffer,batch_stack_pos, batch_buffer_pos,batch_dep, batch_dep_pos,mask_buffer,mask_stack,transitions, batch_dep_label,steps,parser.NULL, parser.P_NULL,parser.L_NULL,batch_dep_buffer,batch_dep_pos_buffer,batch_dep_label_buffer, graph_emb,batch_del_label) update = ((mask_buffer.sum(dim=1) == 0) * (mask_stack.sum(dim=1) == 1) * pad_action).long() step_i += 1 pbar.update(1) del actions_batch,batch_labels,mask_labels,batch_buffer, batch_buffer_pos,mask_buffer, actions_mask_batch, \ batch_stack, batch_stack_pos, token_type_ids, batch_dep, batch_dep_pos,batch_dep_label,\ ones, batch_dep_buffer,batch_dep_pos_buffer,batch_dep_label_buffer if opt.graphinput: del batch_delete, batch_delete_pos, graph_emb, batch_del_label, graph_input print("Average Train Loss: {}".format(loss_meter.avg)) print("") print("Evaluating on dev set", ) model.eval() dev_UAS, dev_LAS = validate(model, parser, dev_batched, dev_data_total, device, opt.batchsize, pad_action, opt) print("- dev UAS: {:.2f}".format(dev_UAS * 100.0)) print("- dev LAS: {:.2f}".format(dev_LAS * 100.0)) if dev_LAS > best_dev_LAS: best_dev_LAS = dev_LAS print("New best dev UAS! Saving model.") torch.save( { 'model': model.state_dict(), 'opt': opt, 'optimizer': optimizer.state_dict() }, output_path) torch.save( { 'model': model.state_dict(), 'opt': opt, 'optimizer': optimizer.state_dict() }, output_path + "pretrained")
def test_normal_mu_shift(): batches = get_batches_normal() # drift_detector_type = "MOA_KL" drift_detector_type = "MOA_SUBSAMPLE_SIMPLE_MAJORITY" univariate_detector_types = \ ["CUSUM", "ADWIN", "GEOMETRIC_MOVING_AVERAGE", "DDM", "EDDM", "EWMA", "PAGE_HINKLEY", "HDDM_A", "HDDM_W", "SEED", "SEQ1"] # univariate_detector_types = ["HDDM_A"] # TODO EnsembleDriftDetectionMethods univariate_detector_options = { "CUSUM": { "minNumInstancesOption": {"type": "IntOption", "value": 300, "min": 0, "max": sys.maxsize}, "deltaOption": {"type": "FloatOption", "value": 0.005, "min": 0.0, "max": 1.0}, "lambdaOption": {"type": "FloatOption", "value": 50.0, "min": 0.0, "max": sys.float_info.max}, }, "ADWIN": { "deltaAdwinOption": {"type": "FloatOption", "value": 0.002, "min": 0.0, "max": 1.0}, }, "DDM": { "minNumInstancesOption": {"type": "IntOption", "value": 30, "min": 0, "max": sys.maxsize}, "warningLevelOption": {"type": "FloatOption", "value": 2.0, "min": 1.0, "max": 4.0}, "outcontrolLevelOption": {"type": "FloatOption", "value": 3.0, "min": 1.0, "max": 5.0}, }, "EWMA": { "minNumInstancesOption": {"type": "IntOption", "value": 30, "min": 0, "max": sys.maxsize}, "lambdaOption": {"type": "FloatOption", "value": 0.2, "min": 0.0, "max": sys.float_info.max}, }, "GEOMETRIC_MOVING_AVERAGE": { "minNumInstancesOption": {"type": "IntOption", "value": 30, "min": 0, "max": sys.maxsize}, "lambdaOption": {"type": "FloatOption", "value": 1.0, "min": 0.0, "max": sys.float_info.max}, "alphaOption": {"type": "FloatOption", "value": 0.99, "min": 0.0, "max": 1.0}, }, "EDDM": {}, "PAGE_HINKLEY": { "minNumInstancesOption": {"type": "IntOption", "value": 30, "min": 0, "max": sys.maxsize}, "deltaOption": {"type": "FloatOption", "value": 0.005, "min": 0.0, "max": 1.0}, "lambdaOption": {"type": "FloatOption", "value": 50.0, "min": 0.0, "max": sys.float_info.max}, "alphaOption": {"type": "FloatOption", "value": 1 - 0.0001, "min": 0.0, "max": 1.0}, }, "HDDM_A": { "driftConfidenceOption": {"type": "FloatOption", "value": 0.001, "min": 0.0, "max": 1.0}, "warningConfidenceOption": {"type": "FloatOption", "value": 0.005, "min": 0.0, "max": 1.0}, "oneSidedTestOption": {"type": "MultiChoiceOption", "value": 1, "options": [0, 1]}, }, "HDDM_W": { "driftConfidenceOption": {"type": "FloatOption", "value": 0.001, "min": 0.0, "max": 1.0}, "warningConfidenceOption": {"type": "FloatOption", "value": 0.005, "min": 0.0, "max": 1.0}, "lambdaOption": {"type": "FloatOption", "value": 0.05, "min": 0.0, "max": 1.0}, "oneSidedTestOption": {"type": "MultiChoiceOption", "value": 0, "options": [0, 1]}, }, "SEED": { "deltaSEEDOption": {"type": "FloatOption", "value": 0.05, "min": 0.0, "max": 1.0}, "blockSizeSEEDOption": {"type": "IntOption", "value": 32, "min": 32, "max": 256}, "epsilonPrimeSEEDOption": {"type": "FloatOption", "value": 0.01, "min": 0.0025, "max": 0.01}, "alphaSEEDOption": {"type": "FloatOption", "value": 0.8, "min": 0.2, "max": 0.8}, "compressTermSEEDOption": {"type": "IntOption", "value": 75, "min": 50, "max": 100}, }, "SEQ1": { "deltaOption": {"type": "FloatOption", "value": 0.01, "min": 0.0, "max": 1.0}, "deltaWarningOption": {"type": "FloatOption", "value": 0.1, "min": 0.0, "max": 1.0}, "blockSeqDriftOption": {"type": "IntOption", "value": 200, "min": 100, "max": 10000}, }, } """ IntOption FloatOption ListOption MultiChoiceOption CusumDM: minNumInstancesOption = new IntOption("minNumInstances", 'n', "The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE); deltaOption = new FloatOption("delta", 'd', "Delta parameter of the Cusum Test", 0.005, 0.0, 1.0); lambdaOption = new FloatOption("lambda", 'l', "Threshold parameter of the Cusum Test", 50, 0.0, Float.MAX_VALUE); ADWINChangeDetector: deltaAdwinOption = new FloatOption("deltaAdwin", 'a', "Delta of Adwin change detection", 0.002, 0.0, 1.0); DDM: minNumInstancesOption = new IntOption("minNumInstances", 'n', "The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE); warningLevelOption = new FloatOption( "warningLevel", 'w', "Warning Level.", 2.0, 1.0, 4.0); outcontrolLevelOption = new FloatOption("outcontrolLevel", 'o', "Outcontrol Level.", 3.0, 1.0, 5.0); EnsembleDriftDetectionMethods: changeDetectorsOption = new ListOption("changeDetectors", 'c', "Change Detectors to use.", new ClassOption("driftDetectionMethod", 'd', "Drift detection method to use.", ChangeDetector.class, "DDM"),new Option[0], ','); predictionOption = new MultiChoiceOption("prediction", 'l', "Prediction to use.", new String[]{"max", "min", "majority"}, new String[]{"Maximum", "Minimum", "Majority"}, 0); EWMAChartDM: minNumInstancesOption = new IntOption("minNumInstances", 'n', "The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE); lambdaOption = new FloatOption("lambda", 'l', "Lambda parameter of the EWMA Chart Method", 0.2, 0.0, Float.MAX_VALUE); GeometricMovingAverageDM: minNumInstancesOption = new IntOption("minNumInstances", 'n', "The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE); lambdaOption = new FloatOption("lambda", 'l', "Threshold parameter of the Geometric Moving Average Test", 1, 0.0, Float.MAX_VALUE); alphaOption = new FloatOption("alpha", 'a', "Alpha parameter of the Geometric Moving Average Test", .99, 0.0, 1.0); HDDM_A_Test: driftConfidenceOption = new FloatOption("driftConfidence", 'd', "Confidence to the drift", 0.001, 0, 1); warningConfidenceOption = new FloatOption("warningConfidence", 'w', "Confidence to the warning", 0.005, 0, 1); oneSidedTestOption = new MultiChoiceOption("typeOfTest", 't', "Monitors error increments and decrements (two-sided) or only increments (one-sided)", new String[]{ "One-sided", "Two-sided"}, new String[]{"One-sided", "Two-sided"}, 1); HDDM_W_Test: driftConfidenceOption = new FloatOption("driftConfidence", 'd', "Confidence to the drift", 0.001, 0, 1); warningConfidenceOption = new FloatOption("warningConfidence", 'w', "Confidence to the warning", 0.005, 0, 1); lambdaOption = new FloatOption("lambda", 'm', "Controls how much weight is given to more recent data compared to older data. Smaller values mean less weight given to recent data.", 0.050, 0, 1); oneSidedTestOption = new MultiChoiceOption("typeOfTest", 't', "Monitors error increments and decrements (two-sided) or only increments (one-sided)", new String[]{"One-sided", "Two-sided"}, new String[]{"One-sided", "Two-sided"},0); PageHinkleyDM: minNumInstancesOption = new IntOption("minNumInstances", 'n', "The minimum number of instances before permitting detecting change.", 30, 0, Integer.MAX_VALUE); deltaOption = new FloatOption("delta", 'd', "Delta parameter of the Page Hinkley Test", 0.005, 0.0, 1.0); lambdaOption = new FloatOption("lambda", 'l', "Lambda parameter of the Page Hinkley Test", 50, 0.0, Float.MAX_VALUE); alphaOption = new FloatOption("alpha", 'a', "Alpha parameter of the Page Hinkley Test", 1 - 0.0001, 0.0, 1.0); RDDM: minNumInstancesOption = new IntOption("minNumInstances", 'n', "Minimum number of instances before monitoring changes.", 129, 0, Integer.MAX_VALUE); warningLevelOption = new FloatOption("warningLevel", 'w', "Warning Level.", 1.773, 1.0, 4.0); driftLevelOption = new FloatOption("driftLevel", 'o', "Drift Level.", 2.258, 1.0, 5.0); maxSizeConceptOption = new IntOption("maxSizeConcept", 'x', "Maximum Size of Concept.", 40000, 1, Integer.MAX_VALUE); minSizeStableConceptOption = new IntOption("minSizeStableConcept", 'y', "Minimum Size of Stable Concept.", 7000, 1, 20000); warnLimitOption = new IntOption("warnLimit", 'z', "Warning Limit of instances", 1400, 1, 20000); SEEDChangeDetector: deltaSEEDOption = new FloatOption("deltaSEED", 'd', "Delta value of SEED Detector", 0.05, 0.0, 1.0); blockSizeSEEDOption = new IntOption("blockSizeSEED", 'b', "BlockSize value of SEED Detector", 32, 32, 256); epsilonPrimeSEEDOption = new FloatOption("epsilonPrimeSEED", 'e', "EpsilonPrime value of SEED Detector", 0.01, 0.0025, 0.01); alphaSEEDOption = new FloatOption("alphaSEED", 'a', "Alpha value of SEED Detector", 0.8, 0.2, 0.8); compressTermSEEDOption = new IntOption("compressTermSEED", 'c', "CompressTerm value of SEED Detector", 75, 50, 100); SeqDrift1ChangeDetector: deltaOption = new FloatOption("deltaSeqDrift1", 'd', "Delta of SeqDrift1 change detection",0.01, 0.0, 1.0); deltaWarningOption = new FloatOption("deltaWarningOption", 'w', "Delta of SeqDrift1 change detector to declare warning state",0.1, 0.0, 1.0); blockSeqDriftOption = new IntOption("blockSeqDrift1Option",'b',"Block size of SeqDrift1 change detector", 200, 100, 10000); SeqDrift2ChangeDetector: deltaSeqDrift2Option = new FloatOption("deltaSeq2Drift", 'd', "Delta of SeqDrift2 change detection",0.01, 0.0, 1.0); blockSeqDrift2Option = new IntOption("blockSeqDrift2Option",'b',"Block size of SeqDrift2 change detector", 200, 100, 10000); EDDM: N/A """ # drift_detector_type = "SKMULTIFLOW_ADWIN" job_conf = { 'moa_jar_path': moa_jar_path, 'drift_detector_type': drift_detector_type, 'univariate_detector_type': drift_detector_type, 'threshold': 0.01, 'py4j_jar_path': py4j_jar_path, } logger.warning('Starting test') dump = False for univariate_cd in univariate_detector_types: job_conf['univariate_detector_type'] = univariate_cd job_conf['univariate_detector_options'] = univariate_detector_options[univariate_cd] print(">>> univariate_cd: %s" % univariate_cd) try: detection_steps = [] warning_steps = [] state = None for i, b in enumerate(batches): new_values = [value(x) for x in b] state = update_state(new_values, state, job_conf, dump) if state[1]["warning_detected"]: # logger.warning('Warning zone has been detected at index: %s, data: %s' % (i, str(b))) warning_steps.append(i) if state[1]["change_detected"]: # logger.warning('Change has been detected at index: %s, data: %s' % (i, str(b))) detection_steps.append(i) print('warning_steps (%s): %s' % (len(warning_steps), warning_steps)) print('detection_steps (%s): %s' % (len(detection_steps), detection_steps)) if not dump: state[0].gg.shutdown() except Exception as e: traceback.print_exc() print(">>> univariate_cd fails: %s, error: %s" % (univariate_cd, e))
} # In Memory # context = StreamingContext(spark.sparkContext, batch_duration) # lines = [[1, 2, 3], [4, 5, 6]] # stream = context.queueStream(lines) # Google storage # context = StreamingContext.getOrCreate(checkpointDirectory, create_context) # stream = context.textFileStream("gs://test1-sha456-logs-sink/data/") # spark._jsc.hadoopConfiguration().set('fs.gs.impl', 'com.google.cloud.hadoop.fs.gcs.GoogleHadoopFileSystem') # spark._jsc.hadoopConfiguration().set('fs.AbstractFileSystem.gs.impl', # 'com.google.cloud.hadoop.fs.gcs.GoogleHadoopFS') # spark._jsc.hadoopConfiguration().set('fs.gs.project.id', project_id) # spark._jsc.hadoopConfiguration().set('google.cloud.auth.service.account.enable', 'true') # spark._jsc.hadoopConfiguration().set('google.cloud.auth.service.account.json.keyfile', cred_location) # Pubsub context = StreamingContext.getOrCreate( checkpoint_directory, lambda: create_context(spark, checkpoint_directory, batch_duration)) stream = pubsub.PubsubUtils.createStream(context, subscription_name, batch_size, True) stream.flatMap(parse_request) \ .updateStateByKey(lambda new_values, state: update_state(new_values, state, job_conf)) \ .map(lambda state: publish_state_metric(state, pushgateway_url, myelin_ns, port, input_drift_probability_metric)) \ .foreachRDD(lambda rdd: write_state_to_bq(rdd, state_table)) context.start() context.awaitTermination()
def solve_lvl(environment, state, goals, current_plan, depth, max_depth, analysis): padding = "".join(["**" for x in range(0, len(current_plan))]) + " " plan = [] if analysis: print("Current Plan: {0}".format("\n".join( [x.simple_str() for x in current_plan]))) print("\n###############################\n") if len(goals) == 0: return plan if depth > max_depth: return None i = 0 while i < len(goals): goal = goals[i] if analysis: print padding + "Current Plan: {0}".format(" -> ".join( [x.simple_str() for x in current_plan])) print padding + "Subgoal: {0}".format(goal) print padding + "Other Goals: {0}".format(", ".join( [str(x) for x in goals[i + 1:]])) print padding + "State: {0}".format(", ".join( [str(s) for s in state])) raw_input("") if action_satisfied(state, goal): if analysis: raw_input(padding + "Goal is already reached!") print "" i += 1 continue possible_actions = sorted( get_possible_actions(environment, goal), key=lambda c: initial_state_count(state, c.preconditions)) # musimy znalesc podcel ktory pomoze nam osiagnac cel # znajdz wszystkie akcje ktore moga osiagnac cel if analysis: print padding + "set of possible actions which reach goal: {0}:".format( goal) print "\n".join( [padding + x.simple_str() for x in possible_actions]) raw_input("") action_found = False for action in possible_actions: if analysis: print padding + "Trying next action to reach goal: {0}:".format( goal) print padding + str(action).replace("\n", "\n" + padding) raw_input("") # sprawdza czy jest przynajmniej jedna akcja dla kazdego warunku ktora osiaga go if not preconditions_reachable(environment, action): if analysis: print padding + "Some preconditions not reachable by any possible action. Have to skip" raw_input("") continue # sprawdza czy jakas akcja zagraza innemu celowi if is_dangerous(goals, action): if analysis: print padding + "Action threaten another goal state. Have to skip" raw_input("") continue # jezeli akcja nie moze byc od razu odrzucona jako nieosiagalna, obnizaj if analysis: print padding + "Action cannot be rejected as unreachable. Have to descend..." raw_input("") temporary_state = list(state) subgoals = list(action.preconditions) current_plan.append(action) solution = solve_lvl(environment, temporary_state, subgoals, current_plan, depth + 1, max_depth, analysis) # jezeli nie znaleziono rozwiazania if solution is None: if analysis: print padding + "No solution found with this action. Have to skip..." current_plan.pop() continue if analysis: print padding + "Possible solution found!" raw_input("") # aktualizacja stanu o efekt ktory wprowadza nowa akcja for effect in action.effects: update_state(temporary_state, effect) # sprawdza czy stan nie usunal jakiegos z poprzednich podceli deleted = [ x for x in goals[0:i] if x != goal and not action_satisfied(temporary_state, x) ] deleted_length = len(deleted) if len(deleted) > 0: if analysis: print padding + "reach {0} but delete other goals: {1}".format( goal, ", ".join([str(x) for x in deleted])) print padding + "Re-adding the deleted goals to the end of the list" raw_input("") [goals.remove(x) for x in deleted] [goals.append(x) for x in deleted] i -= deleted_length if analysis: print padding + "New goals: {0}".format(", ".join( [str(x) for x in goals])) raw_input("") # dodaj podcel do celi plan.extend(solution) # akceptuj tymczasowy stan del state[:] state.extend(temporary_state) # dodaj akcje do planu plan.append(action) if analysis: print padding + "New State: " + ", ".join( [str(x) for x in state]) raw_input("") i += 1 action_found = True break if not action_found: if analysis: print "" raw_input("**" + padding + "No actions found to reach this subgoal. Go back...") print "" return None return plan
def respond_message(message): if message.text.startswith('/start'): register_user(message) message.text = emoji.demojize(message.text) t = Tracker.get_or_none(Tracker.id == message.chat.id) user = User.get_or_none(id=message.chat.id) if not t or not user: send_message( message.chat.id, ":cross_mark: Not a registered user. Please click on /start.") return # update the username with every message # this is important as it is the only way to find out the user identity User.update(username=message.chat.username, ).where( User.id == message.chat.id).execute() # ------------------------------------ # HOST a game # ------------------------------------ if t.state == 'start' and message.text == ":desktop_computer: Host a Game": host_start(message, user) # end game elif t.state == 'host_game' and message.text == ":cross_mark: Leave": host_leave(message, user) # select from a list of roles elif t.state == 'host_game' and message.text == ":right_arrow: Next": # FIXME: poll is deactivated. inline keyboard is used now. # host_select_roles_with_poll(message, user) host_select_roles(message, user) # select from a list of roles elif t.state == 'host_game' and message.text == ":envelope: Send Roles": host_send_roles(message, user) # ------------------------------------ # New Game # ------------------------------------ join_code_pattern = r"^/start (?P<code>\w{4})$" match = re.match(join_code_pattern, message.text) if match: code = match.group("code") message.text = code if t.state == 'start' and message.text == ":game_die: Join a Game": player_leave(message, user) elif t.state == 'join_game': player_start(message, user) elif t.state == 'start' and match: player_start(message, user) # ------------------------------------ # Change Name # ------------------------------------ if t.state == 'start' and message.text == ":bust_in_silhouette: Change Name": update_state(user, 'change_name') text = f":bust_in_silhouette: Current name: <b>{f2p(user.name)}</b>\n\n" text += ":input_latin_letters: Enter your new name:" send_message(user.id, text, reply_markup=create_keyboard([":cross_mark: Discard"])) elif t.state == 'change_name' and message.text == ":cross_mark: Discard": update_state(user, 'start') send_message(user.id, ":cross_mark: Discard", reply_markup=keyboards.main) elif t.state == 'change_name': if len(message.text) > 100: send_message(user.id, "Name length must be less than 100 characters.") return User.update(name=message.text).where(User.id == user.id).execute() update_state(user, 'start') send_message( user.id, f":white_heavy_check_mark: Your Name is updated now to: <b>{message.text}</b>", reply_markup=keyboards.main) # ------------------------------------ # Settings # ------------------------------------ if t.state == 'start' and message.text == ":gear_selector: Settings": edit_game_settings(message, user)