def histograms(self, start_time, stop_time, depth, overlapping=True):
L = stop_time.year - start_time.year + 1
modslopes, noiseterm = self.sn_at_time(start_time,
L,
depth,
overlapping=overlapping)
ns = np.std(noiseterm)
plt.hist(modslopes / ns,
20,
normed=True,
color=cm.Oranges(.8),
alpha=.5)
lab = str(start_time.year) + "-" + str(stop_time.year)
da.fit_normals_to_data(modslopes / ns,
color=cm.Oranges(.9),
lw=3,
label=lab + " Model projections")
plt.hist(noiseterm / ns,
20,
normed=True,
color=cm.Purples(.8),
alpha=.5)
da.fit_normals_to_data(noiseterm / ns,
color=cm.Purples(.9),
lw=3,
label="Noise")
plt.xlabel("S/N")
plt.ylabel("Normalized Frequency")
def clustering_plot(X_clustered, cluster_labels, nclusters, title=None\
, X_center=None):
z = plt.figure(figsize=(10, 10))
if len(cluster_labels) > 0:
if X_center is not None:
alpha = 0.3
else:
alpha = 0.6
print("clustering_plot()" + str(X_clustered.shape))
print("clustering_plot()" + str(X_clustered[0, 0]))
for i in range(X_clustered.shape[0]):
plt.scatter(X_clustered[i, 0], X_clustered[i, 1],\
c=cm.Oranges(cluster_labels[i] / nclusters), alpha=alpha)
if X_center is not None:
for i in range(X_center.shape[0]):
plt.scatter(X_center[i, 0],
X_center[i, 1],
marker="o",
s=400,
c='red')
plt.annotate(str(i), (X_center[i, 0], X_center[i, 1]))
else:
for i in range(X_clustered.shape[0]):
plt.scatter(X_clustered[i, 0], X_clustered[i, 1], c='b')
plt.xticks([])
plt.yticks([])
if title is not None:
plt.title(title, size=17, color='b')
def c_d_Matrix():
step = 10 #step with which the gammas vary until 1
n = int(L / step) #number of transition rates to test for
stability = np.zeros((n, n, L + 1))
axis = np.zeros((n, 2))
for inc in range(1, n):
Set("param.txt", "c", str(inc * step))
for dec in range(inc):
Set("param.txt", "d", str(dec * step))
stability[inc, dec] = gau.Dummy()
print('c=', inc * step, 'd=', dec * step, 'a=',
stability[inc, dec, int(L / 2)])
x = y = np.arange(0, L, step)
# here are the x,y and respective z values
X, Y = np.meshgrid(x, y)
Z = np.array(np.amin(stability, axis=-1))
# this is the value to use for the color
V = np.amax(stability, axis=-1)
plt.xlabel('gamma_R')
# create the figure, add a 3d axis, set the viewing angle
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.view_init(45, 60)
# here we create the surface plot, but pass V through a colormap
# to create a different color for each patch
ax.plot_surface(X, Y, Z, facecolors=cm.Oranges(V))
plt.show()
return (stability)
def da_colors(typ):
d = {}
d["h85"] = cm.Oranges(.8) #cm.Dark2(0.)
d["piC"] = cm.Greens(.7) #cm.Dark2(.2)
d["gpcp"] = cm.Purples(.5) #cm.Dark2(.4)
d["cmap"] = cm.Reds(.8)
d["precl"] = cm.Purples(.9)
return d[typ]
def obs_SN(self, start_time, stop_time, depth, overlapping=True):
self.project_soilmoisture("MERRA2")
self.project_soilmoisture("GLEAM")
L = stop_time.year - start_time.year + 1
modslopes, noiseterm = self.sn_at_time(start_time,
L,
depth,
overlapping=overlapping)
ns = np.std(noiseterm)
plt.hist(modslopes / ns,
20,
normed=True,
color=cm.Oranges(.8),
alpha=.5)
lab = str(start_time.year) + "-" + str(stop_time.year)
da.fit_normals_to_data(modslopes / ns,
color=cm.Oranges(.9),
lw=3,
label=lab +
" trends in H85 projections onto fingerprint")
plt.hist(noiseterm / ns,
20,
normed=True,
color=cm.Purples(.8),
alpha=.5)
da.fit_normals_to_data(
noiseterm / ns,
color=cm.Purples(.9),
lw=3,
label=str(L) +
"-year trends in piControl projection onto fingerprint")
plt.xlabel("S/N")
plt.ylabel("Normalized Frequency")
merra = self.OBS_PROJECTIONS["MERRA2"][depth](time=(start_time,
stop_time))
gleam = self.OBS_PROJECTIONS["GLEAM"][depth](time=(start_time,
stop_time))
merrasig = cmip5.get_linear_trends(merra) / ns
plt.axvline(merrasig, label="MERRA2", c="b", lw=3)
gleamsig = cmip5.get_linear_trends(gleam) / ns
plt.axvline(gleamsig, label="GLEAM", c="r", lw=3)
plt.legend()
def plot_compare_phi_psi(neurons, epsilon_values, tau_y_values, psi_values):
'''This only works for summary type saves.'''
fig, axs = plt.subplots(1, len(psi_values), sharey=True, figsize=(5*len(psi_values)+2, 5))
cm_section = np.linspace(0.3, 1, len(tau_y_values))
colours = []
colours.append([ cm.Blues(x) for x in cm_section ])
colours.append([ cm.Oranges(x) for x in cm_section ])
colours.append([ cm.Purples(x) for x in cm_section ])
colours.append([ cm.Greens(x) for x in cm_section ])
for j, epsilon in enumerate(epsilon_values):
for k, tau_y in enumerate(tau_y_values):
label = "$\\tau_y={}$, $\epsilon={}$".format(tau_y,epsilon)
E = []
phi_values = []
for i in range(len(psi_values)):
E.append([])
phi_values.append([])
for neuron in neurons:
if neuron.hyper['psi'] in psi_values:
phi_values[psi_values.index(neuron.hyper['psi'])].append(neuron.hyper['phi'])
for log in neuron.logs:
if log[0]['tau_y'] == tau_y and log[0]['epsilon'] == epsilon:
E[psi_values.index(neuron.hyper['psi'])].append(log[2]-log[3])
for i in range(len(psi_values)):
if i == 0:
axs[i].plot(phi_values[i], E[i], label=label, color=colours[j][k])
axs[i].set_ylabel('$E$')
else:
axs[i].plot(phi_values[i], E[i], color=colours[j][k])
axs[i].set_title('$\psi={}$'.format(psi_values[i]))
axs[i].set_xlabel('$\phi$')
fig.legend(loc='center left', bbox_to_anchor=(1, 0.5))
# fig.legend(loc='upper center', bbox_to_anchor=(0.5, -0.02), fancybox=True, shadow=True, ncol=6)
fig.tight_layout()
plt.show()
return fig
def plt_2_trajectories(data,
labels,
xyt,
savepath,
usemeans=True,
mid=0,
plttype='scatter',
**kwargs):
plt.figure(figsize=(30, 10))
vals = {}
assert len(data) == len(labels)
ylims = kwargs.pop('ylims', (0, 1))
if usemeans:
means = [np.mean(line) for line in data]
else:
means = [mid] * len(data)
vals['up'] = [
np.array([x for x in line if x >= means[i]])
for i, line in enumerate(data)
]
vals['down'] = [
np.array([x for x in line if x < means[i]])
for i, line in enumerate(data)
]
cols = {'up': 'green', 'down': 'red'}
plt.plot(range(len(labels)), means, lw=4, c=cm.Oranges(0.8))
plt.axhline(y=mid, c=cm.Greys(0.8), alpha=0.7)
for x in range(0, len(means), 12):
plt.axvline(x=x, c=cm.Greys(0.8), alpha=0.7, lw=1.5)
if 'scatter' in plttype:
for k, v in vals.items():
ys = [y for line in v for y in line]
xs = [xval for xval, line in enumerate(v) for y in line]
plt.scatter(xs, ys, alpha=0.25, c=cols[k], label=k)
if 'mean' in plttype:
for k, v in vals.items():
ys = [np.mean(line) for line in v]
xs = range(len(v))
plt.plot(xs, ys, alpha=0.8, lw=2, c=cols[k], label=k)
if 'box' in plttype:
for k, v in vals.items():
plt.boxplot(v, positions=range(len(data)), boxprops={'c': cols[k]})
plt.legend()
plt.xlabel(xyt[0], fontsize=20)
plt.xticks(ticks=range(len(v)),
labels=labels,
rotation=45,
fontsize=10,
ha='center')
plt.ylabel(xyt[1], fontsize=20)
plt.title(xyt[2], fontsize=24)
plt.ylim(*ylims)
plt.savefig(savepath + '.png', bbox_inches='tight')
plt.close('all')
def colorregions(region):
"""Set the colors to ensure a uniform scheme for each region """
d={}
d["ALL"]="k"
d["NHDA"]=cm.gray(.5)
d["NADA"]=cm.Purples(.5)
d["OWDA"]=cm.Blues(.5)
d["MXDA"]=cm.PiYG(.1)
d["ANZDA"]=cm.PiYG(.8)
d["MADA"]=cm.Oranges(.5)
d["GDA"]="k"
return d[region]
def get_colors(color_c=3, color_step=100):
cmap_colors = np.vstack((
cm.Oranges(np.linspace(0.4, 1, color_step)),
cm.Reds(np.linspace(0.4, 1, color_step)),
cm.Greys(np.linspace(0.4, 1, color_step)),
cm.Purples(np.linspace(0.4, 1, color_step)),
cm.Blues(np.linspace(0.4, 1, color_step)),
cm.Greens(np.linspace(0.4, 1, color_step)),
cm.pink(np.linspace(0.4, 1, color_step)),
cm.copper(np.linspace(0.4, 1, color_step)),
))
return cmap_colors[np.arange(color_c * color_step) % (color_step * 8)]
def obs_SN(self,start_time,stop_time=None,overlapping=True,include_dai=False):
if stop_time is None:
stop_time=cmip5.stop_time(self.projection)
target_obs = self.projection(time=(start_time,stop_time))
L=len(target_obs)
modslopes,noiseterm = self.sn_at_time(start_time,L,overlapping=True)
ns=np.std(noiseterm)
signal = float(cmip5.get_linear_trends(target_obs))/ns
plt.hist(modslopes/ns,20,normed=True,color=cm.Oranges(.8),alpha=.5)
lab = str(start_time.year)+"-"+str(stop_time.year)
da.fit_normals_to_data(modslopes/ns,color=cm.Oranges(.9),label=lab+" Model projections")
plt.hist(noiseterm/ns,20,normed=True,color=cm.Greens(.8),alpha=.5)
da.fit_normals_to_data(noiseterm/ns,color=cm.Greens(.9),label="Pre-1850 tree-ring reconstructions")
plt.axvline(signal,color=cm.Blues(.8),lw=3,label=lab+" Tree-ring reconstructions")
print signal
if include_dai:
dai_proj = self.project_dai_on_solver(start=start_time)
daitrend = cmip5.get_linear_trends(dai_proj(time=(start_time,stop_time)))
plt.legend(loc=0)
def plot_sct(self, drop_point, wind_speed_array, launcher_elev_angle,
fall_type):
# -------------------
# plot landing distribution
# hardcoded for noshiro
#
# INPUT:
# drop_point: (n_speed * n_angle * 2(xy) ndarry): landing point coordinate
# wind_speed_array: array of wind speeds
# lancher_elev_angle: elevation angle [deg]
# fall_type = 'Parachute' or 'Ballistic'
#
# -------------------
# plot map
self.plot_map()
# file existence check
#file_exist = os.path.exists("./output")
#if file_exist == False:
# os.mkdir("./output")
title_name = fall_type + ", Launcher elev. " + str(
int(launcher_elev_angle)) + " deg"
imax = len(wind_speed_array)
for i in range(imax):
# cmap = plt.get_cmap("winter")
labelname = str(wind_speed_array[i]) + " m/s"
plt.plot(drop_point[i, :, 0],
drop_point[i, :, 1],
label=labelname,
linewidth=2,
color=cm.Oranges(i / imax))
# output_name = "output/Figure_elev_" + str(int(rail_elev)) + ".png"
output_name = 'results/Figure_' + fall_type + '_elev' + str(
int(launcher_elev_angle)) + 'deg.eps'
plt.title(title_name)
plt.legend()
plt.savefig(output_name, bbox_inches='tight')
plt.show()
def _prediction_1D(axe,
xlim,
varname,
xlabels,
Xmean,
Xweight,
xtitle,
StdMean=None,
Xref=None,
StdRef=None,
modal_label=None):
if xlim is not None:
axe.set_ylim(*xlim)
axe.yaxis.set_major_locator(
ticker.MultipleLocator((xlim[1] - xlim[0]) / 10))
axe.set_xlabel(xtitle, fontsize=15)
axe.set_ylabel(varname, fontsize=20)
if Xmean is not None:
axe.plot(xlabels, Xmean, color="indigo", marker="*", label="Mean")
if StdMean is not None:
axe.fill_between(xlabels,
Xmean - StdMean,
Xmean + StdMean,
alpha=0.3,
color="indigo",
label="Std on mean",
hatch="/")
if Xweight is not None:
colors = cm.Oranges(np.linspace(0.4, 0.9, Xweight.shape[1]))
for i, X in enumerate(Xweight.T):
label = (modal_label or "Weight prediction {}").format(i)
axe.plot(xlabels, X, marker="+", label=label, color=colors[i])
if Xref is not None:
axe.plot(xlabels, Xref, color="g", marker=".", label="Reference")
if StdRef is not None:
axe.fill_between(xlabels,
Xref + StdRef,
Xref - StdRef,
alpha=0.3,
color="g",
label="Std on reference")
def create_colormap_2colors(proportion_colors1):
number_colors1 = math.floor(proportion_colors1 * 256)
number_colors2 = 256 - number_colors1
# sample the colormaps that you want to use. Use 128 from each so we get 256
# colors in total
colors1 = cmx.Blues(np.linspace(0, 1, number_colors1))
oranges = cmx.Oranges(np.linspace(0, 1, number_colors2))
orange = oranges[math.ceil(number_colors2*0.65),:]
colors2 = np.zeros( (number_colors2,4), dtype=np.float64)
colors2[:number_colors2] = orange
# combine them and build a new colormap
colors = np.vstack((colors1, colors2))
mymap = mcolors.LinearSegmentedColormap.from_list('my_colormap', colors)
return mymap
def __init__(self,data_pred,data_gt,colors,img,types,gif_name = "test.gif", plot_ = False, save = True):
self.img = img
self.xs_pred = data_pred[:,:,0]
self.ys_pred = data_pred[:,:,1]
self.xs_gt = data_gt[:,:,0]
self.ys_gt = data_gt[:,:,1]
self.types = types
self.nb_agents = self.xs_pred.shape[0]
self.margin = 1
self.nb_frames = self.xs_pred.shape[1]
self.gif_name = gif_name
self.plot_ = plot_
self.save = save
self.fps = 1
self.colors = colors
self.lin_size = 100
lin = np.linspace(0.6, 0.8, self.lin_size)
self.color_dict = {
"bicycle":cm.Blues(lin),
"pedestrian":cm.Reds(lin),
"car":cm.Greens(lin),
"skate":cm.Greys(lin),
"cart":cm.Purples(lin),
"bus":cm.Oranges(lin)
}
self.colors = [self.color_dict[type_][np.random.randint(self.lin_size)] for type_ in self.types]
self.history = 4
self.get_plots()
def _axe_density_1D(axe, x, y, xlims, varname, modal_preds, truex, title):
# axe.xaxis.set_minor_locator(ticker.MultipleLocator((xlims[1] - xlims[0]) / 100))
# axe.xaxis.set_major_locator(ticker.MultipleLocator((xlims[1] - xlims[0]) / 20))
axe.plot(x, y, "-", linewidth=1)
axe.set_xlim(*xlims)
axe.set_xlabel(varname)
axe.set_title(title)
colors = cm.Oranges(np.linspace(0.4, 0.9, len(modal_preds)))
for i, (X, height, weight) in enumerate(modal_preds):
axe.axvline(
x=X,
color=colors[i],
linestyle="--",
label="$x_{{est}}^{{( {2} )}}$, $w_{{ {2} }} = {1:.3f}$".format(
height, weight, i),
alpha=0.5)
if truex:
axe.axvline(x=truex, label="True value", color="black", alpha=0.5)
axe.legend()
def plot_wz_align(neuron):
sigma_s, epsilon, sigma_y, tau_y = env_extract(neuron)
cm_section = np.linspace(0.3, 1, neuron.S)
colors = [ cm.Oranges(x) for x in cm_section ]
fig, axs = plt.subplots(len(tau_y), len(epsilon), squeeze=True, figsize=(4*len(epsilon),3*len(tau_y)), sharey=True)
for log in neuron.logs:
i = tau_y.index(log.env_parameters['tau_y'])
j = epsilon.index(log.env_parameters['epsilon'])
x_low = 0
x_up = log.timeline[-1]+1
for k in np.arange(0, neuron.S, 1):
axs[i, j].plot(
log.timeline,
(log.W[:, [k], :] @ log.z / (np.sqrt(log.W[:, [k], :] @ np.transpose(log.W[:, [k], :], (0,2,1))) * np.sqrt(np.transpose(log.z, (0,2,1)) @ log.z))).squeeze(),
# (neuron.po.T[None, :, :] @ log.W @ log.z / (np.sqrt(neuron.po.T[None, :, :] @ log.W @ np.transpose(neuron.po.T[None, :, :] @ log.W, (0,2,1))) * np.sqrt(np.transpose(log.z, (0,2,1)) @ log.z))).squeeze(),
color = colors[k],
label = '$\mathbf{{w}}_{{{k}}}$'.format(k=k+1)
)
axs[i, j].set_xlabel('$t$', fontsize=14)
axs[i, j].set_title('$\\tau_y = {}$, $\epsilon = {}$'.format(tau_y[i], epsilon[j]))
tag_R_E(axs[i, j], log, x_low, x_up)
axs[i, j].set_xlim(x_low, x_up)
if j == 0:
axs[i, j].set_ylabel('$\cos(\\theta_{{\mathbf{{z}},\mathbf{{w}}_{{a}}}})$', fontsize=14)
if i == 0:
axs[i, j].legend(loc="upper left")
fig.tight_layout()
plt.show()
return fig
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
data=pd.read_csv("data",sep="\s+",header=None)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x = data[0]
y = data[1]
z = data[2]
c = data[3]
ax.view_init(45,60)
img = ax.scatter(x, y, z, c=c, cmap=plt.hot())
fig.colorbar(img)
fig.savefig("plot.png")
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
x,y = np.meshgrid(data[0], data[1])
z = data[2]
c = data[3]
ax.view_init(45,60)
# here we create the surface plot, but pass V through a colormap
# to create a different color for each patch
ax.plot_surface(x, y, z, facecolors=cm.Oranges(c))
fig.savefig("plot2.png")
import numpy as np
from numpy.random import binomial
from scipy.stats import multivariate_normal, norm
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import math
import os
import errno
import seaborn as sns
from matplotlib.colors import ListedColormap
from mpl_toolkits.mplot3d import Axes3D
blue_cmap = ListedColormap(cm.Blues(np.linspace(0, 1, 20))[10:, :-1])
oran_cmap = ListedColormap(cm.Oranges(np.linspace(0, 1, 20))[10:, :-1])
green_cmap = ListedColormap(cm.Greens(np.linspace(0, 1, 20))[10:, :-1])
def setup_plotting():
"""This function sets up Latex-like fonts, font sizes and other
parameter to make plots look prettier."""
sns.set_style('darkgrid')
plt.rcParams['mathtext.fontset'] = 'stix'
plt.rcParams['font.family'] = 'STIXGeneral'
plt.rcParams['font.size'] = 14
plt.rcParams['figure.figsize'] = (12, 6)
plt.rc("savefig", dpi=300)
plt.rc('figure', titlesize=16)
def mkdir_p(path):
"""Creates a directory in the specified path."""
def LinReg(training,
teacher,
train_len,
test_len,
delay,
washout=8000,
plot=0,
save=0):
#Y_input = narma_10_input[washout:train_len].ravel()
Y_train = teacher[washout:train_len].ravel()
Y_test = teacher[train_len:train_len + test_len].ravel()
#X_input=input_signal[set_number][0][washout+delay:train_len+delay]
X_train = training[washout + delay:train_len + delay]
X_test = training[train_len + delay:train_len + test_len + delay]
#X_nodes = nodes_list[set_number][washout+delay:train_len+delay]
scaler = preprocessing.StandardScaler().fit(X_train)
sX_train = scaler.transform(X_train)
sX_test = scaler.transform(X_test)
nscaler = preprocessing.MinMaxScaler(feature_range=(-1, 1)).fit(X_train)
nX_train = nscaler.transform(X_train)
nX_test = nscaler.transform(X_test)
norm_training = preprocessing.normalize(training, axis=0, norm='max')
norm_X_train = norm_training[washout + delay:train_len + delay]
norm_X_test = norm_training[train_len + delay:train_len + test_len + delay]
lm = linear_model.LinearRegression()
lm.fit(X_train, Y_train)
pred_train = lm.predict(X_train)
pred_test = lm.predict(X_test)
if plot == 1:
colors = np.vstack(
(cm.Blues(np.linspace(0.5, 1,
5)), cm.Greens(np.linspace(0.5, 1, 5)),
cm.Oranges(np.linspace(0.5, 1,
5)), cm.Reds(np.linspace(0.5, 1, 5))))
plt.figure()
for row, c in zip(X_train[2000:12000].T, colors):
plt.plot(range(2000, 12000), row, color=c, linewidth=2.5)
plt.xlabel("time (ms)")
plt.ylabel("spring lengths (m)")
#plt.plot(Y_train[2000:12000])
if save == 1:
plt.savefig("spring_lengths.png")
plt.figure()
plt.plot(range(2000, 12000), pred_test[:10000], linewidth=3.0)
plt.plot(range(2000, 12000), Y_test[:10000], 'r--', linewidth=2.5)
plt.xlabel("time (ms)")
plt.ylabel("y(t)/O(t)")
plt.legend(['system output', 'target output'])
if save == 1:
plt.savefig("spring_output.png")
slm = linear_model.LinearRegression()
slm.fit(sX_train, Y_train)
spred_train = slm.predict(sX_train)
spred_test = slm.predict(sX_test)
nlm = linear_model.LinearRegression()
nlm.fit(nX_train, Y_train)
npred_train = nlm.predict(nX_train)
npred_test = nlm.predict(nX_test)
norm_lm = linear_model.LinearRegression()
norm_lm.fit(norm_X_train, Y_train)
norm_pred_train = norm_lm.predict(norm_X_train)
norm_pred_test = norm_lm.predict(norm_X_test)
error = mean_squared_error(Y_test, pred_test)
serror = mean_squared_error(Y_test, spred_test)
nerror = mean_squared_error(Y_test, npred_test)
norm_error = mean_squared_error(Y_test, norm_pred_test)
#print(mean_squared_error(pred_test,Y_test))
coefs = [lm.coef_, slm.coef_, nlm.coef_, norm_lm.coef_]
errors = [error, serror, nerror, norm_error]
return coefs, errors
def how_long_within(start, nb_max_iter):
z0 = start
z = z0
for i in range(nb_max_iter):
if abs(z) > 2:
return i
z = z * z + z0
return nb_max_iter
MAX = 255
# COLORS = [(random.random(), random.random(), random.random()) for i in range(MAX+1)]
COLORS = [None] * 256
COLORS = [cm.Oranges(i)[0:3] for i in range(256)]
def mandelbrot_image_matrix(nb_pxls, start, radius):
mtrx = np.zeros((nb_pxls, nb_pxls, 3))
for i, row in enumerate(mtrx):
for j, pxl in enumerate(row):
x0 = start.real - (radius / 2) + (j * radius / nb_pxls)
y0 = start.imag - (radius / 2) + (i * radius / nb_pxls)
z0 = complex(x0, y0)
# gray = (MAX - how_long_within(z0, MAX))/MAX
# color = (gray, gray, gray)
index = MAX - how_long_within(z0, MAX)
color = COLORS[index]
mtrx[i, j] = color
return mtrx
detG2 = np.vectorize(_detG2)
#_detG=sy.lambdify([y1,y2,x11,x22],sy.det(G))
#detG=np.vectorize(_detG,excluded={0,1})
Xx1 = np.arange(-1, 1, 0.01)
Xx2 = np.arange(-1, 1, 0.01)
Yy = np.arange(-5, 5, 0.1)
mode = 1
if mode == 0:
X1, X2, Y1 = np.meshgrid(Xx1, Xx2, Yy)
fig = pl.figure()
axes = fig.add_subplot(111, projection='3d')
Z = detG2(Y1, X1, X2)
axes.scatter(X1, X2, Y1, facecolors=cm.Oranges(Z))
pl.plot()
X1, X2 = np.meshgrid(Xx1, Xx2)
fig, ax = pl.subplot(1)
if mode == 2:
X1, X2 = np.meshgrid(Xx1, Xx2)
fig, axes = pl.subplots(1, 1, sharex=True, sharey=True)
fig.subplots_adjust(hspace=0, wspace=0)
matplotlib.rcParams['contour.negative_linestyle'] = 'solid'
Z = np.arctan(detG3(1, 1, np.tan(np.pi / 2 * X1), np.tan(
np.pi / 2 * X2))) * 2 / np.pi
CS = axes.pcolormesh(X1, X2, Z)
CS2 = axes.contour(X1, X2, Z, colors='k')
print(m)
print("Accuracy: %s \n"%c)
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
# create some fake data
x = data['visibility']
y = data['wind']
# here are the x,y and respective z values
X, Y = np.meshgrid(x, y)
Z = np.sinc(np.sqrt(X*X+Y*Y))
# this is the value to use for the color
V = np.sin(Y)
# create the figure, add a 3d axis, set the viewing angle
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.view_init(45,60)
# here we create the surface plot, but pass V through a colormap
# to create a different color for each patch
ax.plot_surface(X, Y, Z, facecolors=cm.Oranges(V))
ax.set_xlabel('visibility')
ax.set_ylabel('wind')
plt.title('Space Shuttle Auto-Landing Control')
plt.show()
del geojson['properties']['city']
del geojson['properties']['fill']
geojson['properties']['category_distrib'] = list(cat_distr)
geojson['properties']['category_more'] = list(cat_distinct)
geojson['properties']['time_distrib'] = list(timeofday_distr)
geojson['properties']['time_more'] = list(timeofday_distinct)
geojson['properties']['days_distrib'] = list(dayofweek_distr)
geojson['properties']['days_more'] = list(dayofweek_distinct)
geojson['properties']['weight'] = float(theta)
neighborhoods.append(geojson)
neighborhoods.sort(key=lambda x: x['properties']['weight'], reverse=True)
a = pretty_floats({"type": "FeatureCollection", "features": neighborhoods})
cat_colors = [
cmlib.Oranges(x) for x in np.linspace(0, 1, len(main_cats_plot))
]
time_colors = [cmlib.Greens(x) for x in np.linspace(0, 1, len(timeOfDay))]
day_colors = [cmlib.Purples(x) for x in np.linspace(0, 1, len(dayOfWeek))]
# select top regions based on volume
MAX_REGIONS = args.max_regions
results = sorted(enumerate(a['features']),
key=lambda x: x[1]['properties']['weight'],
reverse=True)[:MAX_REGIONS]
with zipfile.ZipFile(city + '.zip', 'w') as myzip:
for region_id, res in results:
stats = res['properties']
fig, ax = plt.subplots(1, 4, figsize=(21, 6))
def plot_ed_log(full_df, save=True):
norm = mpl.colors.Normalize(vmin=0, vmax=3.75)
#FULL EIGENPROPERTIES and EIGENVALUES
av_df = pd.read_pickle('analysis/av_sorted_ed_log_og_d.pickle')
#av_df = pd.read_pickle('analysis/av_ed_log_d.pickle')
## TO GET NICE FORMATTING
g = sns.FacetGrid(av_df, col='model', col_wrap=3, hue='Sz')
limits = [(0.5, 2.5), (2.5, 4.5), (1.5, 4.5), (0.5, 2.5), (1.5, 4.5),
(0, 1.5), (-1.0, 1.5), (-1.5, 1.5), (-1.5, 1.5), (-1.5, 1.5),
(-1, 1), (-0.5, 1.0)]
for model in np.arange(32):
for beta in [0.0, 1.0, 2.0]:
rgba_color = cm.Blues(norm(3.75 - beta))
rgba_color2 = cm.Oranges(norm(3.75 - beta))
z = -1
fig, axes = plt.subplots(nrows=2,
ncols=6,
sharey=True,
figsize=(12, 6))
for parm in [
'iao_n_3dz2', 'iao_n_3dpi', 'iao_n_3dd', 'iao_n_2pz',
'iao_n_2ppi', 'iao_n_4s', 'iao_t_pi', 'iao_t_ds',
'iao_t_dz', 'iao_t_sz', 'iao_Jsd', 'iao_Us'
]:
z += 1
ax = axes[z // 6, z % 6]
p = parm
if (parm == 'iao_Jsd'): p = 'Jsd'
if (parm == 'iao_Us'): p = 'Us'
full_df['energy'] -= min(full_df['energy'])
full_df = full_df[full_df['basestate'] == -1]
f_df = full_df[full_df['Sz'] == 0.5]
x = f_df[p].values
y = f_df['energy'].values
yerr = f_df['energy_err'].values
ax.errorbar(x, y, yerr, fmt='s', c=rgba_color, alpha=0.5)
f_df = full_df[full_df['Sz'] == 1.5]
x = f_df[p].values
y = f_df['energy'].values
yerr = f_df['energy_err'].values
ax.errorbar(x, y, yerr, fmt='s', c=rgba_color2, alpha=0.5)
sub_df = av_df[(av_df['model'] == model) & (av_df['Sz'] == 0.5)
& (av_df['beta'] == beta)]
x = sub_df[parm].values
xerr_u = sub_df[parm + '_u'].values
xerr_d = sub_df[parm + '_l'].values
y = sub_df['energy'].values
yerr_u = sub_df['energy_u'].values
yerr_d = sub_df['energy_l'].values
ax.errorbar(x,
y,
xerr=[xerr_d, xerr_u],
yerr=[yerr_d, yerr_u],
markeredgecolor='k',
fmt='o',
c=rgba_color)
sub_df = av_df[(av_df['model'] == model) & (av_df['Sz'] == 1.5)
& (av_df['beta'] == beta)]
x = sub_df[parm].values
xerr_u = sub_df[parm + '_u'].values
xerr_d = sub_df[parm + '_l'].values
y = sub_df['energy'].values
yerr_u = sub_df['energy_u'].values
yerr_d = sub_df['energy_l'].values
ax.errorbar(x,
y,
xerr=[xerr_d, xerr_u],
yerr=[yerr_d, yerr_u],
markeredgecolor='k',
fmt='o',
c=rgba_color2)
ax.set_ylim((-0.2, 6.0))
ax.set_xlabel(parm)
ax.set_ylabel('energy (eV)')
ax.set_xlim(limits[z])
if (save):
plt.savefig('analysis/sorted_ed_' + str(model) + '_' +
str(beta) + '_log_og.pdf',
bbox_inches='tight')
else:
plt.show()
plt.clf()
'''
# ys = [[j[0], j[1]] for j in y]
# ys = list(zip(*ys))
# min_y, max_y = min(ys[1]), max(ys[1])
# min_x, max_x = min(ys[0]), max(ys[0])
# pdb.set_trace()
if args.dists:
dists = torch.norm(z - x, dim=1)
ax.plot(dists)
else:
# plot actual goal points
n_pts = y.shape[0]
goal_colors = iter(cm.Oranges(np.linspace(.2, 1, n_pts)))
for j in range(n_pts):
ax.scatter(y[j][0],
y[j][1],
color=next(goal_colors),
s=144)
ax.annotate(j + 1, (y[j][0], y[j][1]),
ha='center',
va='center')
# plot potential
if config.goals_potential != 'none':
p_lim = 15
px = np.outer(np.linspace(-p_lim, p_lim, 100),
np.ones(100))
py = px.copy().T
