def _write_overlap_info(self, perturbation, M, sim_type=''):
r"""computes and saves overlap matrix plots and info
Parameters:
-----------
perturbation : string
string identifying the perturbation for which the overlap is being computed
M : 2D numpy array
matrix containing the overlap information
sim_type : string
Identifier for bound type or free type simulation
"""
diag_elements = numpy.array([numpy.diag(M, k=1), numpy.diag(M, k=-1)])
fname = os.path.join(self._outputdir,
perturbation) + '_' + sim_type + '_matrix.dat'
fh = open(fname, 'wb')
fh.write(bytes('#Overlap matrix\n', "UTF-8"))
if numpy.min(diag_elements) < 0.03:
fh.write(
bytes(
'#Off diagonal elements of the overlap matrix are smaller than 0.03! Your free energy estimate is \n'
'#not reliable!\n', "UTF-8"))
numpy.savetxt(fh, M, fmt='%.4f')
fh.close()
#now plotting the matrix
fplot = os.path.join(self._outputdir,
perturbation) + '_' + sim_type + '_matrix.png'
# turns off interactive plotting
plt.ioff()
plt.matshow(M)
plt.colorbar()
plt.savefig(fplot, dpi=100)
def main():
args = parse_args()
protein = args.protein
cm = Protein(protein[0:4], protein[4]).cm
plt.matshow(cm, origin='lower', cmap='Greys')
plt.savefig(os.path.join(PATHS.periscope, 'data', f'{protein}_cm.png'))
plt.close()
def drawFile(dataset, matrix, patterns, cells, w, fnum):
'''The similarity of two patterns in the bit-encoding space is displayed alongside
their similarity in the sp-coinc space.'''
score = 0
count = 0
assert len(patterns) == len(cells)
for p in xrange(len(patterns) - 1):
matrix[p + 1:, p] = [
len(Set(patterns[p]).intersection(Set(q))) * 100 / w
for q in patterns[p + 1:]
]
matrix[p, p + 1:] = [
len(Set(cells[p]).intersection(Set(r))) * 5 / 2
for r in cells[p + 1:]
]
score += sum(
abs(np.array(matrix[p + 1:, p]) - np.array(matrix[p, p + 1:])))
count += len(matrix[p + 1:, p])
print 'Score', score / count
fig = pyl.figure(figsize=(10, 10), num=fnum)
pyl.matshow(matrix, fignum=fnum)
pyl.colorbar()
pyl.title('Coincidence Space', verticalalignment='top', fontsize=12)
pyl.xlabel('The Mirror Image Visualization for ' + dataset, fontsize=17)
pyl.ylabel('Encoding space', fontsize=12)
def plot_confusion_matrix(cm, meow_list, name, title):
pylab.clf()
pylab.matshow(cm, fignum=False, cmap='Blues', vmin=0, vmax=1.0)
ax = pylab.axes()
ax.set_xticks(range(len(meow_list)))
ax.set_xticklabels(meow_list)
ax.xaxis.set_ticks_position("bottom")
def main():
# process data
data = np.genfromtxt("../Data/train_data.csv", delimiter=",")
corr_data = data[:, 1:9]
# execute model
test_dataframe = pandas.DataFrame(
corr_data,
columns=[
"GRE Score",
"TOEFL Score",
"University Rating",
"SOP",
"LOR",
"CGPA",
"Research",
"Chance of Admit",
],
)
plt.matshow(test_dataframe.corr())
# use shape 1 for x-axis
plt.xticks(range(test_dataframe.shape[1]),
test_dataframe.columns,
fontsize=7,
rotation=90)
plt.yticks(range(test_dataframe.shape[1]),
test_dataframe.columns,
fontsize=7)
plt.colorbar()
plt.legend()
plt.savefig("../Out/2.png")
def draw(G, A, cluster_map):
import networkx as nx
import matplotlib.pyplot as plt
clust_map = {}
for k, vals in cluster_map.items():
for v in vals:
clust_map[v] = k
colors = []
for i in range(len(G.nodes())):
colors.append(clust_map.get(i, 100))
pos = nx.spring_layout(G)
from matplotlib.pylab import matshow, show, cm
plt.figure(2)
nx.draw_networkx_nodes(G,
pos,
node_size=200,
node_color=colors,
cmap=plt.cm.Blues)
nx.draw_networkx_edges(G, pos, alpha=0.5)
matshow(A, fignum=1, cmap=cm.gray)
plt.show()
show()
def test_H(self):
# Setup feature track
track_id = 0
frame_id = 3
data0 = KeyPoint(np.array([0.0, 0.0]), 21)
data1 = KeyPoint(np.array([0.0, 0.0]), 21)
track = FeatureTrack(track_id, frame_id, data0, data1)
# Setup track cam states
self.msckf.augment_state()
self.msckf.augment_state()
self.msckf.augment_state()
track_cam_states = self.msckf.track_cam_states(track)
# Feature position
p_G_f = np.array([[1.0], [2.0], [3.0]])
# Test
H_f_j, H_x_j = self.msckf.H(track, track_cam_states, p_G_f)
# Assert
self.assertEqual(H_f_j.shape, (4, 3))
self.assertEqual(H_x_j.shape, (4, 39))
# Plot matrix
debug = True
# debug = False
if debug:
plt.matshow(H_f_j)
plt.show()
plt.matshow(H_x_j)
plt.show()
def PlotTurbulenceIllustr(a):
"""
Can generate the grid with
g=kolmogorovutils.GenerateKolmogorov3D( 1025, 129, 129)
a=kolmogorovutils.GridToNumarray(g)
"""
for x in [1,10,100]:
suba= numarray.sum(a[:,:,0:x], axis=2)
suba.transpose()
pylab.clf()
pylab.matshow(suba)
pylab.savefig("temp/turb3d-sum%03i.eps" % x)
for x in [1,10,100]:
for j in [0,1,2]:
suba= numarray.sum(a[:,:200,j*x:(j+1)*x], axis=2)
suba.transpose()
pylab.clf()
pylab.matshow(suba)
pylab.savefig("temp/turb3d-sum%03i-s%i.eps" % (x,j))
def Animate(g):
for i in range(1,64,5):
pylab.clf()
x= g[0:i,:,:]
y= numarray.sum(x, axis=0)
pylab.matshow( y)
pylab.savefig("temp/3dturb-%03i.png" % i)
def showKernel(dataOrMatrix, fileName = None, useLabels = True, **args) :
labels = None
if hasattr(dataOrMatrix, 'type') and dataOrMatrix.type == 'dataset' :
data = dataOrMatrix
k = data.getKernelMatrix()
labels = data.labels
else :
k = dataOrMatrix
if 'labels' in args :
labels = args['labels']
import matplotlib
if fileName is not None and fileName.find('.eps') > 0 :
matplotlib.use('PS')
from matplotlib import pylab
pylab.matshow(k)
#pylab.show()
if useLabels and labels.L is not None :
numPatterns = 0
for i in range(labels.numClasses) :
numPatterns += labels.classSize[i]
#pylab.figtext(0.05, float(numPatterns) / len(labels), labels.classLabels[i])
#pylab.figtext(float(numPatterns) / len(labels), 0.05, labels.classLabels[i])
pylab.axhline(numPatterns, color = 'black', linewidth = 1)
pylab.axvline(numPatterns, color = 'black', linewidth = 1)
pylab.axis([0, len(labels), 0, len(labels)])
if fileName is not None :
pylab.savefig(fileName)
pylab.close()
def plot_pixels(self):
"""
Makes a pixelchart of every embedding in the set.
Usage:
```python
from whatlies.language import SpacyLanguage
from whatlies.transformers import Pca
lang = SpacyLanguage("en_core_web_sm")
names = ['red', 'blue', 'green', 'yellow',
'cat', 'dog', 'mouse', 'rat',
'bike', 'car', 'motor', 'cycle',
'firehydrant', 'japan', 'germany', 'belgium']
emb = lang[names].transform(Pca(12)).filter(lambda e: 'pca' not in e.name)
emb.plot_pixels()
```
"""
names = self.embeddings.keys()
df = self.to_dataframe()
plt.matshow(df)
plt.yticks(range(len(names)), names)
def plot_confusion_matrix(cm, meow_list, name, title):
pylab.clf()
pylab.matshow(cm, fignum=False, cmap='Blues', vmin=0, vmax=1.0)
ax = pylab.axes()
ax.set_xticks(range(len(meow_list)))
ax.set_xticklabels(meow_list)
ax.xaxis.set_ticks_position("bottom")
def main():
show_graph = False
do_run = True
show_result = True
show_trace = False
simdata = np.fromfile('plank.dat', dtype=np.uint8)
simdata.shape = (151, 1080)
if show_graph:
camera = System('Camera', 15, 200, 200, simdata, [])
debug(camera.plot())
result = [0] * (151 * 1080)
if do_run:
sme = SME()
sme.network = System('Camera', 151, 151 * 1080, 200, simdata, result)
sme.network.clock(1080 * 200 + (1080 * 151))
if show_result:
plt.rc("font", size=18)
result = np.array(result)
debug(len(result))
result.shape = (1080, 151)
pylab.matshow(result.T, fignum=100, cmap=pylab.cm.gray)
if show_trace:
debug(camera.trace())
pylab.show()
def BreakIllustration(seed=11):
for x in [1 , 2 , 4, 8, 16 , 25, 100]:
pylab.clf()
m4=GenKolmogorovV2(1025, seed, pybnlib.Kol3DBreakLaw(1.0/x) )
pylab.matshow(m4)
pylab.savefig("temp/breakill-%03i.png" % x)
def plot_confusion_matrix(cm, genre_list, name, title,max,save=False):
pylab.clf()
pylab.matshow(cm, fignum=False, cmap='Greens', vmin=0, vmax=max)
ax = pylab.axes()
ax.set_xticks(range(len(genre_list)))
ax.set_xticklabels(genre_list)
ax.xaxis.set_ticks_position("bottom")
ax.set_yticks(range(len(genre_list)))
ax.set_yticklabels(genre_list)
cm=cm.T
for i in range(len(cm)):
# t=len(cm[0])-i
for j in range(len(cm[0])):
if cm[i,j]<1e-2:
continue
pylab.text(i, j, '%.2f'%cm[i,j])
pylab.title(title)
pylab.colorbar()
pylab.grid(True)
pylab.show()
pylab.xlabel('Predicted class')
pylab.ylabel('True class')
pylab.grid(True)
if save==True:
pylab.savefig(os.path.join(CHART_DIR, "confusion_matrix_%s.png"%name), bbox_inches="tight")
def plot_layer_mat(layer_mat,
layernames=None,
titstr="Correlation of Amplification in BigGAN"):
"""Formatting function for ploting Layer by Layer matrix"""
Lnum = layer_mat.shape[0]
fig = plt.figure(figsize=[9, 8])
plt.matshow(layer_mat, fignum=0)
layermat_nan = layer_mat.copy()
np.fill_diagonal(layermat_nan, np.nan)
plt.title(
"%s across %d layers"
"\nNon-Diagonal mean %.3f median %.3f" %
(titstr, Lnum, np.nanmean(layermat_nan), np.nanmedian(layermat_nan)),
fontsize=15)
fig.axes[0].tick_params(axis="x",
bottom=True,
top=False,
labelbottom=True,
labeltop=False)
if layernames is not None:
plt.yticks(range(Lnum), layernames)
plt.ylim(-0.5, Lnum - 0.5)
plt.xticks(range(Lnum),
layernames,
rotation=35,
rotation_mode='anchor',
ha='right')
plt.xlim(-0.5, Lnum - 0.5)
plt.colorbar()
plt.subplots_adjust(top=0.85)
plt.show()
return fig
def combine_fullrank_matrix(A, A_add, b, b_add, print_out=False):
""" Add rows as long as the resulting matrix is fullrank.
"""
assert np.linalg.matrix_rank(A) == A.shape[0]
counter = 0
for i in range(A_add.shape[0]):
A_addedrow = np.vstack((A, A_add[i, :]))
if np.linalg.matrix_rank(A_addedrow) > np.linalg.matrix_rank(A):
counter += 1
A = A_addedrow
b = np.r_[b, b_add[i]]
# Visualization of dependent matrices.
else:
if print_out:
alpha = np.linalg.lstsq(A.T, A_add[i, :].reshape(-1, 1))[0]
alpha = alpha.reshape(1, -1)[0, :]
alpha[alpha < 1e-12] = 0.0
indices = np.where(alpha > 0.0)[0]
plt.matshow(A)
plt.title('lin indep. rows')
plt.matshow(np.vstack((A_add[i, :], A_add[i, :])))
plt.title('lin. dep. row: {}*{}'.format(indices, alpha[indices]))
if (print_out):
print('added {} linearly independent rows.'.format(counter))
return A, b
def validate(X_test, y_test, pipe, title, fileName):
print('Test Accuracy: %.3f' % pipe.score(X_test, y_test))
y_predict = pipe.predict(X_test)
confusion_matrix = np.zeros((9,9))
for p,r in zip(y_predict, y_test):
confusion_matrix[p-1,r-1] = confusion_matrix[p-1,r-1] + 1
print (confusion_matrix)
confusion_normalized = confusion_matrix.astype('float') / confusion_matrix.sum(axis=1)[:, np.newaxis]
print (confusion_normalized)
pylab.clf()
pylab.matshow(confusion_normalized, fignum=False, cmap='Blues', vmin=0.0, vmax=1.0)
ax = pylab.axes()
ax.set_xticks(range(len(families)))
ax.set_xticklabels(families, fontsize=4)
ax.xaxis.set_label_position('top')
ax.xaxis.set_ticks_position("top")
ax.set_yticks(range(len(families)))
ax.set_yticklabels(families, fontsize=4)
pylab.title(title)
pylab.colorbar()
pylab.grid(False)
pylab.grid(False)
pylab.savefig(fileName, dpi=900)
def VisualizeM(
matrix
): # pour visualiser une matrice rapidement (permet de détecter une erreur aussi)
plt.matshow(
matrix, cmap=plt.cm.jet_r
) # on peut toujours changer de cmap ici aussi, le jet_r assure bleu = humide, rouge = aride
plt.show()
def show_profile(task, fn):
data = zeros((task.Sx, task.Sy))
for i in range(task.Sx):
for j in range(task.Sy):
data[i][j] = fn(task.Gp(i, j, task.Sz / 2))
plb.matshow(data.transpose())
plb.colorbar()
plb.show()
def plot_grid(self, name="", save_figure=True):
#gambar 2D dari grid
plt.matshow(self.matrix_grid(), cmap="RdBl", fignum=0)
# buat save image
if save_figure:
plt.savefig(self.path + name + '.png')
plt.draw()
def plot_assortativity_matrix(degree_correlation_matrix):
# Rappresento la degree correlation matrix con matshow
plt.matshow(degree_correlation_matrix, cmap='hot')
plt.title('Matrice di correlazione')
plt.show()
def PlotSTest(a):
from matplotlib import pylab
x = numpy.mean(a, axis=0)
x.shape = (int(len(x) ** 0.5), int(len(x) ** 0.5))
pylab.matshow(x)
pylab.colorbar()
def plot_dependency_posterior(df, meta, t, num_joints=None):
if num_joints is None:
num_joints = determine_num_joints(df)
plt.figure()
posterior=np.array([df["Posterior%d"%j].iloc[t] for j in range(num_joints)])
plt.matshow(posterior, interpolation='nearest')
plt.show()
def show_profile(task, fn):
data = zeros((task.Sx, task.Sy))
for i in range(task.Sx):
for j in range(task.Sy):
data[i][j] = fn(task.Gp(i, j, task.Sz / 2))
plb.matshow(data.transpose())
plb.colorbar()
plb.show()
def plot(x, mode=None, **kwargs):
"""Plots a tensor/numpy array
If the array has no spatial extend, it will
draw only a single line plot. If the array
has no temporal extend (and no color channels etc.),
it will plot a single frame.
Otherwise it will use `plot_tensor`.
Examples
--------
.. plot::
:include-source:
import convis
inp = convis.samples.moving_grating(2000,50,50)
convis.utils.plot(inp[None,None])
See Also
--------
plot_tensor
plot_5d_matshow
plot_5d_time
"""
import matplotlib.pylab as plt
try:
# assuming a torch Variable on the gpu
x = x.data.cpu().numpy()
except:
x = np.array(x)
if len(x.shape) > 5:
while len(x.shape) > 5:
x = x[0]
if len(x.shape) == 4:
x = x[None]
if len(x.shape) == 3:
x = x[None, None]
if len(x.shape) == 2:
x = x[None, None, None]
if len(x.shape) == 1:
x = x[None, None, :, None, None]
shp = x.shape
if len(shp) == 5:
if mode == 'matshow' or np.prod(shp[:3]) == 1:
# a single frame
plt.matshow(x, **kwargs)
elif mode == 'lines' or (np.prod(shp[:2]) == 1
and np.prod(shp[3:]) == 1):
# a single time line
plt.plot(x.mean((0, 1, 3, 4)), **kwargs)
else:
# a set of images?
plot_tensor(x, **kwargs)
else:
print('x has dimensions:', shp)
def group_causality(sig_list, condition, freqs, ROI_labels=None,
out_path=None, submount=10):
"""
Make group causality analysis, by evaluating significant matrices across
subjects.
----------
sig_list: list
The path list of individual significant causal matrix.
condition: string
One condition of the experiments.
freqs: list
The list of interest frequency band.
min_subject: string
The subject for the common brain space.
submount: int
Significant interactions come out at least in 'submount' subjects.
"""
print 'Running group causality...'
set_directory(out_path)
sig_caus = []
for f in sig_list:
sig_cau = np.load(f)
print sig_cau.shape[-1]
sig_caus.append(sig_cau)
sig_caus = np.array(sig_caus)
sig_group = sig_caus.sum(axis=0)
plt.close()
for i in xrange(len(sig_group)):
fmin, fmax = freqs[i][0], freqs[i][1]
cau_band = sig_group[i]
# cau_band[cau_band < submount] = 0
cau_band[cau_band < submount] = 0
# fig, ax = pl.subplots()
cmap = plt.get_cmap('hot', cau_band.max()+1-submount)
cmap.set_under('gray')
plt.matshow(cau_band, interpolation='nearest', vmin=submount, cmap=cmap)
if ROI_labels == None:
ROI_labels = np.arange(cau_band.shape[0]) + 1
pl.xticks(np.arange(cau_band.shape[0]), ROI_labels, fontsize=9, rotation='vertical')
pl.yticks(np.arange(cau_band.shape[0]), ROI_labels, fontsize=9)
# pl.imshow(cau_band, interpolation='nearest')
# pl.set_cmap('BlueRedAlpha')
np.save(out_path + '/%s_%s_%sHz.npy' %
(condition, str(fmin), str(fmax)), cau_band)
v = np.arange(submount, cau_band.max()+1, 1)
# cax = ax.scatter(x, y, c=z, s=100, cmap=cmap, vmin=10, vmax=z.max())
# fig.colorbar(extend='min')
plt.colorbar(ticks=v, extend='min')
# pl.show()
plt.savefig(out_path + '/%s_%s_%sHz.png' %
(condition, str(fmin), str(fmax)), dpi=300)
plt.close()
return
def VizAttenMat(atten_Matrix):
"""
A function that takes an input 2D Tensor and visualize it using matplotlib
"""
assert len(atten_Matrix.shape)==2, "your input should be a symetrical 2D matrix"
assert atten_Matrix.shape[0]==atten_Matrix.shape[1], "your input should be a symetrical 2D matrix"
plt.matshow(atten_Matrix)
plt.colorbar()
plt.show()
def plot_sparsity_pattern(A, tick_frequency):
""":param A: np array containing the matrix"""
A[np.where(A != 0)] = 1
plt.matshow(A, fignum=None)
plt.colorbar()
plt.xticks(np.arange(0, A.shape[0], tick_frequency))
plt.yticks(np.arange(0, A.shape[0], tick_frequency))
plt.grid()
plt.show()
def savematrixplot(datasetname,tumorname, A, k):
"""
plt.figure("%s_consensus_rank_%d.png" % (tumorname,k))
plt.subplot(211)
plt.matshow(A)
plt.savefig("./" + datasetname + "_results/%s_consensus_rank_%d.png" % (tumorname,k))
"""
mplpl.matshow(A)
mplpl.savefig("./" + datasetname + "_results/%s_consensus_rank_%d.png" % (tumorname,k))
def plot_grid(self):
truth = self.order_matrix > 1
truth = self.item_matrix > 4
dot_only = self.order_matrix * truth # removes all the bordering ones
# dot_only = self.item_matrix * truth # removes all the bordering ones
dot_only = dot_only + truth * self.num_iter // 6 # need to differentiate the early dots from the background of 0 for human eye. + max/6 seemed like the easiest way
plt.matshow(dot_only, cmap=plt.cm.inferno)
plt.colorbar()
plt.show()
def plot_dependency_posterior(df, meta, t, num_joints=None):
if num_joints is None:
num_joints = determine_num_joints(df)
plt.figure()
posterior = np.array(
[df["Posterior%d" % j].iloc[t] for j in range(num_joints)])
plt.matshow(posterior, interpolation='nearest')
plt.show()
def plot_grid(self, name="", save_figure=True):
"""
This plots the 2D representation of the grid
:param name: the name of the image to save
:return:
"""
plt.matshow(self.matrix_grid(), cmap="RdBu", fignum=0)
# Option to save images
if save_figure:
plt.savefig(self.path + name + '.png')
def create_heatmaps(df, key=lambda t: t.minute):
for group, data in df.groupby(df.index.map(key)):
all_mat = np.zeros((100,100), dtype=np.int)
for x, y in zip(data.x, data.y):
all_mat[x, y] += 1
all_mat = all_mat*1.0/len(data)
plt.matshow(all_mat)
plt.title(data.ix[0].name)
print("saving: ", group)
plt.savefig("{:02}.png".format(group))
def plot_grid(self, name="", save_figure=True):
"""
Gridin 2 boyutlu gösterimi
:param name: kaydedilecek resmin adı
:return:
"""
plt.matshow(self.matrix_grid(), cmap="RdBu", fignum=0) #
# Resmi kaydetme opsiyonu
if save_figure:
plt.savefig(self.path + name + '.png')
def savematrixplot(datasetname, tumorname, A, k):
"""
plt.figure("%s_consensus_rank_%d.png" % (tumorname,k))
plt.subplot(211)
plt.matshow(A)
plt.savefig("./" + datasetname + "_results/%s_consensus_rank_%d.png" % (tumorname,k))
"""
mplpl.matshow(A)
mplpl.savefig("./" + datasetname + "_results/%s_consensus_rank_%d.png" %
(tumorname, k))
def plot_matrix_prod(self, n=1, display_transpose=False):
cond_prob_matrix = np.matrix(self.cond_probs.as_matrix())
cond_prob_matrix = cond_prob_matrix**n
if display_transpose:
cond_prob_matrix = cond_prob_matrix.T
plt.matshow(cond_prob_matrix)
ax = plt.gca()
plt.xticks(range(len(self.labels)))
ax.set_xticklabels(self.labels, rotation=90)
plt.yticks(range(len(self.labels)))
ax.set_yticklabels(self.labels)
plt.grid('off')
def PlotCorrelationMatrix(dirin):
from matplotlib import pylab
fnamein=os.path.join(dirin, "cvmatrix.csv")
fnameout=os.path.join(dirin,"plots", "cvmatrix.png")
m=bnmin1io.LoadCVSFile(fnamein)
pylab.clf()
pylab.matshow(m)
pylab.colorbar()
pylab.savefig(fnameout)
def plot_forest_all_proba(y_proba_all, y_gt):
from matplotlib import pylab
N = len(y_gt)
num_tree = len(y_proba_all)
pylab.clf()
mat = np.zeros((num_tree, N))
LOGGER.info('mat.shape={}'.format(mat.shape))
for i in range(num_tree):
mat[i, :] = y_proba_all[i][(range(N), y_gt)]
pylab.matshow(mat, fignum=False, cmap='Blues', vmin=0, vmax=1.0)
pylab.grid(False)
pylab.show()
def predictTest(X_test, y_test):
# 加载模型
print("load GBDT model ...")
model = joblib.load('clfGBDT.model')
# 用测试集验证最优模型
t0 = time()
print("Predicting label on the test set")
y_pre = model.predict(X_test)
# 创建output file（label=0/1 feature1 feature2）
print("create modelResult.txt")
outputFileName = "modelResult.txt"
outputFile = open(outputFileName, 'w')
line = len(y_pre) # txt的行
for i in range(0, line):
outputFile.write(str(y_pre[i]))
outputFile.write('\t')
outputFile.write(str(X_test[i][0]))
outputFile.write('\t')
outputFile.write(str(X_test[i][1]))
outputFile.write('\n')
outputFile.close()
print("modelResult.txt finished ...")
y_preprob = model.predict_proba(X_test)[:, 1]
print('Accuaracy: %.4g' % metrics.accuracy_score(y_test, y_pre))
print('AUC Score (Test): %f' % metrics.roc_auc_score(y_test, y_preprob))
print("done in %0.3fs" % (time() - t0))
# classification_report
# 输入：测试集真实的结果和预测的结果
# 返回：每个类别的准确率召回率F值以及宏平均值。
print("classification report:")
print(classification_report(y_test, y_pre))
# 混淆矩阵
# 输出：
# 第0行第0列的数表示y_true中值为0，y_pred中值也为0的个数；第0行第1列的数表示y_true中值为0，y_pred中值为1的个数
# 第1行第0列的数表示y_true中值为1，y_pred中值也为0的个数；第1行第1列的数表示y_true中值为1，y_pred中值为1的个数
matrix = confusion_matrix(y_test, y_pre)
print("confusion matrix:")
print(matrix)
# 画出混淆矩阵
font = FontProperties(fname=r"c:\windows\fonts\msyh.ttc", size=10) # 字体
plt.matshow(matrix)
plt.colorbar()
plt.xlabel('预测类型', fontproperties=font)
plt.ylabel('实际类型', fontproperties=font)
labels = ['0', '1']
plt.xticks(np.arange(matrix.shape[1]), labels)
plt.yticks(np.arange(matrix.shape[1]), labels)
plt.show()
def plotArray( xyarray, colormap=mpl.cm.gnuplot2, normMin=None, normMax=None, showMe=True,
cbar=False, cbarticks=None, cbarlabels=None, plotFileName='arrayPlot.png',
plotTitle='', sigma=None):
"""
Plots the 2D array to screen or if showMe is set to False, to file. If normMin and
normMax are None, the norm is just set to the full range of the array.
"""
if sigma != None:
meanVal = np.mean(accumulatePositive(xyarray))
stdVal = np.std(accumulatePositive(xyarray))
normMin = meanVal - sigma*stdVal
normMax = meanVal + sigma*stdVal
if normMin == None:
normMin = xyarray.min()
if normMax == None:
normMax = xyarray.max()
norm = mpl.colors.Normalize(vmin=normMin,vmax=normMax)
figWidthPt = 550.0
inchesPerPt = 1.0/72.27 # Convert pt to inch
figWidth = figWidthPt*inchesPerPt # width in inches
figHeight = figWidth*1.0 # height in inches
figSize = [figWidth,figHeight]
params = {'backend': 'ps',
'axes.labelsize': 10,
'axes.titlesize': 12,
'text.fontsize': 10,
'legend.fontsize': 10,
'xtick.labelsize': 10,
'ytick.labelsize': 10,
'figure.figsize': figSize}
plt.rcParams.update(params)
plt.matshow(xyarray, cmap=colormap, origin='lower',norm=norm)
if cbar:
if cbarticks == None:
cbar = plt.colorbar(shrink=0.8)
else:
cbar = plt.colorbar(ticks=cbarticks, shrink=0.8)
if cbarlabels != None:
cbar.ax.set_yticklabels(cbarlabels)
plt.ylabel('Row Number')
plt.xlabel('Column Number')
plt.title(plotTitle)
if showMe == False:
plt.savefig(plotFileName)
# else:
# plt.show()
plt.close()
def plot_block_matrix(labels, tProb_, name='BlockMatrix'):
print "Plot Block Matrix"
indices = np.argsort(labels)
#print indices
block_matrix = tProb_[:,indices]
block_matrix = block_matrix[indices,:]
block_matrix = 1 - block_matrix
#print block_matrix
pylab.matshow(block_matrix, cmap=plt.cm.OrRd)
plt.colorbar()
plt.savefig('./' + name + '.png', dpi=400)
#pylab.show()
plt.close()
def plot_block_matrix(labels, tProb_, name='BlockMatrix'):
print("Plot Block Matrix")
indices = np.argsort(labels)
#print indices
block_matrix = tProb_[:, indices]
block_matrix = block_matrix[indices, :]
block_matrix = 1 - block_matrix
#print block_matrix
pylab.matshow(block_matrix, cmap=plt.cm.OrRd)
plt.colorbar()
plt.savefig('./' + name + '.png', dpi=400)
#pylab.show()
plt.close()
def predict(X, y, model):
labels = model.predict(X).flatten()
n_samples = X.shape[0]
err = float(np.sum(y != labels))/n_samples
print "Prediction error of ", err, "."
cm = sklearn.metrics.confusion_matrix(y, labels)
row_sum = cm.sum(axis=1).reshape(cm.shape[0], 1)
print "Frequencies of each class:", row_sum
cm = cm.astype(float)/row_sum
plt.matshow(cm)
plt.title("Confusion Matrix")
plt.colorbar()
plt.show()
def plot_target(A, cd):
X = []
Y = []
for line in cd:
X.append(float(line.split('\t')[0]))
Y.append(float(line.split('\t')[1]))
for h in range(len(X)):
ax = plt.axes(projection='3d')
a = int(X[h])
b = int(Y[h])
x_st = a - 25
x_en = a + 25
y_st = b - 25
y_en = b + 25
z = []
for i in range(y_st, y_en + 1, 1):
temp = []
for j in range(x_st, x_en + 1, 1):
temp.append(A[i][j])
z.append(temp)
x = np.linspace(x_st, x_en, (x_en - x_st) + 1)
y = np.linspace(y_st, y_en, (y_en - y_st) + 1)
Xin, Yin = np.meshgrid(x, y)
z = np.array(z)
data = z
plt.matshow(data, cmap=plt.cm.gist_earth_r)
params = fitgaussian(data)
fit = gaussian(*params)
p = ax.plot_surface(Xin,
Yin,
fit(*np.indices(data.shape)),
cmap=plt.cm.copper)
q = ax.scatter(Xin, Yin, z, marker='.')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.colorbar()
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('pixel count')
ax = plt.gca()
(height, x, y, width_x, width_y, base) = params
fwhm_x = 2 * sqrt(log(2.0)) * width_x
fwhm_y = 2 * sqrt(log(2.0)) * width_y
print 'Coordinates of the target object', (a, b)
#print 'FWHM-X =', fwhm_x, '\nFWHM-Y =', fwhm_y
print 'Sky base =', base
print 'Peak value =', height
print 'Mean (x,y) =', (x, y)
plt.show()
return None
def simular(self): pass i=0 g = [] while True: pass if (self.uf.find(self.cell(0,0),self.cell(self.N-1,self.N-1))): plt.plot(g) plt.show() pll.matshow(self.celda) pll.show() return int(i) i=i+1 g.append(i/self.N*self.N) self.step()
def main():
parser = ap.ArgumentParser()
parser.add_argument('--data_dir', type=str, default='../data_helpers/', help='Folder containing data splits.')
parser.add_argument('--data', type=str, help='The location of the data file we are using.')
parser.add_argument('--mode', type=str, help='Either PREDICT or TRAIN. Will predict on test dataset or train on new dataset accordingly.')
parser.add_argument('--old_model', type=str, default=None, help='The file location of the neural network model. If this is None, we will train a model from scratch, but this needs to be specified for predict.')
parser.add_argument('--num_hidden', type=int, default=1000, help='The number of hidden layers in the classifier.')
parser.add_argument('--n_iter', type=int, default=2, help='Number of iterations of gradient descent to use.')
parser.add_argument('--outfile', type=str, help='The file which we output the trained model to.')
parser.add_argument('--lr', type=float, default=0.01, help='Learning rate to use.')
parser.add_argument('--allowed_num', type=int, help='The allowed number of training examples for one class.')
parser.add_argument('--name_map', type=str, default='classmap.pkl', help='Name of the pickle file which stores the class map.')
parser.add_argument('--num_split', type=int, default='13', help='The number of training splits to do.')
parser.add_argument('--predict_set', type=str, default='test', help='Whether we predict on train or test.')
parser.add_argument('--lr_decay', type=float, default=0.75, help='Learning rate decay every time we pass over a split.')
parser.add_argument('--hardcode', type=bool, default=False, help='Whether to hardcode allowed number of classes.')
global args
args = parser.parse_args()
class_map = allowed_classes if args.hardcode else pickle.load(open(args.name_map, "r"))
num_classes = len(class_map)
model = None if args.old_model is None else pickle.load(open(args.old_model, "r"))
if args.mode == 'TRAIN':
lr = args.lr
for _ in xrange(args.n_iter):
for split in xrange(args.num_split):
data_loc = args.data_dir + ("trainsplit%d" % split) + args.data
X, y, w = convert_data(data_loc, class_map)
model = train(X, y, w, num_classes, model, lr)
lr *= args.lr_decay
if args.mode == 'PREDICT':
all_predict = np.array([])
all_labels = np.array([])
for split in xrange(args.num_split):
data_loc = args.data_dir + (args.predict_set + "split%d" % split) + args.data
X, y, _ = convert_data(data_loc, class_map)
all_predict = np.concatenate((all_predict, predict_split(X, y, model)), axis=0)
all_labels = np.concatenate((all_labels, y), axis=0)
n_samples = all_labels.size
err = float(np.sum(all_predict != all_labels))/n_samples
print "Prediction error of ", err, "."
cm = sklearn.metrics.confusion_matrix(all_labels, all_predict)
row_sum = cm.sum(axis=1).reshape(cm.shape[0], 1)
print "Frequencies of each class:", row_sum
cm = cm.astype(float)/row_sum
plt.matshow(cm)
plt.title("Confusion Matrix")
plt.colorbar()
plt.show()
def savepic(mat, maxscale, picname):
fig = plt.matshow(mat, vmin=0, vmax=maxscale)
plt.axis('off')
fig.axes.get_xaxis().set_visible(False)
fig.axes.get_yaxis().set_visible(False)
plt.savefig(picname, bbox_inches='tight', pad_inches = 0, dpi=100)
plt.close()
def plot_grade(self, titulo, nome, args, save_figure=True):
"""
Metodo que plota a representacao 2D da grade
:param titulo: Contador das imagens
:param nome: Nome da imagem a ser salva
:param args: Argumentos usados para executar o teste
"""
#Opcoes de cor: "RdBu" "seismic" , "RdYlGn", "jet"
# mais em: http://matplotlib.org/users/colormaps.html
plt.matshow(self.matriz_grade(), cmap="RdBu", fignum=0)
# Opcao para salvar imagens
if save_figure:
plt.savefig(self.pasta + nome + '.png')
plt.title(titulo)
plt.xlabel("Argumentos: " + str(args))
plt.draw()
def plot_confusion_matrix(cm, genre_list, name="", title=""):
pylab.clf()
pylab.matshow(cm, fignum=False, cmap=plt.cm.Blues)
ax = pylab.axes()
ax.set_xticks(range(len(genre_list)))
ax.set_xticklabels(genre_list)
ax.xaxis.set_ticks_position("bottom")
ax.set_yticks(range(len(genre_list)))
ax.set_yticklabels(genre_list)
#pylab.title(title)
pylab.colorbar()
pylab.grid(False)
pylab.xlabel('Predicted class')
pylab.ylabel('True class')
pylab.grid(False)
pylab.show()
def dibujAutom(self):
print self.bondad
#ID = self.id_CI
for i in xrange(self.nCI):
c = (i)#ID) # tupla que dara el numero de la regla y de la CI para guardar la imagen.
matrizEstados = self.m_r[i]
pylab.matshow(matrizEstados,cmap='binary')
pylab.title("Celdas")
pylab.ylabel("Tiempo")
pylab.savefig("Test_Regla_CI%i.eps" %c)
pylab.close()
# Aqui salvamos el automata seleccionado
f = open('automata_CI_%i.txt' %c,'w')
fout = csv.writer(f,delimiter = '\t')
fout.writerows(matrizEstados)
f.close()
def PlotTurbulenceIllustrZFlat(g):
"Like PlotTurbulenceIllustr but use the ZFlatten routine"
Nx, Ny, Nz = g[1]
for x in [1,10,100]:
res=ZFlatten(g,x)
na=kolmogorovutils.GridToNumarray( (res, (Nx,Ny,1)))
na=na[:,:,0]
na.transpose()
pylab.clf()
pylab.matshow(na)
pylab.savefig("temp/turb3d-zflatsum%03i.eps" % x)
def plot_confusion_matrix(cm, targetname):
pylab.clf()
pylab.matshow(cm, fignum=False, cmap='Blues', vmin=0, vmax=1.0)
ax = pylab.axes()
ax.set_xticks(range(len(targetname)))
ax.set_xticklabels(targetname)
ax.xaxis.set_ticks_position("bottom")
ax.set_yticks(range(len(targetname)))
ax.set_yticklabels(targetname)
pylab.title('Confusion Matrix')
pylab.colorbar()
pylab.grid(False)
pylab.xlabel('Predicted class')
pylab.ylabel('True class')
pylab.grid(False)
pylab.show()
def show_confusion_matrix(matrix, labels, title=""):
pylab.clf()
pylab.matshow(matrix, fignum=False, cmap='Blues', vmin=0, vmax=1.0)
pylab.title(title)
pylab.colorbar()
pylab.grid(False)
pylab.xlabel('Predicted Class')
pylab.ylabel('True Class')
nums = range(len(labels))
axes = pylab.axes()
axes.set_xticks(nums)
axes.set_xticklabels(labels)
axes.set_yticks(nums)
axes.set_yticklabels(labels)
axes.xaxis.set_ticks_position('bottom')
pylab.show()
def plot_confusion_matrix(cm, genre_list, name, title):
pylab.clf()
pylab.matshow(cm, fignum=False, cmap='Blues', vmin=0, vmax=1.0)
ax = pylab.axes()
ax.set_xticks(range(len(genre_list)))
ax.set_xticklabels(genre_list)
ax.xaxis.set_ticks_position("bottom")
ax.set_yticks(range(len(genre_list)))
ax.set_yticklabels(genre_list)
pylab.title(title)
pylab.colorbar()
pylab.grid(False)
pylab.xlabel('Predicted class')
pylab.ylabel('True class')
pylab.grid(False)
pylab.savefig(
os.path.join(CHART_DIR, "confusion_matrix_%s.png" % name), bbox_inches="tight")
def plot_confusion_matrix(cm, genre_list, name, title, filename):
pylab.clf()
pylab.matshow(cm, fignum=False)
ax = pylab.axes()
ax.set_xticks(range(len(genre_list)))
ax.set_xticklabels(genre_list)
ax.xaxis.set_ticks_position("bottom")
ax.set_yticks(range(len(genre_list)))
ax.set_yticklabels(genre_list)
pylab.title(title)
pylab.colorbar()
pylab.grid(False)
pylab.xlabel('Predicted class')
pylab.ylabel('True class')
pylab.grid(False)
pylab.show()
filename = '/home/kaushik/Canopy/kaushik_py/music_wav/' + filename
plt.savefig(filename)
def makeItt2():
# makes the pretty latex tabular and prints matrix, emphasises edges, make sure to put a '-' at end
#A = ['S','A','T','A','N','S','S','P','A','W','N','-','S','A','T','A','N','S','P','R','A','W','N','-']
#A = ['S','A','T','A','N','-','S','P','A','W','N','-','P','A','T','A','N','S','-','P','R','A','W','N','-']
A = ['V','E','L','V','E','T','R','Q','P','E','A','L','G','Q','R','I','T','H','M','R','Q','C','K','S']
B = ['P','E','A','T','C','Q','A','T','V','E','L','V','E','T','R','Q','C','K','S','A','L','L','Q','R','I','T','H','A','M','Q','C','K','S','L','V','A','R','P','Q','E','V','T','Y','M','E','T']
theMat, temp = MakeMatrixFull(A)
string = "\\begin{tabular}{|"
for i in range(len(A)-1):
string = string + 'c'
string = string + '|}'
print string
print '\hline'
string = ""
for i in range(len(A)-2):
string = string + A[i] + " & "
string = string + A[-2] + " \\\\"
print string
print '\hline'
for i in range(len(A)-1):
string = ""
for j in range(len(A)):
if theMat[i+1][j] == 0:
if A[(j+i+1)%len(A)] == '-':
if j < len(A) - 1:
string = string + " \\textcolor{blue}{$\star$} "
theMat[i+1][j] = -1
else:
if A[j] == '-':
if j < len(A) - 1:
string = string + " \\textcolor{blue}{$\star$} "
theMat[i+1][j] = -1
else:
string = string + " " + A[(j+i+1)%len(A)] + " "
else:
string = string + " \\textcolor{red}{" + A[(j+i+1)%len(A)] + "} "
if j < len(A) - 2:
string = string + "&"
else:
string = string + "\\"
print string
print '\hline'
print '\end{tabular}'
plt.matshow(theMat)
def diff_mat(fmin, fmax, mat_dir=None, ROI_labels=None,
incon_event=['LRst', 'RLst'], con_event=['LLst', 'RRst']):
"""
Make comparisons between two conditions' group causal matrices
----------
con_event: list
The list of congruent conditions.
incon_event: string
The name of incongruent condition.
ROI_labels: list
The list of ROIs.
fmin, fmax:int
The interest bandwidth.
min_subject: string
The subject for the common brain space.
"""
fn_con1 = mat_dir + '/%s_%d_%dHz.npy' % (con_event[0], fmin, fmax)
fn_con2 = mat_dir + '/%s_%d_%dHz.npy' % (con_event[1], fmin, fmax)
fn_incon1 = mat_dir + '/%s_%d_%dHz.npy' % (incon_event[0], fmin, fmax)
fn_incon2 = mat_dir + '/%s_%d_%dHz.npy' % (incon_event[1], fmin, fmax)
am_ROI = len(ROI_labels)
con_cau1 = np.load(fn_con1)
con_cau2 = np.load(fn_con2)
con_cau = con_cau1 + con_cau2
incon_cau = np.load(fn_incon1) + np.load(fn_incon2)
con_cau[con_cau > 0] = 1
incon_cau[incon_cau > 0] = 1
dif_cau = incon_cau - con_cau
dif_cau[dif_cau < 0] = 0
com_cau = incon_cau - dif_cau
com_cau[com_cau < 0] = 0
fn_dif = mat_dir + '/incon_con_%d-%dHz.npy' % (fmin, fmax)
fn_com = mat_dir + '/com_incon_con_%d-%dHz.npy' % (fmin, fmax)
fig_dif = mat_dir + '/incon_con_%d-%dHz.png' % (fmin, fmax)
plt.matshow(dif_cau, interpolation='nearest')
plt.xticks(np.arange(am_ROI), ROI_labels, fontsize=9, rotation='vertical')
plt.yticks(np.arange(am_ROI), ROI_labels, fontsize=9)
# pl.tight_layout(pad=2)
# pl.show()
plt.savefig(fig_dif, dpi=300)
plt.close()
np.save(fn_dif, dif_cau)
np.save(fn_com, com_cau)
