Python pylab.matshow函数代码示例

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 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 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 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 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 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 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 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 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 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):
     """
     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 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()