def initKK():
#global args
global args
#global import
global PluginManager
#global import
global argparse
#get python version
pythonVersion = sys.version_info
#check that python is at least 2.7
if sys.version_info[0] == 2 and sys.version_info[1] < 7:
#err msg
# ->as logging isn't init'd yet, just print directly
print('ERROR: KnockKnock requires python 2.7+ (found: %s)' % (pythonVersion))
#bail
return False
#TODO: check for python 3.0?
#try import argparse
# ->should work now since just checked that python is 2.7+
try:
#import
import argparse
#handle exception
# ->bail w/ error msg
except ImportError:
#err msg
# ->as logging isn't init'd yet, just print directly
print('ERROR: could not load required module (argparse)')
#bail
return False
#add knock knock's lib path to system path
# ->ensures 3rd-party libs will be imported OK
sys.path.insert(0, os.path.join(utils.getKKDirectory(), 'libs'))
#now can import 3rd party lib
# ->yapsy
from yapsy.PluginManager import PluginManager
#parse options/args
# ->will bail (with msg) if usage is incorrect
args = parseArgs()
#init output/logging
if not utils.initLogging(args.verbosity):
#bail
return False
#dbg msg
utils.logMessage(utils.MODE_INFO, 'initialized logging')
#check version (Mavericks/Yosemite for now)
# ->this isn't a fatal error for now, so just log a warning for unsupported versions
if not utils.isSupportedOS():
#dbg msg
utils.logMessage(utils.MODE_WARN, '%s is not an officially supported OS X version (you milage may vary)' % ('.'.join(utils.getOSVersion())))
#dbg msg
else:
#dbg msg
utils.logMessage(utils.MODE_INFO, '%s is a supported OS X version' % ('.'.join(utils.getOSVersion())))
#load python <-> Objc bindings
# ->might fail if non-Apple version of python is being used
if not utils.loadObjcBindings():
#dbg msg
utils.logMessage(utils.MODE_ERROR, 'python <-> Objc bindings/module not installed\n run via /usr/bin/python or install modules via \'pip install pyobjc\' to fix')
#bail
return False
#load whitelists
whitelist.loadWhitelists()
#init plugin manager
if not initPluginManager():
#bail
return False
#dbg msg
utils.logMessage(utils.MODE_INFO, 'initialized plugin manager')
#giving warning about r00t
if 0 != os.geteuid():
#dbg msg
utils.logMessage(utils.MODE_INFO, 'not running as r00t...some results may be missed (e.g. CronJobs)')
return True
#!/usr/bin/python
"""
This library implements some api functions for quizlet
"""
import utils
import logging
import os
import httplib
import urllib
import json
utils.initLogging()
conf = utils.getConf()
def _get_quizlet_response(method, path, params):
accesstoken = conf['quizlet']['accesstoken']
headers = {
"Authorization": "Bearer %s" % accesstoken,
"Content-Type": "application/x-www-form-urlencoded"
}
conn = httplib.HTTPSConnection("api.quizlet.com")
conn.request(method, path, params, headers)
resp = conn.getresponse()
return resp
def initKK():
#global args
global args
#global import
global PluginManager
#global import
global argparse
#get python version
pythonVersion = sys.version_info
#check that python is at least 2.7
if sys.version_info[0] == 2 and sys.version_info[1] < 7:
#err msg
# ->as logging isn't init'd yet, just print directly
print('ERROR: KnockKnock requires python 2.7+ (found: %s)' %
(pythonVersion))
#bail
return False
#TODO: check for python 3.0?
#try import argparse
# ->should work now since just checked that python is 2.7+
try:
#import
import argparse
#handle exception
# ->bail w/ error msg
except ImportError:
#err msg
# ->as logging isn't init'd yet, just print directly
print('ERROR: could not load required module (argparse)')
#bail
return False
#add knock knock's lib path to system path
# ->ensures 3rd-party libs will be imported OK
sys.path.insert(0, os.path.join(utils.getKKDirectory(), 'libs'))
#now can import 3rd party lib
# ->yapsy
from yapsy.PluginManager import PluginManager
#parse options/args
# ->will bail (with msg) if usage is incorrect
args = parseArgs()
#init output/logging
if not utils.initLogging(args.verbosity):
#bail
return False
#dbg msg
utils.logMessage(utils.MODE_INFO, 'initialized logging')
#check version (Mavericks/Yosemite for now)
# ->this isn't a fatal error for now, so just log a warning for unsupported versions
if not utils.isSupportedOS():
#dbg msg
utils.logMessage(
utils.MODE_WARN,
'%s is not an officially supported OS X version (your mileage may vary)'
% ('.'.join(utils.getOSVersion())))
#dbg msg
else:
#dbg msg
utils.logMessage(
utils.MODE_INFO, '%s is a supported OS X version' %
('.'.join(utils.getOSVersion())))
#load python <-> Objc bindings
# ->might fail if non-Apple version of python is being used
if not utils.loadObjcBindings():
#dbg msg
utils.logMessage(
utils.MODE_ERROR,
'python <-> Objc bindings/module not installed\n run via /usr/bin/python or install modules via \'pip install pyobjc\' to fix'
)
#bail
return False
#load whitelists
whitelist.loadWhitelists()
#init plugin manager
if not initPluginManager():
#bail
return False
#dbg msg
utils.logMessage(utils.MODE_INFO, 'initialized plugin manager')
#giving warning about r00t
if 0 != os.geteuid():
#dbg msg
utils.logMessage(
utils.MODE_INFO,
'not running as r00t...some results may be missed (e.g. CronJobs)')
return True
logging.debug("Subplots : %s", SubplotsPerPlot)
logging.debug("nTotal : %s", nTotal)
logging.debug("nPlosts : %s", nPlots)
iPLotted = 0
for i in range(nPlots):
fig = make_subplots(SubplotsPerPlot[0], SubplotsPerPlot[1])
for ir in range(SubplotsPerPlot[0]):
for ic in range(SubplotsPerPlot[1]):
logging.debug(
"Plot %s -- iPLotted = %s / row = %s / column = %s", i,
iPLotted, ir + 1, ic + 1)
fig.add_trace(figures[iPLotted], row=ir + 1, col=ic + 1)
fig.update_xaxes(title_text=figures_titles[iPLotted][0],
row=ir + 1,
col=ic + 1)
fig.update_yaxes(title_text=figures_titles[iPLotted][1],
row=ir + 1,
col=ic + 1)
iPLotted += 1
if not batch:
fig.show()
if __name__ == "__main__":
initLogging(20)
dataset = "dataset_1809.10717.csv"
plotDataset(dataset, batch=False)
import signal #Portability problem ???
import tempfile
import pipes
#import Gnuplot, Gnuplot.funcutils
import p2dbstore
import p2data
import utils
args = utils.argParse('reader')
#Init output (logging and verbosity)
utils.initLogging(args['verbosity'])
logger = utils.getLogger()
if args['csvdump'] != None and args['database']:
p2data.csvDump(args['database'], args['csvdump'])
exit(0)
if args['last_data'] != None:
p2data.csvLastDataDump(args['last_data'])
exit(0)
if 'field_list' in args and args['field_list']:
names = p2data.colNames()
print "Field list :"
import backend
import processes
import convert
from output import puppet
from utils import initLogging
from os.path import basename
log = initLogging()
log.info("main: Starting run")
processes_dic = {}
log.info("main: Starting process detect")
for plugin in processes.plugins:
log.debug("main: running %s process plugin" %plugin.__name__)
processes_dic[plugin.__name__] = plugin.run()
log.info("main: Done with process detect")
backend_dic = {}
log.info("main: Starting package backend run")
for plugin in backend.plugins:
log.debug("main: running %s package backend plugin" % plugin.__name__)
for key in processes_dic.keys():
backend_dic[plugin.__name__] = plugin.run(processes_dic[key])
log.info("main: Done with package backend run")
converted = []
def initKK(): #global args global args #global import global PluginManager #add knock knock's lib path to system path # ->ensures 3rd-party libs will be imported OK sys.path.insert(0, os.path.join(utils.getKKDirectory(), 'libs')) #now can import 3rd party lib # ->yapsy from yapsy.PluginManager import PluginManager #parse options/args # ->will bail (with msg) if usage is incorrect args = parseArgs() #init output/logging if not utils.initLogging(args.verbosity): #bail return False #dbg msg utils.logMessage(utils.MODE_INFO, 'initialized logging') #check version # ->only support Mavericks for now if not utils.isSupportedOS(): #dbg msg utils.logMessage(utils.MODE_INFO, '%.1f is not a fully supported OS X version' % (utils.getOSVersion())) #bail #return False #dbg msg else: #dbg msg utils.logMessage(utils.MODE_INFO, '%.1f is a supported OS X version' % (utils.getOSVersion())) #load python <-> Objc bindings # ->might fail if non-Apple version of python is being used if not utils.loadObjcBindings(): #dbg msg utils.logMessage(utils.MODE_ERROR, 'python <-> Objc bindings/module not installed\n run via /usr/bin/python or install modules via \'pip install pyobjc\' to fix') #bail return False #load whitelists whitelist.loadWhitelists() #init plugin manager if not initPluginManager(): #bail return False #dbg msg utils.logMessage(utils.MODE_INFO, 'initialized plugin manager') #giving warning about r00t if 0 != os.geteuid(): #dbg msg utils.logMessage(utils.MODE_INFO, 'not running as r00t...some results may be missed') return True
def initKK():
#global args
global args
#global import
global PluginManager
#add knock knock's lib path to system path
# ->ensures 3rd-party libs will be imported OK
sys.path.insert(0, os.path.join(utils.getKKDirectory(), 'libs'))
#now can import 3rd party lib
# ->yapsy
from yapsy.PluginManager import PluginManager
#parse options/args
# ->will bail (with msg) if usage is incorrect
args = parseArgs()
#init output/logging
if not utils.initLogging(args.verbosity):
#bail
return False
#dbg msg
utils.logMessage(utils.MODE_INFO, 'initialized logging')
#check version
# ->only support Mavericks for now
if not utils.isSupportedOS():
#dbg msg
utils.logMessage(
utils.MODE_INFO, '%.1f is not a fully supported OS X version' %
(utils.getOSVersion()))
#bail
#return False
#dbg msg
else:
#dbg msg
utils.logMessage(
utils.MODE_INFO,
'%.1f is a supported OS X version' % (utils.getOSVersion()))
#load python <-> Objc bindings
# ->might fail if non-Apple version of python is being used
if not utils.loadObjcBindings():
#dbg msg
utils.logMessage(
utils.MODE_ERROR,
'python <-> Objc bindings/module not installed\n run via /usr/bin/python or install modules via \'pip install pyobjc\' to fix'
)
#bail
return False
#load whitelists
whitelist.loadWhitelists()
#init plugin manager
if not initPluginManager():
#bail
return False
#dbg msg
utils.logMessage(utils.MODE_INFO, 'initialized plugin manager')
#giving warning about r00t
if 0 != os.geteuid():
#dbg msg
utils.logMessage(utils.MODE_INFO,
'not running as r00t...some results may be missed')
return True
fdpid.write(str(pid))
fdpid.close()
logger.debug("Background process started. Pid = "+str(pid))
return pid
signal.signal(signal.SIGINT, gentle_exit)
signal.signal(10, gentle_exit)
#Argument parse
args = utils.argParse('monitor')
#Init output (logging and verbosity)
utils.initLogging(args['verbosity'], args['log_file'], args['log_level'], args['log_num'], args['log_size'])
logger = utils.getLogger()
#start background process to start a daemon
pidfile = args['pidfile']
if args['background']:
exit(start_daemon(pidfile))
elif args['stop']: #or kill an existing daemon
try:
pidfd = open(pidfile,"r")
pid = int(pidfd.read())
os.kill(pid, 10)
logger.debug("Sig 10 send to process",pid)
except:
exit(0)
def train_model():
args = parser.parse_args()
## Logging
log_path = "./trained_models/{}/".format(args.name)
os.makedirs(log_path, exist_ok=True)
initLogging(log_file=log_path + 'train.log')
if args.tensorboard:
logger = SummaryWriter(log_path + 'train-pre{}-nll{}'.format(
args.pretrain_epochs, args.train_epochs))
logger_val = SummaryWriter(log_path + 'validation-pre{}-nll{}'.format(
args.pretrain_epochs, args.train_epochs))
logging.info("------------- {} -------------".format(args.name))
logging.info("Batch size : {}".format(args.batch_size))
logging.info("Learning rate : {}".format(args.learning_rate))
logging.info("Use Planning Coupled: {}".format(args.use_planning))
logging.info("Use Target Fusion: {}".format(args.use_fusion))
## Initialize network and optimizer
PiP = pipNet(args)
if args.use_cuda:
PiP = PiP.cuda()
optimizer = torch.optim.Adam(PiP.parameters(), lr=args.learning_rate)
crossEnt = torch.nn.BCELoss()
## Initialize training parameters
pretrainEpochs = args.pretrain_epochs
trainEpochs = args.train_epochs
batch_size = args.batch_size
## Initialize data loaders
logging.info("Train dataset: {}".format(args.train_set))
trSet = highwayTrajDataset(path=args.train_set,
targ_enc_size=args.social_context_size +
args.dynamics_encoding_size,
grid_size=args.grid_size,
fit_plan_traj=False)
logging.info("Validation dataset: {}".format(args.val_set))
valSet = highwayTrajDataset(path=args.val_set,
targ_enc_size=args.social_context_size +
args.dynamics_encoding_size,
grid_size=args.grid_size,
fit_plan_traj=True)
trDataloader = DataLoader(trSet,
batch_size=batch_size,
shuffle=True,
num_workers=args.num_workers,
collate_fn=trSet.collate_fn)
valDataloader = DataLoader(valSet,
batch_size=batch_size,
shuffle=True,
num_workers=args.num_workers,
collate_fn=valSet.collate_fn)
logging.info(
"DataSet Prepared : {} train data, {} validation data\n".format(
len(trSet), len(valSet)))
logging.info("Network structure: {}\n".format(PiP))
## Training process
for epoch_num in range(pretrainEpochs + trainEpochs):
if epoch_num == 0:
logging.info('Pretrain with MSE loss')
elif epoch_num == pretrainEpochs:
logging.info('Train with NLL loss')
## Variables to track training performance:
avg_time_tr, avg_loss_tr, avg_loss_val = 0, 0, 0
## Training status, reclaim after each epoch
PiP.train()
PiP.train_output_flag = True
for i, data in enumerate(trDataloader):
st_time = time.time()
nbsHist, nbsMask, planFut, planMask, targsHist, targsEncMask, targsFut, targsFutMask, lat_enc, lon_enc, _ = data
if args.use_cuda:
nbsHist = nbsHist.cuda()
nbsMask = nbsMask.cuda()
planFut = planFut.cuda()
planMask = planMask.cuda()
targsHist = targsHist.cuda()
targsEncMask = targsEncMask.cuda()
lat_enc = lat_enc.cuda()
lon_enc = lon_enc.cuda()
targsFut = targsFut.cuda()
targsFutMask = targsFutMask.cuda()
# Forward pass
fut_pred, lat_pred, lon_pred = PiP(nbsHist, nbsMask, planFut,
planMask, targsHist,
targsEncMask, lat_enc, lon_enc)
if epoch_num < pretrainEpochs:
# Pre-train with MSE loss to speed up training
l = maskedMSE(fut_pred, targsFut, targsFutMask)
else:
# Train with NLL loss
l = maskedNLL(fut_pred, targsFut, targsFutMask) + crossEnt(
lat_pred, lat_enc) + crossEnt(lon_pred, lon_enc)
# Back-prop and update weights
optimizer.zero_grad()
l.backward()
prev_vec_norm = torch.nn.utils.clip_grad_norm_(
PiP.parameters(), 10)
optimizer.step()
# Track average train loss and average train time:
batch_time = time.time() - st_time
avg_loss_tr += l.item()
avg_time_tr += batch_time
# For every 100 batches: record loss, validate model, and plot.
if i % 100 == 99:
eta = avg_time_tr / 100 * (len(trSet) / batch_size - i)
epoch_progress = i * batch_size / len(trSet)
logging.info(f"Epoch no:{epoch_num+1}" +
f" | Epoch progress(%):{epoch_progress*100:.2f}" +
f" | Avg train loss:{avg_loss_tr/100:.2f}" +
f" | ETA(s):{int(eta)}")
if args.tensorboard:
logger.add_scalar(
"RMSE" if epoch_num < pretrainEpochs else "NLL",
avg_loss_tr / 100, (epoch_progress + epoch_num) * 100)
## Validatation during training:
eval_batch_num = 20
with torch.no_grad():
PiP.eval()
PiP.train_output_flag = False
for i, data in enumerate(valDataloader):
nbsHist, nbsMask, planFut, planMask, targsHist, targsEncMask, targsFut, targsFutMask, lat_enc, lon_enc, _ = data
if args.use_cuda:
nbsHist = nbsHist.cuda()
nbsMask = nbsMask.cuda()
planFut = planFut.cuda()
planMask = planMask.cuda()
targsHist = targsHist.cuda()
targsEncMask = targsEncMask.cuda()
lat_enc = lat_enc.cuda()
lon_enc = lon_enc.cuda()
targsFut = targsFut.cuda()
targsFutMask = targsFutMask.cuda()
if epoch_num < pretrainEpochs:
# During pre-training with MSE loss, validate with MSE for true maneuver class trajectory
PiP.train_output_flag = True
fut_pred, _, _ = PiP(nbsHist, nbsMask, planFut,
planMask, targsHist,
targsEncMask, lat_enc,
lon_enc)
l = maskedMSE(fut_pred, targsFut, targsFutMask)
else:
# During training with NLL loss, validate with NLL over multi-modal distribution
fut_pred, lat_pred, lon_pred = PiP(
nbsHist, nbsMask, planFut, planMask, targsHist,
targsEncMask, lat_enc, lon_enc)
l = maskedNLLTest(fut_pred,
lat_pred,
lon_pred,
targsFut,
targsFutMask,
avg_along_time=True)
avg_loss_val += l.item()
if i == (eval_batch_num - 1):
if args.tensorboard:
logger_val.add_scalar(
"RMSE" if epoch_num < pretrainEpochs else
"NLL", avg_loss_val / eval_batch_num,
(epoch_progress + epoch_num) * 100)
break
# Clear statistic
avg_time_tr, avg_loss_tr, avg_loss_val = 0, 0, 0
# Revert to train mode after in-process evaluation.
PiP.train()
PiP.train_output_flag = True
## Save the model after each epoch______________________________________________________________________________
epoCount = epoch_num + 1
if epoCount < pretrainEpochs:
torch.save(
PiP.state_dict(),
log_path + "{}-pre{}-nll{}.tar".format(args.name, epoCount, 0))
else:
torch.save(
PiP.state_dict(), log_path + "{}-pre{}-nll{}.tar".format(
args.name, pretrainEpochs, epoCount - pretrainEpochs))
# All epochs finish________________________________________________________________________________________________
torch.save(PiP.state_dict(), log_path + "{}.tar".format(args.name))
logging.info("Model saved in trained_models/{}/{}.tar\n".format(
args.name, args.name))
"""
import torch
import logging
from tqdm import tqdm
from torch.optim import Adam
from torch.nn import CrossEntropyLoss
from data.dataloader import generate_loader
from config import Configure
from networks.RCNN import BiGruCNN
from framework import MyFrame
from utils import initLogging
name = 'HAN_rcnn_drop0.2'
mylog = 'logs/' + name + '.log'
path = 'weights/' + name + '.pkl'
initLogging(mylog)
device = 2
total_epochs = 30
valid_best_score = 0.
train_loader, valid_loader, testa_loader = generate_loader(train_bs=32)
opt = Configure()
net = BiGruCNN
loss_func = CrossEntropyLoss(size_average=True)
solver = MyFrame(net=net, loss=loss_func, opt=opt, lr=1e-3, device=device)
solver.load(path)
# solver.net.embedding.weight.requires_grad = True
no_optim_round = 0
for epoch in range(total_epochs):
# train
def model_evaluate():
args = parser.parse_args()
## Initialize network
PiP = pipNet(args)
PiP.load_state_dict(
torch.load('./trained_models/{}/{}.tar'.format(
(args.name).split('-')[0], args.name)))
if args.use_cuda:
PiP = PiP.cuda()
## Evaluation Mode
PiP.eval()
PiP.train_output_flag = False
initLogging(log_file='./trained_models/{}/evaluation.log'.format((
args.name).split('-')[0]))
## Intialize dataset
logging.info("Loading test data from {}...".format(args.test_set))
tsSet = highwayTrajDataset(path=args.test_set,
targ_enc_size=args.social_context_size +
args.dynamics_encoding_size,
grid_size=args.grid_size,
fit_plan_traj=True,
fit_plan_further_ds=args.plan_info_ds)
logging.info("TOTAL :: {} test data.".format(len(tsSet)))
tsDataloader = DataLoader(tsSet,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.num_workers,
collate_fn=tsSet.collate_fn)
## Loss statistic
logging.info(
"<{}> evaluated by {}-based NLL & RMSE, with planning input of {}s step."
.format(args.name, args.metric, args.plan_info_ds * 0.2))
if args.metric == 'agent':
nll_loss_stat = np.zeros(
(np.max(tsSet.Data[:, 0]).astype(int) + 1,
np.max(tsSet.Data[:, 13:(13 + tsSet.grid_cells)]).astype(int) + 1,
args.out_length))
rmse_loss_stat = np.zeros(
(np.max(tsSet.Data[:, 0]).astype(int) + 1,
np.max(tsSet.Data[:, 13:(13 + tsSet.grid_cells)]).astype(int) + 1,
args.out_length))
both_count_stat = np.zeros(
(np.max(tsSet.Data[:, 0]).astype(int) + 1,
np.max(tsSet.Data[:, 13:(13 + tsSet.grid_cells)]).astype(int) + 1,
args.out_length))
elif args.metric == 'sample':
rmse_loss = torch.zeros(25).cuda()
rmse_counts = torch.zeros(25).cuda()
nll_loss = torch.zeros(25).cuda()
nll_counts = torch.zeros(25).cuda()
else:
raise RuntimeError("Wrong type of evaluation metric is specified")
avg_eva_time = 0
## Evaluation process
with torch.no_grad():
for i, data in enumerate(tsDataloader):
st_time = time.time()
nbsHist, nbsMask, planFut, planMask, targsHist, targsEncMask, targsFut, targsFutMask, lat_enc, lon_enc, idxs = data
# Initialize Variables
if args.use_cuda:
nbsHist = nbsHist.cuda()
nbsMask = nbsMask.cuda()
planFut = planFut.cuda()
planMask = planMask.cuda()
targsHist = targsHist.cuda()
targsEncMask = targsEncMask.cuda()
lat_enc = lat_enc.cuda()
lon_enc = lon_enc.cuda()
targsFut = targsFut.cuda()
targsFutMask = targsFutMask.cuda()
# Inference
fut_pred, lat_pred, lon_pred = PiP(nbsHist, nbsMask, planFut,
planMask, targsHist,
targsEncMask, lat_enc, lon_enc)
# Performance metric
if args.metric == 'agent':
dsIDs, targsIDs = tsSet.batchTargetVehsInfo(idxs)
l, c = maskedNLLTest(fut_pred,
lat_pred,
lon_pred,
targsFut,
targsFutMask,
separately=True)
# Select the trajectory with the largest probability of maneuver label when evaluating by RMSE
fut_pred_max = torch.zeros_like(fut_pred[0])
for k in range(lat_pred.shape[0]):
lat_man = torch.argmax(lat_pred[k, :]).detach()
lon_man = torch.argmax(lon_pred[k, :]).detach()
indx = lon_man * 3 + lat_man
fut_pred_max[:, k, :] = fut_pred[indx][:, k, :]
# Using the most probable trajectory
ll, cc = maskedMSETest(fut_pred_max,
targsFut,
targsFutMask,
separately=True)
l = l.detach().cpu().numpy()
ll = ll.detach().cpu().numpy()
c = c.detach().cpu().numpy()
cc = cc.detach().cpu().numpy()
for j, targ in enumerate(targsIDs):
dsID = dsIDs[j]
nll_loss_stat[dsID, targ, :] += l[:, j]
rmse_loss_stat[dsID, targ, :] += ll[:, j]
both_count_stat[dsID, targ, :] += c[:, j]
elif args.metric == 'sample':
l, c = maskedNLLTest(fut_pred, lat_pred, lon_pred, targsFut,
targsFutMask)
nll_loss += l.detach()
nll_counts += c.detach()
fut_pred_max = torch.zeros_like(fut_pred[0])
for k in range(lat_pred.shape[0]):
lat_man = torch.argmax(lat_pred[k, :]).detach()
lon_man = torch.argmax(lon_pred[k, :]).detach()
indx = lon_man * 3 + lat_man
fut_pred_max[:, k, :] = fut_pred[indx][:, k, :]
l, c = maskedMSETest(fut_pred_max, targsFut, targsFutMask)
rmse_loss += l.detach()
rmse_counts += c.detach()
# Time estimate
batch_time = time.time() - st_time
avg_eva_time += batch_time
if i % 100 == 99:
eta = avg_eva_time / 100 * (len(tsSet) / args.batch_size - i)
logging.info("Evaluation progress(%):{:.2f}".format(
i / (len(tsSet) / args.batch_size) * 100, ) +
" | ETA(s):{}".format(int(eta)))
avg_eva_time = 0
# Result Summary
if args.metric == 'agent':
# Loss averaged from all predicted vehicles.
ds_ids, veh_ids = both_count_stat[:, :, 0].nonzero()
num_vehs = len(veh_ids)
rmse_loss_averaged = np.zeros((args.out_length, num_vehs))
nll_loss_averaged = np.zeros((args.out_length, num_vehs))
count_averaged = np.zeros((args.out_length, num_vehs))
for i in range(num_vehs):
count_averaged[:, i] = \
both_count_stat[ds_ids[i], veh_ids[i], :].astype(bool)
rmse_loss_averaged[:,i] = rmse_loss_stat[ds_ids[i], veh_ids[i], :] \
* count_averaged[:, i] / (both_count_stat[ds_ids[i], veh_ids[i], :] + 1e-9)
nll_loss_averaged[:,i] = nll_loss_stat[ds_ids[i], veh_ids[i], :] \
* count_averaged[:, i] / (both_count_stat[ds_ids[i], veh_ids[i], :] + 1e-9)
rmse_loss_sum = np.sum(rmse_loss_averaged, axis=1)
nll_loss_sum = np.sum(nll_loss_averaged, axis=1)
count_sum = np.sum(count_averaged, axis=1)
rmseOverall = np.power(
rmse_loss_sum / count_sum,
0.5) * 0.3048 # Unit converted from feet to meter.
nllOverall = nll_loss_sum / count_sum
elif args.metric == 'sample':
rmseOverall = (torch.pow(rmse_loss / rmse_counts, 0.5) * 0.3048).cpu()
nllOverall = (nll_loss / nll_counts).cpu()
# Print the metrics every 5 time frame (1s)
logging.info("RMSE (m)\t=> {}, Mean={:.3f}".format(
rmseOverall[4::5], rmseOverall[4::5].mean()))
logging.info("NLL (nats)\t=> {}, Mean={:.3f}".format(
nllOverall[4::5], nllOverall[4::5].mean()))
model.compile(optimizer='adam', loss='mse')
logging.info("Starting to train %s epochs", epochs)
model.fit(X, y, epochs=epochs, verbose=0)
for testSeq, expectation in testSequence:
x_input = np.array(testSeq)
x_input = x_input.reshape((1, nsteps, nfeatures))
yhat = model.predict(x_input, verbose=0)
logging.info("Predicted %s as next step for %s", yhat, testSeq)
logging.info("Expected %s", expectation)
if __name__ == "__main__":
initLogging(10)
if True:
logging.info("Prediction next integer")
seriesLength = 4
lengths = 200
startVal = 1
seriesLin = [1 * x for x in range(1, lengths + 1)]
testSeries = [
([(lengths + 2) + x
for x in range(seriesLength)], lengths + 2 + seriesLength),
([(lengths + 20) + x
for x in range(seriesLength)], lengths + 20 + seriesLength),
([(lengths + 200) + x
for x in range(seriesLength)], lengths + 200 + seriesLength)
