def test_model_invalid_input_shape(): num_classes = 1 for input_shape in [(123, 567, 3)]: with pytest.raises(ValueError): get_model(num_classes=num_classes, weights=None, input_shape=input_shape)
def ask_question_(question): print("Question:", question) reference = find_references2(question) if len(reference) == 0: return model_, tokenizer_ = m.get_model() encoded = tokenizer_.encode_plus(question, reference) # To separate our question and answer in the input to the model, # we want to create a binary mask for question and answer # sep_index = encoded.index(tokenizer_.sep_token_id) # question_len = sep_index + 1 # answer_len = len(encoded) - question_len # token_type_ids = [0] * question_len + [1] * answer_len token_type_ids = encoded['token_type_ids'] [start, end] = model_(torch.tensor([encoded['input_ids']]), token_type_ids=torch.tensor([token_type_ids])) answer_start = torch.argmax(start) answer_end = torch.argmax(end) answer__ = torch.max(start) end__ = torch.max(end) tokens = tokenizer_.convert_ids_to_tokens(encoded['input_ids']) answer = recreate_answer(tokens, answer_start, answer_end) print('Answer: ', answer)
def main(): print('loading data...') tokenizer = FullTokenizer(config.bert_vocab, do_lower_case=config.to_lower) pos_2_id, id_2_pos = read_dict(config.pos_dict) tag_2_id, id_2_tag = read_dict(config.tag_dict) config.num_pos = len(pos_2_id) config.num_tag = len(tag_2_id) data_reader = DataReader(config, tokenizer, pos_2_id, tag_2_id) input_file = args.input print('input file: {}'.format(input_file)) input_data = data_reader.load_data_from_file(input_file) print('building model...') model = get_model(config, is_training=False) saver = tf.train.Saver(max_to_keep=1) with tf.Session(config=sess_config) as sess: if tf.train.latest_checkpoint(config.result_dir): saver.restore(sess, tf.train.latest_checkpoint(config.result_dir)) print('loading model from {}'.format(tf.train.latest_checkpoint(config.result_dir))) batch_iter = make_batch_iter(list(zip(*input_data)), config.batch_size, shuffle=False) outputs = inference(sess, model, batch_iter, verbose=True) print('========== Saving Result ==========') output_file = args.output save_result(outputs, output_file, tokenizer, id_2_tag) else: print('model not found.') print('done')
def ask_question(question, model_=None, tokenizer_=None): print("Question:", question) reference = find_reference_scp_universal(question) print("Reference:\n", reference) if reference is None or len(reference) == 0: return QuestionResults.NO_REF_FOUND, "[NO REF FOUND]" if model_ is None: model_, tokenizer_ = m.get_model() encoded = tokenizer_.encode_plus(question, reference) token_type_ids = encoded['token_type_ids'] [start, end] = model_(torch.tensor([encoded['input_ids']]), token_type_ids=torch.tensor([token_type_ids])) answer_start = torch.argmax(start) answer_end = torch.argmax(end) answer__ = torch.max(start) end__ = torch.max(end) tokens = tokenizer_.convert_ids_to_tokens(encoded['input_ids']) answer = recreate_answer(tokens, answer_start, answer_end) print('Answer: ', answer) log(question, reference, answer) return QuestionResults.OK, answer
def test(): print('loading data...') tokenizer = FullTokenizer(config.bert_vocab, do_lower_case=config.to_lower) pos_2_id, id_2_pos = read_dict(config.pos_dict) tag_2_id, id_2_tag = read_dict(config.tag_dict) config.num_pos = len(pos_2_id) config.num_tag = len(tag_2_id) data_reader = DataReader(config, tokenizer, pos_2_id, tag_2_id) test_data = data_reader.read_test_data() print('building model...') model = get_model(config, is_training=False) saver = tf.train.Saver(max_to_keep=1) with tf.Session(config=sess_config) as sess: if tf.train.latest_checkpoint(config.result_dir): saver.restore(sess, tf.train.latest_checkpoint(config.result_dir)) print('loading model from {}'.format(tf.train.latest_checkpoint(config.result_dir))) print('========== Test ==========') test_batch_iter = make_batch_iter(list(zip(*test_data)), config.batch_size, shuffle=False) outputs, test_loss, test_accu = evaluate(sess, model, test_batch_iter, verbose=True) print('The average test loss is {:>.4f}, average test accuracy is {:>.4f}'.format(test_loss, test_accu)) print('========== Saving Result ==========') save_result(outputs, config.test_result, tokenizer, id_2_tag) else: print('model not found.') print('done')
def test_model_valid_input_shape(): num_classes = 1 for input_shape in [(160, 576, 3), (320, 1152, 3)]: model = get_model(num_classes=num_classes, weights=None, input_shape=input_shape) y_pred = model.predict(np.expand_dims(np.random.randn(*input_shape), 0)) assert (y_pred.shape[1:3] == input_shape[:2]) assert (y_pred.shape[3] == num_classes)
def main(settings): print('Attempting to load Dataframes...') distributionDF = load_df(settings, DISTRIB_FILE) wordsDF = load_df(settings, WORDS_FILE) if settings['reloadData'] or settings['retrainModel'] or ( distributionDF is None or wordsDF is None): model, bow_corpus, corpusDF = get_model(settings) print('Calculating Dataframes...') distributionDF, wordsDF = createMatrix(settings, model, bow_corpus, corpusDF) save_to_excel(settings, distributionDF, wordsDF) save_figures(settings, distributionDF, wordsDF, n=settings['nbFigures'])
def test(): print('load data...') word_2_id, id_2_word = read_dict(config.word_dict) accu_2_id, id_2_accu = read_dict(config.accu_dict) art_2_id, id_2_art = read_dict(config.art_dict) if os.path.exists(config.word2vec_model): embedding_matrix = load_embedding(config.word2vec_model, word_2_id.keys()) else: embedding_matrix = np.random.uniform( -0.5, 0.5, [len(word_2_id), config.embedding_size]) data_reader = DataReader(config) test_data = data_reader.read_test_data(word_2_id, accu_2_id, art_2_id) art_data = data_reader.read_article(art_2_id.keys(), word_2_id) print('build model...') with tf.variable_scope('model'): model = get_model(config, embedding_matrix, is_training=False) saver = tf.train.Saver(max_to_keep=1) with tf.Session(config=config_proto) as sess: print('load model from: ' + config.model_file) saver.restore(sess, config.model_file) print('========== Test ==========') test_batch_iter = make_batch_iter(list(zip(*test_data)), config.batch_size, shuffle=False) outputs = inference(sess, model, test_batch_iter, art_data, verbose=True) save_result(outputs, config.test_result, id_2_accu, id_2_art) result = judger.get_result(config.test_data, config.test_result) accu_micro_f1, accu_macro_f1 = judger.calc_f1(result[0]) article_micro_f1, article_macro_f1 = judger.calc_f1(result[1]) score = [(accu_micro_f1 + accu_macro_f1) / 2, (article_micro_f1 + article_macro_f1) / 2] print('Micro-F1 of accusation: %.4f' % accu_micro_f1) print('Macro-F1 of accusation: %.4f' % accu_macro_f1) print('Micro-F1 of relevant articles: %.4f' % article_micro_f1) print('Macro-F1 of relevant articles: %.4f' % article_macro_f1) print('Score: ', score)
def model_fn(features, labels, mode, params): features = tf.reshape(features["x"], [-1, 28, 28, 1]) model = get_model() if mode == tf.estimator.ModeKeys.PREDICT: logits = model(features, training=False) elif mode == tf.estimator.ModeKeys.EVAL: logits = model(features, training=False) elif mode == tf.estimator.ModeKeys.TRAIN: logits = model(features, training=True) predicted_classes = tf.argmax(logits, 1) if mode == tf.estimator.ModeKeys.PREDICT: predictions = { 'class_ids': predicted_classes[:, tf.newaxis], 'probabilities': tf.nn.softmax(logits), 'logits': logits, } return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions) # Compute loss. loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits) # Compute evaluation metrics. accuracy = tf.metrics.accuracy(labels=labels, predictions=predicted_classes, name='acc_op') metrics = {'accuracy': accuracy} tf.summary.scalar('accuracy', accuracy[1]) tf.summary.scalar('loss', loss) if mode == tf.estimator.ModeKeys.EVAL: return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=metrics) # Create training op. assert mode == tf.estimator.ModeKeys.TRAIN optimizer = tf.train.AdamOptimizer(learning_rate=0.01) train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step()) return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)
def train(args: argparse.Namespace) -> None: """ Training script copied from here https://github.com/elleobrien/Dog_Breed_Classifier/blob/master/breed_classifier.py """ # todo: try PYTHONHASHSEED np.random.seed(RD_SEED) tf.random.set_seed(RD_SEED) rn.seed(RD_SEED) mlflow.log_metric("test_size", TEST_SIZE) images, labels = split_json(args.data_description) X_train, X_test, Y_train, Y_test = train_test_split( images, labels, test_size=TEST_SIZE, stratify=labels, random_state=SPLIT_SEED) train_ds = DogsDataset( args.data_dir, X_train, Y_train, CLASS_ENCODING, ) validation_ds = DogsDataset( args.data_dir, X_test, Y_test, CLASS_ENCODING, ) model = get_model() history = model.fit( train_ds, epochs=EPOCHS, validation_data=validation_ds, ) final_val_acc = history.history["val_acc"][-1] print("Validation Accuracy: %1.3f" % (final_val_acc))
def model_predict(model_id): """ POST /model/<model_id>/prediction asks for a new prediction from this specific model. The format of the input request is: { "input" : "sample text to classify" } :param model_id: ID of model stored in model info entry :return: """ info_dict = conn.find(model_id) model = get_model('FastTextModel', info_dict['location'], 'MinioLoader')\ .load(app.instance_path) if model is None: raise ModelException('Model could not be found at path: {}'.format( app.instance_path)) try: to_predict = json.loads(request.data.decode('utf-8'))['input'] except Exception as e: return jsonify('Could not load input as JSON: ' + str(e)) prediction = model.predict(to_predict) result = {'label': prediction[0][0], 'score': prediction[1][0]} return jsonify(result)
models = [] labels = [] for conf in args.modelsConfig: if os.path.isfile(conf): paramPath = None with open(conf, "r") as stream: modelDict = yaml.load(stream) elif os.path.isdir(conf): maxStep = 0 path = os.path.join(conf, "learner") paramDirs = os.listdir(os.path.join(conf, "learner")) for paramDir in paramDirs: if paramDir.startswith("weights_step"): name = paramDir.split('/')[0] step = int(re.findall(r'\d+', name)[0]) if step > maxStep: paramPath = os.path.join(path, paramDir) maxStep = step modelFile = os.path.join(conf, "controller", "model.yaml") with open(modelFile, "r") as stream: modelDict = yaml.load(stream) models.append( get_model(modelDict, tf.Variable(1), 0.1, 13, 6, modelDict['type'], paramPath)) labels.append(modelDict['type']) test_models(args.actionSequence, args.groundTruth, models, labels, args.time)
import json questions = [ "What is SCP-%NUM%?", "Who created SCP-%NUM%?", "IS SCP-%NUM% hostile?", "How big is SCP-%NUM%?", "How tall is SCP-%NUM%?" ] SCPs = [i + 101 for i in range(100)] results = [] print("Preparing model...") model, tokenizer = m.get_model() def question_worker(question, scp): question = question.replace("%NUM%", str(scp)) # print("Asking " + question) result, answer = load.ask_question(question) # print("Answer: " + answer) global results results += [{"scp": scp, "question": question, "answer": answer}] return result == load.QuestionResults.OK threads = [] i = 0 total = len(SCPs) * len(questions)
parser = argparse.ArgumentParser() parser.add_argument('-task', help='evaluation configuration') args = parser.parse_args() eval_config = args.task config_path = './configs/config.yaml' with open(config_path, 'r') as f: cfg = yaml.load(f, Loader=yaml.FullLoader) num_workers = cfg['train']['num_workers'] device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # generate trainer model = get_model(input_dim=1192, neuron_hidden_layers=[50, 25, 10], device=device) model.to(device) test_dataset = get_dataset('./test', "test_demo") test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=cfg['test']['batch_size'], num_workers=num_workers, shuffle=False) optimizer = torch.optim.Adam(model.parameters(), lr=1e-4) if eval_config == "depth": model_path = '../weights_in_all/attention/model_d.pt' out_img_path = 'test_d.png' else: model_path = '../weights_in_all/attention/model.pt' out_img_path = 'test_s.png' model.load_state_dict(torch.load(model_path)) trainer = Trainer(model, optimizer, device)
def fit_model(model_name, batch_size=16, n_fold=1, shape=384): n_classes = 10 aug = partial(augment, expected_shape=shape) n_fold = int(n_fold) batch_size = int(batch_size) model, preprocess = get_model(model_name, shape, n_classes=n_classes) def make_config(**kwargs): d = { 'n_fold': int(n_fold), 'transform': preprocess, 'batch_size': batch_size, 'train': True, 'size': shape, 'aug': aug, 'center_crop_size': 0 } d.update(kwargs) return d kaggle_train = KaggleDataset(**make_config()) kaggle_val = KaggleDataset(**make_config(train=False)) pseudo_train = PseudoDataset(**make_config()) pseudo_val = PseudoDataset(**make_config(train=False)) extra_train = ExtraDataset(**make_config()) extra_val = ExtraDataset(**make_config(train=False)) frozen_epochs = 1 steps_per_epoch = 500 validation_steps = 50 loss = 'categorical_crossentropy' model.compile(optimizer='adam', loss=loss, metrics=['accuracy']) model.fit_generator( DataCollection(kaggle_train, extra_train, pseudo_train), epochs=frozen_epochs, steps_per_epoch=steps_per_epoch, validation_data=DataCollection(kaggle_val, extra_val, pseudo_val), workers=8, validation_steps=validation_steps, use_multiprocessing=False, max_queue_size=50, ) for layer in model.layers: layer.trainable = True epoch = frozen_epochs for stage, (train, val) in enumerate(( (DataCollection(kaggle_train, extra_train, pseudo_train), DataCollection(kaggle_val, extra_val, pseudo_val)), (DataCollection(kaggle_train, pseudo_train), DataCollection(kaggle_val, pseudo_val)), (DataCollection(pseudo_train), DataCollection(pseudo_val)), )): model, epoch = fit_once(model=model, model_name=model_name, loss='categorical_crossentropy', train=train, val=val, start_epoch=epoch, stage=stage, n_fold=n_fold, initial=True if stage > 0 else False)
def main(): torch.manual_seed(317) torch.backends.cudnn.benckmark = True train_logger = Logger(opt, "train") val_logger = Logger(opt, "val") start_epoch = 0 print('Creating model...') model = get_model(opt.arch, opt.heads).to(opt.device) optimizer = torch.optim.Adam(model.parameters(), opt.lr) criterion = CtdetLoss(opt) print('Loading model...') if opt.load_model != '': model, optimizer, start_epoch = load_model( model, opt.load_model, optimizer, opt.lr, opt.lr_step) model = torch.nn.DataParallel(model) # amp scaler = GradScaler() print('Setting up data...') train_dataset = Dataset(opt, 'train') val_dataset = Dataset(opt, 'val') train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=16, pin_memory=True, drop_last=True ) val_loader = torch.utils.data.DataLoader( val_dataset, batch_size=1, shuffle=False, num_workers=1, pin_memory=True ) # cal left time time_stats = TimeMeter(opt.num_epochs, len(train_loader)) for epoch in range(start_epoch + 1, opt.num_epochs + 1): print('train...') train(model, train_loader, criterion, optimizer, train_logger, opt, epoch, scaler, time_stats) if epoch % opt.val_intervals == 0: print('val...') val(model, val_loader, criterion, val_logger, opt, epoch) save_model(os.path.join(opt.save_dir, f'model_{epoch}.pth'), epoch, model, optimizer) # update learning rate if epoch in opt.lr_step: lr = opt.lr * (0.1 ** (opt.lr_step.index(epoch) + 1)) print('Drop LR to', lr) for param_group in optimizer.param_groups: param_group['lr'] = lr # without optimizer save_model(os.path.join(opt.save_dir, 'model_final.pth'), epoch, model)
create_matrices(train, word_index, label_index, case_index, char_index, pos_tag_index)) validation_set = padding( create_matrices(validation, word_index, label_index, case_index, char_index, pos_tag_index)) test_set = padding( create_matrices(test, word_index, label_index, case_index, char_index, pos_tag_index)) idx2Label = {v: k for k, v in label_index.items()} train_batch, train_batch_len = create_batches(train_set) dev_batch, dev_batch_len = create_batches(validation_set) test_batch, test_batch_len = create_batches(test_set) model = get_model(wordEmbeddings, caseEmbeddings, char_index, label_index, posTagEmbedding) epochs = 80 for epoch in range(epochs): print("Epoch %d/%d" % (epoch, epochs)) for i, batch in enumerate( iterate_mini_batches(train_batch, train_batch_len)): labels, tokens, casing, char, pos_tag = batch model.train_on_batch([tokens, pos_tag, casing, char], labels) # Performance on dev dataset predLabels, correctLabels = tag_dataset(dev_batch) pre_dev, rec_dev, f1_dev = compute_f1(predLabels, correctLabels, idx2Label) print("Dev-Data: Prec: %.5f, Rec: %.5f, F1: %.5f" % (pre_dev, rec_dev, f1_dev)) # Performance on test dataset
def fit_model(model_name, partial_fit=False, batch_size=32, n_fold=1, shape=384): n_fold = int(n_fold) batch_size = int(batch_size) if partial_fit: logger.info(f'Using existing model {model_name}') model = load_model(model_name) preprocess = preprocess_input else: model, preprocess = get_model(model_name, shape, n_classes=14951) train = Dataset(n_fold=n_fold, batch_size=batch_size, transform=preprocess, train=True, size=shape, aug=augment, file_list='data/train.csv') val = Dataset(n_fold=n_fold, batch_size=batch_size, transform=preprocess, train=False, size=shape, aug=augment, file_list='data/train.csv') frozen_epochs = 1 steps_per_epoch = len(train.data) // batch_size // 100 validation_steps = 100 loss = 'categorical_crossentropy' if not partial_fit: model.compile(optimizer='adam', loss=loss, metrics=['accuracy']) model.fit_generator( train, epochs=frozen_epochs, steps_per_epoch=steps_per_epoch, validation_data=val, workers=8, validation_steps=validation_steps, use_multiprocessing=False, callbacks=get_callbacks(model_name, 'frozen', n_fold), max_queue_size=50, ) for layer in model.layers: layer.trainable = True else: model_name = model_name.split('/')[1].split('_')[0] logger.info(f'model name is {model_name}') fit_once( model=model, model_name=model_name, loss='categorical_crossentropy', train=train, val=val, start_epoch=frozen_epochs, n_fold=n_fold, )
def main(): os.makedirs(config.temp_dir, exist_ok=True) os.makedirs(config.result_dir, exist_ok=True) os.makedirs(config.train_log_dir, exist_ok=True) logger.setLevel(logging.INFO) init_logger(logging.INFO) logger.info('loading dict...') config.src_2_id, config.id_2_src = read_json_dict(config.src_vocab_dict) config.src_vocab_size = min(config.src_vocab_size, len(config.src_2_id)) config.tgt_2_id, config.id_2_tgt = read_json_dict(config.tgt_vocab_dict) config.tgt_vocab_size = min(config.tgt_vocab_size, len(config.tgt_2_id)) data_reader = DataReader(config) evaluator = Evaluator('tgt') logger.info('building model...') model = get_model(config) saver = tf.train.Saver(max_to_keep=10) if args.do_train: logger.info('loading data...') train_data = data_reader.load_train_data() valid_data = data_reader.load_valid_data() logger.info(log_title('Trainable Variables')) for v in tf.trainable_variables(): logger.info(v) logger.info(log_title('Gradients')) for g in model.gradients: logger.info(g) with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) else: logger.info('initializing from scratch...') tf.global_variables_initializer().run() train_writer = tf.summary.FileWriter(config.train_log_dir, sess.graph) valid_log_history = run_train(sess, model, train_data, valid_data, saver, evaluator, train_writer) save_json( valid_log_history, os.path.join(config.result_dir, config.current_model, 'valid_log_history.json')) if args.do_eval: logger.info('loading data...') valid_data = data_reader.load_valid_data() with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) predicted_ids, valid_loss, valid_accu = run_evaluate( sess, model, valid_data) logger.info( 'average valid loss: {:>.4f}, average valid accuracy: {:>.4f}' .format(valid_loss, valid_accu)) logger.info(log_title('Saving Result')) save_outputs(predicted_ids, config.id_2_tgt, config.valid_data, config.valid_outputs) results = evaluator.evaluate(config.valid_data, config.valid_outputs, config.to_lower) save_json(results, config.valid_results) else: logger.info('model not found!') if args.do_test: logger.info('loading data...') test_data = data_reader.load_test_data() with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) predicted_ids = run_test(sess, model, test_data) logger.info(log_title('Saving Result')) save_outputs(predicted_ids, config.id_2_tgt, config.test_data, config.test_outputs) results = evaluator.evaluate(config.test_data, config.test_outputs, config.to_lower) save_json(results, config.test_results) else: logger.info('model not found!')
raw_corpus = read_corpus(corpus_path) print "corpus size:", len(raw_corpus) # 167765 ##convert raw_corpus to ids_corpus ids_corpus = map_corpus(raw_corpus, embeddings, word_to_indx, max_len=100) ###read annotation data train = read_annotations(args.train, num_neg=20) dev_path = 'data/dev.txt' dev = read_annotations(args.dev, num_neg=20) test_path = 'data/test.txt' test = read_annotations(args.test, num_neg=20) # print "num of training queries:", len(train) # print "number of dev queries:", len(dev) ##189 # print "number of test queries:", len(test) ##186 ##Load model model = get_model(embeddings, args, ids_corpus) print(model) if args.cuda: model = model.cuda() # train if args.mode == 1: #training optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate, weight_decay=0) train_model(ids_corpus, model, train, dev, test)
import tensorflow as tf from src.model import get_model BATCH_SIZE = 1 x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, None, 3]) adj = tf.placeholder(tf.int32, shape=[BATCH_SIZE, None, 10]) x_hole y = tf.placeholder(tf.float32, shape=[BATCH_SIZE, None, 3]) is_training = tf.placeholder(tf.bool) #[1,input_size,3] output = get_model(x, adj,is_training)
("TTA Averaged", "Single inference")) if add_selectbox == "Single Inference": TTA = 1 st.set_option('deprecation.showfileUploaderEncoding', False) file_buffer = st.file_uploader("Upload Image:", type="jpg") try: if file_buffer is not None: image = Image.open(file_buffer) image = cv2.cvtColor( np.array(image).transpose((1, 0, 2)), cv2.COLOR_BGR2RGB) if DEBUG: st.write(image.shape) st.image(image, use_column_width=True) model = get_model(RESNEST_MODEL) model = load_weights( model=model, model_ckpt_path=MODEL_CKPT_PATH, ) if DEBUG: print(type(model)) predictions = [] for _ in range(TTA): predictions.append( infer_once( image=image, transforms=INFER_TRANSFORMS, model=model, debug=DEBUG,
def train(): if not os.path.exists(config.result_dir): os.makedirs(config.result_dir) if not os.path.exists(config.train_log_dir): os.mkdir(config.train_log_dir) if not os.path.exists(config.valid_log_dir): os.mkdir(config.valid_log_dir) print('loading data...') tokenizer = FullTokenizer(config.bert_vocab, do_lower_case=config.to_lower) pos_2_id, id_2_pos = read_dict(config.pos_dict) tag_2_id, id_2_tag = read_dict(config.tag_dict) config.num_pos = len(pos_2_id) config.num_tag = len(tag_2_id) data_reader = DataReader(config, tokenizer, pos_2_id, tag_2_id) train_data = data_reader.read_train_data() valid_data = data_reader.read_valid_data() print('building model...') model = get_model(config, is_training=True) tvars = tf.trainable_variables() assignment_map, initialized_variable_names = get_assignment_map_from_checkpoint(tvars, config.bert_ckpt) tf.train.init_from_checkpoint(config.bert_ckpt, assignment_map) print('========== Trainable Variables ==========') for v in tvars: init_string = '' if v.name in initialized_variable_names: init_string = '<INIT_FROM_CKPT>' print(v.name, v.shape, init_string) print('========== Gradients ==========') for g in model.gradients: print(g) best_score = 0.0 saver = tf.train.Saver(max_to_keep=1) with tf.Session(config=sess_config) as sess: if tf.train.latest_checkpoint(config.result_dir): saver.restore(sess, tf.train.latest_checkpoint(config.result_dir)) print('loading model from {}'.format(tf.train.latest_checkpoint(config.result_dir))) else: tf.global_variables_initializer().run() print('initializing from scratch.') train_writer = tf.summary.FileWriter(config.train_log_dir, sess.graph) for i in range(config.num_epoch): print('========== Epoch {} Train =========='.format(i + 1)) train_batch_iter = make_batch_iter(list(zip(*train_data)), config.batch_size, shuffle=True) train_loss, train_accu = run_epoch(sess, model, train_batch_iter, train_writer, verbose=True) print('The average train loss is {:>.4f}, average train accuracy is {:>.4f}'.format(train_loss, train_accu)) print('========== Epoch {} Valid =========='.format(i + 1)) valid_batch_iter = make_batch_iter(list(zip(*valid_data)), config.batch_size, shuffle=False) outputs, valid_loss, valid_accu = evaluate(sess, model, valid_batch_iter, verbose=True) print('The average valid loss is {:>.4f}, average valid accuracy is {:>.4f}'.format(valid_loss, valid_accu)) print('========== Saving Result ==========') save_result(outputs, config.valid_result, tokenizer, id_2_tag) if valid_accu > best_score: best_score = valid_accu saver.save(sess, config.model_file)
def main(): os.makedirs(config.temp_dir, exist_ok=True) os.makedirs(config.result_dir, exist_ok=True) os.makedirs(config.train_log_dir, exist_ok=True) logger.setLevel(logging.INFO) init_logger(logging.INFO, 'temp.log.txt', 'w') logger.info('preparing data...') config.word_2_id, config.id_2_word = read_json_dict(config.vocab_dict) config.vocab_size = min(config.vocab_size, len(config.word_2_id)) config.oov_vocab_size = min(config.oov_vocab_size, len(config.word_2_id) - config.vocab_size) embedding_matrix = None if args.do_train: if os.path.exists(config.glove_file): logger.info('loading embedding matrix from file: {}'.format( config.glove_file)) embedding_matrix, config.word_em_size = load_glove_embedding( config.glove_file, list(config.word_2_id.keys())) logger.info('shape of embedding matrix: {}'.format( embedding_matrix.shape)) else: if os.path.exists(config.glove_file): with open(config.glove_file, 'r', encoding='utf-8') as fin: line = fin.readline() config.word_em_size = len(line.strip().split()) - 1 data_reader = DataReader(config) evaluator = Evaluator('tgt') logger.info('building model...') model = get_model(config, embedding_matrix) saver = tf.train.Saver(max_to_keep=10) if args.do_train: logger.info('loading data...') train_data = data_reader.read_train_data() valid_data = data_reader.read_valid_data() logger.info(log_title('Trainable Variables')) for v in tf.trainable_variables(): logger.info(v) logger.info(log_title('Gradients')) for g in model.gradients: logger.info(g) with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) else: logger.info('initializing from scratch...') tf.global_variables_initializer().run() train_writer = tf.summary.FileWriter(config.train_log_dir, sess.graph) valid_log_history = run_train(sess, model, train_data, valid_data, saver, evaluator, train_writer) save_json( valid_log_history, os.path.join(config.result_dir, config.current_model, 'valid_log_history.json')) if args.do_eval: logger.info('loading data...') valid_data = data_reader.read_valid_data() with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) predicted_ids, valid_loss, valid_accu = run_evaluate( sess, model, valid_data) logger.info( 'average valid loss: {:>.4f}, average valid accuracy: {:>.4f}' .format(valid_loss, valid_accu)) logger.info(log_title('Saving Result')) save_outputs(predicted_ids, config.id_2_word, config.valid_data, config.valid_outputs) results = evaluator.evaluate(config.valid_data, config.valid_outputs, config.to_lower) save_json(results, config.valid_results) else: logger.info('model not found!') if args.do_test: logger.info('loading data...') test_data = data_reader.read_test_data() with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) predicted_ids = run_test(sess, model, test_data) logger.info(log_title('Saving Result')) save_outputs(predicted_ids, config.id_2_word, config.test_data, config.test_outputs) results = evaluator.evaluate(config.test_data, config.test_outputs, config.to_lower) save_json(results, config.test_results) else: logger.info('model not found!')
def main(): if not os.path.exists(config.result_dir): os.makedirs(config.result_dir) if not os.path.exists(config.train_log_dir): os.makedirs(config.train_log_dir) if not os.path.exists(config.valid_log_dir): os.makedirs(config.valid_log_dir) print('preparing data...') config.word_2_id, config.id_2_word = read_dict(config.word_dict) config.attr_2_id, config.id_2_attr = read_dict(config.attr_dict) config.vocab_size = min(config.vocab_size, len(config.word_2_id)) config.oov_vocab_size = len(config.word_2_id) - config.vocab_size config.attr_size = len(config.attr_2_id) embedding_matrix = None if args.do_train: if os.path.exists(config.glove_file): print('loading embedding matrix from file: {}'.format(config.glove_file)) embedding_matrix, config.word_em_size = load_glove_embedding(config.glove_file, list(config.word_2_id.keys())) print('shape of embedding matrix: {}'.format(embedding_matrix.shape)) else: if os.path.exists(config.glove_file): with open(config.glove_file, 'r', encoding='utf-8') as fin: line = fin.readline() config.word_em_size = len(line.strip().split()) - 1 data_reader = DataReader(config) evaluator = Evaluator('description') print('building model...') model = get_model(config, embedding_matrix) saver = tf.train.Saver(max_to_keep=10) if args.do_train: print('loading data...') train_data = data_reader.read_train_data() valid_data = data_reader.read_valid_data_small() print_title('Trainable Variables') for v in tf.trainable_variables(): print(v) print_title('Gradients') for g in model.gradients: print(g) with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint(config.result_dir) if model_file is not None: print('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) else: print('initializing from scratch...') tf.global_variables_initializer().run() train_writer = tf.summary.FileWriter(config.train_log_dir, sess.graph) valid_writer = tf.summary.FileWriter(config.valid_log_dir, sess.graph) run_train(sess, model, train_data, valid_data, saver, evaluator, train_writer, valid_writer, verbose=True) if args.do_eval: print('loading data...') valid_data = data_reader.read_valid_data() with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint(config.result_dir) if model_file is not None: print('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) predicted_ids, alignment_history, valid_loss, valid_accu = run_evaluate(sess, model, valid_data, verbose=True) print('average valid loss: {:>.4f}, average valid accuracy: {:>.4f}'.format(valid_loss, valid_accu)) print_title('Saving Result') save_result(predicted_ids, alignment_history, config.id_2_word, config.valid_data, config.valid_result) evaluator.evaluate(config.valid_data, config.valid_result, config.to_lower) else: print('model not found!') if args.do_test: print('loading data...') test_data = data_reader.read_test_data() with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint(config.result_dir) if model_file is not None: print('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) predicted_ids, alignment_history = run_test(sess, model, test_data, verbose=True) print_title('Saving Result') save_result(predicted_ids, alignment_history, config.id_2_word, config.test_data, config.test_result) evaluator.evaluate(config.test_data, config.test_result, config.to_lower) else: print('model not found!')
ingrs_vocab = pickle.load(open(os.path.join(data_dir, 'ingr_vocab.pkl'), 'rb')) vocab = pickle.load(open(os.path.join(data_dir, 'instr_vocab.pkl'), 'rb')) ingr_vocab_size = len(ingrs_vocab) instrs_vocab_size = len(vocab) output_dim = instrs_vocab_size t = time.time() sys.argv = [''] # del sys args = get_parser() args.maxseqlen = 15 args.ingrs_only = False model = get_model(args, ingr_vocab_size, instrs_vocab_size) # Load the trained model parameters model_path = os.path.join(data_dir, 'modelbest.ckpt') #print(os.path.exists('./data/' + 'modelbest.ckpt')) #sys.stdout.flush() # model_path = os.path.join("https://drive.google.com/open?id=1dpSIUZFtl03dvH1midHn67EZKyDzEAvy", "") #dicty = torch.load(model_path, map_location=torch.device('cpu')) #import torchvision.models as models #resnet50 = models.resnet50(pretrained=True) #print(resnet50) #print(os.listdir("./.torch/models"))
def train(): if not os.path.exists(config.result_dir): os.makedirs(config.result_dir) print('load data...') word_2_id, id_2_word = read_dict(config.word_dict) accu_2_id, id_2_accu = read_dict(config.accu_dict) art_2_id, id_2_art = read_dict(config.art_dict) if os.path.exists(config.word2vec_model): embedding_matrix = load_embedding(config.word2vec_model, word_2_id.keys()) else: embedding_matrix = np.random.uniform( -0.5, 0.5, [len(word_2_id), config.embedding_size]) data_reader = DataReader(config) train_data = data_reader.read_train_data(word_2_id, accu_2_id, art_2_id) valid_data = data_reader.read_valid_data(word_2_id, accu_2_id, art_2_id) art_data = data_reader.read_article(art_2_id.keys(), word_2_id) print('build model...') with tf.variable_scope('model'): model = get_model(config, embedding_matrix, is_training=True) print('========== Trainable Variables ==========') for v in tf.trainable_variables(): print(v) saver = tf.train.Saver(max_to_keep=1) with tf.Session(config=config_proto) as sess: tf.global_variables_initializer().run() saver.save(sess, config.model_file) for i in range(config.num_epoch): print('========== Epoch %2d Train ==========' % (i + 1)) train_batch_iter = make_batch_iter(list(zip(*train_data)), config.batch_size, shuffle=True) train_loss, _ = run_epoch(sess, model, train_batch_iter, art_data, verbose=True) print('The average train loss of epoch %2d is %.4f' % ((i + 1), train_loss)) print('========== Epoch %2d Valid ==========' % (i + 1)) valid_batch_iter = make_batch_iter(list(zip(*valid_data)), config.batch_size, shuffle=False) outputs = inference(sess, model, valid_batch_iter, art_data, verbose=True) print('========== Saving model ==========') saver.save(sess, config.model_file) save_result(outputs, config.valid_result, id_2_accu, id_2_art) result = judger.get_result(config.valid_data, config.valid_result) accu_micro_f1, accu_macro_f1 = judger.calc_f1(result[0]) article_micro_f1, article_macro_f1 = judger.calc_f1(result[1]) score = [(accu_micro_f1 + accu_macro_f1) / 2, (article_micro_f1 + article_macro_f1) / 2] print('Micro-F1 of accusation: %.4f' % accu_micro_f1) print('Macro-F1 of accusation: %.4f' % accu_macro_f1) print('Micro-F1 of relevant articles: %.4f' % article_micro_f1) print('Macro-F1 of relevant articles: %.4f' % article_macro_f1) print('Score: ', score)
exp.set_property('test_images_version', hashlib.md5(test_images).hexdigest()) exp.set_property('test_labels_version', hashlib.md5(test_labels).hexdigest()) class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot'] exp.set_property('class_names', class_names) # Log auxiliary data as table log_auxiliary_data_as_table() # Log images sample for each class log_images_sample(class_names, train_labels, train_images, exp) # Prepare model model = get_model(model_params, optim_params) # Log model summary model.summary(print_fn=lambda x: exp.log_text('model_summary', x)) # Log model visualization log_visualized_model(model, exp) # Log interactive visualizations log_interactive_visualisations() # Train model model.fit(train_images, train_labels, batch_size=training_params.batch_size, epochs=training_params.n_epochs, shuffle=training_params.shuffle,