def test_model_construction():
import json
import os
from utils import construct_model
config_folder = 'config/PEMS08'
for file_name in os.listdir(config_folder):
config_file = os.path.join(config_folder, file_name)
with open(config_file, 'r') as f:
config = json.loads(f.read().strip())
config['adj_filename'] = 'data/PEMS08/PEMS08.csv'
config['id_filename'] = None
construct_model(config)
def train_mnli_meta(**kwargs):
train, dev_matched_train, test, dev_matched_test, dev_mismatched_test, vocab = prepare_mnli_split(root='datasets/data',
urls=['https://www.nyu.edu/projects/bowman/multinli/multinli_1.0.zip'],
dir='MultiNLI',
name='MultiNLI',
data_path='datasets/data/MultiNLI/multinli_1.0',
train_genres=[['government'], ['telephone'], ['slate'], ['travel']],
test_genres=[['fiction']],
max_len=60)
weight_matrix = prepare_glove(glove_path="datasets/GloVe/glove.840B.300d.txt",
vocab=vocab)
train_loaders = [DataLoader(
MultiNLIDataset(dataset=t),
batch_size=kwargs['batch_size'],
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available()) for t in train]
val_matched_loaders = [DataLoader(
MultiNLIDataset(dataset=t),
batch_size=2000,
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available()) for t in dev_matched_train]
model = construct_model(model_type=kwargs['type'],
weight_matrix=weight_matrix)
num_parameters = sum([p.data.nelement() for p in model.parameters()])
print(f'Number of model parameters: {num_parameters}')
cudnn.benchmark = True
if torch.cuda.is_available():
torch.cuda.set_device(kwargs['device'])
if torch.cuda.is_available():
model = model.cuda()
loss_function = torch.nn.CrossEntropyLoss().cuda()
else:
loss_function = torch.nn.CrossEntropyLoss()
optimizer = construct_optimizer(optimizer=kwargs['optim'],
model=model,
lr=kwargs['lr_outer_meta'])
meta_model = MetaTrainWrapper(module=model,
inner_lr=kwargs['lr_inner_meta'],
use_maml=kwargs['use_maml'],
optim=optimizer,
second_order=True,
sample_task=True)
train_batcher = Batcher(loaders=train_loaders,
batch_size=kwargs['num_inner_iterations'])
meta_model.train()
for epoch in range(kwargs['epochs']):
for train_batch in tqdm(train_batcher):
meta_model(tasks=[ClassifierTask() for _ in range(len(train_loaders))],
train_batch=train_batch,
val_loaders=train_loaders)
print(f'Epoch {epoch + 1} Validation')
prec = []
for loader in val_matched_loaders:
prec.append(validate(val_loader=loader,
model=model,
criterion=loss_function,
epoch=epoch,
print_freq=kwargs['print_freq'],
writer=None))
print(f'Average Matched Precision is {np.mean(prec)}')
train_loader = DataLoader(
MultiNLIDataset(dataset=test[0]),
batch_size=kwargs['batch_size'],
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available())
val_matched_loader = DataLoader(
MultiNLIDataset(dataset=dev_matched_test[0]),
batch_size=kwargs['batch_size'],
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available())
val_mismatched_loader = DataLoader(
MultiNLIDataset(dataset=dev_mismatched_test[0]),
batch_size=kwargs['batch_size'],
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available())
print('Zero Shot Performance')
validate(val_loader=train_loader,
model=model,
criterion=loss_function,
epoch=0,
print_freq=kwargs['print_freq'],
writer=None)
validate(val_loader=val_matched_loader,
model=model,
criterion=loss_function,
epoch=0,
print_freq=kwargs['print_freq'],
writer=None)
validate(val_loader=val_mismatched_loader,
model=model,
criterion=loss_function,
epoch=0,
print_freq=kwargs['print_freq'],
writer=None)
if kwargs['k'] > 0:
print(f"{kwargs['k']}-Shot Performance")
optimizer = construct_optimizer(optimizer=kwargs['optim'],
model=model,
lr=kwargs['lr_kshot'])
train_batcher = Batcher(loaders=[train_loader],
batch_size=1)
for i, train_batch in enumerate(train_batcher):
train_single_epoch(train_loader=train_batch[0],
model=model,
criterion=loss_function,
optimizer=optimizer,
epoch=i,
total_steps=0,
print_freq=kwargs['print_freq'],
num_batches=1,
writer=None)
validate(val_loader=val_matched_loader,
model=model,
criterion=loss_function,
epoch=0,
print_freq=kwargs['print_freq'],
writer=None)
validate(val_loader=val_mismatched_loader,
model=model,
criterion=loss_function,
epoch=0,
print_freq=kwargs['print_freq'],
writer=None)
if i >= kwargs['k']:
break
def train_mnli_kshot(**kwargs):
dir = set_directory(name=kwargs['type'], type_net=kwargs['type'])
writer = SummaryWriter(dir)
train, dev_matched_train, test, dev_matched_test, dev_mismatched_test, vocab = prepare_mnli_split(root='datasets/data',
urls=['https://www.nyu.edu/projects/bowman/multinli/multinli_1.0.zip'],
dir='MultiNLI',
name='MultiNLI',
data_path='datasets/data/MultiNLI/multinli_1.0',
train_genres=[['government', 'telephone', 'slate', 'travel']],
test_genres=[['fiction']],
max_len=60)
weight_matrix = prepare_glove(glove_path="datasets/GloVe/glove.840B.300d.txt",
vocab=vocab)
train_loader = DataLoader(
MultiNLIDataset(dataset=train[0]),
batch_size=kwargs['batch_size'],
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available())
val_loader = DataLoader(
MultiNLIDataset(dataset=dev_matched_train[0]),
batch_size=kwargs['batch_size'],
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available())
model = construct_model(model_type=kwargs['type'],
weight_matrix=weight_matrix)
num_parameters = sum([p.data.nelement() for p in model.parameters()])
print(f'Number of model parameters: {num_parameters}')
if torch.cuda.is_available():
torch.cuda.set_device(kwargs['device'])
if torch.cuda.is_available():
model = model.cuda()
loss_function = torch.nn.CrossEntropyLoss().cuda()
else:
loss_function = torch.nn.CrossEntropyLoss()
optimizer = construct_optimizer(optimizer=kwargs['optim'],
model=model,
lr=kwargs['lr'])
cudnn.benchmark = True
total_steps = 0
for epoch in tqdm(range(kwargs['epochs'])):
total_steps = train_single_epoch(train_loader=train_loader,
model=model,
criterion=loss_function,
optimizer=optimizer,
epoch=epoch,
total_steps=total_steps,
print_freq=kwargs['print_freq'],
writer=writer)
validate(val_loader=val_loader,
model=model,
criterion=loss_function,
epoch=epoch,
print_freq=kwargs['print_freq'],
writer=writer)
print('Zero Shot Performance')
train_loader = DataLoader(
MultiNLIDataset(dataset=test[0]),
batch_size=kwargs['batch_size'],
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available())
val_loader = [DataLoader(
MultiNLIDataset(dataset=dataset[0]),
batch_size=kwargs['batch_size'],
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available()) for dataset in [dev_matched_test, dev_mismatched_test]]
validate(val_loader=train_loader,
model=model,
criterion=loss_function,
epoch=epoch,
print_freq=kwargs['print_freq'],
writer=writer)
for loader in val_loader:
validate(val_loader=loader,
model=model,
criterion=loss_function,
epoch=epoch,
print_freq=kwargs['print_freq'],
writer=writer)
if kwargs['k'] > 0:
print(f"{kwargs['k']}-Shot Performance")
optimizer = construct_optimizer(optimizer=kwargs['optim'],
model=model,
lr=kwargs['lr_kshot'])
train_batcher = Batcher(loaders=[train_loader],
batch_size=1)
for i, train_batch in enumerate(train_batcher):
train_single_epoch(train_loader=train_batch[0],
model=model,
criterion=loss_function,
optimizer=optimizer,
epoch=i,
total_steps=0,
print_freq=kwargs['print_freq'],
num_batches=1,
writer=writer)
for loader in val_loader:
validate(val_loader=loader,
model=model,
criterion=loss_function,
epoch=epoch,
print_freq=kwargs['print_freq'],
writer=writer)
if i >= kwargs['k']:
break
def train_mnli(**kwargs):
dir = set_directory(name=kwargs['type'], type_net=kwargs['type'])
writer = SummaryWriter(dir)
train, dev_matched, dev_mismatched, vocab = prepare_mnli(root='datasets/data',
urls=['https://www.nyu.edu/projects/bowman/multinli/multinli_1.0.zip'],
dir='MultiNLI',
name='MultiNLI',
data_path='datasets/data/MultiNLI/multinli_1.0',
max_len=60)
weight_matrix = prepare_glove(glove_path="datasets/GloVe/glove.840B.300d.txt",
vocab=vocab)
train_loader = DataLoader(
MultiNLIDataset(dataset=train),
batch_size=kwargs['batch_size'],
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available())
val_loader = [DataLoader(
MultiNLIDataset(dataset=loader),
batch_size=kwargs['batch_size'],
shuffle=True,
num_workers=1,
pin_memory=torch.cuda.is_available()) for loader in [dev_matched, dev_mismatched]]
model = construct_model(model_type=kwargs['type'],
weight_matrix=weight_matrix)
num_parameters = sum([p.data.nelement() for p in model.parameters()])
print(f'Number of model parameters: {num_parameters}')
if torch.cuda.is_available():
torch.cuda.set_device(kwargs['device'])
if torch.cuda.is_available():
model = model.cuda()
loss_function = torch.nn.CrossEntropyLoss().cuda()
else:
loss_function = torch.nn.CrossEntropyLoss()
optimizer = construct_optimizer(optimizer=kwargs['optim'],
model=model,
lr=kwargs['lr'])
total_steps = 0
cudnn.benchmark = True
for epoch in tqdm(range(kwargs['epochs'])):
total_steps = train_single_epoch(train_loader=train_loader,
model=model,
criterion=loss_function,
optimizer=optimizer,
epoch=epoch,
total_steps=total_steps,
print_freq=kwargs['print_freq'],
writer=writer)
for loader in val_loader:
validate(val_loader=loader,
model=model,
criterion=loss_function,
epoch=epoch,
print_freq=kwargs['print_freq'],
writer=writer)
import numpy as np
from flask import Flask, request, jsonify
from flask_cors import CORS
from utils import construct_model, construct_data
model, df = construct_model()
app = Flask(__name__)
CORS(app)
@app.route('/', methods=['POST'])
def predict():
data = construct_data(df, request)
graded = [(key, data[key]) for key in data.keys()]
progression = {
key: entry["value"]
for (key, entry) in graded if not entry['is_expected']
}
margins = list(reversed(np.linspace(0.6, 1.5, num=17)**2))
predictions = []
for index, key in enumerate(progression):
keys = [k for k in list(progression.keys())[:index + 1]]
prediction = model.predict([[
float(entry["value"])
if entry["value"] and k in keys else entry["expected_value"]
for k, entry in graded
]])[0]
parser = argparse.ArgumentParser()
parser.add_argument("--config", type=str, help='configuration file')
parser.add_argument("--test", action="store_true", help="test program")
parser.add_argument("--plot", help="plot network graph", action="store_true")
parser.add_argument("--save", action="store_true", help="save model")
args = parser.parse_args()
config_filename = args.config
with open(config_filename, 'r') as f:
config = json.loads(f.read())
print(json.dumps(config, sort_keys=True, indent=4))
net = construct_model(config)
batch_size = config['batch_size']
num_of_vertices = config['num_of_vertices']
graph_signal_matrix_filename = config['graph_signal_matrix_filename']
if isinstance(config['ctx'], list):
ctx = [mx.gpu(i) for i in config['ctx']]
elif isinstance(config['ctx'], int):
ctx = mx.gpu(config['ctx'])
loaders = []
true_values = []
for idx, (x, y) in enumerate(generate_data(graph_signal_matrix_filename)):
if args.test:
x = x[:100]
y = y[:100]
np.save('{}weights_{}_{}_{}.npy'.format(models_folder, weights[0], weights[1], weights[2]), weights)
# Each timestep has 6 "features" (ax_L, ay_L, az_L, ax_R, ay_R, az_R)
# Shape of dataset = (n, 636, 6)
# To plot:
#plt.plot(X_train[0,:,1]) # Left y acceleration
#plt.plot(X_train[0,:,4]) # Right y acceleration
#plt.plot(y_train[0,:,0]*100,'g') # HS
#plt.plot(y_train[0,:,1]*100, 'r') # TO
#plt.show()
# Contstruct the model
shape = (X_train.shape[1], X_train.shape[2] - 2) # Not training on first 2 columns (id and time)
model = construct_model(input_shape=shape, output_dim=3, weights=weights)
#tensorboard = TensorBoard(log_dir="logs/{}".format(time()))
nepochs = 10
diff_accuracy = 100
delta = 0.001
accuracy = 1
counter = 1
history_list = []
while diff_accuracy > delta: # While diff accuracy is greater than delta
print('Epoch #{}'.format(counter))
history = train_model(model, X_train[:,:,2:], y_train[:], 32, nepochs=1)
