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,
