def advection():
#loadnamenpy = 'advection_marginal_7397.npy'
loadnamenpy = 'advection_marginal_6328.npy'
loadnamenpy = 'advection_marginal_8028.npy'
loadnamenpy = 'advection_marginal_5765.npy'
#loadnamenpy = 'advection_marginal_4527.npy'
case = '_'.join(loadnamenpy.split('_')[:2])
dataman = DataIO(case)
fuk, fu, gridvars, ICparams = dataman.loadSolution(loadnamenpy)
grid = PdfGrid(gridvars)
V = Visualize(grid)
V.plot_fuk3D(fuk)
V.plot_fu3D(fu)
V.plot_fu(fu, dim='t', steps=5)
V.plot_fu(fu, dim='x', steps=5)
V.show()
# Learn
difflearn = PDElearn(fuk,
grid,
fu=fu,
ICparams=ICparams,
scase=case,
trainratio=0.8,
debug=False,
verbose=True)
difflearn.fit_sparse(feature_opt='2ndorder',
variableCoef=True,
variableCoefBasis='simple_polynomial',
variableCoefOrder=3,
use_sindy=True,
sindy_alpha=0.001)
def analyze(self, adjust=False, plot=False, learn=False, adjustparams={}, learnparams={'feature_opt':'1storder', 'coeforder':1}):
dataman = DataIO(self.case)
fu, gridvars, ICparams = dataman.loadSolution(self.loadnamenpy, array_opt='marginal')
##Make fu smaller (in time)
if adjust:
fu, gridvars = self.adjust(fu, gridvars, adjustparams)
grid = PdfGrid(gridvars)
if plot:
V = Visualize(grid)
V.plot_fu3D(fu)
V.plot_fu(fu, dim='t', steps=5)
V.plot_fu(fu, dim='x', steps=5)
V.show()
if learn:
t0 = time.time()
print('fu dimension: ', fu.shape)
print('fu num elem.: ', np.prod(fu.shape))
feature_opt = learnparams['feature_opt']
coeforder = learnparams['coeforder']
sindy_alpha = learnparams['sindy_alpha']
RegCoef = learnparams['RegCoef']
nzthresh = learnparams['nzthresh']
# Learn
difflearn = PDElearn(grid=grid, fu=fu, ICparams=ICparams, scase=self.case, trainratio=0.8, debug=False, verbose=True)
difflearn.fit_sparse(feature_opt=feature_opt, variableCoef=True, variableCoefBasis='simple_polynomial', \
variableCoefOrder=coeforder, use_sindy=True, sindy_alpha=sindy_alpha, RegCoef=RegCoef, nzthresh=nzthresh)
print('learning took t = ', str(t0 - time.time()))
def plot(self):
dataman = DataIO(self.case)
fu, gridvars, ICparams = dataman.loadSolution(self.loadnamenpy,
array_opt='marginal')
grid = PdfGrid(gridvars)
V = Visualize(grid)
V.plot_fu3D(fu)
V.plot_fu(fu, dim='t', steps=5)
V.plot_fu(fu, dim='x', steps=5)
V.show()
criterion = 'bic'
if "savenamepdf" not in locals():
# Check if there is already a loadfile (if not load it)
savenamepdf = 'advection_reaction_analytical_388_128.npy'
dataman = DataIO(case)
fu, gridvars, ICparams = dataman.loadSolution(savenamepdf, array_opt='marginal')
grid = PdfGrid(gridvars)
fu = grid.adjust(fu, adjustgrid)
if plot:
s = 10
V = Visualize(grid)
V.plot_fu3D(fu)
V.plot_fu(fu, dim='t', steps=s)
V.plot_fu(fu, dim='x', steps=s)
V.show()
difflearn = PDElearn(grid=grid, fu=fu, ICparams=ICparams, scase=case, trainratio=trainratio, verbose=True)
output = difflearn.fit_sparse(feature_opt=feature_opt, variableCoef=variableCoef, variableCoefBasis=variableCoefBasis, \
variableCoefOrder=coeforder, use_rfe=use_rfe, rfe_alpha=rfe_alpha, nzthresh=nzthresh, maxiter=maxiter, \
LassoType=LassoType, RegCoef=RegCoef, cv=cv, criterion=criterion, print_rfeiter=print_rfeiter, shuffle=shuffle, \
basefile=savenamepdf, adjustgrid=adjustgrid, save=save, normalize=normalize, comments=comments)
d = DataIO(case, directory=LEARNDIR)
learndata, pdfdata, mcdata = d.readLearningResults(savenamepdf.split('.')[0]+'.txt', PDFdata=True, MCdata=True, display=False)
else:
# Train model. Comment out if unneeded
logging.info("Beginning training")
lda = Model(num_categories=NUM_CATEGORIES)
ldamodel = lda.create_model(train_doc_matrix,
train_term_dictionary,
ROOT,
language=lang)
logging.info('Model created')
# Displays topics with top words
logging.info('TOP WORDS OF EACH CATEGORY FOR FINAL MODEL')
for i in ldamodel.print_topics():
for j in i:
logging.info(j)
if WRITE:
# Cluster information to csv
test_clusters = p.cluster_data(doc_matrix=test_doc_matrix,
ldamodel=ldamodel,
to_csv=True,
keywords=test_keywords,
filenames=test_filenames,
num_categories=NUM_CATEGORIES)
if VISUALIZE:
# Visualize model
visualize = Visualize(num_categories=NUM_CATEGORIES, language=lang)
visualize.visualize(ldamodel=ldamodel,
doc_matrix=test_doc_matrix,
raw_documents=test_docs)
fig, ax = plt.subplots(1, 2, figsize=(9, 4))
# Coefficients Dependence Multi
featarray, relevant_feats = A.getCoefDependence(output_vec,
threshold=0.01,
invert_sign=True)
for i in range(len(relevant_feats)):
ax[0].plot(variable, featarray[:, i], '.-', linewidth=2)
ax[0].set_xlabel(xlabel, fontsize=14)
ax[0].set_ylabel('Coefficients', fontsize=14)
ax[0].legend(latexify_varcoef(relevant_feats, cdf=True), fontsize=14)
ax[0].grid(color='k', linestyle='--', linewidth=1)
V = Visualize(grid0)
s = 10
snapidx = [int(i) for i in np.linspace(0, len(V.grid.tt) - 1, s)]
leg = []
xidx = np.where(V.grid.xx > 2.00)[0]
for tidx in snapidx:
ax[1].plot(V.grid.uu, fu0[:, xidx, tidx], linewidth=2)
leg.append('$t = %3.2f$ s' % (g.tt[tidx]))
ax[1].set_xlabel('$U$', fontsize=14)
ax[1].set_ylabel('$f_u(U; x^*, t)$', fontsize=14)
ax[1].legend(leg)
plt.show()
fig.savefig(FIGDIR + savename + '.pdf')
# # Plot boundary
p["alpha"], p["gamma"] = .15, .30
p["c_rr"], p["c_bb"] = .01, .05
p["c_rb"], p["c_br"] = .20, .15
create_artificial_data(p)
elif run_type == 'v':
"""
Run interactive visualisation of model
Second argument is the timestep-interval
"""
# set-up models
models = initiate_models(params_model)
# set-up visualisation
data.assign_data(models)
visualisation = Visualize(models)
# run models
for t in data.daterange():
print("Timestep %i" % data.get_timestep(t))
for model in models:
if t in data.measurements:
model.collect_data_fit()
model.step(visualize=True)
if data.get_timestep(t) % vis_steps == 0:
visualisation.update()
res = input(
"Press enter to continue simulation, type 'q' to stop current run:\n\t"
)
if res == 'q':
break
def run_fusion(
files,
has_camera=True,
has_wheel=True,
data_direc='',
write_results=True,
is_move_video=True,
is_interact=True,
move_to_app=False,
interactive_video='drivelog_temp.avi',
):
"""
Callback function that
runs fusion on the two data
csv files
"""
df = fusion.fuse_csv(files)
if not 'timestamp_x' in df.columns.values.tolist():
df['timestamp_x'] = df['timestamp']
if write_results:
df.to_csv('%s/fused.csv' % data_direc)
if has_camera:
###
# All events that are dependent on the camera
###
head_ann = HeadAnnotator()
head_events_hash, head_events_list = head_ann.annotate_events(df)
shc = SignalHeadClassifier(head_ann.df, head_ann.events)
head_events_sentiment = shc.classify_signals()
for i in xrange(len(head_events_list)):
head_events_list[i] = head_events_list[i] + (head_events_sentiment[i])
print head_events_list
if has_wheel:
###
# All events that are dependent on the steering wheel
###
lane_events_hash, lane_events_list = LaneAnnotator(data_direc).annotate_events(df)
if has_wheel and has_camera:
slc = SignalLaneClassifier(df, lane_events_list, head_events_list, head_events_hash, head_events_sentiment)
lane_events_sentiment = slc.classify_signals()
for i in xrange(len(lane_events_list)):
lane_events_list[i] = lane_events_list[i] + (lane_events_sentiment[i])
#### Compute sentiment classifications
# annotate the video
print "Creating video report....."
video_index = 'frameIndex'
metadata_file = 'annotated_metadata.json'
#interactive_video = "annotated_fused.avi"
# Created a fused video if possible
if (is_move_video and has_camera and has_wheel):
print head_events_list
print lane_events_list
final_fused_video = annotation.annotate_video(
'drivelog_temp.avi',
interactive_video,
map(lambda (s, e, t, sent, reason): \
(df.loc[s, video_index], df.loc[e, video_index], t, sent, reason),
head_events_list),
map(lambda (s, e, t, sent, reason): \
(df.loc[s, video_index], df.loc[e, video_index], t, sent, reason),
lane_events_list),
metadata_file
)
move_video(final_fused_video, data_direc)
move_video(metadata_file, data_direc)
# Otherwise, create the two seperate ones
else:
if (is_move_video and has_camera):
# I MAY HAVE BROKE THIS @chris
print head_events_list
final_head_video = annotation.annotate_video(
'drivelog_temp.avi',
interactive_video,
map(lambda (s, e, t, sent, reason): \
(df.loc[s, video_index], df.loc[e, video_index], t, sent, reason),
head_events_list),
[],
metadata_file
)
move_video(final_head_video, data_direc)
move_video(metadata_file, data_direc)
elif (is_move_video and has_wheel and len(lane_events_list) > 0):
print lane_events_list
final_lane_video = annotation.annotate_video(
'drivelog_temp.avi',
interactive_video,
[],
map(lambda (s, e, t, sent, reason): \
(df.loc[s, video_index], df.loc[e, video_index], t, sent, reason),
lane_events_list),
metadata_file
)
move_video(final_lane_video, data_direc)
move_video(metadata_file, data_direc)
else:
final_plain_video = annotation.annotate_video(
'drivelog_temp.avi',
interactive_video,
[],
[],
metadata_file
)
# Also copy drivelog_temp
if (is_move_video and has_camera):
move_video('drivelog_temp.avi', data_direc)
video_name = os.path.join(data_direc, interactive_video)
if (move_to_app):
# Convert video
convert_command = 'ffmpeg -i ' + video_name + ' ' + data_direc + '/annotated_fused.mp4'
os.system(convert_command)
time.sleep(1)
# Replace most recent, and add to data dir
shutil.rmtree('../app/static/data/recent', ignore_errors = True)
time.sleep(1)
shutil.copytree(data_direc, '../app/static/data/recent')
time.sleep(1)
dir_name = data_direc.split('/')[-1]
shutil.copytree(data_direc, '../app/static/data/' + dir_name)
if (has_camera and has_wheel and write_results):
print "Plotting...."
vis = Visualize(
df,
{
"head_turns": head_events_list,
"lane_changes": lane_events_list,
"head_sentiment": head_events_sentiment,
"lane_sentiment": lane_events_sentiment
},
video_name=video_name,
data_direc=data_direc
)
vis.visualize(is_interact=is_interact)
if (has_wheel and has_camera):
return dict(
head_events_hash=head_events_hash,
head_events_list=head_events_list,
lane_events_hash=lane_events_hash,
lane_events_list=lane_events_list,
head_events_sentiment=head_events_sentiment,
lane_events_sentiment=lane_events_sentiment,
df=df,
)
else:
return None