def main():
train_x, train_y, val_x, val_y, test_x, test_y = load_data()
train_x, train_y = preprocess_data(train_x, train_y)
val_x, val_y = preprocess_data(val_x, val_y)
test_x, test_y = preprocess_data(test_x, test_y)
train_a_network(train_x, train_y, val_x, val_y, test_x, test_y)
def end2end(mcat_ratio: float, epochs: int, dim: int, nlayers: int, fname: str,
gpu: bool, name: str, lr: float, batch_size: int,
split_ratio: float, vectors: str, data_dir: str, pbar_width: int,
wandb: bool, boom_dim: int, dropout: float, ema: float,
overwrite_model: bool) -> str:
''' Loads the data, preprocesses it if needed, builds the SHARNN model,
trains it and evaluates it. '''
from data import load_data
from modules import SHARNN
pp_path = get_path(data_dir) / f'{fname}_pp.tsv'
if not pp_path.is_file():
from data import preprocess_data
raw_path = get_path(data_dir) / f'{fname}.tsv'
cats_path = get_path(data_dir) / 'cats.json'
mcat_dict_path = get_path(data_dir) / 'mcat_dict.json'
if not (raw_path.is_file() and cats_path.is_file()
and mcat_dict_path.is_file()):
from db import ArXivDatabase
db = ArXivDatabase(data_dir=data_dir)
db.get_mcat_dict()
db.get_cats()
if not raw_path.is_file():
db.get_training_df()
preprocess_data(data_dir=data_dir)
train_dl, val_dl, vocab = load_data(tsv_fname=f'{fname}_pp',
batch_size=batch_size,
split_ratio=split_ratio,
vectors=vectors,
data_dir=data_dir)
model = SHARNN(dim=dim,
nlayers=nlayers,
data_dir=data_dir,
pbar_width=pbar_width,
vocab=vocab,
boom_dim=boom_dim,
dropout=dropout)
if gpu: model.cuda()
model = model.fit(train_dl,
val_dl,
epochs=epochs,
lr=lr,
mcat_ratio=mcat_ratio,
name=name,
use_wandb=wandb,
ema=ema,
overwrite_model=overwrite_model)
return model.evaluate(val_dl)
def run():
model = GRU(FLAGS.input_dim, FLAGS.hidden_dim)
print(model)
optimizer = optim.SGD(model.parameters(), lr=0.001)
data_paths = [FLAGS.data_path, FLAGS.eval_data_path]
datasets, embeddings = preprocess_data(data_paths, FLAGS.embedding_path)
training_data = Dataset(datasets[0])
eval_data = Dataset(datasets[1], shuffle=False, truncate_final_batch=True)
if FLAGS.extract:
raise NotImplementedError
def eval_fn():
return evaluate(model, eval_data, embeddings)
def ckpt_fn(ckpt_args):
step = ckpt_args['step']
best_dev_error = ckpt_args['best_dev_error']
best = ckpt_args.get('best', False)
save_dict = pack_checkpoint(step, best_dev_error, model, optimizer)
filename = ckpt_path(FLAGS.save_path, filename=FLAGS.experiment_name, best=best)
print("Checkpointing...")
save(save_dict, filename)
train_args = dict(step=0, best_dev_error=1.0)
train(model, optimizer, training_data, embeddings, eval_fn, ckpt_fn, train_args)
def main():
print('getting data...')
df = get_data()
X_train, X_test, y_train, y_test, enc = preprocess_data(df)
print('training...')
model = Net()
target = to_tensor(y_train)
loss_fn = torch.nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
for i in range(100):
y_pred = model(to_tensor(X_train))
loss = loss_fn(y_pred, target)
print(f'loss on pass {i}: {loss}')
optimizer.zero_grad()
loss.backward()
optimizer.step()
print('trained!')
y_pred = enc.inverse_transform(model.predict(to_tensor(X_test)))
# print('y_test')
y_test_deenc = enc.inverse_transform((y_test))
# print(y_test_deenc)
# print('y_pred')
# print((y_pred))
print(f'accuracy score: {balanced_accuracy_score(y_test_deenc,y_pred)}')
return X_train, X_test, y_train, y_test, model
def _init():
# Read data and shuffle it
dataframe = pandas.read_csv('data/log.csv', sep=',', header=0)
dataframe = dataframe.reindex(numpy.random.permutation(dataframe.index))
# Generate features and targets
processed_features, processed_targets = preprocess_data(dataframe)
print('==========Feature Summary==========')
print(processed_features.describe())
print()
print('==========Target Summary===========')
print(processed_targets.describe())
print()
# ratio = training data / all data
training_data_ratio = 0.8
# Separate data to training and validation sets
training_data_count = math.ceil(training_data_ratio * len(dataframe))
training_examples = processed_features.head(training_data_count)
training_targets = processed_targets.head(training_data_count)
validation_data_count = len(dataframe) - training_data_count
validation_examples = processed_features.tail(validation_data_count)
validation_targets = processed_targets.tail(validation_data_count)
# Train neural network
model = NeuralNetworkModel(hidden_units=[10, 10])
model.train(
learning_rate=0.005,
steps=750,
batch_size=training_data_count,
training_examples=training_examples,
training_targets=training_targets,
validation_examples=validation_examples,
validation_targets=validation_targets
)
# Predict unlabeled data and display result
unlabeled_dataframe = pandas.read_csv('data/log_unlabeled.csv', sep=',', header=0)
unlabeled_features, unlabeled_targets = preprocess_data(unlabeled_dataframe)
unlabeled_predictions = model.predict(unlabeled_features, unlabeled_targets)
result_table = restore_category(unlabeled_features).assign(prediction=unlabeled_predictions)
print('\n==========Unlabeled Data Predictions==========')
print(result_table.to_string())
def extract_data(size=256):
print("Extracting data..")
X, y = data.extract_data(size=256)
print("Preprocessing data..")
X, y, nb_samples, num_categories = data.preprocess_data(X, y, save=True, subtract_mean=True)
return X, y, nb_samples, num_categories
def extract_data(size=256):
print("Extracting data..")
X, y = data.extract_data(size=256)
print("Preprocessing data..")
X, y, nb_samples, num_categories = data.preprocess_data(X, y, save=True, subtract_mean=True)
return X, y, nb_samples, num_categories
def build_validation_data_loader(self) -> keras.InputData:
if not self.data_downloaded:
self.download_directory = download_cifar10_tf_sequence(
download_directory=self.download_directory,
url=self.context.get_data_config()["url"],
)
self.data_downloaded = True
(_, _), (test_data, test_labels) = get_data(self.download_directory)
return preprocess_data(test_data), preprocess_labels(test_labels)
def main():
# Use the loading function from Assignment 1
train_x, train_y, val_x, val_y, test_x, test_y = load_data(use_all=True,
val_size=5000)
# Use the preprocessing function from Assignment 1
train_x, train_y = preprocess_data(train_x, train_y)
val_x, val_y = preprocess_data(val_x, val_y)
test_x, test_y = preprocess_data(test_x, test_y)
# Process the data so they have a zero mean
mean, std = np.mean(train_x), np.std(
train_x) # Find mean and std of training data
train_x = process_zero_mean(train_x, mean, std)
val_x = process_zero_mean(val_x, mean, std)
test_x = process_zero_mean(test_x, mean, std)
# Testing gradients
# test_grad_computations(train_x, train_y)
# Testing model capabilities
# overfit_test(train_x, train_y)
# Test different model parameters
# train_a_network(train_x, train_y, val_x, val_y, test_x, test_y)
# Find a good regularisation value
# lambda_search(train_x, train_y, val_x, val_y)
# Train a network with optimal hyper-parameter values using almost all of the data
# use_all=True, val_size=1000 | cycles = 5 | n_s = 1000 | lambda = 0.00087
# train_a_network(train_x, train_y, val_x, val_y, test_x, test_y, n_cycles=5)
# Report the effect of adding noise to the training data
# test_noise(train_x, train_y, val_x, val_y, test_x, test_y)
# Report the effect of different number of nodes
# test_nodes(train_x, train_y, val_x, val_y, test_x, test_y)
# Report the effect of ensemble method
test_ensemble(train_x, train_y, val_x, val_y, test_x, test_y)
def main():
# Use the loading function from Assignment 1
train_x, train_y, val_x, val_y, test_x, test_y = load_data(use_all=True,
val_size=5000)
# Use the preprocessing function from Assignment 1
train_x, train_y = preprocess_data(train_x, train_y)
val_x, val_y = preprocess_data(val_x, val_y)
test_x, test_y = preprocess_data(test_x, test_y)
# Process the data so they have a zero mean
mean, std = np.mean(train_x), np.std(
train_x) # Find mean and std of training data
train_x = process_zero_mean(train_x, mean, std)
val_x = process_zero_mean(val_x, mean, std)
test_x = process_zero_mean(test_x, mean, std)
# Testing gradients
# test_grad_computations(train_x, train_y)
# Training simple k-layer networks
train_simple(train_x, train_y, val_x, val_y, test_x, test_y)
# os.chdir(wpath)
# print(os.getcwd())
with open("train2012_MAX.txt", 'r', encoding="utf8", errors="ignore"
) as f: # encoding='cp1252', encoding='utf8', errors="replace"
data_train = f.readlines()
# data_train = load_file('data/test2011')
data_valid = load_file('data/dev2012')
data_test = load_file('data/test2011')
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased',
do_lower_case=True)
print('PREPROCESSING DATA...')
X_train, y_train = preprocess_data(data_train, tokenizer, punctuation_enc,
segment_size)
X_valid, y_valid = preprocess_data(data_valid, tokenizer, punctuation_enc,
segment_size)
print('INITIALIZING MODEL...')
output_size = len(punctuation_enc)
bert_punc = nn.DataParallel(
BertPunc(segment_size, output_size, dropout).cuda())
# print('TRAINING TOP LAYER...')
# data_loader_train = create_data_loader(X_train, y_train, True, batch_size_top)
# data_loader_valid = create_data_loader(X_valid, y_valid, False, batch_size_top)
# freeze all layers of bert and just train task based classifier so that the gradients are not computed in backward(). Parameters of newly constructed modules (below requires_grad=False statment) have requires_grad=True by default
# for p in bert_punc.module.bert.parameters():
# p.requires_grad = False
def run(epochs=500, training_percentage=0.4, validation_percentage=0.1, extract=True, cont=True, size=256, top_k=5):
'''Does the routine required to get the data, put them in needed format and start training the model
saves weights whenever the model produces a better test result and keeps track of the best loss'''
if extract:
print("Extracting data..")
X, y = data.extract_data(size=size)
print("Preprocessing data..")
X, y, nb_samples, num_categories = data.preprocess_data(X, y, save=True, subtract_mean=True)
else:
print("Loading data..")
h5f = h5py.File('data.hdf5', 'r')
nb_samples = h5f['nb_samples'].value
num_categories = h5f['n_categories'].value
h5f.close()
print("Number of categories: {}".format(num_categories))
print("Number of samples {}".format(nb_samples))
data_ids = np.arange(start=0, stop=nb_samples)
val_ids = data.produce_validation_indices(data_ids, nb_samples * validation_percentage)
train_ids = data.produce_train_indices(dataset_indx=data_ids, number_of_samples=nb_samples * training_percentage,
val_indx=val_ids)
# X_train, y_train, X_test, y_test = data.split_data(X, y, split_ratio=split)
X_train, y_train, X_val, y_val = data.load_dataset_bit_from_hdf5(train_ids, val_ids, only_train=False)
X_val = X_val / 255
print("Building and Compiling model..")
model = m.get_model(n_outputs=num_categories, input_size=size)
if cont:
# model.load_weights_until_layer("pre_trained_weights/latest_model_weights.hdf5", 26)
model.load_weights("pre_trained_weights/latest_model_weights.hdf5")
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=["accuracy"])
print("Training..")
best_performance = np.inf
for i in range(epochs):
train_ids = data.produce_train_indices(dataset_indx=data_ids, number_of_samples=15000, val_indx=val_ids)
X_train, y_train = data.load_dataset_bit_from_hdf5(train_ids, val_ids, only_train=True)
X_train = X_train / 255
X_train = data.augment_data(X_train)
# fit the model on the batches generated by datagen.flow()
metadata = model.fit(X_train, y_train, validation_data=[X_val, y_val], batch_size=64,
nb_epoch=1, verbose=1, shuffle=True, class_weight=None,
sample_weight=None)
current_loss = metadata.history['loss'][-1]
current_val_loss = metadata.history['val_loss'][-1]
preds = model.predict_proba(X_val, batch_size=64)
print("Loss: {}".format(current_loss))
print("Val_loss: {}".format(current_val_loss))
top_3_error = get_top_n_error(preds, y_val, top_k)
print("Top 3 error: {}".format(top_3_error))
if current_val_loss < best_performance:
model.save_weights("pre_trained_weights/model_weights.hdf5", overwrite=True)
best_performance = current_val_loss
print("Saving weights..")
model.save_weights("pre_trained_weights/latest_model_weights.hdf5", overwrite=True)
axes[(0, 0)].set_title('Truth: 1', fontsize=15)
axes[(0, 1)].set_title('Truth: 0', fontsize=15)
axes[(0, 0)].set_ylabel('Pred: 1', fontsize=15)
axes[(1, 0)].set_ylabel('Pred: 0', fontsize=15)
# axes[(1,1)].y
plt.savefig('uncertainty')
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Uncertainty estimation and evaluation')
parser.add_argument("checkpoint", type=str)
parser.add_argument("--datadir", type=str, default='dataset'),
params, _ = parser.parse_known_args()
print("preprocess")
train_set, val_set, test_set, tay_set = data.preprocess_data(
data_folder=params.datadir)
model = torch.load(params.checkpoint, map_location=device)
train_it, val_it, test_it, tay_it = data.get_batch_iterators(
64, train_set, val_set, test_set, tay_set)
ground_truth, predictions, dropout_preds, ids = predict(model,test_it, num_samples=100)
np.savetxt('predictions.csv', predictions)
np.savetxt('dropout_preds.csv', dropout_preds)
np.savetxt('ground_truth.csv', ground_truth)
sorted_variances = dropout_preds.var(axis=1).argsort(axis=0)
max_indices, min_indices = sorted_variances[:5], sorted_variances[-5:]
# print(dropout_preds.var(axis=1).max(axis=0))
# print(dropout_preds.var(axis=1).min(axis=0))
# network training
parser.add_argument("--batch_size", type=int, default=16, help="batch size")
parser.add_argument("--unit_epoch", type=int, default=50, help="number of transition epochs")
parser.add_argument("--lambda_gp", type=float, default=10., help="weight of gradient penalty in WGAN")
parser.add_argument("--lambda_drift", type=float, default=0.001, help="weight of drift term in D_loss")
parser.add_argument("--num_aug", type=int, default=5, help="times of data augmentation; \
x5 when training unconditional gan (using only mel data); x1 when training conditional gan (using the whole training set)")
parser.add_argument("--lr", type=float, default=0.001, help="initial learning rate")
parser.add_argument("--outf", type=str, default="logs", help='path of log files')
# inference
parser.add_argument("--num", type=int, default=1000, help="number of images to generate")
arg = parser.parse_args()
if arg.preprocess:
mel_only = False if arg.cond else True
preprocess_data(root_dir='../data_2018', mel_only=mel_only)
assert arg.mode == "train" or arg.mode == "test", "invalid argument!"
if arg.mode == "train":
if arg.cond:
print("\ntrain conditional GAN ...\n")
gan_trainer = CondTrainer(arg, device, device_ids)
else:
gan_trainer = Trainer(arg, device, device_ids)
gan_trainer.train()
if arg.mode == "test":
gan_generator = ImageGenerator(arg, device)
gan_generator.generate(arg.num)
target_words_emb)
word_sim = fluid.layers.reduce_sum(word_sim, dim=-1)
word_sim = fluid.layers.reshape(word_sim, shape=[-1])
pred = fluid.layers.sigmoid(word_sim)
# 通过估计的输出概率定义损失函数，注意我们使用的是sigmoid_cross_entropy_with_logits函数
# 将sigmoid计算和cross entropy合并成一步计算可以更好的优化，所以输入的是word_sim，而不是pred
loss = fluid.layers.sigmoid_cross_entropy_with_logits(word_sim, label)
loss = fluid.layers.reduce_mean(loss)
# 返回前向计算的结果，飞桨会通过backward函数自动计算出反向结果。
return pred, loss
corpus = preprocess_data()
word2id_dict, word2id_freq, id2word_dict = build_dict(corpus)
corpus = [word2id_dict[word] for word in corpus]
vocab_size = len(word2id_dict)
print(f"vocab size: {vocab_size}")
corpus = subsampling(corpus, word2id_freq)
print("after subsampling %d tokens in the corpus" % len(corpus))
# print(f"finish create dateset: {len(dataset)} sample")
step = 0
learning_rate = 0.001
# 定义一个使用word-embedding查询同义词的函数
# 这个函数query_token是要查询的词，k表示要返回多少个最相似的词，embed是我们学习到的word-embedding参数
# 我们通过计算不同词之间的cosine距离，来衡量词和词的相似度
I_val = utils.make_grid(fixed_batch, nrow=4, normalize=True, scale_each=True)
writer.add_image('val/image', I_val, epoch)
if opt.log_images and (not opt.no_attention):
print('\nlog attention maps ...\n')
# training data
__, a1, a2 = model(inputs[0:16,:,:,:])
if a1 is not None:
attn1 = visualize_attn(I_train, a1, up_factor=opt.base_up_factor, nrow=4)
writer.add_image('train/attention_map_1', attn1, epoch)
if a2 is not None:
attn2 = visualize_attn(I_train, a2, up_factor=2*opt.base_up_factor, nrow=4)
writer.add_image('train/attention_map_2', attn2, epoch)
# val data
__, a1, a2 = model(fixed_batch)
if a1 is not None:
attn1 = visualize_attn(I_val, a1, up_factor=opt.base_up_factor, nrow=4)
writer.add_image('val/attention_map_1', attn1, epoch)
if a2 is not None:
attn2 = visualize_attn(I_val, a2, up_factor=2*opt.base_up_factor, nrow=4)
writer.add_image('val/attention_map_2', attn2, epoch)
# Append the row to the dataframes
train_results = train_results.append(train_row, ignore_index=True)
val_results = val_results.append(val_row, ignore_index=True)
# write to csvs
train_results.to_csv('train_scores.csv')
val_results.to_csv('val_scores.csv')
if __name__ == "__main__":
preprocess_data(root_dir='../ImageDataSet/Xray')
main()
def run(epochs=500,
training_percentage=0.4,
validation_percentage=0.1,
extract=True,
cont=True,
size=256,
top_k=5):
'''Does the routine required to get the data, put them in needed format and start training the model
saves weights whenever the model produces a better test result and keeps track of the best loss'''
if extract:
print("Extracting data..")
X, y = data.extract_data(size=size)
print("Preprocessing data..")
X, y, nb_samples, num_categories = data.preprocess_data(
X, y, save=True, subtract_mean=True)
else:
print("Loading data..")
h5f = h5py.File('data.hdf5', 'r')
nb_samples = h5f['nb_samples'].value
num_categories = h5f['n_categories'].value
h5f.close()
print("Number of categories: {}".format(num_categories))
print("Number of samples {}".format(nb_samples))
data_ids = np.arange(start=0, stop=nb_samples)
val_ids = data.produce_validation_indices(
data_ids, nb_samples * validation_percentage)
train_ids = data.produce_train_indices(dataset_indx=data_ids,
number_of_samples=nb_samples *
training_percentage,
val_indx=val_ids)
# X_train, y_train, X_test, y_test = data.split_data(X, y, split_ratio=split)
X_train, y_train, X_val, y_val = data.load_dataset_bit_from_hdf5(
train_ids, val_ids, only_train=False)
X_val = X_val / 255
print("Building and Compiling model..")
model = m.get_model(n_outputs=num_categories, input_size=size)
if cont:
# model.load_weights_until_layer("pre_trained_weights/latest_model_weights.hdf5", 26)
model.load_weights("pre_trained_weights/latest_model_weights.hdf5")
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=["accuracy"])
print("Training..")
best_performance = np.inf
for i in range(epochs):
train_ids = data.produce_train_indices(dataset_indx=data_ids,
number_of_samples=15000,
val_indx=val_ids)
X_train, y_train = data.load_dataset_bit_from_hdf5(train_ids,
val_ids,
only_train=True)
X_train = X_train / 255
X_train = data.augment_data(X_train)
# fit the model on the batches generated by datagen.flow()
metadata = model.fit(X_train,
y_train,
validation_data=[X_val, y_val],
batch_size=64,
nb_epoch=1,
verbose=1,
shuffle=True,
class_weight=None,
sample_weight=None)
current_loss = metadata.history['loss'][-1]
current_val_loss = metadata.history['val_loss'][-1]
preds = model.predict_proba(X_val, batch_size=64)
print("Loss: {}".format(current_loss))
print("Val_loss: {}".format(current_val_loss))
top_3_error = get_top_n_error(preds, y_val, top_k)
print("Top 3 error: {}".format(top_3_error))
if current_val_loss < best_performance:
model.save_weights("pre_trained_weights/model_weights.hdf5",
overwrite=True)
best_performance = current_val_loss
print("Saving weights..")
model.save_weights("pre_trained_weights/latest_model_weights.hdf5",
overwrite=True)
from utils import read_imagenet_classnames, display_results, run_inference, parse_base64
from torchvision import models
parser = argparse.ArgumentParser(description='Inference Trained Model')
parser.add_argument('--data', metavar='DIR', default='./data', help='default data path')
parser.add_argument('-bs', '--batch-size', metavar='BS', default=2, help='maximum batchsize')
parser.add_argument('-tp', '--top-predictions', metavar='NUMPRED',\
default=5, help='number of top predictions per sample')
parser.add_argument('-exp', '--export', action="store_true",help='export model to onnx')
def export_model(model):
model_path = 'checkpoints/model.pt'
sample_input = torch.randn((1, 3, 256, 256))
model = model.cpu()
model.eval()
model = torch.jit.trace(model, sample_input)
torch.jit.save(model, model_path)
if __name__ == "__main__":
args = parser.parse_args()
model = models.resnet18(pretrained=True)
if args.export:
export_model(model)
else:
imagenet_classes = read_imagenet_classnames("cache/imagenet_classnames.txt")
data = preprocess_data("cache")
predictions = run_inference(model, data[0], args.top_predictions)
display_results(data, predictions, imagenet_classes)
def train():
# get batch iterator
print("preprocess")
train_set, val_set, test_set, _ = data.preprocess_data(
data_folder=params.datadir)
print(model_config)
print("Training model...")
model_config['num_embeddings'] = train_set.fields[
'text'].vocab.vectors.shape[0]
model_config['embedding_dim'] = train_set.fields[
'text'].vocab.vectors.shape[1]
model = Main(model_config, train_set.fields['text'].vocab)
pytorch_total_params = sum(p.numel() for p in model.parameters())
print(pytorch_total_params)
model.to(device)
grad_params = [p for p in model.parameters() if p.requires_grad]
# weight = torch.FloatTensor(N_CLASSES).fill_(1)
weight = torch.FloatTensor([0.3, 0.7])
ce_loss = nn.CrossEntropyLoss(weight=weight).to(device)
lr = model_config['learning_rate']
epoch = 1
prev_dev_accuracy = 0
optimizer = optim.Adam(grad_params,
lr,
weight_decay=model_config['weight_decay'])
best_epoch = 0
while epoch < params.epochs:
# writer.add_scalar(
# 'Learning rate', optimizer.param_groups[0]['lr'], epoch)
optimizer.param_groups[0]['lr'] = optimizer.param_groups[0]['lr'] * \
LR_DECAY if epoch > 1 else optimizer.param_groups[0]['lr']
train_it, val_it, test_it, _ = data.get_batch_iterators(
MINIBATCH_SIZE, train_set, val_set, test_set)
train_loss = 0
train_loss_epoch = 0
batches = 0
for batch in train_it:
optimizer.zero_grad()
output = model.forward(batch.text)
loss = ce_loss(output, batch.label_a)
loss.backward()
train_loss += loss
train_loss_epoch += loss
optimizer.step()
batches += 1
if batches % 50 == 0:
train_loss = 0
# writer.add_scalar('Loss', train_loss, batches / 50)
print("Training Loss at epoch: {} is: {}".format(epoch, train_loss))
# writer.add_scalar('Loss (Epoch)', train_loss_epoch, epoch)
n_correct = 0
n_tested = 0
true_positive = [0, 0]
true_negative = [0, 0]
false_positive = [0, 0]
false_negative = [0, 0]
true_labels = [0, 0]
for batch in val_it:
output = model.forward(batch.text)
scores, predictions = torch.max(output, dim=1)
for i in range(2):
true_labels = (batch.label_a == i).nonzero()
false_labels = (batch.label_a != i).nonzero()
true_positive[i] += (
predictions[true_labels] == i).sum().item()
false_negative[i] += (predictions[true_labels] !=
i).sum().item()
false_positive[i] += (
predictions[false_labels] == i).sum().item()
true_negative[i] += (predictions[false_labels] !=
i).sum().item()
n_correct += (batch.label_a == predictions).sum()
n_tested += batch.label_a.shape[0]
# writer.add_scalar('Validation accuracy', accuracy, epoch)
macro_precision = 0.0
macro_recall = 0.0
macro_f1 = 0.0
non_zero_devision = 1e-6
for i in range(2):
precision = (
true_positive[i] /
(true_positive[i] + false_positive[i] + non_zero_devision))
macro_precision += precision
recall = (
true_positive[i] /
(true_positive[i] + false_negative[i] + non_zero_devision))
macro_recall += recall
macro_f1 += 2 * (precision*recall) / \
(precision+precision+ non_zero_devision)
macro_precision /= 2
macro_recall /= 2
macro_f1 /= 2
print(
f'Precision: {macro_precision}\nRecall: {macro_recall}\nF1: {macro_f1}'
)
accuracy = n_correct.item() / n_tested
if macro_f1 <= prev_dev_accuracy:
# optimizer.param_groups[0]['lr'] /= 2
lr = optimizer.param_groups[0]['lr']
print(f"lr: {lr} and threshold: {THRESHOLD}")
else:
prev_dev_accuracy = macro_f1
best_epoch = epoch
if (params.save_model):
torch.save(
model,
os.path.join(params.outputdir, params.model + "_epoch_" +
str(epoch) + ".pt"))
print("Validation accuracy at epoch: {} is: {}, f1 {}".format(
epoch, accuracy, macro_f1))
# Store model
epoch += 1
validate(test_it, best_epoch, train_set.fields['text'].vocab, model_config)
# Dataset parameters
img_rows, img_cols = 28, 28 #input image dimensions for the MNIST dataset
num_classes = 10 #number of classes in the MNIST dataset
# Load the data, and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Specify channel order
K.set_image_data_format('channels_last')
# Preprocess the data
input_shape, x_train, y_train, x_test, y_test = preprocess_data(
x_train,
y_train,
x_test,
y_test,
img_rows,
img_cols,
num_classes,
K.image_data_format(),
print_shape=False)
model = ThreeLayersCNN(input_shape=input_shape,
nb_filters=num_filters,
nb_classes=num_classes,
print_model_summary=False)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train,
####
####
#### Responsible for loading data as well as training and evaluating the model
####
####
import constants as C
from data import load_raw_data, preprocess_data, split_data_to_training_and_test_sets
from model import create_logistic_regression_model, create_SVM, calculate_accuracy
if __name__ == '__main__':
# Loads the raw data
dataset = load_raw_data()
# Splits the data to training and test sets
X, y = preprocess_data(dataset, C.FEATURES)
X_train, X_test, y_train, y_test = split_data_to_training_and_test_sets(
X, y)
# Generate the LR model, train, and get the accuracy score
lr_classifier = create_logistic_regression_model(X_train, y_train)
accuracy = calculate_accuracy(lr_classifier, X_test, y_test)
print()
print('--------------')
print('Accuracy of logistic regression model using all features:',
accuracy)
print('--------------')
print()
# Generate the SVC model, train, and get the accuracy score