def routeProviders(id=None, page=1):
if not isMod():
flash('You must be logged in to do that!', 'error')
return redirect('/')
if not id:
try: r = Provider.objects().paginate(page=int(page), per_page=20)
except:
flash("You've reached the end of providerss listing!", 'warning')
return redirect('/mod/schools/%s' % int(page)-1)
return render('providers.html', providers=r)
else:
q = Provider.objects(id=id)
if not len(q):
flash("No provider request with ID '%s'" % id)
return redirect('/')
return render('providers.html', p=q[0])
def routeMod(id=None, action=None):
if not isMod(): return redirect(url_for('/find'))
if action == 'adduser':
if request.form.get('user') and request.form.get('pw'):
u = Admin(username=request.form.get('user'),
password=hashPw(request.form.get('pw')))
u.save()
flash('Added user "%s" successfully!' % request.form.get('user'), 'success')
return redirect('/mod')
elif action =='rmvuser':
q = Admin.objects(id=id)
if len(q):
q[0].delete()
flash('Deleted user successfully!', 'success')
return redirect('/mod')
flash('Error deleting user!', 'error')
return redirect('/mod')
if not id:
flash('Error processing your request!', 'error')
return redirect('/mod')
act = action.split('_', 1)
if act[-1] == 'provider':
q = Provider.objects(id=id)
text = 'submission'
url = '/mod/provider'
elif act[-1] == 'school':
q = School.objects(id=id)
text = 'request'
url ='/mod/school'
if not len(q):
flash('Error processing your request! (Could not find %s)' % text, 'error')
return redirect(url+'s')
q = q[0]
if act[0] == 'del':
q.delete()
flash('Deleted %s!' % text, 'success')
return redirect(url+'s')
elif act[0] == 'mark':
q.active = False
q.save()
flash('Marked %s as done!' % text, 'success')
return redirect(url+'/%s' % id)
def run(model,
continuous,
batchsize,
resolution,
epochs,
spec='cqt',
phase=False,
size=512,
lr=1e-5,
weight_decay=.0,
state=None,
index=None):
train = Provider('train', resolution, continuous, batchsize, spec, phase)
valid = Provider('valid', resolution, continuous, batchsize, spec, phase)
test = Provider('test', resolution, continuous, batchsize, spec, phase)
device = torch.device('cuda:0')
model = model(train.shape(), 120 if continuous else 2, size)
net = model.cuda()
funcs = {'rmse': RMSE, "mcorr": MeanCorr} if continuous else {'rmse': RMSE}
criterion = nn.MSELoss()
optimizer = optim.Adam(net.parameters(), lr=lr, weight_decay=weight_decay)
testers = {i: {k: v() for k, v in funcs.items()} for i in ['aro', 'val']}
params = 0
for i in model.parameters():
params += np.asarray(i.shape).prod()
records = {
'args': {
'model': model.identifier(),
'time': datetime.now(),
'params': params
},
'time': [],
'train': defaultdict(partial(defaultdict, list)),
'valid': defaultdict(partial(defaultdict, list)),
'test': defaultdict(partial(defaultdict, list))
}
for i in [
'continuous', 'batchsize', 'resolution', 'epochs', 'spec', 'phase',
'size', 'lr', 'weight_decay', 'params'
]:
records['args'][i] = locals()[i]
def forward(update, data, dataset):
loss = 0
net.train(update)
for x, y in tqdm(data, ncols=55, desc=data.group):
x = torch.Tensor(x).float().to(device=device)
y = torch.Tensor(y).float().to(device=device)
p = net.forward(x)
l = criterion(p, y)
if update:
optimizer.zero_grad()
l.backward()
optimizer.step()
p = p.cpu().detach().numpy()
y = y.cpu().detach().numpy()
loss += l.item() * y.shape[0]
size = int(y.shape[1] / 2)
val_p = p[:, :size]
val_y = y[:, :size]
aro_p = p[:, size:]
aro_y = y[:, size:]
for _, i in testers['aro'].items():
i.accept(aro_p, aro_y)
for _, i in testers['val'].items():
i.accept(val_p, val_y)
del x, y, p, l
output = dataset + ': '
for g, i in testers.items():
for t, j in i.items():
value = j.finish()
output += '{}-{}: {:.3f}, '.format(g, t, value)
records[dataset][g][t].append(value)
loss /= data.total()
records[dataset]['gnr']['loss'].append(loss)
print(output + "loss: {:.4f}".format(loss))
return loss
train_loss = []
valid_loss = []
best_loss = None
best_model = None
states = []
start = datetime.now()
if state is None:
for i in range(epochs):
print('Epoch {}'.format(i + 1))
train_loss.append(forward(True, train, 'train'))
valid_loss.append(forward(False, valid, 'valid'))
states.append(copy.deepcopy(net.state_dict()))
if best_loss is None or valid_loss[-1] < best_loss:
best_loss = valid_loss[-1]
best_model = i
print()
records['time'].append(datetime.now() - start)
net.load_state_dict(states[best_model])
else:
net.load_state_dict(state)
states = [state]
forward(False, test, 'test')
if os.path.exists('data/records.db'):
with open('data/records.db', 'rb') as f:
data = pickle.load(f)
else:
data = []
if state is None:
data.append(records)
elif index is not None:
data[index]['test'] = records['test']
with open('data/records.db', 'wb') as f:
pickle.dump(data, f)
if state is None:
plt.plot(train_loss, label='train')
plt.plot(valid_loss, label='valid')
plt.ylim(0, 0.05)
plt.legend()
plt.show()
return states
def get_organisations(self):
return Provider(self.__api_id,
self.__api_password).fetch_organisations()
def get_backlog_item(self, id):
return Provider(self.__api_id,
self.__api_password).fetch_backlog_item(id)
def get_backlog(self):
return Provider(self.__api_id, self.__api_password).fetch_backlog()
