def show_confirmation():
""" confirm information about habit to user """
hour = int(request.args.get("hour"))
user_id = session['user_id']
user = User.query.filter(User.user_id == user_id).one()
tz = user.tz
# create an arrow object, replace hour and timezone, convert to UTC and format for db
t = arrow.now()
time = t.replace(hour=int('{}'.format(hour)), tzinfo='{}'.format(tz))
utc_time = time.to('UTC')
utc_time = utc_time.format('YYYY-MM-DD HH:mm:ss ZZ')
create_habit_id = session['habit_id']
if 'break_habit_id' not in session:
break_habit_id = None
else:
break_habit_id = session['break_habit_id']
if 'partner_id' not in session:
partner_id = None
else:
partner_id = session['partner_id']
habit_id = add_new_habit_return_id(user_id, create_habit_id,
break_habit_id, utc_time, partner_id)
habit = UserHabit.query.filter(UserHabit.habit_id == habit_id).first()
send_habit_intro_msg(user_id)
return render_template('confirm.html', habit=habit)
def test(self, loader, epoch, name):
self.model.eval()
user_id_list, pred_y = [], []
with torch.no_grad():
for index, datum_tuple in enumerate(loader):
creative_id, ad_id, product_id, advertiser_id, industry, product_category, time, user_id, _ = datum_tuple
advertiser_id, product_id, product_category, industry, time = advertiser_id.to(
device, non_blocking=True), product_id.to(
device, non_blocking=True), product_category.to(
device, non_blocking=True), industry.to(
device,
non_blocking=True), time.to(device,
non_blocking=True)
#获取embedding抽取的向量
inputlist_tensor = [
creative_id, ad_id, advertiser_id, product_id,
product_category, industry, time
]
emb_layer_mat = []
for index, input_col in enumerate(inputlist_tensor):
emb_layer_col_mat = {}
for j in range(len(self.emb_layer[index])):
if index in [2, 3, 4, 5, 6]:
self.emb_layer[index][j] = self.emb_layer[index][
j].to(device, non_blocking=True)
emb_layer_col_mat[j] = self.emb_layer[index][j](
input_col)
emb_layer_col_mat[j] = emb_layer_col_mat[j].to(
device, non_blocking=True)
emb_layer_mat.append(emb_layer_col_mat)
output = self.model(emb_layer_mat)
pred_y.extend(list(output.cpu().detach().numpy()))
user_id_list.extend(list(user_id.numpy()))
output_data = DataFrame({'user_id': user_id_list, 'pred': pred_y})
if not os.path.isdir(
'../../oof/bk_oof/Multi_Head_ResNext_seed_{}_aug'.format(
self.seed)):
os.mkdir('../../oof/bk_oof/Multi_Head_ResNext_seed_{}_aug'.format(
self.seed))
pickle.dump(
output_data,
open(
'../../oof/bk_oof/Multi_Head_ResNext_seed_{}_aug/{}_{}_folds_{}.pkl'
.format(self.seed, name, epoch, self.folds), 'wb'))
def _process_data_batch(self, data, phase, retain_graph=None):
if len(data) == 3:
data, time, event = data
elif len(data) == 4: # With patient id (not needed here)
data, time, event, pid = data
data = self._data_to_device(data)
time = time.to(self.device)
event = event.to(self.device)
with torch.set_grad_enabled(phase == 'train'):
feature_representations, risk = self.model(data)
modality_features = feature_representations['modalities']
loss = self._compute_loss(risk, time, event, modality_features)
if phase == 'train':
# Zero out parameter gradients
self.optimizer.zero_grad()
if retain_graph is not None:
loss.backward(retain_graph=retain_graph)
else:
loss.backward()
self.optimizer.step()
return loss, risk, time, event
def forward(self,
time,
click_time,
creative_id,
ad_id,
product_id,
product_category,
advertiser_id,
industry,
advertiser_id_industry,
product_category_advertiser_id,
product_category_industry,
product_id_advertiser_id,
product_id_industry,
product_id_product_category,
target_encode_sequence,
x_len,
x_flatten,
gender = None,\
age = None):
time = time.to(args.device)
click_time = click_time.to(args.device)
creative_id = creative_id.to(args.device)
ad_id = ad_id.to(args.device)
product_id = product_id.to(args.device)
advertiser_id = advertiser_id.to(args.device)
advertiser_id_industry = advertiser_id_industry.to(args.device)
product_category_advertiser_id = product_category_advertiser_id.to(
args.device)
product_id_advertiser_id = product_id_advertiser_id.to(args.device)
product_id_product_category = product_id_product_category.to(
args.device)
target_encode_sequence = target_encode_sequence.to(args.device)
x_len = x_len.to(args.device)
x_flatten = x_flatten.to(args.device)
if gender is not None:
gender = gender.to(args.device)
age = age.to(args.device)
a_wv = torch.cat([
self.ln_50s[0](ad_id),
self.ln_50s[1](creative_id),
self.ln_50s[2](product_id_product_category),
self.ln_50s[3](product_id),
self.ln_one_hot_target(target_encode_sequence),
self.position_embeddings(time),
self.click_time_embeddings(click_time),
],
dim=-1)
b_wv = torch.cat([
self.ln_50s[4](advertiser_id),
self.ln_50s[5](advertiser_id_industry),
self.ln_50s[6](product_category_advertiser_id),
self.ln_50s[7](product_id_advertiser_id),
self.ln_one_hot_target(target_encode_sequence),
self.position_embeddings(time),
self.click_time_embeddings(click_time),
],
dim=-1)
hidden = self.re2_block(a_wv, b_wv, x_len)
cat = torch.cat(
[self.ln_hidden(hidden),
self.ln_tfidf_stack(x_flatten)], dim=-1)
output_age = self.decoder_age(cat)
output_gender = self.decoder_gender(cat)
if (gender is None):
return output_gender, output_age, hidden
loss_age = nn.CrossEntropyLoss()
loss_gender = nn.CrossEntropyLoss()
l_age = loss_age(output_age, age.long())
l_gender = loss_gender(output_gender, gender.long())
l = 0.5 * l_gender + 0.5 * l_age
return l, l_gender, l_age, output_gender, output_age, hidden
def view_node_html(self, nid):
# TODO: Move view code out of model
ENV = Environment(loader=PackageLoader('controllers', 'templates'))
template = ENV.get_template('data.html')
# Setup some base variables
ENV = Environment(loader=PackageLoader('controllers', 'templates'))
fields = ['datatype', 'apikey', 'title', 'description', 'lat', 'lon',
'createdhuman', 'updated', 'latest', 'nid', 'createdby']
timeadj = int(self.kwargs['timeadj']) if 'timeadj' in self.kwargs else 0
timeadjcalc = (timeadj*60)*60 # Timestamp adjustment for local time
count = int(self.kwargs['count']) if 'count' in self.kwargs else 3000
if count > 12000: count = 12000
countfrom = int(self.kwargs['from']) if 'from' in self.kwargs else 0
if countfrom < 0: countfrom = 0
# Now make the query
#try:
jsonstr = self.db.readasjson('nodes', fields, [int(nid)])
if jsonstr:
data = json.loads(jsonstr)
node = data[0]
graph = []
# Speck data display
if node['datatype'] == 'speck':
keyarr = ['timestamp', 'raw', 'concentration', 'humidity']
graph = {'humidity':'humidity','concentration':'particles'}
# Frackbox display
elif node['datatype'] == 'frackbox':
graph = {' NOppb':'NOppb', ' O3ppb':'O3ppb',' NO2ppb':'NO2ppb',' PIDppm':'PIDppm'}
keyarr = node['latest']['csvheader'].split(',')
# Observation
else:
node['title'] = 'Observation:<br /> {}'.format(node['title'])
graph = {}
keyarr = []
if 'name' in node['latest']:
node['title'] = '{} [{}]'.format(node['title'], node['latest']['name'])
header = '<h2>{}: Created {}</h2><p>{}</p><hr />'.format(node['title'], node['createdhuman'], node['description'])
# Now bring back some actual data!
searchfor = {'nid':nid}
intable = 'csvs'
returnfields = ['timestamp', 'csv']
sql = 'ORDER BY timestamp DESC LIMIT {}, {}'.format(countfrom, count)
rows = self.db.searchfor(intable, returnfields, searchfor, sql, 'many')
# And grab a list of annotations: TODO: Think about limits i.e. sql = 'ORDER BY timestamp DESC LIMIT {}, {}'.format(countfrom, count)
sql = 'ORDER BY timestamp DESC '
annotations = self.db.searchfor('annotations', ['aid','timestamp','text', 'nid'], {'nid':nid}, sql, 'many')
i=0
try:
for ano in annotations:
timestamp = int(ano[1]+timeadjcalc)
mydate = datetime.datetime.fromtimestamp(timestamp).strftime('%d %b %Y %H:%M:%S ({}GMT)'.format(timeadj))
annotations[i] = (ano[0], ano[1], ano[2], mydate, ano[3])
i+=1
annotationsjson = json.dumps(annotations)
except:
annotationsjson = "[]"
# And prep vars used to format the output
table = '<table class="whitetable"><tr><th>'
table += '</th><th>'.join(keyarr)+'</th></tr>\n\n\n'
starttime = ''
rowdatetime = ''
# Make a record of the position of the keys
graphpos = {}
for item in graph:
key = item
mapname = graph[item].replace(' ', '')
for position, findkey in enumerate(keyarr):
if findkey == key:
graphpos[key] = {'position':position,'color':"'#000'", 'data':[], 'name':"'{}'".format(mapname)}
i = 0
# Now loop through the data and generate data and json. The array is reversed to enable to graph to display
for row in reversed(rows):
vals = row[1].split(',')
# Create a timestamp
timestamp = int(vals[0]) #+timeadjcalc
time = arrow.get(timestamp)
local = time.to('US/Central')
rowdatetime = local.format('YYYY-MM-DD HH:mm:ss')
vals[0] = rowdatetime
if i == 0: starttime = rowdatetime
# Prep the js
for key in graph:
n = graphpos[key]['position']
val = vals[n]
if val.replace(' ', '') is not '':
graphpos[key]['data'].append( {'x':timestamp, 'y':val} )
# Prep the HTML
line = '<tr><td>'
line += '</td><td>'.join(vals)
line += '</td></tr>'
table += line
i += 1
# Now prep the final output
data = []
for item in graphpos: data.append(graphpos[item])
jsondata = json.dumps(data)
jsdata = jsondata.replace('"', '') # Javscript formated data
jsdata = jsdata.replace(' ', '')
table += '</table>'
prevcount = countfrom-count
nextlink = '<a class="prevnext" href="/api/viewhtml/{}/?count={}&from={}&timeadj={}">Next»</a>'.format(nid, count, countfrom+count, timeadj)
if prevcount <= 0:
prevcount=0
prevlink = ''
if countfrom > 0:
prevlink = '<a class="prevnext" href="/api/viewhtml/{}/?count={}&from={}&timeadj={}">«Previous</a>'.format(nid, count, prevcount, timeadj)
header += '<strong>{}</strong> | <strong>View</strong> {} Points <strong> From:</strong> {} <strong>To:</strong> {} | <strong>{}</strong>'.format(prevlink, count, rowdatetime, starttime, nextlink)
templatevars = {'nid':nid,'table':table, 'header':header, 'jsdata':jsdata, 'timeadj':timeadj, 'annotationsjson':annotationsjson, 'annotations':annotations}
return template.render(var=templatevars)
else:
return 'No data'
def forward(self,
time,
click_time,
creative_id,
ad_id,
advertiser_id,
advertiser_id_industry,
product_category_advertiser_id,
product_id_advertiser_id,
product_id_product_category,
product_id,
target_encode_sequence,
x_len,
labels = None):
time = time.to(args.device)
click_time = click_time.to(args.device)
creative_id = creative_id.to(args.device)
ad_id = ad_id.to(args.device)
advertiser_id = advertiser_id.to(args.device)
advertiser_id_industry = advertiser_id_industry.to(args.device)
product_category_advertiser_id = product_category_advertiser_id.to(args.device)
product_id_advertiser_id = product_id_advertiser_id.to(args.device)
product_id_product_category = product_id_product_category.to(args.device)
product_id = product_id.to(args.device)
target_encode_sequence = target_encode_sequence.to(args.device)
x_len = x_len.to(args.device)
if labels is not None:
labels = labels.to(args.device)
a_wv = torch.cat([
self.ln_50s[0](ad_id),
self.ln_50s[1](creative_id),
self.ln_50s[2](product_id_product_category),
self.ln_50s[3](product_id),
self.ln_one_hot_target(target_encode_sequence),
self.position_embeddings(time),
self.click_time_embeddings(click_time),
],dim=-1)
b_wv = torch.cat([
self.ln_50s[4](advertiser_id),
self.ln_50s[5](advertiser_id_industry),
self.ln_50s[6](product_category_advertiser_id),
self.ln_50s[7](product_id_advertiser_id),
self.ln_one_hot_target(target_encode_sequence),
self.position_embeddings(time),
self.click_time_embeddings(click_time),
],dim=-1)
hidden_wv = self.re2_block_wv(a_wv, b_wv, x_len)
# cat = torch.cat([hidden_wv, x_flatten], dim = -1)
out_label = self.decoder(hidden_wv)
if(labels is None):
return out_label
loss_func = nn.CrossEntropyLoss()
l = loss_func(out_label, labels.long())
return l, out_label
def forward(self,
time,
click_time,
ad_id_wv,
ad_id_glove,
advertiser_id_wv,
advertiser_id_glove,
target_encode_sequence,
x_len,
gender = None,\
age = None):
time = time.to(args.device)
click_time = click_time.to(args.device)
ad_id_wv = ad_id_wv.to(args.device)
ad_id_glove = ad_id_glove.to(args.device)
advertiser_id_wv = advertiser_id_wv.to(args.device)
advertiser_id_glove = advertiser_id_glove.to(args.device)
target_encode_sequence = target_encode_sequence.to(args.device)
x_len = x_len.to(args.device)
# x_flatten = x_flatten.to(args.device)
if gender is not None:
gender = gender.to(args.device)
age = age.to(args.device)
a_wv = torch.cat([
self.ln_100s[0](ad_id_wv),
self.ln_100s[1](ad_id_glove),
self.ln_100s[2](advertiser_id_wv),
self.ln_100s[3](advertiser_id_glove),
self.ln_one_hot_target(target_encode_sequence),
self.position_embeddings(time),
self.click_time_embeddings(click_time),
],
dim=-1)
hidden = self.re2_one(a_wv, x_len)
# cat = torch.cat([self.ln_hidden(hidden), self.ln_tfidf_stack(x_flatten)], dim = -1)
cat = hidden
output_age = self.decoder_age(cat)
output_gender = self.decoder_gender(cat)
if (gender is None):
return output_gender, output_age, hidden
# loss_age = nn.CrossEntropyLoss()
# loss_gender = nn.CrossEntropyLoss()
# l_age = loss_age(output_age,age.long())
# l_gender = loss_gender(output_gender,gender.long())
l_gender = self.label_smooth_gender(output_gender, gender.long())
l_age = self.label_smooth_age(output_age, age.long())
l = 0.5 * l_gender + 0.5 * l_age
l = 0.5 * l_gender + 0.5 * l_age
return l, l_gender, l_age, output_gender, output_age, hidden
def evaluate(self, loader, epoch):
self.model.eval()
user_id_list, true_y, pred_y = [], [], []
loss_all, num_batch = 0., 0.
with torch.no_grad():
for index, datum_tuple in enumerate(loader):
creative_id, ad_id, product_id, advertiser_id, industry, product_category, time, user_id, y_label = datum_tuple
advertiser_id, product_id, product_category, industry, time = advertiser_id.to(device,non_blocking=True), \
product_id.to(device,non_blocking=True), \
product_category.to(device,non_blocking=True), \
industry.to(device,non_blocking=True), \
time.to(device,non_blocking=True)
#获取embedding抽取的向量
inputlist_tensor = [
creative_id, ad_id, advertiser_id, product_id,
product_category, industry, time
]
emb_layer_mat = []
for index, input_col in enumerate(inputlist_tensor):
emb_layer_col_mat = {}
for j in range(len(self.emb_layer[index])):
if index in [2, 3, 4, 5, 6]:
self.emb_layer[index][j] = self.emb_layer[index][
j].to(device, non_blocking=True)
emb_layer_col_mat[j] = self.emb_layer[index][j](
input_col)
emb_layer_col_mat[j] = emb_layer_col_mat[j].to(
device, non_blocking=True)
emb_layer_mat.append(emb_layer_col_mat)
output = self.model(emb_layer_mat)
y_label = y_label.to(device, non_blocking=True)
y_label = y_label.long()
loss = self.loss_func(output, y_label)
loss_all += loss.item()
num_batch += 1
pred_y.extend(list(output.cpu().detach().numpy()))
true_y.extend(list(y_label.cpu().detach().numpy()))
user_id_list.extend(list(user_id.numpy()))
del creative_id, ad_id, product_id, advertiser_id, industry, product_category, time, y_label
_ = gc.collect()
pred = np.argmax(np.array(pred_y), 1)
true = np.array(true_y).reshape((-1, ))
acc_score = accuracy_score(true, pred)
loss_valid = loss_all / num_batch
output_data = DataFrame({'user_id': user_id_list, 'pred': pred_y})
if acc_score > 0.48:
if not os.path.isdir('../../oof/bk_oof/Multi_Head_ResNext'):
os.mkdir('../../oof/bk_oof/Multi_Head_ResNext')
pickle.dump(
output_data,
open(
'../../oof/bk_oof/Multi_Head_ResNext/val_{}_folds_{}.pkl'.
format(epoch, self.folds), 'wb'))
del pred, true, pred_y, true_y
_ = gc.collect()
return acc_score, loss_valid
def train(self):
iter_wrapper = lambda x: tqdm(x, total=len(self.train_data))
start_epoch = -1
best_valid = 0.
min_lr = 1e-7
if self.is_resume:
print('Let Continue!')
checkpoint = torch.load(PATH_CHECKPOINT) # 加载断点
self.model.load_state_dict(checkpoint['model_state_dict'])
self.optim.load_state_dict(checkpoint['optimizer_state_dict'])
start_epoch = checkpoint['epoch']
best_valid = checkpoint['best_valid']
for epoch in range(start_epoch + 1, EPOCHS):
print('=========================')
print('Processing Epoch {}'.format(epoch))
print('=========================')
loss_per_epoch, train_n_batch = 0., 0.
for index, data in iter_wrapper(enumerate(self.train_data)):
creative_id, ad_id, product_id, advertiser_id, industry, product_category, time, user_id, y_label = data
advertiser_id, product_id, product_category, industry, time = advertiser_id.to(device,non_blocking=True),\
product_id.to(device,non_blocking=True), \
product_category.to(device,non_blocking=True), \
industry.to(device,non_blocking=True), \
time.to(device,non_blocking=True)
self.model.train()
self.optim.zero_grad()
#获取embedding抽取的向量
inputlist_tensor = [
creative_id, ad_id, advertiser_id, product_id,
product_category, industry, time
]
emb_layer_mat = []
for index, input_col in enumerate(inputlist_tensor):
emb_layer_col_mat = {}
for j in range(len(self.emb_layer[index])):
if index in [2, 3, 4, 5, 6]:
self.emb_layer[index][j] = self.emb_layer[index][
j].to(device, non_blocking=True)
emb_layer_col_mat[j] = self.emb_layer[index][j](
input_col)
emb_layer_col_mat[j] = emb_layer_col_mat[j].to(
device, non_blocking=True)
emb_layer_mat.append(emb_layer_col_mat)
output = self.model(emb_layer_mat)
y_label = y_label.to(device, non_blocking=True)
y_label = y_label.long()
loss = self.loss_func(output, y_label)
loss_per_epoch += loss.item()
train_n_batch += 1
loss.backward()
nn.utils.clip_grad_norm_(self.model.parameters(), 10.) # 梯度裁剪
self.optim.step()
del creative_id, ad_id, product_id, advertiser_id, industry, product_category, time, y_label
_ = gc.collect()
if self.val_data is not None: # Do Validation
valid_score, valid_loss = self.evaluate(self.val_data, epoch)
print('evaluate done!')
if valid_score > 0.48:
self.test(self.test_data, epoch)
if valid_score > best_valid:
best_valid = valid_score
self.scheduler_ReduceLROnPlateauLR.step(valid_score)
if self.optim.param_groups[0]['lr'] < min_lr:
print("stopping")
break
torch.cuda.empty_cache()
def time_converter_1(time: str) -> str:
ampm = time.replace(".", "")
return to("%H:%M", from_(ampm, "%I:%M %p"))
def PlotFunc_nina(dspec,time,freq,SS,fd,tau,
edges,eta_fit,eta_sig,etas,measure,etas_fit,fit_res,
tau_lim=None,fd_lim=None,method='eigenvalue'):
'''
Plotting script to look at invidivual chunks
Arguments
dspec -- 2D numpy array containing the dynamic spectrum
time -- 1D numpy array of the dynamic spectrum time bins (with units)
freq -- 1D numpy array of the dynamic spectrum frequency channels (with units)
SS -- 2D numpy array of the conjugate spectrum
fd -- 1D numpy array of the SS fd bins (with units)
tau -- 1D numpy array of the SS tau bins (with units)
edges -- 1D numpy array with the bin edges for theta-theta
eta_fit -- Best fit curvature
eta_sig -- Error on best fir curvature
etas -- 1D numpy array of curvatures searched over
measure -- 1D numpy array with largest eigenvalue (method = 'eigenvalue') or chisq value (method = 'chisq') for etas
etas_fit -- Subarray of etas used for fitting
fit_res -- Fit parameters for parabola at extremum
tau_lim -- Largest tau value for SS plots
method -- Either 'eigenvalue' or 'chisq' depending on how curvature was found
'''
if fd_lim is None:
fd_lim=min(2*edges.max(),fd.max().value)
if np.isnan(eta_fit):
eta=etas.mean()
thth_red, thth2_red, recov, model, edges_red,w,V = THTH.modeler(SS, tau, fd, etas.mean(), edges)
else:
eta=eta_fit
thth_red, thth2_red, recov, model, edges_red,w,V = THTH.modeler(SS, tau, fd, eta_fit, edges)
ththE_red=thth_red*0
ththE_red[ththE_red.shape[0]//2,:]=np.conjugate(V)*np.sqrt(w)
##Map back to time/frequency space
recov_E=THTH.rev_map(ththE_red,tau,fd,eta,edges_red,isdspec = False)
model_E=np.fft.ifft2(np.fft.ifftshift(recov_E))[:dspec.shape[0],:dspec.shape[1]]
model_E*=(dspec.shape[0]*dspec.shape[1]/4)
model_E[dspec>0]=np.sqrt(dspec[dspec>0])*np.exp(1j*np.angle(model_E[dspec>0]))
model_E=np.pad(model_E,
( (0,SS.shape[0]-model_E.shape[0]),
(0,SS.shape[1]-model_E.shape[1])),
mode='constant',
constant_values=0)
recov_E=np.abs(np.fft.fftshift(np.fft.fft2(model_E)))**2
model_E=model_E[:dspec.shape[0],:dspec.shape[1]]
N_E=recov_E[:recov_E.shape[0]//4,:].mean()
SS_ext=ext_find(fd,tau)
SS_min=np.median(np.abs(SS)**2)/10
SS_max=np.max(np.abs(2*recov)**2)*np.exp(-2.7)
thth_min=np.median(np.abs(thth_red))/10
thth_max=np.max(np.abs(thth_red))
grid=plt.GridSpec(5,2)
plt.figure(figsize=(8,20))
plt.subplot(grid[0,0])
plt.imshow(dspec,
aspect='auto',
extent=ext_find(time.to(u.min),freq),
origin='lower')#,vmin=0,vmax=dspec.max())
plt.xlabel('Time (min)')
plt.ylabel('Freq (MHz)')
plt.title('Data Dynamic Spectrum')
plt.subplot(grid[0,1])
plt.imshow(model[:dspec.shape[0],:dspec.shape[1]],
aspect='auto',
extent=ext_find(time.to(u.min),freq),
origin='lower')#,vmin=0,vmax=dspec.max())
plt.xlabel('Time (min)')
plt.ylabel('Freq (MHz)')
plt.title('Model Dynamic Spectrum')
plt.subplot(grid[1,0])
plt.imshow(np.abs(SS)**2,
norm=LogNorm(),
origin='lower',
aspect='auto',
extent=SS_ext,
vmin=SS_min,vmax=SS_max)
plt.xlim((-fd_lim,fd_lim))
plt.ylim((0,tau_lim))
plt.xlabel(r'$f_D$ (mHz)')
plt.ylabel(r'$\tau$ (us)')
plt.title('Data Secondary Spectrum')
plt.subplot(grid[1,1])
plt.imshow(np.abs(recov)**2,
norm=LogNorm(),
origin='lower',
aspect='auto',
extent=SS_ext,
vmin=SS_min,vmax=SS_max)
plt.xlim((-fd_lim,fd_lim))
plt.ylim((0,tau_lim))
plt.xlabel(r'$f_D$ (mHz)')
plt.ylabel(r'$\tau$ (us)')
plt.title('Model Secondary Spectrum')
plt.subplot(grid[2,0])
plt.imshow(np.abs(thth_red)**2,
norm=LogNorm(),
origin='lower',
aspect='auto',
extent=[edges_red[0],edges_red[-1],edges_red[0],edges_red[-1]],
vmin=thth_min,vmax=thth_max**2.)
plt.xlabel(r'$\theta_1$')
plt.ylabel(r'$\theta_2$')
plt.title(r'Data $\theta-\theta$')
plt.subplot(grid[2,1])
plt.imshow(np.abs(thth2_red)**2,
norm=LogNorm(),
origin='lower',
aspect='auto',
extent=[edges_red[0],edges_red[-1],edges_red[0],edges_red[-1]],
vmin=thth_min,vmax=thth_max**2.)
plt.xlabel(r'$\theta_1$')
plt.ylabel(r'$\theta_2$')
plt.title(r'Data $\theta-\theta$')
plt.subplot(grid[3,:])
plt.plot(etas,measure)
if not np.isnan(eta_fit):
exp_fit = int(('%.0e' % eta_fit.value)[2:])
exp_err = int(('%.0e' % eta_sig.value)[2:])
fmt = "{:.%se}" % (exp_fit - exp_err)
fit_string = fmt.format(eta_fit.value)[:2 + exp_fit - exp_err]
err_string = '0%s' % fmt.format(10**(exp_fit) + eta_sig.value)[1:]
plt.plot(etas_fit,
THTH.chi_par(etas_fit.value, *fit_res),
label=r'$\eta$ = %s $\pm$ %s $s^3$' % (fit_string, err_string))
plt.legend()
if method == 'eigenvalue':
plt.title('Eigenvalue Search')
plt.ylabel(r'Largest Eigenvalue')
else:
plt.title('Chisquare Search')
plt.ylabel(r'$\chi^2$')
plt.xlabel(r'$\eta$ ($s^3$)')
plt.subplot(grid[4,0])
plt.imshow(np.angle(model_E),
cmap='twilight',
aspect='auto',
extent=ext_find(time.to(u.min),freq),
origin='lower',
vmin=-np.pi,vmax=np.pi)
plt.xlabel('Time (min)')
plt.ylabel('Freq (MHz)')
plt.title('Recovered Phases')
plt.subplot(grid[4,1])
plt.imshow(recov_E,
norm=LogNorm(),
origin='lower',
aspect='auto',
extent=ext_find(fd,tau),
vmin=N_E)
plt.xlim((-fd_lim,fd_lim))
plt.ylim((0,tau_lim))
plt.xlabel(r'$f_D$ (mHz)')
plt.ylabel(r'$\tau$ (us)')
plt.title('Recovered Wavefield')
plt.colorbar()
plt.tight_layout()
def test_timing():
time = arrow.utcnow()
write_to_file(time.format() + " " + time.to("Asia/Singapore").format() + '\n')