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 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 plotting(sim_context1,sim_context2,diff,data_df,total_samples):
plt.plot(sim_context1,label="Context 1")
plt.plot(sim_context2,label="Context 2")
x_labels_word1 = data_df["word1"]
x_labels_word2 = data_df["word2"]
xlabels = [0] * total_samples
xticks_x = [0] * total_samples
for wp in range (total_samples):
xlabels[wp] = x_labels_word1[wp]+ "\n"+x_labels_word2[wp]
xticks_x[wp] = wp+1
plt.plot(diff,label="Difference")
plt.legend(loc='center right')
# Add title and x, y labels
plt.title("Elmo Embedding Model Results", fontsize=16, fontweight='bold')
plt.xlabel("Word")
plt.ylabel("Similarity")
plt.xticks(xticks_x, xlabels)
plt.show()
def calibration_plot(prob, ytest):
# stolen from stackoverflow!
outcome = ytest
data = pd.DataFrame(dict(prob=prob, outcome=outcome))
#group outcomes into bins of similar probability
bins = np.linspace(0, 1, 20)
cuts = pd.cut(prob, bins)
binwidth = bins[1] - bins[0]
#freshness ratio and number of examples in each bin
cal = data.groupby(cuts).outcome.agg(['mean', 'count'])
cal['pmid'] = (bins[:-1] + bins[1:]) / 2
cal['sig'] = np.sqrt(cal.pmid * (1 - cal.pmid) / cal['count'])
#the calibration plot
ax = plt.subplot2grid((3, 1), (0, 0), rowspan=2)
p = plt.errorbar(cal.pmid, cal['mean'], cal['sig'])
plt.plot(cal.pmid, cal.pmid, linestyle='--', lw=1, color='k')
plt.ylabel("Empirical P(Product)")
#the distribution of P(fresh)
ax = plt.subplot2grid((3, 1), (2, 0), sharex=ax)
plt.bar(left=cal.pmid - binwidth / 2, height=cal['count'],
width=.95 * (bins[1] - bins[0]),
fc=p[0].get_color())
plt.xlabel("Predicted P(Product)")
plt.ylabel("Number")
def getGraph():
for i, clf in enumerate((svm, rbf_svc, rbf_svc_tunning)):
# Se grafican las fronteras
plt.subplot(2, 2, i + 1)
plt.subplots_adjust(wspace=0.4, hspace=0.4)
Z = clf.predict(np.c_[x_matrizSetEntrenamientoVect, y_clases])
#Color en las gráficas
Z = Z.reshape(x_matrizSetEntrenamientoVect.shape)
plt.contourf(x_matrizSetEntrenamientoVect,
y_clases,
Z,
cmap=plt.cm.Paired,
alpha=0.8)
#Puntos de entrenamiento
plt.scatter(x_matrizSetEntrenamientoVect[:, 0],
x_matrizSetEntrenamientoVect[:, 1],
c=y_clases,
cmap=plt.cm.Paired)
plt.xlabel('Longitud Sepal')
plt.ylabel('Peso Sepal')
plt.xlim(x_matrizSetEntrenamientoVect.min(),
x_matrizSetEntrenamientoVect.max())
plt.ylim(y_clases.min(), y_clases.max())
plt.xticks(())
plt.yticks(())
plt.title(titles[i])
plt.show()
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 plot_single(df_metrics):
"""
APFD plot for single Embedding Neural Network model
:param df_metrics:
:return:
"""
apfd = df_metrics['apfd']
miu = np.round(np.mean(apfd), 2)
sigma = np.round(np.std(apfd), 2)
label = 'regression' + '\n $\mu$ - ' + str(miu) + ' $\sigma$ - ' + str(
sigma)
sns.distplot(apfd,
kde=True,
bins=int(180 / 5),
color=sns.color_palette()[0],
hist_kws={'edgecolor': 'black'},
kde_kws={
'linewidth': 4,
'clip': (0.0, 1.0)
},
label=label)
plt.legend(frameon=True, loc='upper left', prop={'size': 20})
plt.xlabel('APFD')
#plt.title('APFD Distribution - 100 revisions ')
plt.show()
def show(self, w):
"""
illustrate the learning curve
Parameters
----------
w : int, window size for smoothing the curve
"""
# plot data
plt.subplot(121)
plt.plot(self.tn_it, self.tn_err, 'b.', alpha=0.2)
plt.plot(self.tt_it, self.tt_err, 'r.', alpha=0.2)
# plot smoothed line
xne,yne = self._smooth( self.tn_it, self.tn_err, w )
xte,yte = self._smooth( self.tt_it, self.tt_err, w )
plt.plot(xne, yne, 'b')
plt.plot(xte, yte, 'r')
plt.xlabel('iteration'), plt.ylabel('cost energy')
plt.subplot(122)
plt.plot(self.tn_it, self.tn_cls, 'b.', alpha=0.2)
plt.plot(self.tt_it, self.tt_cls, 'r.', alpha=0.2)
# plot smoothed line
xnc, ync = self._smooth( self.tn_it, self.tn_cls, w )
xtc, ytc = self._smooth( self.tt_it, self.tt_cls, w )
plt.plot(xnc, ync, 'b', label='train')
plt.plot(xtc, ytc, 'r', label='test')
plt.xlabel('iteration'), plt.ylabel( 'classification error' )
plt.legend()
plt.show()
return
def plot_histogram(entries):
n, bins, patches = plt.hist(entries.values(), 50, normed=1, facecolor='green', alpha=0.75)
plt.xlabel('Time (h)')
plt.ylabel('Probability')
plt.grid(True)
plt.show()
def show(self, w):
"""
illustrate the learning curve
Parameters
----------
w : int, window size for smoothing the curve
"""
# plot data
plt.subplot(121)
plt.plot(self.tn_it, self.tn_err, 'b.', alpha=0.2)
plt.plot(self.tt_it, self.tt_err, 'r.', alpha=0.2)
# plot smoothed line
xne, yne = self._smooth(self.tn_it, self.tn_err, w)
xte, yte = self._smooth(self.tt_it, self.tt_err, w)
plt.plot(xne, yne, 'b')
plt.plot(xte, yte, 'r')
plt.xlabel('iteration'), plt.ylabel('cost energy')
plt.subplot(122)
plt.plot(self.tn_it, self.tn_cls, 'b.', alpha=0.2)
plt.plot(self.tt_it, self.tt_cls, 'r.', alpha=0.2)
# plot smoothed line
xnc, ync = self._smooth(self.tn_it, self.tn_cls, w)
xtc, ytc = self._smooth(self.tt_it, self.tt_cls, w)
plt.plot(xnc, ync, 'b', label='train')
plt.plot(xtc, ytc, 'r', label='test')
plt.xlabel('iteration'), plt.ylabel('classification error')
plt.legend()
plt.show()
return
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 plot_error(self, train_errors):
n = len(train_errors)
training, = plt.plot(range(n), train_errors, label="Training Error")
plt.legend(handles=[training])
plt.title("Error Plot")
plt.ylabel('Error')
plt.xlabel('Iterations')
plt.show()
def plot_accuracy(self, train_acc, test_acc):
n = len(train_acc)
plt.plot(range(n), train_acc, label="train")
plt.plot(range(n), test_acc, label="test")
plt.legend(loc='lower right')
plt.title("Overfit")
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.show()
def Test2():
t = np.linspace(0,10,100)
x = np.sin(t)
plt.plot(t, x)
plt.title('sin(x)')
plt.xlabel('time (s)')
plt.ylabel('magnitude')
plt.show()
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)
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)
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_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 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()
def multiplot_gen_property_type():
#
# font = {'family': 'Liberation Serif',
# 'weight': 'normal',
# 'size': 15
# }
#
# # play around with the font size if it is too big or small
# matplotlib.rcParams['axes.titlesize'] = 12
# matplotlib.rcParams['axes.labelsize'] = 12
# matplotlib.rc('font', **font)
# # matplotlib.rcParams['text.usetex'] = True
# matplotlib.rcParams['pdf.fonttype'] = 42
# matplotlib.rcParams['pdf.use14corefonts'] = True
x = list(data.keys())
y1=[]
y2=[]
y3=[]
y4=[]
y5=[]
y6=[]
for year in data.keys():
for option_name, count in data[year].items():
if option_name == 'domain':
y1.append(count)
if option_name == 'sitekey':
y2.append(count)
if option_name == 'third-party':
y3.append(count)
if option_name == 'websocket':
y4.append(count)
if option_name == 'webrtc':
y5.append(count)
if option_name == 'csp':
y6.append(count)
plt.plot(x, y1,'-o',label='domain')
plt.plot(x, y2,'-v',label='sitekey')
plt.plot(x, y3,'-^',label='third-party')
plt.plot(x, y4,'-<',label='websocket')
plt.plot(x, y5,'->',label='webrtc')
plt.plot(x, y6,'-1',label='csp')
plt.xticks(rotation='vertical')
plt.xlabel('Year')
plt.ylabel('Count')
plt.legend(ncol=2)
plt.tight_layout()
plt.savefig('easylist-property-type.pdf ', format='pdf', dpi=1200)
def plot_histogram(entries):
n, bins, patches = plt.hist(entries.values(),
50,
normed=1,
facecolor='green',
alpha=0.75)
plt.xlabel('Time (h)')
plt.ylabel('Probability')
plt.grid(True)
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 plot(data, fname):
plt.clf()
width = 10
data = np.array(data)
bins = np.arange(0, max(data), step=width)
sns.distplot(data, norm_hist=True, kde=True, bins=bins, label='No ones')
plt.ylim((0, 0.001))
plt.xlabel('First passage time (ps)')
plt.text(
1000, 0.0005,
'MFPT = {0:4.2f} +/- {1:4.2f} ps'.format(data.mean(), 2 * data.std()))
plt.savefig(fname, transparanet=True)
def plot_graph(self, auroc_results, y_label: str):
for ad_key, ad_label in AD_NAMES.items():
plt.plot(self.x_axis,
numpy.asarray(auroc_results[ad_key], ),
label=ad_label)
plt.legend(loc='lower left')
plt.xlabel(self.x_axis_label)
plt.ylabel(ylabel=y_label)
to_print = plt.gcf()
plt.show()
file_name_with_metric = y_label + "-" + self.file_name
to_print.savefig(file_name_with_metric, bbox_inches='tight')
def _build_plot_static(self, metric_group):
metrics = self.get_metrics_history()
if metric_group not in metrics:
raise ValueError("can't find metric group")
for name, values in metrics[metric_group].items():
plt.plot(values, label=name)
plt.legend(loc='best')
plt.title(metric_group, fontsize=16, fontweight='bold')
plt.xlabel("Generations")
plt.show()
return None
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()
def random_tensor(shape=None,
sparsity=0.5,
seed=1234,
distributed='normal',
normal=None,
uniform=None,
plot=True):
np.random.seed(seed)
tensor_size = prod(shape)
if distributed == 'normal':
mean, std = normal
data = np.random.normal(mean, std, tensor_size)
if plot == True:
n, bins, patches = plt.hist(data,
30,
normed=True,
facecolor='blue',
alpha=0.5)
y = mlab.normpdf(bins, mean, std)
plt.plot(bins, y, 'r--')
plt.xlabel('Expectation')
plt.ylabel('Probability')
plt.title('Histogram of Normal Distribution:$\mu =' + str(mean) +
'$, $\sigma=' + str(std) + '$')
plt.axvline(norm.ppf(sparsity) * std + mean)
plt.show()
data[data <= norm.ppf(sparsity) * std + mean] = 0
if distributed == 'uniform':
low, high = uniform
data = np.random.uniform(low, high, size=tensor_size)
if plot == True:
n, bins, patches = plt.hist(data,
30,
normed=True,
facecolor='blue',
alpha=0.5)
plt.xlabel('Expectation')
plt.ylabel('Probability')
plt.title('Histogram of Uniform Distribution:$low =' + str(low) +
'$, $high =' + str(high) + '$')
plt.axvline((high - low) * sparsity)
plt.show()
data[data <= (high - low) * sparsity] = 0
return tensor(data.reshape(shape))
def plot_average(collected_results, versions, args, plot_std=True):
test_type = args.test_type
model_name = args.model
means, stds = [], []
for version in versions:
data = collected_results[version]
if (plot_std):
means.append(np.mean(data))
stds.append(np.std(data))
else:
means.append(data)
means = np.array(means)
stds = np.array(stds)
if (test_type == "size" or test_type == "allsize"):
x = ["0%", "20%", "40%", "60%", "80%", "100%"]
elif (test_type == "accdomain" or test_type == "moredomain"):
x = [0, 1, 2, 3, 4]
else:
x = versions
color = 'blue'
plt.plot(x, means, color=color)
if (plot_std):
plt.fill_between(x,
means - stds,
means + stds,
alpha=0.1,
edgecolor=color,
facecolor=color,
linewidth=1,
antialiased=True)
plt.xticks(np.arange(len(x)), x, fontsize=18)
plt.yticks(fontsize=18)
plt.xlabel(XLABELS[test_type], fontsize=18)
plt.ylabel('average absolute effect size', fontsize=18)
plt.title("Influence of {} on bias removal \nfor {}".format(
TITLES[test_type], MODEL_FORMAL_NAMES[model_name]),
fontsize=18)
plt.tight_layout()
plot_path = os.path.join(
args.eval_results_dir, "plots",
"{}-{}-avg{}.png".format(model_name, test_type,
"-std" if plot_std else ""))
plt.savefig(plot_path)
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 saveMagPhasePlot(self, t, x, filename):
mag = absolute(x).astype('float')
phase = angle(x).astype('float')
plt.subplot(211)
plt.plot(t, mag)
plt.ylabel('Magitude')
plt.title('SSPF Sequence')
plt.grid(True)
plt.subplot(212)
plt.plot(t, phase)
plt.xlabel('Off-Resonance (Hz)')
plt.ylabel('Phase')
plt.grid(True)
plt.savefig(filename)
def showMagPhasePlot(self, t, x):
mag = absolute(x)
phase = angle(x)
plt.subplot(211)
plt.plot(t, mag)
plt.ylabel('Magitude')
plt.title('SSPF Sequence')
plt.grid(True)
plt.subplot(212)
plt.plot(t, phase)
plt.xlabel('Off-Resonance (Hz)')
plt.ylabel('Phase')
plt.grid(True)
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 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 display_populations(self,
top_k=10,
max_chromosome_len=1024,
rounding=None):
for pop_idx, population in enumerate(self._populations):
num_chromosomes = min(len(population), top_k)
heatmap = []
gene_max = 0
for cidx, chromosome in enumerate(population):
genes = []
for gene in chromosome[:max_chromosome_len]:
if isinstance(rounding, type(None)):
genes.append(str(gene))
elif rounding > 0:
genes.append(round(float(gene), rounding))
else:
genes.append(int(gene))
gene_max = max(gene_max, gene)
heatmap.append(genes)
if cidx > num_chromosomes:
break
fig, ax = plt.subplots()
im = ax.imshow(heatmap,
interpolation='nearest',
cmap="viridis",
aspect='auto')
# gradient bar
cbar = ax.figure.colorbar(im, ax=ax)
cbar.ax.set_ylabel('Gene value', rotation=-90, va="bottom")
plt.title(f'Population - top {num_chromosomes}',
fontsize=16,
fontweight='bold')
plt.xlabel("Genes")
plt.ylabel("Chromosome")
# fig.tight_layout()
plt.show()
def print_all_results(collected_results, versions, args):
test_type = args.test_type
model_name = args.model
for test_name in collected_results:
test_results = collected_results[test_name]
x, y = [], []
for version in versions:
if (version in test_results):
x.append(version)
y.append(test_results[version]['mean'])
plt.plot(x, y, label=test_name)
plt.xticks(np.arange(len(x)), x)
plt.xlabel(XLABELS[test_type])
plt.ylabel('average absolute effect size')
plt.legend(loc='best')
plt.title("SEAT effect sizes on {} with {}".format(model_name,
TITLES[test_type]))
plot_path = os.path.join(args.eval_results_dir, "plots",
"{}-{}.png".format(model_name, test_type))
plt.savefig(plot_path)
def getGraph():
for i, clf in enumerate((svm, rbf_svc, rbf_svc_tunning)):
# Se grafican las fronteras
plt.subplot(2, 2, i + 1)
plt.subplots_adjust(wspace=0.4, hspace=0.4)
Z = clf.predict(np.c_[x_matrizSetEntrenamientoVect, y_clases])
#Color en las gráficas
Z = Z.reshape(x_matrizSetEntrenamientoVect.shape)
plt.contourf(x_matrizSetEntrenamientoVect, y_clases, Z, cmap=plt.cm.Paired, alpha=0.8)
#Puntos de entrenamiento
plt.scatter(x_matrizSetEntrenamientoVect[:, 0], x_matrizSetEntrenamientoVect[:, 1], c=y_clases, cmap=plt.cm.Paired)
plt.xlabel('Longitud Sepal')
plt.ylabel('Peso Sepal')
plt.xlim(x_matrizSetEntrenamientoVect.min(), x_matrizSetEntrenamientoVect.max())
plt.ylim(y_clases.min(), y_clases.max())
plt.xticks(())
plt.yticks(())
plt.title(titles[i])
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()))
allY = []
for file_name in args.files:
Y = []
with open(file_name) as fp:
for idx, line in enumerate(fp):
if len(Y) > args.size:
break
if args.type == 'epoch':
if 'Epoch' not in line:
continue
else:
if 'Episode' not in line:
continue
Y.append(float(line.split(' ')[-1][:-1]))
allY.append(Y)
fig = plt.figure()
ax = plt.subplot(111)
plt.xlabel('epochs' if args.type == 'epoch' else 'episodes')
plt.ylabel('reward per epoch' if args.type == 'epoch' else 'reward per episode')
for idx, Y in enumerate(allY):
ax.plot(Y, label=LABELS[idx])
plt.title('Instruction following learning performance one hot')
ax.legend(loc='upper center', shadow=True, ncol=2)
# plt.legend()
plt.show()
test_scores_std = np.std(test_scores, axis=1)
plt.grid()
plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
train_scores_mean + train_scores_std, alpha=0.1,
color="r")
plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
test_scores_mean + test_scores_std, alpha=0.1, color="g")
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)
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')
plt.figure()
plt.scatter(result['g_auto'] - result['u_auto'], result['g_auto'] - result['r_auto'], s=10, c='gray', edgecolor='none', alpha = 0.5)
plt.scatter(subset['g_auto'] - subset['u_auto'], subset['g_auto'] - subset['r_auto'], s=20, c='blue', edgecolor='none')
BergondGCs = Bergond[Bergond['Type'] =='gc']
BergondGCs[['RAJ2000', 'DEJ2000']].to_csv('/Volumes/VINCE/OAC/imaging/BergondGCs_RADEC.reg', index = False, sep =' ', header = None)
cat1 = coords.SkyCoord(GCs['RA_g'], GCs['DEC_g'], unit=(u.degree, u.degree))
cat2 = coords.SkyCoord(BergondGCs['RAJ2000'], BergondGCs['DEJ2000'], unit=(u.degree, u.degree))
index,dist2d, _ = cat1.match_to_catalog_sky(cat2)
mask = dist2d.arcsec < 0.3
new_idx = index[mask]
VIMOS = GCs.ix[mask].reset_index(drop = True)
BergondMatch = BergondGCs.ix[new_idx].reset_index(drop = True)
print len(BergondMatch)
x = VIMOS['VREL_helio']
xerr = VIMOS['VERR']
y = BergondMatch['HRV']
yerr = BergondMatch['e_HRV']
plt.errorbar(x, y, yerr= yerr, xerr = xerr, fmt = 'o', c ='red',label = 'Bergond et al.')
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.xlabel(r'Velocity from this work [km s$^-1$ ]')
plt.ylabel(r'Velocity from the literature [km s$^-1$ ]')
plt.legend(loc = 'upper left')
plt.tight_layout()
plt.show()
print 'rms (VIMOS - Bergond) GCs = ', np.std(x-y)
df_di_produce["mon_int"] = df_di_produce.apply(report_month, axis=1, date_col="date")
df_di_produce.index = df_di_produce["date"]
df_di_produce_summer = df_di_produce[
(df_di_produce["mon_int"] >= 1) & (df_di_produce["mon_int"] <= 12)
] # just get June - August for each year
print(df_di_produce_summer)
grouper_year = pd.TimeGrouper("A")
df_avg = df_di_produce_summer.groupby(grouper_year).mean()
df_avg["year"] = df_avg.index.year
df_avg["year_str"] = df_avg.apply(year_str, axis=1, year_col="year")
pertinent_columns = ["Lemons Avg Price", "Navel_Oranges Avg Price", "Lettuce Avg Price", di_str, "year_str"]
df_summer_avg = df_avg[pertinent_columns]
df_summer_avg.plot(
kind="scatter",
y=["Lemons Avg Price", "Navel_Oranges Avg Price", "Lettuce Avg Price"],
x=[di_str] * 3,
color=["blue", "red", "green"],
label=["lemon", "orange", "lettuce"],
)
title = "Produce Price vs Percent Severe Drought"
plt.xlabel("Percent of CA experiencing severe drought")
plt.ylabel("Price (USD/lb)")
plt.legend(loc="best")
plt.title(title)
fig = gcf()
fig.set_size_inches(18.5, 14.5)
plot_name = "price_vs_drought_index"
figure_name = "plots/{0}.png".format(plot_name)
fig.savefig(figure_name)
df_summer_avg.to_csv("data/ca_price_vs_pct_severe_di.csv", index=False)
def drawErrorPlot(self, error_list):
plt.xlim(0, len(error_list))
plt.xlabel('Squared Error')
plt.plot(error_list)
plt.show()
t_tuple = (TOMATOES, 'tomatoes')
lemon_tuple = (LEMONS, 'lemons')
tuple_list = [o_tuple, g_tuple, b_tuple, s_tuple, lettuce_tuple, t_tuple, lemon_tuple]
csv_paths = []
for produce_tuple in tuple_list:
filepath, produce_item = produce_tuple
csv_path = 'data\\produce\\{0}.csv'.format(produce_item)
csv_paths.append((csv_path, produce_item))
excel_to_csv(filepath, csv_path)
dfs = {}
for csv_tuple in csv_paths:
csv_path, produce_item = csv_tuple
df = pd.read_csv(csv_path, sep=',', quotechar='"', skiprows=8, header=0, index_col=0)
df1 = df.loc[2010:]
dfs[produce_item] = df1
for key in dfs:
produce_df = dfs[key]
produce_df_stacked = produce_df.stack()
produce_df_stacked.plot(kind='bar', color='c')
title = '{0} CPI'.format(key)
y_label = '{0} Average Price/lb'.format(key)
x_label = 'Month'
plt.title(title)
plt.ylabel(y_label)
plt.xlabel(x_label)
fig = gcf()
fig.set_size_inches(18.5, 14.5)
figure_name = 'plots\\{0}.png'.format(key)
fig.savefig(figure_name)
#V:Python 3.6.3
import pandas as pd
from IPython.display import display
from matplotlib.pylab import plt
data = pd.read_csv('house3.csv')
data['total_price'] = data['price'] * data['area'] / 10000
data_mean = data.groupby('district')['price'].mean()
data_count = data.groupby('district')['price'].count()
#柱状图分析各区的二手房的房价
plt.figure(figsize=(10, 6))
plt.rc('font', family='SimHei', size=13)
plt.title(u'各区域的平均二手房房价')
plt.xlabel(u'南京城区')
plt.ylabel(u'平均房价')
plt.bar(data_mean.index, data_count.values, color='g')
plt.show()
plt.figure(figsize=(10, 10))
plt.rc('font', family='SimHei', size=13)
explode = [0] * len(data_count)
explode[9] = 0.1
plt.pie(data_count,
radius=2,
autopct='%1.f%%',
shadow=True,
labels=data_mean.index,
explode=explode)
plt.axis('equal')
def show(self, w):
"""
illustrate the learning curve
Parameters
----------
w : int, window size for smoothing the curve
"""
if len(self.tn_mc) > 0:
# malis training, increase number of subplots
nsp = 5
else:
nsp = 3
# print the maximum iteration
self.print_max_update()
# using K as iteration unit
tn_it = self.tn_it
for i in xrange(len(tn_it)):
tn_it[i] = tn_it[i] / float(1000)
tt_it = self.tt_it
for i in xrange(len(tt_it)):
tt_it[i] = tt_it[i] / float(1000)
# plot data
plt.subplot(1,nsp, 1)
plt.plot(tn_it, self.tn_err, 'b.', alpha=0.2)
plt.plot(tt_it, self.tt_err, 'r.', alpha=0.2)
# plot smoothed line
xne,yne = self._smooth( tn_it, self.tn_err, w )
xte,yte = self._smooth( tt_it, self.tt_err, w )
plt.plot(xne, yne, 'b')
plt.plot(xte, yte, 'r')
plt.xlabel('iteration (K)'), plt.ylabel('cost energy')
plt.subplot(1,nsp,2)
plt.plot(tn_it, self.tn_cls, 'b.', alpha=0.2)
plt.plot(tt_it, self.tt_cls, 'r.', alpha=0.2)
# plot smoothed line
xnc, ync = self._smooth( tn_it, self.tn_cls, w )
xtc, ytc = self._smooth( tt_it, self.tt_cls, w )
plt.plot(xnc, ync, 'b', label='train')
plt.plot(xtc, ytc, 'r', label='test')
plt.xlabel('iteration (K)'), plt.ylabel( 'classification error' )
if len(tn_it) == len( self.tn_re ):
plt.subplot(1, nsp, 3)
plt.plot(tn_it, self.tn_re, 'b.', alpha=0.2)
plt.plot(tt_it, self.tt_re, 'r.', alpha=0.2)
# plot smoothed line
xnr, ynr = self._smooth( tn_it, self.tn_re, w )
xtr, ytr = self._smooth( tt_it, self.tt_re, w )
plt.plot(xnr, ynr, 'b', label='train')
plt.plot(xtr, ytr, 'r', label='test')
plt.xlabel('iteration (K)'), plt.ylabel( 'rand error' )
if len(tn_it) == len( self.tn_mc ):
plt.subplot(1, nsp, 4)
plt.plot(tn_it, self.tn_mc, 'b.', alpha=0.2)
plt.plot(tt_it, self.tt_mc, 'r.', alpha=0.2)
# plot smoothed line
xnm, ynm = self._smooth( tn_it, self.tn_mc, w )
xtm, ytm = self._smooth( tt_it, self.tt_mc, w )
plt.plot(xnm, ynm, 'b', label='train')
plt.plot(xtm, ytm, 'r', label='test')
plt.xlabel('iteration (K)'), plt.ylabel( 'malis weighted cost energy' )
if len(tn_it) == len( self.tn_me ):
plt.subplot(1, nsp, 5)
plt.plot(tn_it, self.tn_me, 'b.', alpha=0.2)
plt.plot(tt_it, self.tt_me, 'r.', alpha=0.2)
# plot smoothed line
xng, yng = self._smooth( tn_it, self.tn_me, w )
xtg, ytg = self._smooth( tt_it, self.tt_me, w )
plt.plot(xng, yng, 'b', label='train')
plt.plot(xtg, ytg, 'r', label='test')
plt.xlabel('iteration (K)'), plt.ylabel( 'malis weighted pixel error' )
plt.legend()
plt.show()
return
# create the integrator object
ta = hy.taylor_adaptive(
# The ODEs.
[(x, dxdt), (y, dydt), (z, dzdt), (px, dpxdt), (py, dpydt), (pz, dpzdt)],
# The initial conditions.
[-0.45, 0.80, 0.00, -0.80, -0.45, 0.58],
# Operate below machine precision
# and in high-accuracy mode.
tol=1e-18,
high_accuracy=True)
# integrate the RTBP up to time unit
t_grid = np.linspace(0, 200, 2500)
out = ta.propagate_grid(t_grid)
print(out)
# plot
from matplotlib.pylab import plt
plt.rcParams["figure.figsize"] = (12, 6)
plt.subplot(1, 2, 1)
plt.plot(out[4][:, 0], out[4][:, 1])
plt.xlabel("x")
plt.ylabel("y")
plt.subplot(1, 2, 2)
plt.plot(out[4][:, 0], out[4][:, 2])
plt.xlabel("x")
plt.ylabel("z")
plt.show()
xls_date = xlrd.xldate_as_tuple(float(index_name), 0)
year, month, day, hour, minute, second = xls_date
py_datetime = datetime.datetime(year, month, day, hour, minute, second)
datetime_str = py_datetime.strftime('%b-%Y')
return datetime_str
emp_data_dir_2013 = 'data/emp_data_2008_2014'
emp_files = get_files_in_directory(emp_data_dir_2013, '.csv')
df_list = []
for csv_file in emp_files:
pathname = csv_file[0]
ag_row, header_row = get_csv_row_number(pathname, 'TOTAL AGRICULTURAL')
df = pd.read_csv(pathname, sep=',', quotechar='"', skiprows=header_row-1, index_col=1, header=0)
df_list.append(df)
pertinent_dfs = []
for df in df_list:
columns_not_of_interest = ['NAICS CODES', 'TITLE']
df_columns = list(df.columns.values)
column_list = [column for column in df_columns if column not in columns_not_of_interest]
df_pert_dirty = df[column_list]
df_clean = df_pert_dirty.loc['TOTAL AGRICULTURAL', :]
df_clean_reindex = df_clean.rename(rename_index)
print(df_clean_reindex)
pertinent_dfs.append(df_clean_reindex)
s_concat = pd.concat(pertinent_dfs)
s_concat.plot(kind='bar')
plt.title('CA Agricultural Employment')
plt.xlabel('Month')
plt.ylabel('Agricultural Employment')
plt.show()