def plot_horizontal_bar_from_cm(confusion_matrix = None, classes = []):
# plt.rcdefaults()
# plt.subplots(figsize = (10, 30))
width = 0.30
# Example data
y_lables = 12 * ['a', 'b', 'c', 'd']
y_pos = list(range(len(y_lables)))
print(y_pos)
true_positives = 12 * [8.84036186, 12.94095337, 11.19919226, 10.64395389]
false_negatives = 12 * [1, 1, 1, 1]
false_positives = 12 * [2, 13, 13, 3]
TP = plt.barh(y_pos, true_positives, width, color = 'green', label = 'TP')
FN = plt.barh(y_pos, false_negatives, width, label = 'FN', left = TP)
plt.barh(y_pos, false_positives, width, label = 'FP', left = FN)
# ax.barh([p + width for p in y_pos], false_negatives, width, label = 'FN')
# ax.barh([p + width * 2 for p in y_pos], false_positives, width, label = 'FP')
plt.set_yticks([p + 1.5 * width for p in y_pos])
plt.set_yticklabels(y_lables)
plt.invert_yaxis() # labels read top-to-bottom
plt.set_xlabel('Performance')
plt.set_title('How fast do you want to go today?')
plt.legend(['TP', 'FN', 'FP'], loc = 'upper right')
plt.show()
def label(plt, xlabel):
rng = np.arange(122.7, 123.5, 0.1)
plt.set_ylim(rng[0], rng[-1])
plt.set_yticks(rng, ["%.1f" for i in rng])
plt.set_xlabel(xlabel)
plt.set_ylabel("Convertible Bond Price")
plt.legend(["Binomial", "FDE - Implicit", "FDE - Crank-Nicolson", "FDE - Penalty"],
prop={"size": "small"})
def plot_barcode(vertices, edges = None, plt = plt, N_s = 50, k=4, r=.6, w=.5, annotate = False, triangulation='rips4'): vertices, tangents, curve, edges, simplices = hm.get_all(vertices, N_s, k, w, r, triangulation=triangulation, edges=edges) if edges is None: edges = _edges simplices = hm.get_ordered_simplices(vertices, curve, edges) barcode = bc.get_barcode(simplices, degree_values=curve[np.argsort(curve)]) plot_barcode_gant(barcode, plt = plt, annotate = annotate) try: plt.set_yticks([]) except: plt.gca().set_yticks([])
def plot_confusion_matrix(cm, fig, counter, num_plots, title='Confusion matrix', cmap=plt.cm.Blues):
ax = fig.add_subplot(1, num_plots, counter+1)
ax.imshow(cm, interpolation='nearest', cmap=cmap)
ax.set_title(title)
tick_marks = np.arange(len(np.unique(test_labels_df['cat'])))
plt.set_xticks(tick_marks, np.unique(test_labels_df['cat']), rotation=45)
plt.set_yticks(tick_marks, np.unique(test_labels_df['cat']))
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
def plot_confusion_matrix(cm, fig, counter, num_plots, title='Confusion matrix', cmap=plt.cm.Blues):
ax = fig.add_subplot(1, num_plots, counter+1)
ax.imshow(cm, interpolation='nearest', cmap=cmap)
ax.set_title(title)
tick_marks = np.arange(len(np.unique(test_labels_df['cat'])))
plt.set_xticks(tick_marks, np.unique(test_labels_df['cat']), rotation=45)
plt.set_yticks(tick_marks, np.unique(test_labels_df['cat']))
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
def plotstft(plt,
samples,
samplerate,
binsize=2**10,
plotpath=None,
colormap="jet"):
s = stft(samples, binsize)
sshow, freq = logscale_spec(s, factor=1.0, sr=samplerate)
ims = 20. * np.log10(np.abs(sshow) / 10e-6) # amplitude to decibel
timebins, freqbins = np.shape(ims)
print("timebins: ", timebins)
print("freqbins: ", freqbins)
# plt.figure()
plt.imshow(np.transpose(ims),
origin="lower",
aspect="auto",
cmap=colormap,
interpolation="none")
# plt.figure.colorbar()
plt.set_xlabel("time (s)")
plt.set_ylabel("frequency (Hz)")
plt.set_xlim([0, timebins - 1])
plt.set_ylim([0, freqbins])
xlocs = np.float32(np.linspace(0, timebins - 1, 5))
plt.set_xticks(xlocs, [
"%.02f" % l for l in ((xlocs * len(samples) / timebins) +
(0.5 * binsize)) / samplerate
])
ylocs = np.int16(np.round(np.linspace(0, freqbins - 1, 10)))
plt.set_yticks(ylocs, ["%.02f" % freq[i] for i in ylocs])
# if plotpath:
# plt.savefig(plotpath, bbox_inches="tight")
# else:
# plt.show()
# plt.clf()
return ims
def getGraph(pos, neg):
N = 1
positive = pos
negative = neg
ind = np.arange(N) # the x locations for the groups
width = 0.02 # the width of the bars: can also be len(x) sequence
fig, plt = plt.subplots()
rects1 = plt.bar(ind, positive, width, color='#4bf3a2')
rects2 = plt.bar(ind + width, negative, width, color='#f25454')
# add some text for labels, title and axes ticks
plt.set_xticklabels(ind)
plt.set_yticks((np.arange(0, 1.1, 0.10)))
plt.legend((rects1[0], rects2[0]), ('Postive', 'Negative'))
canvas = fig.canvas
return canvas
def __init__(self, figsize=(10, 10), dpi=100):
Figure.__init__(self, figsize=figsize, dpi=dpi)
titles = [{
"title": "Orginalny obraz"
}, {
"title": "sinogram"
}, {
"title": "IRadon"
}, {
"title": "Sinogram po filtrze"
}, {
"title": "IRadon po filtrze"
}]
for i in range(1, 6):
plt = self.add_subplot(2, 3, i)
if "title" in titles[i - 1]:
plt.set_title(titles[i - 1]["title"])
plt.set_xticks([])
plt.set_yticks([])
self.plots[(2, 3, i)] = [plt, None]
def plot_clustering(n_clusters, cluster_labels, X):
plt.figure()
sample_silhouette_values = silhouette_samples(X, cluster_labels)
y_lower = 10
for i in range(n_clusters):
# Aggregate the silhouette scores for samples belonging to
# cluster i, and sort them
ith_cluster_silhouette_values = \
sample_silhouette_values[cluster_labels == i]
ith_cluster_silhouette_values.sort()
size_cluster_i = ith_cluster_silhouette_values.shape[0]
y_upper = y_lower + size_cluster_i
color = plt.spectral(float(i) / n_clusters)
plt.fill_betweenx(np.arange(y_lower, y_upper),
0, ith_cluster_silhouette_values,
facecolor=color, edgecolor=color, alpha=0.7)
# Label the silhouette plots with their cluster numbers at the middle
plt.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
# Compute the new y_lower for next plot
y_lower = y_upper + 10 # 10 for the 0 samples
plt.set_title("The silhouette plot for the various clusters.")
plt.set_xlabel("The silhouette coefficient values")
plt.set_ylabel("Cluster label")
# The vertical line for average silhouette score of all the values
plt.axvline(x=silhouette_avg, color="red", linestyle="--")
plt.set_yticks([]) # Clear the yaxis labels / ticks
plt.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])
plt.show()
def plot_2D_scores(plt,fig,filename_data_pos,filename_data_neg,filename_data_grid,filename_scores_grid,th,noice_needed=0,caption='',filename_out=None):
if not os.path.isfile(filename_data_pos): return
if not os.path.isfile(filename_data_neg): return
if not os.path.isfile(filename_data_grid): return
data = tools_IO.load_mat(filename_scores_grid, dtype=numpy.chararray, delim='\t')
data = data[1:,:]
grid_scores = data[:, 1:].astype('float32')
data = tools_IO.load_mat(filename_data_grid, dtype=numpy.chararray, delim='\t')
data_grid = data[:,1:].astype('float32')
data = tools_IO.load_mat(filename_data_pos, dtype=numpy.chararray, delim='\t')
l1 = (data[:, 0]).astype('float32')
x1 = data[:,1:].astype('float32')
data = tools_IO.load_mat(filename_data_neg, dtype=numpy.chararray, delim='\t')
l2 = (data[:, 0]).astype('float32')
x2 = data[:,1:].astype('float32')
X = numpy.vstack((x1,x2))
labels = numpy.hstack((l1, l2)).astype(int)
X1 = X[labels > 0]
X0 = X[labels <= 0]
#'''
max = numpy.max(grid_scores)
min = numpy.min(grid_scores)
for i in range(0,grid_scores.shape[0]):
if(grid_scores[i]>th):
grid_scores[i]=(grid_scores[i]-th)/(max-th)
else:
grid_scores[i] = (grid_scores[i] - th) / (th-min)
#'''
S=int(math.sqrt(grid_scores.shape[0]))
grid_scores=numpy.reshape(grid_scores,(S,S))
minx=numpy.min(data_grid[:, 0])
maxx=numpy.max(data_grid[:, 0])
miny=numpy.min(data_grid[:, 1])
maxy=numpy.max(data_grid[:, 1])
if noice_needed>0:
noice1 = 0.05-0.2*numpy.random.random_sample(X1.shape)
noice0 = 0.05-0.2*numpy.random.random_sample(X0.shape)
X1+=noice1
X0+=noice0
plt.set_title(caption)
xx, yy = numpy.meshgrid(numpy.linspace(minx, maxx, num=S), numpy.linspace(miny, maxy,num=S))
plt.contourf(xx, yy, numpy.flip(grid_scores,0), cmap=cm.coolwarm, alpha=.8)
#plt.imshow(grid_scores, interpolation='bicubic',cmap=cm.coolwarm,extent=[minx,maxx,miny,maxy],aspect='auto')
plt.plot(X0[:, 0], X0[:, 1], 'ro', color='blue', alpha=0.4)
plt.plot(X1[: ,0], X1[:, 1], 'ro' ,color='red' , alpha=0.4)
plt.grid()
plt.set_xticks(())
plt.set_yticks(())
#fig.subplots_adjust(hspace=0.001,wspace =0.001)
if filename_out is not None:
plt.savefig(filename_out)
return
#
#plt.bar(np.arange(69),weights[0,:],label = features)
#
order = np.argsort(np.abs(weights[:]))[::-1]
plt.bar(np.arange(20),weights[order[:20]])
plt.xticks(np.arange(20), features[order[:20]],fontsize =12)
plt.xticks(rotation="vertical")
plt.ylabel("Feature weights")
plt.savefig("/neurospin/brainomics/2016_schizConnect/analysis/all_studies+VIP/Freesurfer/all_subjects/results/ROIs_analysis/weights/svm_weights_top20.png")
plt.barh(np.arange(20),weights[order[:20]])
plt.set_yticks(np.arange(20))
plt.set_yticklabels(features[order[:20]])
plt.xticks(np.arange(20), features[order[:20]],fontsize =12)
plt.xticks(rotation="vertical")
plt.ylabel("Feature weights")
plt.rc('font', family='serif')
plt.figure
plt.grid()
fig, ax = plt.subplots()
# Example data
features_names = features[order[:20]]
y_pos = np.arange(len(features_names))
import pickle
import matplotlib.pyplot as plt
import numpy as np
# Example data
people = ('TP', 'FP', 'FN', 'TN')
y_pos = np.arange(len(people))
performance = (64354, 2701, 17007, 2417826)
plt.barh(y_pos, performance, align='center',
color='green', ecolor='black')
plt.set_yticks(y_pos)
plt.set_yticklabels(people)
plt.invert_yaxis() # labels read top-to-bottom
plt.set_xlabel('Performance')
plt.set_title('Precission - 0.959 Recal - 0.790')
plt.show()
J.append(calcJ(d, centers))
return centers, J, closest
c, J, closest = kmeans(d, 2, 6)
print("centers")
print(c)
print("J=")
print(J)
plt.figure(1)
plt.subplot(511)
plt.title('plot-of-2D-data')
plt.set_yticks(scipy.arange(0, 5, 0.5))
plt.subplot(51 (n + 2))
plt.title('clustering of 2D data')
plt.set_yticks(scipy.arange(0, 5, 0.5))
plt.scatter(d[:, 0], d[:, 1], s=50, c=closest, alpha=0.5)
plt.scatter(c[:, 0], c[:, 1], s=80, c="green", alpha=0.5)
plt.subplots_adjust(hspace=0.8, wspace=0.5)
plt.savefig('ssdemo6.png')
plt.savefig('plot-of-2D-data-k-means.png')
plt.figure(2)
plt.scatter(d[:, 0], d[:, 1], s=80)
print("closest=")
print(closest)
plt.subplot(213)
plt.set_yticks(scipy.arange(4, 10, 0.5))
#ax = fig.add_subplot(131)
#rects1 = ax.bar(x, stand_alone, width, label='Stand Alone')
#rects1 = ax.bar(x - width/2, stand_alone, width, color='cornflowerblue')
#rects1 = ax.bar(x,time, width)
rects1 = ax.bar(x, read, width, hatch='....', color='white', edgecolor='black')
#rects1 = ax.bar(x - width/2, stand_alone, width, label='Stand Alone')
#rects2 = ax.bar(x, collocated, width, label='Collocated')
#rects2 = ax.bar(x + width/2, collocated, width, color='orange')
#rects2 = ax.bar(x + width/2, collocated, width, label='Collocated')
# Add some text for labels, title and custom x-axis tick labels, etc.
plt.set_ylabel('Traffic in Million', fontsize=12)
plt.set_title('Read', fontsize=14)
plt.set_xticks(x)
plt.set_xticklabels(
labels,
fontsize=12,
)
#ax.set_xticklabels(labels, fontsize=12, rotation='vertical')
#ax.legend(loc=1, bbox_to_anchor=(0.5, 0., 0.5, 0.99))
plt.set_yticks(np.arange(0, max(read) + 2, 3))
x = np.arange(len(labels)) # the label locations
fig.subplots_adjust(wspace=.5)
plt.tight_layout()
plt.show()
fig.savefig('method-stream.png', dpi=100)
import matplotlib.pyplot as plt
these_times = times[times.team == team]
plt.plot(these_times.time.as_matrix(),
np.ones(len(these_times)), 'o')
plt.set_ylabel(team, rotation='horizontal',
labelpad=30)
plt.set_ybound(0.5, 1.5)
plt.set_position([0.1, 0.1, 8.0, 1.0])
plt.set_yticks([])
alpha=alpha,
height=bar_width,
hatch=hatch1)
plt.barh(y=np.arange(len(x_data)) + bar_width,
width=y_data2,
label='RNR methods',
color='indianred',
alpha=alpha,
height=bar_width,
hatch=hatch2)
# 为Y轴设置刻度值
if y_label1:
plt.yticks(np.arange(len(x_data)) + bar_width / 2, x_data, color='black')
else:
plt.set_yticks([])
plt.xlabel(xlabel, fontdict=fontdict)
plt.xticks(color='black')
if add_baselines:
plt.ylabel("Baselines", fontdict=fontdict)
plt.xlim(0.13, 0.18)
my_x_ticks = np.arange(0.13, 0.18, 0.01)
plt.xticks(my_x_ticks)
plt.legend(loc='lower center',
bbox_to_anchor=(upper_dis, right_dis),
ncol=ncol)
ax2 = fig.add_subplot(layout1, layout2, 2)
# ML100K: 2/4
# Delicious: 2/15
plt.show()
#Kernel Density Estimate (KDE). KDE is a fundamental data smoothing problem where inferences about
#the population are made, based on a finite data sample.
#It helps generate estimations of the overall distributions.
#estimations of the overall distributions
pd.plotting.scatter_matrix(retscomp, diagonal='kde', figsize=(10,10));
#heat maps to visualize the correlation ranges among the competing stocks.
#The lighter the color, the more correlated the two stocks are
mk=plt.subplot()
plt.imshow(corr, cmap='hot', interpolation='none')
plt.colorbar()
plt.set_xticks(range(len(corr)), corr.columns)
plt.set_yticks(range(len(corr)), corr.columns)
plt.show()
#this might not show causality, and could just show the trend in the technology
#industry rather than show how competing stocks
#Stock RETURNS n RISKS
#average of returns (Return Rate) and the standard deviation of returns (Risk).
plt.scatter(retscomp.mean(), retscomp.std())
plt.xlabel("Expected returns")
plt.ylabel("Risk")
plt.legend
for label, x, y in zip(retscomp.columns, retscomp.mean(), retscomp.std()):
plt.annotate(
label,
def Pilot_Plot():
# Creating big figure to hold all
fig = plt.figure(figsize=(20, 16))
# setting font size
plt.rcParams.update({'font.size': 8})
# # Turn off axis lines and ticks of the big subplot
# ax.spines['top'].set_color('none')
# ax.spines['bottom'].set_color('none')
# ax.spines['left'].set_color('none')
# ax.spines['right'].set_color('none')
# Plotting estimated mu vs. response mu
ax0 = fig.add_subplot(231)
ax0.scatter(res_mu, est_mu, marker='.', label=f'n={len(res_mu)}')
ax0.legend()
ax0.set_title(
'FOR VALIDATION: Participant response as a function of estimated mu')
ax0.set_xlabel('response mu (radians)')
ax0.set_ylabel('estimated mu (radians)')
plt.set_xticks(card_direc)
plt.set_yticks(card_direc)
# Plotting MSE across presentation times
ax1 = fig.add_subplot(232)
ax1.set_title('MSE across stimulus presentation times')
ax1.set_xlabel('Presentation Times (ms)')
ax1.set_ylabel('MSE')
# plt.bar(np.arange(8), durMSE, width=0.2)
ax1.plot(np.arange(8), durMSE)
ax1.set_xticks(np.arange(8), labels=durVal)
#######################################################################################################
# # Plotting response time vs. estimated mu, vs. response_mu
# plt.figure(figsize=(13,6))
#
# plt.subplot(211)
# plt.scatter(est_mu, data[colnames.index('keyRT')], marker='.', label=f'n={len(est_mu)}')
# plt.legend()
# plt.title('Response time as a function of estimated mean location')
# plt.xlabel('est_mu (radians)')
# plt.ylabel('response time (ms)')
#
# plt.subplot(212)
# plt.scatter(res_mu, data[colnames.index('keyRT')], marker='.',label=f'n={len(res_mu)}')
# plt.legend()
# plt.title('Response time as a function of participant-observed mean location')
# plt.xlabel('response mu (radians)')
# plt.ylabel('response time (ms)')
#
# plt.tight_layout()
# plt.show()
# #######################################################################################################
# ## Plotting cardinal vs. oblique MSE
# plt.figure(figsize=(4,3))
# plt.title('MSE, by orientation of MSE \n(each direction padded by pi/8 radians')
# plt.bar([0, 1], [card_MSE, obli_MSE])
# plt.ylabel('MSE')
# plt.xticks([0,1], ('cardinal','oblique'))
# plt.show()
#######################################################################################################
## Plotting relationship of accuracy with RT and PT
## TODO: Plot SAT curve after fitting logistic function
plt.figure(figsize=(14, 4))
plt.rcParams.update({'font.size': 6})
ax2 = fig.add_subplot(233)
# plt.title('Response time-Accuracy')
# plt.xlabel('Response time (ms)')
# plt.ylabel('Accuracy (percent distance of response mu from est_mu)')
# plt.scatter(keyRT, ERxTrials * 100, marker='.', s=1)
# plt.xticks(durVal, labels=durVal)
ax2.set_title('Presentation Time vs. Accuracy')
ax2.set_xlabel('Presentation time (ms)')
ax2.set_ylabel('Accuracy (percent distance of response mu from est_mu)')
ax2.scatter(vizDur, res_acc * 100)
ax2.set_xticks(durVal, labels=durVal)
# Boxplot, Response time median, mean, IQR for each stimulus duration
ax3 = fig.add_subplot(234)
ax3.set_title(
'Response time, by stimulus duration \n(orange = median, green = mean)'
)
ax3.set_ylabel('Response time (ms)')
ax3.set_xlabel('Presentation duration (ms)')
ax3.boxplot(dur_RT, meanline=True, showmeans=True)
ax3.set_xticks(np.arange(1, len(durVal) + 1), labels=durVal)
#######################################################################################################
# ## Accuracy as a function of distance of initial probe to (1) response mu and (2) estimated mu
# fig = plt.figure(figsize=(10,5))
#
# ax = fig.add_subplot(111) # The big subplot
# ax1 = fig.add_subplot(211)
# ax2 = fig.add_subplot(212)
#
# # Turn off axis lines and ticks of the big subplot
# ax.spines['top'].set_color('none')
# ax.spines['bottom'].set_color('none')
# ax.spines['left'].set_color('none')
# ax.spines['right'].set_color('none')
# ax.tick_params(labelcolor='w', top='off', bottom='off', left='off', right='off')
# ax.set_ylabel('Trial Accuracy')
#
# # fig.suptitle('Accuracy vs. probe locations')
# ax1.scatter(probe2est, ERxTrials, marker='.', s=1)
# ax1.set_xlabel('distance from initial probe to estimated mu (radians)')
# ax2.scatter(probe2res, ERxTrials, marker='.', s=1)
# ax2.set_xlabel('distance from initial probe to response mu (radians)')
# plt.tight_layout()
#
# plt.figure(figsize=(14, 4))
# plt.rcParams.update({'font.size': 6})
ax4 = fig.add_subplot(235)
plt.title('Presentation Time-Accuracy Curve')
plt.xlabel('Presentation time (ms)')
plt.ylabel('Accuracy (percent distance of response mu from est_mu)')
plt.scatter(vizDur, res_acc * 100)
plt.xticks(durVal, labels=durVal)
plt.title('Error vs. Propmix')
plt.xlabel('Response time (ms)')
plt.ylabel('Accuracy (percent distance of response mu from est_mu)')
plt.scatter(keyRT, res_acc * 100, marker='.', s=1)
# plt.xticks(durVal, labels=durVal)
plt.figure(figsize=(12, 4))
plt.rcParams.update({'font.size': 12})
plt.suptitle('Parameter dependency on response time')
plt.rcParams.update({'font.size': 8})
plt.subplot(121)
plt.title(
'Mean response time as a function of kappa (concentration) of stimulus'
)
for i, x in enumerate(propVal):
plt.plot(kpVal[i], kp_RT_mean[i], label=f'propmix = {x}')
plt.legend()
plt.xlabel('estimated kappa')
plt.ylabel('mean RT (ms)')
plt.title('RT by kappa')
## All kappa
# plt.plot(kapVal, kap_RT_mean)
# plt.xlabel('kappa')
# plt.ylabel('mean RT (ms)')
plt.subplot(122)
plt.bar(propVal, prop_RT_mean)
plt.title('Mean response time as a function of noise present')
plt.xlabel(
'Proportion of uniform noise to von Mises distribution in stimulus')
plt.ylabel('mean RT (ms)')
plt.xticks(propVal)
