def test_psv_dataset_tfm_segmentation_cropped():
from psv.ptdataset import PsvDataset, TFM_SEGMENTATION_CROPPED
ds = PsvDataset(transform=TFM_SEGMENTATION_CROPPED)
assert len(ds) == 956, "The dataset should have this many entries"
mb = ds[0]
image = mb['image']
mask = mb['mask']
assert isinstance(image, torch.Tensor)
assert isinstance(mask, torch.Tensor)
assert mask.shape[-2:] == image.shape[-2:]
# Hard to test due to randomness....
PLOT=True
if PLOT:
from matplotlib.pylab import plt
import torchvision.transforms.functional as F
a = ds.get_annotation(0)
plt.figure()
plt.suptitle('Visualizing test_psv_dataset_tfm_segmentation_cropped, close if ok')
plt.subplot(121)
plt.imshow(F.to_pil_image(image))
plt.title('image')
plt.subplot(122)
plt.imshow(a.colors[mask.numpy()])
plt.title('mask')
plt.show()
def plot():
plt.figure(figsize=(20, 10))
width = 0.5
index = np.arange(26)
print 'SUM PLOT 1', sum(row[0] for row in data)
print 'SUM PLOT 2', sum(row[1] for row in data)
print 'SUM PLOT 3', sum(row[2] for row in data)
print data[0]
p0 = plt.bar(index, data[0], width, color='y') # people
p1 = plt.bar(index, data[1], width, color='g') # nature
p2 = plt.bar(index, data[2], width, color='r') # activity
p3 = plt.bar(index, data[3], width, color='b') # food
p4 = plt.bar(index, data[4], width, color='c') # symbols
p5 = plt.bar(index, data[5], width, color='m') # objects
p6 = plt.bar(index, data[6], width, color='k') # flags
p7 = plt.bar(index, data[7], width, color='w') # uncategorized
plt.ylabel('Usage')
plt.title('Emoji category usage per city')
plt.xticks(index + width/2.0, cities)
plt.yticks(np.arange(0, 1, 0.1))
plt.legend((p0[0], p1[0], p2[0], p3[0], p4[0], p5[0], p6[0], p7[0]), categories_names)
plt.show()
def compare_MC_exact():
max_error = []
sum_error = []
walkers = []
for i in range(500,20000,500):
d1 = Diffusion(t=0.2)
t_exact,u_exact = d1.exact()
t_uniform , mc_uniform = d1.MC_uniform(i)
print len(u_exact)
print len(mc_uniform)
diff = u_exact[:] - mc_uniform[:]
temp = max(abs(diff))
max_error.append(temp)
temp = sum(diff)
sum_error.append(temp)
temp = i
print temp
walkers.append(temp)
from matplotlib.pylab import plt
plt.figure(2)
plt.plot(walkers,max_error,'o-')
plt.xlabel('Number of walkers')
plt.ylabel('Maximum error')
plt.savefig('mcuniform_error1.eps')
plt.figure(3)
plt.plot(walkers,sum_error,'o-')
plt.xlabel('Number of walkers')
plt.ylabel('Accumulated error')
plt.savefig('mcuniform_error2.eps')
def __init__(self,
dir_name='/home/steve/Data/FusingLocationData/0010/'):
if not dir_name[-1] is '/':
dir_name = dir_name + '/'
imu_left = np.loadtxt(dir_name + 'LEFT_FOOT.data', delimiter=',')
imu_right = np.loadtxt(dir_name + 'RIGHT_FOOT.data', delimiter=',')
imu_head = np.loadtxt(dir_name + 'HEAD.data', delimiter=',')
uwb_head = np.loadtxt(dir_name + 'uwb_result.csv', delimiter=',')
beacon_set = np.loadtxt(dir_name + 'beaconSet.csv', delimiter=',')
print('average time interval of left:',
float(imu_left[-1, 1] - imu_left[0, 1]) / float(imu_left.shape[0]))
print('average time interval of right:',
float(imu_right[-1, 1] - imu_right[0, 1]) / float(imu_right.shape[0]))
print('average time interval of head:',
float(imu_head[-1, 1] - imu_head[0, 1]) / float(imu_head.shape[0]))
plt.figure()
plt.plot(imu_left[1:, 1] - imu_left[:-1, 1], label='time left')
plt.plot(imu_right[1:, 1] - imu_right[:-1, 1], label='time right')
# time_diff = imu_left[1:,1] - imu_left[:-1,1]
# plt.plot(time_diff-time_diff.mean(),label='time diff')
plt.plot(imu_head[1:, 1] - imu_head[:-1, 1], label=' time head')
plt.grid()
plt.legend()
plt.show()
def AddRegressor():
rng = np.random.RandomState(1) # 和random_state的用法一致 在这可以固定生成的随机数
x = np.sort(5 * rng.rand(80, 1),
axis=0) # rng.rand(80,1) 生成80行1列的随机数 乘以5就是生成0-5的随机数
y = np.sin(x).ravel() # ravel()降维
y[::5] += 0.3 * (0.5 - rng.rand(16))
# plt.show()
reg1 = tree.DecisionTreeRegressor(max_depth=2)
reg2 = tree.DecisionTreeRegressor(max_depth=5)
reg1.fit(x, y)
reg2.fit(x, y)
test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
y1 = reg1.predict(test)
y2 = reg2.predict(test)
#plt.figure()
plt.figure()
plt.scatter(x, y, label='dian')
plt.plot(test, y1, color='red', label='max_depth=2')
plt.plot(test, y2, color='yellow', label="max_depth=5")
plt.xlabel('data')
plt.ylabel('target')
plt.legend(loc='upper right')
plt.show()
def view(dataset, i):
if not (hasattr(dataset, 'sensor_events')):
return
tmp_act_evants = dataset.activity_events.loc[
dataset.activity_events['Activity'] == i]
print(dataset.activities_map[i])
print(tmp_act_evants['Duration'].describe())
fig = plt.figure()
tmp_act_evants['StartTime'].iloc[0]
all = pd.DataFrame()
for index, row in tmp_act_evants.iterrows():
myse = dataset.sensor_events.loc[
(dataset.sensor_events['time'] >= row['StartTime'])
& (dataset.sensor_events['time'] <= row['EndTime'])].copy()
myse['relative'] = dataset.sensor_events['time'] - row['StartTime']
myse['tpercent'] = myse['relative'] / row['Duration']
all = pd.concat([all, myse[['tpercent', 'SID']]])
# plt.scatter(myse['tpercent'],myse['SID'])
tmp = all.copy()
tmp['tpercent'] = (tmp['tpercent'] * 2).round(0) / 2
fig = plt.figure(figsize=(10, 5))
a = pd.pivot_table(tmp,
columns='tpercent',
index='SID',
aggfunc=np.count_nonzero,
fill_value=0)
a = a / a.max()
# plt.imshow(a, cmap='hot', interpolation='nearest')
sns.heatmap(a / a.max(), cmap=sns.cm.rocket_r)
def example_image(graph, filename, layout='spring', edge_labels=False,
node_labels=False, show=False):
"""Generates example image with graph.
Uses nx.draw_networkx_* methods, and matplotlib to draw and save the
image.
"""
# positions for all nodes
pos = LAYOUT_DICT[layout](graph)
# configure the image
plt.figure(figsize=(2, 2))
plt.axis('off')
# draw all of the things!
nx.draw_networkx_nodes(graph, pos, nodelist=graph.nodes(), node_color='r')
nx.draw_networkx_edges(graph, pos, width=1.0, alpha=0.5, arrows=True)
if node_labels:
nlabels = {node: str(node) for node in graph.nodes()}
nx.draw_networkx_labels(graph, pos, nlabels, font_size=16)
if edge_labels:
elabels = {edge: str(idx) for idx, edge in enumerate(graph.edges())}
nx.draw_networkx_edge_labels(graph, pos, elabels)
# place the file where it belongs
path = os.path.join(os.environ['ERDOS_PATH'], "content/images", filename)
plt.savefig(path)
if show:
plt.show()
def plot_first_factors(X_data, y_data, analysis_type="lda"):
"""Generate scatterplot of two principal components (pca or lda) of data set."""
le = preprocessing.LabelEncoder()
le.fit(y_data)
colours = [
'blue', 'green', 'red', 'cyan', 'magenta', 'yellow', 'darkgreen',
'darkorange', 'yellow', 'black'
]
if analysis_type == "pca":
transform = PCA(n_components=2)
XX_data = transform.fit(X_data).transform(X_data)
elif analysis_type == "lda":
transform = LinearDiscriminantAnalysis(n_components=2)
XX_data = transform.fit(X_data, y_data).transform(X_data)
else:
print("Type", analysis_type,
"not recognised, use either 'pca' or 'lda'.")
return
plt.figure()
for i, j in enumerate(le.classes_):
plt.scatter(XX_data[y_data == j, 0],
XX_data[y_data == j, 1],
alpha=0.8,
color=colours[i],
label=str(j))
plt.legend(loc='best', shadow=False, scatterpoints=1)
plt.title(analysis_type)
def bar_graph(category, age_grp, sex, x, y, year=None, country=None):
plt.figure()
plt.ylabel('ATE = Y1 - Y0')
plt.xlabel('Years')
plt.bar(range(len(x)), x, align='center')
plt.xticks(range(len(x)), y, rotation='vertical')
if country:
plt.title("%s Suicide Rates for WC; %s ages %s" %
(country, sex, age_grp))
name = country + sex + age_grp + '.png'
# plt.show()
plt.tight_layout()
plt.savefig('./graphs/Countries' + '/' + sex + '/' +
name.replace(' ', '_'))
elif year:
plt.title("Change in Suicide Rates per Country in %s; %s ages %s" %
(year, sex, age_grp))
name = category + sex + str(year) + age_grp + '.png'
# plt.show()
plt.tight_layout()
plt.savefig('./graphs/' + category + '/' + sex + '/' + str(year) +
'/' + name.replace(' ', ''))
else:
plt.title("Change in Suicide Rates in %s Countries; %s ages %s" %
(category, sex, age_grp))
name = category + sex + age_grp + '.png'
# plt.show()
plt.tight_layout()
plt.savefig('./graphs/' + category + '/' + sex + '/' +
name.replace(' ', ''))
def graph(train_df, test_df, p_forecast, f_forecast, metric, key):
fig = plt.figure(figsize=(40,10))
forecast_ds = np.array(f_forecast["ds"])
print(len(forecast_ds))
print(len(train_df))
forecast_ds = forecast_ds[int(train_df["values"].count()):]
plt.plot(np.array(train_df["ds"]), np.array(train_df["y"]),'b', label="train", linewidth=3)
plt.plot(np.array(test_df["ds"]), np.array(test_df["y"]), 'k', label="test", linewidth=3)
plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_raw_" + metric + ".png", transparent=True)
prophet = np.array(p_forecast["yhat"])
prophet_upper = np.array(p_forecast["yhat_upper"])
prophet_lower = np.array(p_forecast["yhat_lower"])
fourier = f_forecast["yhat"]
fourier = fourier[len(train_df["values"]):]
print(len(forecast_ds))
print(len(fourier))
plt.plot(forecast_ds, fourier, 'g', label="fourier_yhat", linewidth=3)
plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_fourier_" + metric + ".png", transparent=True)
prophet = prophet[len(train_df["values"]):]
prophet_upper = prophet_upper[len(train_df["values"]):]
prophet_lower = prophet_lower[len(train_df["values"]):]
plt.plot(forecast_ds, prophet, '*y', label="prophet_yhat", linewidth=3)
plt.plot(forecast_ds, prophet_upper, 'y', label="yhat_upper", linewidth=3)
plt.plot(forecast_ds, prophet_lower, 'y', label="yhat_lower", linewidth=3)
plt.plot()
plt.xlabel("Timestamp")
plt.ylabel("Value")
plt.legend(loc=1)
plt.title("Prophet Model Forecast")
plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_compare_" + metric + ".png", transparent=True)
plt.close()
fig = plt.figure(figsize=(40,10))
forecast_ds = np.array(f_forecast["ds"])
forecast_ds = forecast_ds[len(train_df["values"]):]
plt.plot(np.array(train_df["ds"]), np.array(train_df["y"]),'b', label="train", linewidth=3)
plt.plot(np.array(test_df["ds"]), np.array(test_df["y"]), 'k', label="test", linewidth=3)
prophet = np.array(p_forecast["yhat"])
prophet_upper = np.array(p_forecast["yhat_upper"])
prophet_lower = np.array(p_forecast["yhat_lower"])
prophet = prophet[len(train_df["values"]):]
prophet_upper = prophet_upper[len(train_df["values"]):]
prophet_lower = prophet_lower[len(train_df["values"]):]
plt.plot(forecast_ds, prophet, '*y', label="prophet_yhat", linewidth=3)
plt.plot(forecast_ds, prophet_upper, 'y', label="yhat_upper", linewidth=3)
plt.plot(forecast_ds, prophet_lower, 'y', label="yhat_lower", linewidth=3)
plt.savefig( "../testing/compare_fourier_prophet/" + str(key) + "_prophet_" + metric + ".png", transparent=True)
plt.close()
def test_psv_dataset_crop_and_pad():
import psv.ptdataset as P
TFM_SEGMENTATION_CROPPED = psv.transforms.Compose(
psv.transforms.ToSegmentation(),
# Crop in on the facades
psv.transforms.SetCropToFacades(pad=20, pad_units='percent', skip_unlabeled=True, minsize=(512, 512)),
psv.transforms.ApplyCrop('image'),
psv.transforms.ApplyCrop('mask'),
# Resize the height to fit in the net (with some wiggle room)
# THIS is the test case -- the crops will not usually fit anymore
psv.transforms.Resize('image', height=400),
psv.transforms.Resize('mask', height=400, interpolation=P.Image.NEAREST),
# Reandomly choose a subimage
psv.transforms.SetRandomCrop(512, 512),
psv.transforms.ApplyCrop('image'),
psv.transforms.ApplyCrop('mask', fill=24), # 24 should be unlabeled
psv.transforms.DropKey('annotation'),
psv.transforms.ToTensor('image'),
psv.transforms.ToTensor('mask', preserve_range=True),
)
ds = P.PsvDataset(transform=TFM_SEGMENTATION_CROPPED)
assert len(ds) == 956, "The dataset should have this many entries"
mb = ds[0]
image = mb['image']
mask = mb['mask']
assert isinstance(image, torch.Tensor)
assert isinstance(mask, torch.Tensor)
assert mask.shape[-2:] == image.shape[-2:]
# Hard to test due to randomness....
PLOT=True
if PLOT:
from matplotlib.pylab import plt
import torchvision.transforms.functional as F
a = ds.get_annotation(0)
plt.figure()
plt.suptitle('Visualizing test_psv_dataset_tfm_segmentation_cropped,\n'
'close if ok \n '
'confirm boundary is marked unlabeled')
plt.subplot(121)
plt.imshow(F.to_pil_image(image))
plt.title('image')
plt.subplot(122)
plt.imshow(a.colors[mask.numpy()])
plt.title('mask')
plt.show()
def plot_gallery(images, titles, h, w, n_row=3,n_col=4):
plt.figure(figsize=(1.8*n_col, 2.4*n_row))
plt.subplots_adjust(bottom=0,left=.01,right=.99,top=.90,hspace=.35)
for i in range(n_row * n_col):
plt.subplot(n_row,n_col,i+1)
plt.imshow(images[i].reshape(h,w),cmap=plt.cm.gray)
plt.title(titles[i],size=12)
plt.xticks(())
plt.yticks(())
def f(self, **kwargs):
kwargs['always_apply'] = True
print(kwargs)
aug = self.tfms(**kwargs)
# Just copy all images, next step will be for continious albus
image = aug(image=self.image.copy())['image']
plt.figure(figsize=(10, 10))
plt.imshow(image)
plt.axis('off')
plt.show()
def plot(ranks):
plt.figure(figsize=(20, 10))
plt.title("A2.3 PageRank (s-Sensibility)")
plt.xlabel("Node ID")
plt.ylabel("Pagerank")
for row in ranks:
plt.plot(row)
plt.legend(['s = %.2f' % s for s in numpy.arange(0.0, 1.0, 0.05)],
loc='upper right',
prop={'size': 7})
plt.savefig("submission/pagerank.png")
def save_plot(filter_bank, name):
rows , cols = filter_bank.shape[0:2]
plt.figure()
sub = 1
for row in range(rows):
for col in range(cols):
plt.subplot(rows, cols, sub)
plt.imshow(filter_bank[row][col], cmap='gray')
plt.axis('off')
sub += 1
plt.savefig(name)
def update_data(args, show_seconds=20, subsampling=10):
# load previous
metadata1 = np.load(os.path.join(args.session1, 'metadata.npy'), allow_pickle=True).item()
data1 = np.load(os.path.join(args.session1, 'NIdaq.npy'), allow_pickle=True).item()
t1 = np.arange(len(data1['analog'][0,:]))/metadata1['NIdaq-acquisition-frequency']
metadata2 = np.load(os.path.join(args.session2, 'metadata.npy'), allow_pickle=True).item()
data2 = np.load(os.path.join(args.session2, 'NIdaq.npy'), allow_pickle=True).item()
t2 = np.arange(len(data2['analog'][0,:]))/metadata1['NIdaq-acquisition-frequency']
metadata = np.load(os.path.join(args.session1, 'metadata.npy'), allow_pickle=True).item()
data = np.load(os.path.join(args.session, 'NIdaq.npy'), allow_pickle=True).item()
t = np.arange(len(data['analog'][0,:]))/metadata1['NIdaq-acquisition-frequency']
tstart = np.min([t.max(), t1.max(), t2.max()])-show_seconds # showing the last 5 seconds
# checking that the two realisations are the same:
plt.figure(figsize=(7,5))
plt.plot(t1[t1>tstart][::subsampling],
data1[args.type][args.channel,t1>tstart][::subsampling], label='session #1')
plt.plot(t2[t2>tstart][::subsampling],
data2[args.type][args.channel,t2>tstart][::subsampling], label='session #2')
plt.plot(t[t>tstart][::subsampling],
data[args.type][args.channel,t>tstart][::subsampling], label='session')
plt.legend()
plt.show()
y = input(' /!\ ----------------------- /!\ \n Confirm that you want to replace\n the "%s" data of channel "%s" in session:\n "%s"\n by the data of session #1 ? [yes/No]' % (args.type, args.channel, args.session))
if y in ['y', 'Y', 'yes', 'Yes']:
temp = str(tempfile.NamedTemporaryFile().name)+'.npy'
print("""
---> moving the old data to the temporary file directory as: "%s" [...]
""" % temp)
shutil.move(os.path.join(args.session, 'NIdaq.npy'), temp)
print('applying changes [...]')
data[args.type][args.channel,:] = data1[args.type][args.channel,:len(data[args.type][args.channel,:])]
np.save(os.path.join(args.session, 'NIdaq.npy'), data)
print('done !')
else:
print('--> data update aborted !! ')
def plot_four(plot_data):
fig = plt.figure(figsize=(20, 10))
# gs = gridspec.GridSpec(1, 2, height_ratios=[1, 2])
ax = fig.add_subplot(223, projection='3d')
ax.scatter(plot_data['sx'], plot_data['sy'], plot_data['sz'])
ax.plot(plot_data['sx'], plot_data['sy'], plot_data['sz'], color='b')
ax.view_init(azim=0, elev=90) #xy plane
plt.xticks(fontsize=10)
ax.set_title('Displacement Projection in xy Plane',size=20)
ax2 = fig.add_subplot(224, projection='3d')
ax2.scatter(plot_data['sx'], plot_data['sy'], plot_data['sz'])
ax2.plot(plot_data['sx'], plot_data['sy'], plot_data['sz'], color='b')
ax2.view_init(azim=0, elev=45)
ax2.set_title('Displacement',size=20)
ax3 = fig.add_subplot(221)
# 50 represents number of points to make between T.min and T.max
xnew = np.linspace(0,8,50)
spl = make_interp_spline(pd.Series(range(9)), plot_data['tilt1'], k=3) # type: BSpline
x = spl(xnew)
spl = make_interp_spline(pd.Series(range(9)), plot_data['tilt2'], k=3) # type: BSpline
y = spl(xnew)
spl = make_interp_spline(pd.Series(range(9)), plot_data['compass'], k=3) # type: BSpline
z = spl(xnew)
ax3.plot(x,"b-",label='tilt1')
ax3.plot(y,"r-",label='tilt2')
ax3.plot(z,"g-",label='compass')
ax3.legend(loc="lower left",prop={'size': 20})
ax3.set_title('Orientation Plot (degree)',size=20)
ax3.tick_params(labelsize=20)
ax4 = fig.add_subplot(222)
# x = gaussian_filter1d(plot_data['ax'], sigma=1)
# y = gaussian_filter1d(plot_data['ay'], sigma=1)
# z = gaussian_filter1d(plot_data['az'], sigma=1)
# mag = gaussian_filter1d(plot_data['accelerometer'], sigma=1)
spl = make_interp_spline(pd.Series(range(9)), plot_data['ax'], k=3) # type: BSpline
x = spl(xnew)
spl = make_interp_spline(pd.Series(range(9)), plot_data['ay'], k=3) # type: BSpline
y = spl(xnew)
spl = make_interp_spline(pd.Series(range(9)), plot_data['az'], k=3) # type: BSpline
z = spl(xnew)
spl = make_interp_spline(pd.Series(range(9)), plot_data['accelerometer'], k=3) # type: BSpline
mag = spl(xnew)
ax4.plot(x/1000,"c--",label='ax')
ax4.plot(y/1000,"g--",label='ay')
ax4.plot(z/1000,"b--",label='az')
ax4.plot(mag,"r-",label='Acc')
ax4.legend(loc="lower left",prop={'size': 20})
ax4.set_title('Acceleration Plot (g)',size=20)
ax4.tick_params(labelsize=20)
plt.tight_layout()
plt.show()
fig.savefig('FourInOne.png')
def __init__(self, parent=None):
super(Plot, self).__init__(parent)
self.mainWindow = parent
self.fig = plt.figure()
self.canvas = FigureCanvas(self.fig)
self.graphNavigationBar = NavigationToolbar(self.canvas, parent)
self.legendList = PlotLegendList()
self.defaultPlot()
# Current selected scans, detectors and counters
self.detectors = []
self.scans = []
self.counters = []
self.currentTab = 0
# Adds the plotting widgets to the layout
splitter = qtWidgets.QSplitter()
splitter.setOrientation(qtCore.Qt.Vertical)
splitter.addWidget(self.graphNavigationBar)
splitter.addWidget(self.canvas)
splitter.addWidget(self.legendList)
# Adds the splitter as the layout of the widget
layout = qtWidgets.QVBoxLayout()
layout.addWidget(splitter)
self.setLayout(layout)
def plot_score_dist(spacing, std_along, prob_miss, max_distance):
from matplotlib.pylab import plt
plt.close("Score Dist")
plt.figure("Score Dist")
d = np.linspace(0, max_distance, 500)
plt.plot(d, [score_dist(di, spacing, std_along, prob_miss) for di in d])
plt.vlines(spacing, 0, 1)
plt.vlines(spacing * 2, 0, 1, ls='--')
plt.annotate("Miss-detect the next mine", (spacing * 2, 0.5), (12, 0),
textcoords='offset points')
plt.ylabel('$p(d)$')
plt.xlabel('$d$')
plt.grid()
plt.xticks(np.arange(max_distance))
plt.xlim(0, max_distance)
plt.savefig('score_dist.pdf')
def getfigure(figure=None, clear=False, show=False, save=False):
save = save
if not isinstance(figure, plt.Figure):
figure = plt.figure(figure)
if clear:
figure.clear()
if show or save:
def finalyse(name, save=save, show=show):
if show:
figure.show()
figure.canvas.draw()
fout = ""
if save:
if isinstance(save, basestring):
fout = save
f = save
else:
fout = getattr(save, "name", "")
#fout = name + "." + figure_format
f = save
figure.savefig(f)
log.notice("Figure %s saved to %s"%(name, fout))
return fout
else:
def finalyse(name):
return name
return figure, finalyse
def getfigure(figure=None, clear=False, show=False, save=False):
save = save
if not isinstance(figure, plt.Figure):
figure = plt.figure(figure)
if clear:
figure.clear()
if show or save:
def finalyse(name, save=save, show=show):
if show:
figure.show()
figure.canvas.draw()
fout = ""
if save:
if isinstance(save, basestring):
fout = save
f = save
else:
fout = getattr(save, "name", "")
#fout = name + "." + figure_format
f = save
figure.savefig(f)
log.notice("Figure %s saved to %s" % (name, fout))
return fout
else:
def finalyse(name):
return name
return figure, finalyse
def initPlots(self):
##
# if the plot is detached just return
if not self.attached:
return
dataCom = self.dataCom
##
# if igure has been close we need to build a new one
if self.fig is None:
self.fig = plt.figure(self.figId, **self._initkwargs)
fig = self.fig
## clear the figure
fig.clear()
###
# make the subplots
self.rtdSubPlots = self.makeSubPlots()
###
# init all subplots
for p in self.rtdSubPlots:
p.initPlot()
try:
fig.canvas.show()
except AttributeError:
pass
self.lastConfigCounter = dataCom.permanentData["COUNTER.CONFIG"]
self.initCanvas(fig)
self.figSize = list(fig.get_size_inches())
def show(self):
if self.fig is None:
self.fig = plt.figure(self.figId, **self._initkwargs)
if not self.showed:
self.fig.show()
self.showed = True
def fxcor_subplot(result, GCs, stars):
'''
Makes subplot of TDR vs VERR and VREL.
Returns a figure object
'''
plt.close('all')
fig = plt.figure(figsize=(6,6))
gs = gridspec.GridSpec(70,40,bottom=0.10,left=0.15,right=0.98, top = 0.95)
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
R_vel = plt.subplot(gs[10:40,0:40])
R_err = plt.subplot(gs[40:70,0:40])
R_hist = plt.subplot(gs[0:10,0:40])
R_hist.axis('off')
plt.setp(R_vel.get_xticklabels(), visible=False)
x = result.TDR
y = result.VREL_helio
R_vel.scatter(x, y, s=10, c='gray', edgecolor='none', alpha = 0.6, label = 'All')
x = GCs.TDR
y = GCs.VREL_helio
R_vel.scatter(x, y, s=11, c='orange', edgecolor='none', alpha = 0.8, label = 'GCs')
x = stars.TDR
y = stars.VREL_helio
R_vel.scatter(x, y, s=11, c='green', edgecolor='none', alpha = 0.8, label = 'Stars')
R_vel.set_xlim(1,20)
R_vel.set_ylim(-2000,5000)
R_vel.set_ylabel(r'$v$ $[km \, s^{-1}]$')
plt.setp(R_vel.get_yticklabels()[0], visible=False)
x = result.TDR
y = result.VERR
R_err.scatter(x, y,s=10, c='gray', edgecolor='none', alpha = 0.6)
x = GCs.TDR
y = GCs.VERR
R_err.scatter(x, y,s=11, c='orange', edgecolor='none', alpha = 0.8)
x = stars.TDR
y = stars.VERR
R_err.scatter(x, y,s=11, c='green', edgecolor='none', alpha = 0.8)
R_err.set_ylim(2,80)
R_err.set_xlim(1,20)
R_err.set_ylabel(r'$\delta v$ $[km \, s^{-1}]$')
R_err.set_xlabel(r'TDR')
plt.setp(R_err.get_yticklabels()[-1], visible=False)
R_vel.legend()
R_hist.hist([GCs.TDR,stars.TDR], range = (1,20), bins = 50, normed=True,
color=['orange','green'])
return fig
def plt_score(history):
plt.figure()
plt.plot()
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.savefig('acc.png')
# loss
plt.figure()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.savefig('loss.png')
def __init__(self):
super(PlotWidget, self).__init__()
self.plotWidget = QWidget()
self.fig = plt.figure()
#self.fig.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0)
self.canvas = FigureCanvas(self.fig)
self.defaultPlot()
layout = QVBoxLayout()
layout.addWidget(self.canvas)
self.plotWidget.setLayout(layout)
def __init__(self, dataCom, figId, **kwargs):
fig = plt.figure(figId, **kwargs)
self._initkwargs = kwargs
self.figId = figId
self.dataCom = dataCom
self.lastDataCounter = -99
self.lastConfigCounter = -99
self.fig = fig
self.rtdSubPlots = []
self.checkCanvas()
self.showed = False
def make_radar(skill: int, strength: int, defence: int, willpower: int,
attack: int, stamina: int):
'''
:return: PNG type image binary content
'''
value = [skill, strength, defence, willpower, attack, stamina]
if not all(map(lambda x: isinstance(x, int) and 0 < x <= 100, value)):
return
font = FontProperties(fname=settings.PINGFANG_FONT, size=23)
plt.figure(figsize=(4.8, 4.8)) # 图片大小
name = [
'技术\n ', '力量 ', '防守 ', '\n意志力', ' 进攻 ', ' 耐力 '
] # 标签
theta = np.linspace(0, 2 * np.pi, len(name),
endpoint=False) # 将圆周根据标签的个数等比分
theta = np.concatenate((theta, [theta[0]])) # 闭合
value = np.concatenate((value, [value[0]])) # 闭合
ax = plt.subplot(111, projection='polar') # 构建图例
ax.set_theta_zero_location('N') # 设置极轴方向
ax.fill(theta, value, color="#EF2D55", alpha=0.35) # 填充色,透明度
for i in [20, 40, 60, 80, 100]: # 绘等分线
ax.plot(theta, [i] * (6 + 1), 'k-', lw=1,
color='#8989A3') # 之所以 n +1，是因为要闭合！
ax.plot(theta, value, 'ro-', 'k-', lw=1, alpha=0.75,
color='#FF465C') # 绘数据图
ax.set_thetagrids(theta * 180 / np.pi,
name,
fontproperties=font,
color='#8989A3') # 替换标签
ax.set_ylim(0, 100) # 设置极轴的区间
ax.spines['polar'].set_visible(False) # 去掉最外围的黑圈
ax.grid(True, color='#8989A3', linestyle='-', linewidth=1)
ax.set_yticks([])
buf = io.BytesIO()
plt.savefig(buf, transparent=True) # 透明
plt.close('all') # 关闭所有绘图
buf.seek(0)
return buf
def plot_scatter_annotate(data, labels, title):
plt.figure(figsize=(10, 10))
assert data.shape[0] == len(labels), 'size mismatch'
plt.subplots_adjust(bottom=0.1)
plt.scatter(data[:, 0],
data[:, 1],
marker='o',
s=100,
cmap=plt.get_cmap('Spectral'))
plt.title(title)
for label, x, y in zip(labels, data[:, 0], data[:, 1]):
plt.annotate(label,
xy=(x, y),
xytext=(-20, 20),
textcoords='offset points',
ha='right',
va='bottom',
bbox=dict(boxstyle='round,pad=0.5',
fc='yellow',
alpha=0.5),
arrowprops=dict(arrowstyle='->',
connectionstyle='arc3,rad=0'))
plt.show()
def example_pic():
"""Generate the example graph picture."""
# create graph from edge list
graph = nx.Graph([(0, 1), (0, 2), (1, 3), (3, 0)])
# positions for all nodes
pos = nx.spring_layout(graph)
# each node is labaled by its own name
labels = {node: str(node) for node in graph.node.keys()}
# configure the image
plt.figure(figsize=(2, 2))
plt.axis('off')
# draw all of the things!
nx.draw_networkx_nodes(graph, pos, nodelist=[0, 1, 2, 3], node_color='r')
nx.draw_networkx_edges(graph, pos, width=1.0, alpha=0.5)
nx.draw_networkx_labels(graph, pos, labels, font_size=16)
# place the file where it belongs
path = os.path.join(os.environ['ERDOS_PATH'], "content/images", "nodes_edges_example.png")
plt.savefig(path)
def example_image(graph,
filename,
layout='spring',
edge_labels=False,
node_labels=False,
show=False):
"""Generates example image with graph.
Uses nx.draw_networkx_* methods, and matplotlib to draw and save the
image.
"""
# positions for all nodes
pos = LAYOUT_DICT[layout](graph)
# configure the image
plt.figure(figsize=(2, 2))
plt.axis('off')
# draw all of the things!
nx.draw_networkx_nodes(graph, pos, nodelist=graph.nodes(), node_color='r')
nx.draw_networkx_edges(graph, pos, width=1.0, alpha=0.5, arrows=True)
if node_labels:
nlabels = {node: str(node) for node in graph.nodes()}
nx.draw_networkx_labels(graph, pos, nlabels, font_size=16)
if edge_labels:
elabels = {edge: str(idx) for idx, edge in enumerate(graph.edges())}
nx.draw_networkx_edge_labels(graph, pos, elabels)
# place the file where it belongs
path = os.path.join(os.environ['ERDOS_PATH'], "content/images", filename)
plt.savefig(path)
if show:
plt.show()
def filter_show(filters, nx=8, margin=3, scale=10):
FN, C, FH, FW = filters.shape
ny = int(np.ceil(FN / nx))
fig = plt.figure()
fig.subplots_adjust(left=0,
right=1,
bottom=0,
top=1,
hspace=0.05,
wspace=0.05)
for i in range(FN):
ax = fig.add_subplot(ny, nx, i + 1, xticks=[], yticks=[])
ax.imshow(filters[i, 0], cmap=plt.cm.gray_r, interpolation='nearest')
plt.show()
def plot_result(filename='glances.csv'):
import pandas as pd
from matplotlib.pylab import plt
data = pd.read_csv(filename)
mem_used = data['mem_used'].apply(lambda x: float(x) / (10**9))
plt.figure(1)
plt.subplot(121)
mem_used.plot(color="r", linestyle="-", linewidth=1)
plt.xlabel('time step')
plt.ylabel('GB')
plt.title('mem_used')
plt.subplot(122)
gpu_0_proc = data['gpu_0_proc']
gpu_0_proc.plot(color="b", linestyle="-", linewidth=1)
plt.xlabel('time step')
plt.ylabel('proc')
plt.title('gpu_0_proc')
plt.show()
print("mean mem_used:{},mean_gpu_0_proc:{}".format(mem_used.mean(),
gpu_0_proc.mean()))
def drawSurfacePlot(self, f1):
"""
Method to draw a surface plot for test spec
using Word Rank | Tf-Idf Score | PI
"""
test_doc = {}
f1.next()
for row in f1:
test_doc[row[0]] = [row[1], row[2]]
sorted_test_doc = sorted(test_doc.items(),
key=lambda e: e[1][0],
reverse=True)
word_rank = []
PI_list = []
tf_idf_list = []
for i, word in enumerate(sorted_test_doc):
word_rank.append(i + 1)
PI_list.append(word[1][0])
tf_idf_list.append(word[1][1])
PI_list = [float(pi) for pi in PI_list]
tf_idf_list = [float(tf_idf) for tf_idf in tf_idf_list]
fig = plt.figure()
ax = Axes3D(fig)
X = word_rank
X_clone = word_rank
Y = tf_idf_list
X, Y = np.meshgrid(X, Y)
print X
# Z should be a function of X and Y
Z = PI_list
X_clone, Z = np.meshgrid(X_clone, Z)
ax.plot_surface(X,
Y,
Z,
rstride=10,
cstride=10,
cmap=plt.cm.RdBu,
alpha=None)
#ax.contour(X, Y, Z, zdir='x', offset=-4, cmap=cm.hsv)
#ax.contour(Y, Y, Z, zdir='y', offset=4, cmap=cm.hsv)
#ax.contour(Y, Y, Z, zdir='z', offset=-2, cmap=cm.hsv)
#ax.set_zlim(0, 1)
plt.show()
def plot_piledspectra():
fig = plt.figure(figsize = (6,8))
plt.xlim(5000,9000)
specindex = range(0,100,10)
offset = np.arange(0,len(specindex)) * 0.5
ylim = [0.5, offset[-1] + 1.3]
plt.ylim(ylim[0], ylim[1])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.xlabel(r'Restrame Wavelength [ \AA\ ]')
plt.ylabel(r'Flux')
line_wave = [5175., 5892., 6562.8, 8498., 8542., 8662.]
# ['Mgb', 'NaD', 'Halpha', 'CaT', 'CaT', 'CaT']
for line in line_wave:
x = [line, line]
y = [ylim[0], ylim[1]]
plt.plot(x, y, c= 'gray', linewidth=1.0)
plt.annotate(r'CaT', xy=(8540.0, ylim[1] + 0.05), xycoords='data', annotation_clip=False)
plt.annotate(r'H$\alpha$', xy=(6562.8, ylim[1] + 0.05), xycoords='data', annotation_clip=False)
plt.annotate(r'NaD', xy=(5892., ylim[1] + 0.05), xycoords='data', annotation_clip=False)
plt.annotate(r'Mg$\beta$', xy=(5175., ylim[1] + 0.05), xycoords='data', annotation_clip=False)
for i,j in zip(specindex,offset):
iraf.noao.onedspec.continuum(input = GCssorted.ORIGINALFILE.iloc[i] + '[1]', output = '/Volumes/VINCE/OAC/continuum.fits',
type = 'ratio', naverage = '3', function = 'spline3',
order = '5', low_reject = '2.0', high_reject = '2.0', niterate = '10')
data = fits.getdata('/Volumes/VINCE/OAC/continuum.fits', 0)
hdu = fits.open(GCssorted.ORIGINALFILE.iloc[i])
header1 = hdu[1].header
lamRange = header1['CRVAL1'] + np.array([0., header1['CD1_1'] * (header1['NAXIS1'] - 1)])
wavelength = np.linspace(lamRange[0],lamRange[1], header1['NAXIS1'])
hdu.close()
zp = 1. + (GCssorted.VREL.iloc[i] / 299792.458)
plt.plot(wavelength/zp, gaussian_filter(data,2) + j, c = 'black', lw=1)
os.remove('/Volumes/VINCE/OAC/continuum.fits')
def drawSurfacePlot(self, f1):
"""
Method to draw a surface plot for test spec
using Word Rank | Tf-Idf Score | PI
"""
test_doc = {}
f1.next()
for row in f1:
test_doc[row[0]] = [row[1], row[2]]
sorted_test_doc = sorted(test_doc.items(), key=lambda e: e[1][0], reverse=True)
word_rank = []
PI_list = []
tf_idf_list = []
for i, word in enumerate(sorted_test_doc):
word_rank.append(i + 1)
PI_list.append(word[1][0])
tf_idf_list.append(word[1][1])
PI_list = [float(pi) for pi in PI_list]
tf_idf_list = [float(tf_idf) for tf_idf in tf_idf_list]
fig = plt.figure()
ax = Axes3D(fig)
X = word_rank
X_clone = word_rank
Y = tf_idf_list
X, Y = np.meshgrid(X, Y)
print X
# Z should be a function of X and Y
Z = PI_list
X_clone, Z = np.meshgrid(X_clone, Z)
ax.plot_surface(X, Y, Z, rstride=10, cstride=10, cmap=plt.cm.RdBu, alpha=None)
#ax.contour(X, Y, Z, zdir='x', offset=-4, cmap=cm.hsv)
#ax.contour(Y, Y, Z, zdir='y', offset=4, cmap=cm.hsv)
#ax.contour(Y, Y, Z, zdir='z', offset=-2, cmap=cm.hsv)
#ax.set_zlim(0, 1)
plt.show()
def plot(self,x, mk="b-", axis=None, figure=None, **kwargs):
""" plot the fitted model according to a x array
Parameters:
-----------
x : array like
mk : string, optional
marker short string description, default is 'b-'
axis : matplotlib axis, optional
if not given take the subplot 1,1 of figure
figure : matplotlib figure, optional
if not given take plt.figure()
**kwargs : optional
other plot parameter
"""
from matplotlib.pylab import plt
if axis is None:
if figure is None:
figure = plt.figure()
axis = figure.add_subplot(111)
return axis.plot(x, self.model(x), mk, **kwargs)
def surfMagnitudePhaseImage(self, image):
import numpy as np
X = np.linspace(-1, 1, 64)
Y = np.linspace(-1, 1, 64)
X, Y = np.meshgrid(X, Y)
mag = absolute(image).astype('float')
phase = angle(image).astype('float')
fig = plt.figure()
ax = fig.add_subplot(211, projection='3d')
Z = mag
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.jet,
linewidth=0, antialiased=True)
ax.set_zlim3d(np.min(Z), np.max(Z))
fig.colorbar(surf)
ax = fig.add_subplot(212, projection='3d')
Z = phase
surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.jet,
linewidth=0, antialiased=True)
ax.set_zlim3d(np.min(Z), np.max(Z))
fig.colorbar(surf)
plt.show()
'Kd': 3,
'sat_lim_max': 10,
'sat_lim_min': -10
}
new_controller('example_configuration.cnf', 'example_controller.py', 'PIDAW', param)
# Create a motor object for simulation
motor = DC_Motor(configfile='model.cnf', controlmodule='example_controller')
# Simulate the system with an alternating step reference
ref, u, x, y = motor.simulate(30, 'steps')
# Visualize simulation
t = np.array([ii * motor.h for ii in range(len(u[0,:]))])
plt.figure(1);
plt.step(t, u[0])
limits = np.array(plt.axis())*np.array([1.,1.,1.1,1.1])
plt.axis(limits)
plt.title('Control signal(s)')
plt.figure(2);
plt.step(t, np.transpose(x))
limits = np.array(plt.axis())*np.array([1.,1.,1.1,1.1])
plt.axis(limits)
plt.title('System states')
plt.figure(3);
plt.step(t, ref[0])
plt.step(t, x[0])
limits = np.array(plt.axis())*np.array([1.,1.,1.1,1.1])
plt.legend()
# - - - - - - - - - - - - - - - - - - - - - - -
# - - - - - - - - - - - - - - - - - - - - - - -
mask = (((result['g_auto'] - result['r_auto']) < (0.2 + 0.6 * (result['g_auto'] - result['i_auto']))) &
((result['g_auto'] - result['r_auto']) > (-0.2 + 0.6 * (result['g_auto'] - result['i_auto']))) &
((result['g_auto'] - result['i_auto']) > 0.5) &
((result['g_auto'] - result['i_auto']) < 1.3) &
((result['i_auto']) < 24))
subset = result[mask]
subset = subset.sample(n=1000)
plt.figure()
plt.scatter(result['g_auto'] - result['i_auto'], result['g_auto'] - result['r_auto'], s=10, c='gray', edgecolor='none', alpha = 0.5)
plt.scatter(subset['g_auto'] - subset['i_auto'], subset['g_auto'] - subset['r_auto'], s=20, c='blue', edgecolor='none')
plt.scatter(GCs['g_auto'] - GCs['i_auto'], GCs['g_auto'] - GCs['r_auto'], s=10, c='red', edgecolor='none')
plt.xlabel('(g - i)')
plt.ylabel('(g - r)')
plt.xlim(-1,4)
plt.ylim(-1,4)
plt.figure()
plt.scatter(subset['g_auto'] - subset['r_auto'], subset['r_auto'], s=30, c='blue', edgecolor='none')
plt.scatter(GCs['g_auto'] - GCs['r_auto'], GCs['i_auto'], s=8, c='red', edgecolor='none')
plt.ylim(13,24)
plt.gca().invert_yaxis()
plt.xlabel('(g - i)')
plt.ylabel('i')
[u, v, h] = f_step.call([p, u, v, h])
# Create an integrator function
f = MXFunction([p, uk, vk, hk], [u, v, h])
f.init()
print "generated discrete dynamics"
# Allocate memory
u = copy.deepcopy(u0)
v = copy.deepcopy(v0)
h = copy.deepcopy(h0)
# Prepare plotting
if plot_progress:
fig = plt.figure(1)
ax = fig.add_subplot(111, projection="3d")
# plt.clf()
# plt.grid(True)
plt.ion()
plt.hold(False)
plt.draw()
plt.show()
# Measurement
h_meas = []
# Simulate once to generate "measurements"
for k in range(num_measurements):
# Visualize the pool
if plot_progress:
def plot_spectrum(result, correct = True, interactive = False):
plt.close('all')
plt.ioff()
if interactive:
plt.ion()
hdu = fits.open(result['ORIGINALFILE'])
galaxy = gaussian_filter(hdu[1].data, 1)
thumbnail = hdu['THUMBNAIL'].data
twoD = hdu['2D'].data
header = hdu[0].header
header1 = hdu[1].header
hdu.close()
lamRange = header1['CRVAL1'] + np.array([0., header1['CD1_1'] * (header1['NAXIS1'] - 1)])
if correct:
zp = 1. + (result['VREL'] / 299792.458)
else:
zp = 1.
wavelength = np.linspace(lamRange[0],lamRange[1], header1['NAXIS1']) / zp
ymin, ymax = np.min(galaxy), np.max(galaxy)
ylim = [ymin, ymax] + np.array([-0.02, 0.1])*(ymax-ymin)
ylim[0] = 0.
xmin, xmax = np.min(wavelength), np.max(wavelength)
### Define multipanel size and properties
fig = plt.figure(figsize=(8,6))
gs = gridspec.GridSpec(200,130,bottom=0.10,left=0.10,right=0.95)
### Plot the object in the sky
ax_obj = fig.add_subplot(gs[0:70,105:130])
ax_obj.imshow(thumbnail, cmap = 'gray', interpolation = 'nearest')
ax_obj.set_xticks([])
ax_obj.set_yticks([])
### Plot the 2D spectrum
ax_2d = fig.add_subplot(gs[0:11,0:100])
ix_start = header['START_{}'.format(int(result['DETECT']))]
ix_end = header['END_{}'.format(int(result['DETECT']))]
ax_2d.imshow(twoD, cmap='spectral',
aspect = "auto", origin = 'lower', extent=[xmin, xmax, 0, 1],
vmin = -0.2, vmax=0.2)
ax_2d.set_xticks([])
ax_2d.set_yticks([])
### Add spectra subpanels
ax_spectrum = fig.add_subplot(gs[11:85,0:100])
ax_blue = fig.add_subplot(gs[110:200,0:50])
ax_red = fig.add_subplot(gs[110:200,51:100])
### Plot some atomic lines
line_wave = [4861., 5175., 5892., 6562.8, 8498., 8542., 8662.]
# ['Hbeta', 'Mgb', 'NaD', 'Halpha', 'CaT', 'CaT', 'CaT']
for i in range(len(line_wave)):
x = [line_wave[i], line_wave[i]]
y = [ylim[0], ylim[1]]
ax_spectrum.plot(x, y, c= 'gray', linewidth=1.0)
ax_blue.plot(x, y, c= 'gray', linewidth=1.0)
ax_red.plot(x, y, c= 'gray', linewidth=1.0)
### Plot the spectrum
ax_spectrum.plot(wavelength, galaxy, 'k', linewidth=1.3)
ax_spectrum.set_ylim(ylim)
ax_spectrum.set_xlim([xmin,xmax])
ax_spectrum.set_ylabel(r'Arbitrary Flux')
ax_spectrum.set_xlabel(r'Restframe Wavelength [ $\AA$ ]')
### Plot blue part of the spectrum
x1, x2 = 300, 750
ax_blue.plot(wavelength[x1:x2], galaxy[x1:x2], 'k', linewidth=1.3)
ax_blue.set_xlim(wavelength[x1],wavelength[x2])
ax_blue.set_ylim(galaxy[x1:x2].min(), galaxy[x1:x2].max())
ax_blue.set_yticks([])
### Plot red part of the spectrum
x1, x2 = 1400, 1500
ax_red.plot(wavelength[x1:x2], galaxy[x1:x2], 'k', linewidth=1.3)
ax_red.set_xlim(wavelength[x1],wavelength[x2])
ax_red.set_ylim(galaxy[x1:x2].min(), galaxy[x1:x2].max())
ax_red.set_yticks([])
### Plot text
#if interactive:
textplot = fig.add_subplot(gs[80:200,105:130])
kwarg = {'va' : 'center', 'ha' : 'left', 'size' : 'medium'}
textplot.text(0.1, 1.0,r'ID = {} \, {}'.format(result.ID, int(result.DETECT)),**kwarg)
textplot.text(0.1, 0.9,r'$v =$ {}'.format(int(result.VREL)), **kwarg)
textplot.text(0.1, 0.8,r'$\delta \, v = $ {}'.format(int(result.VERR)), **kwarg)
textplot.text(0.1, 0.7,r'SN1 = {0:.2f}'.format(result.SN1), **kwarg)
textplot.text(0.1, 0.6,r'SN2 = {0:.2f}'.format(result.SN2), **kwarg)
textplot.text(0.1, 0.5,r'TDR = {0:.2f}'.format(result.TDR), **kwarg)
textplot.text(0.1, 0.4,r'SG = {}'.format(result.SG), **kwarg)
textplot.axis('off')
return fig
plt.plot(train_sizes, train_scores_mean, '-', color="r",
label="Training score")
plt.plot(train_sizes, test_scores_mean, '-', color="g",
label="Cross-validation score")
plt.ylim(0,1.2)
plt.xlim(0,200)
plt.legend(loc="best")
plt.xlabel("Train test size")
plt.savefig("learning_curves.png")
plt.close("all")
# plot the model vs the predictions
for what_plot in [0,1,2,3]:
fig=plt.figure(figsize=(16,8))
#
ax1 = fig.add_subplot(1,2,1); ax2 = fig.add_subplot(1,2,2)
ax1.tick_params(labelsize=20); ax2.tick_params(labelsize=20)
#
if(what_plot==3):
# actual data
ax1.scatter(X_test[models_features[i]]["Budget"],X_test[models_response[i]],c=X_test[models_features[i]]["AveStudioShare"],s=2.**((X_test[models_features[i]]["TheatersOpening"])+4),cmap="Reds",alpha=0.8)
#
# predictions
predictions = the_best_models[i].predict(X_test[models_features[i]])
predictions_with_error = np.random.normal(predictions,np.sqrt(best_mse[i]),size=len(predictions))
ax2.scatter(X_test[models_features[i]]["Budget"],predictions_with_error,c=X_test[models_features[i]]["AveStudioShare"],s=2.**((X_test[models_features[i]]["TheatersOpening"])+4),cmap="Greens",alpha=0.8)
#
if(what_plot==2):
# actual data
GCs = pd.read_csv('/Volumes/VINCE/OAC/GCs_903.csv', dtype = {'ID': object}, comment = '#')
# ----------------------------------
rep1 = GCs[GCs.Alt1.isin(GCs.ID)]
df1 = pd.DataFrame()
df2 = pd.DataFrame()
for j in range(0,len(rep1)):
df1.iloc[j] = rep1.iloc[j]
x = VIMOS['VREL_helio']
xerr = VIMOS['VERR']
y = SchuberthMatch['HRV']
yerr = SchuberthMatch['e.1']
print 'rms (VIMOS - Schuberth) GCs = ', np.std(x-y)
plt.close('all')
plt.figure(figsize=(6,6))
plt.errorbar(x, y, yerr= yerr, xerr = xerr, fmt = 'o', c ='black', label = 'Schuberth et al.')
plt.plot([-200, 2200], [-200, 2200], '--k')
plt.xlim(-200,2200)
plt.ylim(-200,2200)
x = VIMOS['r_auto']
y = SchuberthMatch['Rmag']
plt.scatter(x, y, c ='black')
def plotting(self,pressurelattice,invasionlattice,pressure,number_of_clusters):
from matplotlib.pylab import plt
#Plotting the invasionlattice
plt.figure(2)
plt.imshow(invasionlattice, cmap='Greys',interpolation='nearest')
plt.title("Invasion lattice")
plt.colorbar()
plt.savefig(self.pathsimulation + "invasionlattice.png", bbox_inches="tight")
plt.close()
#plotting the pressure
plt.figure(5)
plt.plot(pressure)
plt.xlabel('Time')
plt.ylabel('Pressure')
plt.title('P(t)')
plt.savefig(self.pathsimulation +"pressure.png", bbox_inches="tight")
plt.close()
#plotting the clusterlattice
plt.figure(6)
plt.imshow(self.lw, interpolation='nearest')
plt.title("Clusterlattice")
plt.colorbar()
plt.savefig(self.pathsimulation +"clusterlattice.png", bbox_inches="tight")
plt.close()
#Temporal diagram
plt.figure(7)
plt.imshow(self.temporalplot,interpolation='nearest')
plt.title('Temporal diagram')
plt.colorbar()
plt.savefig(self.pathsimulation +"temporal.png", bbox_inches="tight")
plt.close()
#Plotting pressure distribution in the cell.
plt.figure(3)
plt.hist(pressurelattice.ravel(), bins=30, fc='k', ec='k')
plt.savefig(self.pathsimulation +"pressuredistribution.png", bbox_inches="tight")
plt.close()
#Plotting the number of clusters as a function of interation.
plt.figure(1)
plt.plot(number_of_clusters)
plt.xlabel('Iteration number/time')
plt.ylabel('Number of clusters')
plt.title('Number_of_cluster(t)')
plt.savefig(self.pathsimulation +"clusterN.png", bbox_inches="tight")
plt.close()
import csv
import datetime
from pylab import *
from matplotlib.pylab import plt
from matplotlib import dates as mtd
from matplotlib.dates import HourLocator, DayLocator,DateFormatter
f1=open("./Turnstile/Turnstile-Data.txt","rb")
#f2=open("./Turnstile/Sp170St.txt","wb")
rv=csv.reader(f1)
#ro=csv.writer(f2)
fig=plt.figure(figsize=(10,8))
ax1=fig.add_subplot(3,1,1)
ax2=fig.add_subplot(3,1,3)
fig_wnd=plt.figure()
ax1_wnd=fig_wnd.add_subplot(3,1,1)
print "The station we are analyzing is 170th Street on line 4"
REMOTE="R243"; BOOTH="R284" # This is the code for the subway stop
print "We are considering turnstile numbers over the weekday from Jan 7th to Jan 11, 2013"
T_ent=-1 # Entry count on turnstile
T_exit=-1 # Exit count on turnstile
trun=[]
SCP=""
flag=-1
for rw in rv:
if (rw[0]==BOOTH and rw[1]==REMOTE) :
flag=1
print len(rw)
if SCP!=rw[2]:
T_ent=-1 # Entry count on turnstile
T_exit=-1 # Exit count on turnstile
SCP=rw[2]
truth = np.array(y_test)
from sklearn.metrics import accuracy_score, f1_score, recall_score, precision_score
accuracy_score(predictions,truth)
f1_score(predictions,truth,average="weighted")
recall_score(predictions,truth,average="weighted")
precision_score(predictions,truth,average="weighted")
from sklearn.metrics import roc_curve, auc
from matplotlib.pylab import plt
import seaborn as sns
all_categories = np.unique(articles["category"])
fig=plt.figure(figsize=(8,8))
ax=fig.add_subplot(1,1,1)
plt.tick_params(labelsize=20)
for i in range(len(all_categories)):
mask = y_test == all_categories[i]
prob_category = clf.predict_proba(X_test)[:,i]
dummy_y = np.ones(len(y_test))
dummy_y[~mask] = 0
fpr, tpr, thresholds = roc_curve(dummy_y, prob_category)
ax.plot(fpr,tpr,label=all_categories[i]+", AUC = "+str(round(auc(fpr,tpr),2)),lw=2)
ax.legend(loc=4,fontsize="large")
ax.plot([0, 1], [0, 1], "k--")
ax.set_xlim([0.0, 1.0]);ax.set_ylim([0.0, 1.05])
ax.set_xlabel("False Positive Rate",fontsize=20); ax.set_ylabel("True Positive Rate",fontsize=20)
plt.savefig("roc_curve_body.png",bbox_inches="tight")
def telluric_psf(obs,plot=False,plot_med=False):
"""
Telluric PSF
Measure the instrumental profile of HIRES by treating telluric
lines as delta functions. The width of the telluric lines is a
measure of the PSF width.
Method
------
Fit a comb of gaussians to the O2 bandhead from 6270-6305A. The
comb of gaussians that describes the telluric lines has 4 free
parameters:
- sig : width of the line
- wls0 : shift of telluric line centers: -0.1 to +0.1 angstroms
- wls1 : wavelength stretch allows for 1% fluctuation in dlam/dpix
0.99 to 1.01.
- d : scale factor to apply to the telluric lines
If wls0 is off by more than a line width, we might not find a
solution. We perform a scan in wls0.
Parameters
----------
obs : CPS observation id.
"""
# Load spectral region and prep.
spec = smio.getspec_fits(obs=obs)[14]
spec = spec[(spec['w'] > 6270) & (spec['w'] < 6305)]
spec['s'] /= continuum.cfit(spec)
# figure out where the 95 percentile is for data that's this
# noisey, then adjust continuum
serr = np.median(spec['serr'])
contlevel = np.percentile(np.random.randn(spec.size)*serr,95)
spec['s'] *= (1+contlevel)
darr = np.array(tell.d)
# Intialize parameters
p0 = lmfit.Parameters()
p0.add('wls0',value=0.0)
p0.add('sig',value=0.02,min=0,max=0.1)
p0.add('wls1',value=1.0,min=0.99,max=1.01)
p0.add('d',value=1,min=0.25,max=2)
def model(p):
return telluric_comb(p['sig'].value,p['wls0'].value,p['wls1'].value,
spec['w'],tell.wcen,darr=p['d'].value*darr)
def res(p):
"""
Residuals
Returns residuals for use in the LM fitter. I compute the
median absolute deviation to flag outliers. I remove these
values from the residual array. However, I divide the
residuals by the total number of residuals (post sigma
clipping) so a to not penalize solutions with more points.
Parameters
----------
p : lmfit parameters object
Returns
-------
res : Residual array (used in lmfit)
"""
mod = model(p)
res = (spec['s'] - mod) / spec['serr'] # normalized residuals
mad = np.median(np.abs(res))
b = (np.abs(res) < 5*mad )
res /= b.sum()
if b.sum() < 10:
return res * 10
else:
return res[b]
# Do a scan over different wavelength shifts
wstep = 0.01
wrange = 0.1
wls0L = np.arange(-wrange,wrange+wstep,wstep)
chiL = np.zeros(len(wls0L))
outL = []
for i in range(len(wls0L)):
p = copy.deepcopy(p0)
p['wls0'].value = wls0L[i]
out = lmfit.minimize(res,p)
chiL[i] = np.sum(res(p)**2)
outL+=[out]
# If the initial shift is off by a lot, the line depths will go to
# zero and median residual will be 0. Reject these values
out = outL[np.nanargmin(chiL)]
p = out.params
lmfit.report_fit(out.params)
# Bin up the regions surronding the telluric lines
wtellmid = np.mean(tell.wcen)
def getseg(wcen):
wcen = wtellmid + (wcen-wtellmid)*p['wls1'].value + p['wls0'].value
dw = spec['w'] - wcen
b = np.abs(dw) < 0.3
seg = pd.DataFrame({'dw':dw,'s':spec['s'],'model':model(p)})
seg = pdplus.LittleEndian(seg.to_records(index=False))
seg = pd.DataFrame(seg)
return seg[b]
seg = map(getseg,list(tell.wcen))
seg = pd.concat(seg,ignore_index=True)
wstep = 0.025
bins = np.arange(-0.3,0.3+wstep,wstep)
seg['dw0'] = 0.
for dw0 in np.arange(-0.3,0.3,wstep):
seg['dw0'][seg.dw.between(dw0,dw0+wstep)] = dw0
bseg = seg.groupby('dw0',as_index=False).median()
mod = model(p) # best fit model
def plot_spectrum():
# Plot telluric lines and fits
plt.plot(spec['w'],spec['s'],label='Stellar Spectrum')
plt.plot(spec['w'],mod,label='Telluric Model')
plt.plot(spec['w'],spec['s']-mod+0.5,label='Residuals')
plt.xlim(6275,6305)
plt.ylim(0.0,1.05)
plt.xlabel('Wavelength (A)')
plt.ylabel('Intensity')
plt.title('Telluric Lines')
def plot_median_profile():
# Plot median line profile
plt.plot(bseg.dw,bseg.s,'.',label='Median Stellar Spectrum')
plt.plot(bseg.dw,bseg.model,'-',label='Median Telluric Model')
plt.title('Median Line Profile')
plt.xlabel('Distance From Line Center (A)')
yl = list(plt.ylim())
yl[1] = 1.05
plt.ylim(*yl)
if plot:
# Used for stand-alone telluric diagnostic plots
gs = GridSpec(1,4)
fig = plt.figure(figsize=(12,3))
plt.gcf().set_tight_layout(True)
plt.sca(fig.add_subplot(gs[0,:3]))
plot_spectrum()
plt.sca(fig.add_subplot(gs[0,3]))
plot_median_profile()
if plot_med:
# Used in quicklook plot
plot_median_profile()
# sig = width of telluric line in
sig = p['sig'].value # [Angstroms]
sig = sig/6290*3e5 # [km/s]
sig = sig/1.3 # [pixels]
return sig