def __init__(self, inference_type, model_file): self._opt, state_dict = interactive.load_model_file(model_file) self._data_loader, self._text_encoder = interactive.load_data( inference_type, self._opt) n_ctx = self._get_n_ctx(self._data_loader) n_vocab = len(self._text_encoder.encoder) + n_ctx self._model = interactive.make_model(self._opt, n_vocab, n_ctx, state_dict)
def __init__(self, graph, model_path, decoding_algorithm): self.graph = graph self.model_path = model_path self.decoding_algorithm = decoding_algorithm self._opt, self._state_dict = interactive.load_model_file( self.model_path) self._data_loader, self._text_encoder = interactive.load_data( self.graph, self._opt) self._sampler = interactive.set_sampler(self._opt, self.decoding_algorithm, self._data_loader) self._n_ctx = self._calc_n_ctx() self._n_vocab = len(self._text_encoder.encoder) + self._n_ctx self._model = interactive.make_model(self._opt, self._n_vocab, self._n_ctx, self._state_dict) self._model.to(device=settings.device) self._input_event_model = None self._response_model = None self._annotator_input_model = None self._annotator_response_model = None
def fetch_model(args): opt, state_dict = interactive.load_model_file(args.model_file) data_loader, text_encoder = interactive.load_data("atomic", opt) n_ctx = data_loader.max_event + data_loader.max_effect n_vocab = len(text_encoder.encoder) + n_ctx model = interactive.make_model(opt, n_vocab, n_ctx, state_dict) if args.device != "cpu": cfg.device = int(args.device) cfg.do_gpu = True torch.cuda.set_device(cfg.device) model.cuda(cfg.device) else: cfg.device = "cpu" # Set the sampling algorithm sampling_algorithm = args.sampling_algorithm sampler = interactive.set_sampler(opt, sampling_algorithm, data_loader) return model, sampler, data_loader, text_encoder
import src.data.config as cfg import src.interactive.functions as interactive if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("--device", type=str, default="cpu") parser.add_argument("--model_file", type=str, default="models/atomic-generation/iteration-500-50000/transformer/categories_oEffect#oReact#oWant#xAttr#xEffect#xIntent#xNeed#xReact#xWant/model_transformer-nL_12-nH_12-hSize_768-edpt_0.1-adpt_0.1-rdpt_0.1-odpt_0.1-pt_gpt-afn_gelu-init_pt-vSize_40542/exp_generation-seed_123-l2_0.01-vl2_T-lrsched_warmup_linear-lrwarm_0.002-clip_1-loss_nll-b2_0.999-b1_0.9-e_1e-08/bs_1-smax_40-sample_greedy-numseq_1-gs_1000-es_1000-categories_oEffect#oReact#oWant#xAttr#xEffect#xIntent#xNeed#xReact#xWant/6.25e-05_adam_64_22000.pickle") parser.add_argument("--sampling_algorithm", type=str, default="help") args = parser.parse_args() opt, state_dict = interactive.load_model_file(args.model_file) data_loader, text_encoder = interactive.load_data("atomic", opt) n_ctx = data_loader.max_event + data_loader.max_effect n_vocab = len(text_encoder.encoder) + n_ctx model = interactive.make_model(opt, n_vocab, n_ctx, state_dict) if args.device != "cpu": cfg.device = int(args.device) cfg.do_gpu = True torch.cuda.set_device(cfg.device) model.cuda(cfg.device) else: cfg.device = "cpu" while True: input_event = "help"
def load_and_cache_examples(args, tokenizer, evaluate=False, output_examples=False): # COMET model setting up device = "0" comet_model = "pretrained_models/atomic_pretrained_model.pickle" sampling_algo = "beam-2" opt, state_dict = interactive.load_model_file(comet_model) data_loader, text_encoder = interactive.load_data("atomic", opt) n_ctx = data_loader.max_event + data_loader.max_effect n_vocab = len(text_encoder.encoder) + n_ctx model = interactive.make_model(opt, n_vocab, n_ctx, state_dict) nlp = spacy.load("en_core_web_sm") if device != "cpu": cfg.device = int(device) cfg.do_gpu = True torch.cuda.set_device(cfg.device) model.cuda(cfg.device) else: cfg.device = "cpu" sampling_algorithm = sampling_algo sampler = interactive.set_sampler(opt, sampling_algorithm, data_loader) def augment(article): context = (article.numpy().decode('UTF-8')) category_list = ["xNeed", "xIntent", "xWant", "xReact"] for category in category_list: entity_list = nlp(context) input_event = context replaced = [] replacement_list = ["PersonX", "PersonY", "PersonZ"] r = 0 for entity in entity_list.ents: if entity.label_ == 'PERSON' or entity.label_ == 'NORP': input_event = input_event.replace(entity.text, replacement_list[r]) r += 1 if (r == 3): break outputs = interactive.get_atomic_sequence(input_event, model, sampler, data_loader, text_encoder, category) for key in outputs: prefix = "" if (key[0] == "o"): if (key == "oEffect"): prefix = " Everyone else " elif (key == "oReact"): prefix = "They are " elif (key == "oWant"): prefix = "They want " else: if (len(replaced) != 0): prefix = replaced[0] else: prefix = "Person" if (key == "xAttr"): prefix += " is " elif (key == "xEffect"): prefix += " " elif (key == "xIntent"): prefix += " intends " elif (key == "xReact"): prefix += " is " elif (key == "xNeed"): prefix += " needs " elif (key == "xWant"): prefix += " wants " for j in range(5): if (outputs[key]["beams"][j] != 'none'): comet_inf = outputs[key]["beams"][j] if (len(replaced) > 0): comet_inf = comet_inf.replace( "personx", replaced[0]) if (len(replaced) > 1): comet_inf = comet_inf.replace( "persony", replaced[1]) article += prefix + (comet_inf) + ". " break return article def process_example(example): example['context'] = tf.py_function(func=augment, inp=[example['context']], Tout=tf.string) return example ## End if args.local_rank not in [-1, 0] and not evaluate: # Make sure only the first process in distributed training process the dataset, and the others will use the cache torch.distributed.barrier() # Load data features from cache or dataset file input_dir = args.data_dir if args.data_dir else "." cached_features_file = os.path.join( input_dir, "cached_{}_{}_{}".format( "dev" if evaluate else "train", list(filter(None, args.model_name_or_path.split("/"))).pop(), str(args.max_seq_length), ), ) # Init features and dataset from cache if it exists if os.path.exists(cached_features_file) and not args.overwrite_cache: logger.info("Loading features from cached file %s", cached_features_file) features_and_dataset = torch.load(cached_features_file) features, dataset, examples = ( features_and_dataset["features"], features_and_dataset["dataset"], features_and_dataset["examples"], ) else: logger.info("Creating features from dataset file at %s", input_dir) if not args.data_dir and ((evaluate and not args.predict_file) or (not evaluate and not args.train_file)): try: import tensorflow_datasets as tfds except ImportError: raise ImportError( "If not data_dir is specified, tensorflow_datasets needs to be installed." ) if args.version_2_with_negative: logger.warn( "tensorflow_datasets does not handle version 2 of SQuAD.") tfds_examples = tfds.load("squad") tfds_examples["train"] = tfds_examples["train"].map( lambda x: process_example(x)) examples = SquadV1Processor().get_examples_from_dataset( tfds_examples, evaluate=evaluate) else: processor = SquadV2Processor( ) if args.version_2_with_negative else SquadV1Processor() if evaluate: examples = processor.get_dev_examples( args.data_dir, filename=args.predict_file) else: examples = processor.get_train_examples( args.data_dir, filename=args.train_file) features, dataset = squad_convert_examples_to_features( examples=examples, tokenizer=tokenizer, max_seq_length=args.max_seq_length, doc_stride=args.doc_stride, max_query_length=args.max_query_length, is_training=not evaluate, return_dataset="pt", threads=args.threads, ) if args.local_rank in [-1, 0]: logger.info("Saving features into cached file %s", cached_features_file) torch.save( { "features": features, "dataset": dataset, "examples": examples }, cached_features_file) if args.local_rank == 0 and not evaluate: # Make sure only the first process in distributed training process the dataset, and the others will use the cache torch.distributed.barrier() if output_examples: return dataset, examples, features return dataset
def _create_examples(self, lines, labels, is_training): """Creates examples for the training and dev sets.""" # if type == "train" and lines[0][-1] != "label": # raise ValueError("For training, the input file must contain a label column.") device = 0 comet_model = "pretrained_models/atomic_pretrained_model.pickle" sampling_algo = "beam-5" opt, state_dict = interactive.load_model_file(comet_model) data_loader, text_encoder = interactive.load_data("atomic", opt) # data_loader.max_event = 30 n_ctx = data_loader.max_event + data_loader.max_effect n_vocab = len(text_encoder.encoder) + n_ctx model = interactive.make_model(opt, n_vocab, n_ctx, state_dict) nlp = spacy.load("en_core_web_sm") if device != "cpu": cfg.device = int(device) cfg.do_gpu = True torch.cuda.set_device(cfg.device) model.cuda(cfg.device) else: cfg.device = "cpu" # import pdb; pdb.set_trace() # print(model) # cuda_check = model.is_cuda # if cuda_check: # print("im on the gpu bro") sampling_algorithm = sampling_algo sampler = interactive.set_sampler(opt, sampling_algorithm, data_loader) examples = [] # print(lines[5]["context"]) # print("jere") # aug_context = augment(lines[5]["context"]) FAIL_COUNT = 0 data_loader.max_event = 17 wentToPast = False i = 0 while (i < len(lines) - 2): # while(i < 2): # while(i < 5530): if i % 50 == 0: print("WTF: ", i) # print(lines[i]["context"]) # import pdb; pdb.set_trace() new_context = lines[i]["context"].split()[:30] new_context = ' '.join(new_context) # print("KIRBY: ", new_context) # aug_context = augment(new_context) # if wentToPast: # data_loader.max_event = 17 # wentToPast = False try: # print("HERE; ", data_loader.max_event, len(examples)) aug_context = self.augment(new_context, data_loader, nlp, model, sampler, text_encoder) # print("HI FRIENDS") examples += [ SQA(input_id=str(i), contexts=aug_context, question=lines[i]["question"], choice_1=lines[i]["answerA"], choice_2=lines[i]["answerB"], choice_3=lines[i]["answerC"], label=str(int(labels[i]) - 1)) ] i = i + 1 # data_loader.max_event = 17 # print(len(examples)) except: wentToPast = True FAIL_COUNT += 1 # print("Bruh I failed, help me redeem myself: " + lines[i]["context"]) # print(FAIL_COUNT) # print("length of failed sentence") # data_loader.max_event = 17 # i -= 1 print("TOTAL EXAMPLES TODAY IS: ", len(examples)) print(examples) return examples
# %% sentence_model = SentenceTransformer( "stsb-distilbert-base", device=('cuda:' + args.device if torch.cuda.is_available() else 'cpu')) kb_model = KeyBERT(model=sentence_model) bc = BertClient() # start bert service command: # bert-serving-start -model_dir ~/.bert-as-service/uncased_L-24_H-1024_A-16/ -num_worker=4 # or # nohup bert-serving-start -model_dir ~/.bert-as-service/uncased_L-24_H-1024_A-16/ -num_worker=4 & # %% opt, state_dict = interactive.load_model_file(args.model_file) data_loader, text_encoder = interactive.load_data("conceptnet", opt) n_ctx = data_loader.max_e1 + data_loader.max_e2 + data_loader.max_r n_vocab = len(text_encoder.encoder) + n_ctx comet_model = interactive.make_model(opt, n_vocab, n_ctx, state_dict) if args.device != "cpu": cfg.device = int(args.device) cfg.do_gpu = True torch.cuda.set_device(cfg.device) comet_model.cuda(cfg.device) else: cfg.device = "cpu" # %% [markdown]
import pandas as pd if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("--device", type=str, default="1") parser.add_argument("--model_file", type=str, default="models/motiv_sent-generation/motiv_model.pickle") parser.add_argument("--sampling_algorithm", type=str, default="beam-4") # greedy; beam-# where # is the beam size; topk-# where # is k args = parser.parse_args() opt, state_dict = interactive.load_model_file(args.model_file) data_loader, text_encoder = interactive.load_data("motiv_sent", opt) n_ctx = data_loader.max_event + data_loader.max_effect n_vocab = len(text_encoder.encoder) + n_ctx model = interactive.make_model(opt, n_vocab, n_ctx, state_dict) if args.device != "cpu": cfg.device = int(args.device) cfg.do_gpu = True torch.cuda.set_device(cfg.device) model.cuda(cfg.device) else: cfg.device = "cpu" sampling_algorithm = args.sampling_algorithm print(f"cfg.device: {cfg.device}")
"--model_file", type=str, default= "models/atomic-generation/iteration-500-50000/transformer/categories_oEffect#oReact#oWant#xAttr#xEffect#xIntent#xNeed#xReact#xWant/model_transformer-nL_12-nH_12-hSize_768-edpt_0.1-adpt_0.1-rdpt_0.1-odpt_0.1-pt_gpt-afn_gelu-init_pt-vSize_40542/exp_generation-seed_123-l2_0.01-vl2_T-lrsched_warmup_linear-lrwarm_0.002-clip_1-loss_nll-b2_0.999-b1_0.9-e_1e-08/bs_1-smax_40-sample_greedy-numseq_1-gs_1000-es_1000-categories_oEffect#oReact#oWant#xAttr#xEffect#xIntent#xNeed#xReact#xWant/6.25e-05_adam_64_22000.pickle" ) parser.add_argument("--sampling_algorithm", type=str, default="help") parser.add_argument("--loader_path", type=str, default="") args = parser.parse_args() opt, state_dict = interactive.load_model_file(args.model_file) #OLD #data_loader, text_encoder = interactive.load_data("atomic", opt) #ADRIAN ADDED data_loader, text_encoder = interactive.load_data("atomic", opt, args.loader_path) ### n_ctx = data_loader.max_event + data_loader.max_effect n_vocab = len(text_encoder.encoder) + n_ctx model = interactive.make_model(opt, n_vocab, n_ctx, state_dict) if args.device != "cpu": cfg.device = int(args.device) cfg.do_gpu = True torch.cuda.set_device(cfg.device) model.cuda(cfg.device) else: cfg.device = "cpu" #ADRIAN ADDED