def master_loop():
    gene_names = []
    master_store = []
    time_stamps = []
    dump_dict = {}
    for file_name in os.listdir(source_folder):
        if file_name[-4:] == '.vcf':
            print file_name
            master_mix = np.array(pull_average_depth_for_genes(pull_depth_from_vcf(file_name)))
            time_stamps.append(file_name[:-4])
            gene_names = master_mix[:, 0]
            master_store.append(master_mix[:, 1])
            dump_dict[file_name[:-4]] = [master_mix]

    print dump_dict
    dump(dump_dict, open('my_pipe.dmp', 'w'))
    arg_sorter = np.argsort(np.array([int(val[1:]) for val in time_stamps]))
    time_stamps = np.array(time_stamps)[arg_sorter]
    print time_stamps
    master_store = np.array(master_store)
    master_store = master_store[arg_sorter, :].astype(np.float32)
    master_store[np.isnan(master_store)] = 0
    print master_store
    dataframe = pd.DataFrame(data=master_store.T, index=gene_names, columns=time_stamps)
    sns.heatmap(dataframe)
    sns.plt.show()
    sns.clustermap(dataframe)
    sns.plt.show()
    sns.clustermap(dataframe, col_cluster=False)
    sns.plt.show()
Example #2
0
def plot_filter_seq_heat(filter_outs, out_pdf, whiten=True, drop_dead=True):
    # compute filter output means per sequence
    filter_seqs = filter_outs.mean(axis=2)

    # whiten
    if whiten:
        filter_seqs = preprocessing.scale(filter_seqs)

    # transpose
    filter_seqs = np.transpose(filter_seqs)

    if drop_dead:
        filter_stds = filter_seqs.std(axis=1)
        filter_seqs = filter_seqs[filter_stds > 0]

    # downsample sequences
    seqs_i = np.random.randint(0, filter_seqs.shape[1], 500)

    hmin = np.percentile(filter_seqs[:,seqs_i], 0.1)
    hmax = np.percentile(filter_seqs[:,seqs_i], 99.9)

    sns.set(font_scale=0.3)

    plt.figure()
    sns.clustermap(filter_seqs[:,seqs_i], row_cluster=True, col_cluster=True, linewidths=0, xticklabels=False, vmin=hmin, vmax=hmax)
    plt.savefig(out_pdf)
    #out_png = out_pdf[:-2] + 'ng'
    #plt.savefig(out_png, dpi=300)
    plt.close()
def plot_centrimo(centrimo_in, figure_output):
    centrimo_table = pd.read_table(centrimo_in, index_col=0)
    centrimo_table.sort(columns="Average", axis=0, ascending=False, inplace=True)
    sns.clustermap(centrimo_table, method='single', metric="euclidean",
                   z_score=None, row_cluster=False, col_cluster=True)
    f = plt.gcf()
    f.savefig(figure_output, bbox_inches='tight')
Example #4
0
def plot_target_corr(filter_outs, seq_targets, filter_names, target_names, out_pdf, seq_op='mean'):
    num_seqs = filter_outs.shape[0]
    num_targets = len(target_names)

    if seq_op == 'mean':
        filter_outs_seq = filter_outs.mean(axis=2)
    else:
        filter_outs_seq = filter_outs.max(axis=2)

    # std is sequence by filter.
    filter_seqs_std = filter_outs_seq.std(axis=0)
    filter_outs_seq = filter_outs_seq[:,filter_seqs_std > 0]
    filter_names_live = filter_names[filter_seqs_std > 0]

    filter_target_cors = np.zeros((len(filter_names_live),num_targets))
    for fi in range(len(filter_names_live)):
        for ti in range(num_targets):
            cor, p = spearmanr(filter_outs_seq[:,fi], seq_targets[:num_seqs,ti])
            filter_target_cors[fi,ti] = cor

    cor_df = pd.DataFrame(filter_target_cors, index=filter_names_live, columns=target_names)

    sns.set(font_scale=0.3)
    plt.figure()
    sns.clustermap(cor_df, cmap='BrBG', center=0, figsize=(8,10))
    plt.savefig(out_pdf)
    plt.close()
def visualizeConsensus(consensusMat, connectivityMatrices, clusters, colNames):
	if colNames=='noXLabels':
		#put concensus matrix into dataframe to build hierarchical clustermap		
		dataframe=pd.DataFrame(data=consensusMat)
		#clusters by columns and rows and annotates probablility a particular sample clusters together
		#cluster distance is meausred by average Euclidean Distance in seaborn for hierarchical clustering
		consensusClustered=sns.clustermap(dataframe, col_cluster=True, row_cluster=True, annot=True)
		consensusClustered.savefig(str(matrixPath)+'consensus_Matrix_over_'+str(len(connectivityMatrices))+'_runs_at_k='+str(clusters)+'.png')
	
	else:
		#assigns sample names to consensus matrix
		sampleNames=[]
		with open(colNames) as input:
			for line in input:
				sampleNames.append(line.rstrip('\n'))
		#put concensus matrix into dataframe to build hierarchical clustermap		
		dataframe=pd.DataFrame(data=consensusMat, index=sampleNames, columns=sampleNames)
		#clusters by columns and rows and annotates probablility a particular sample clusters together
		#cluster distance is meausred by average Euclidean Distance in seaborn for hierarchical clustering
		consensusClustered=sns.clustermap(dataframe, col_cluster=True, row_cluster=True, annot=True)
		consensusClustered_non_annt=sns.clustermap(dataframe, col_cluster=True, row_cluster=True, annot=False)
		plt.setp(consensusClustered.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
		plt.setp(consensusClustered_non_annt.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
		plt.setp(consensusClustered.ax_heatmap.xaxis.get_majorticklabels(), rotation=90)
		plt.setp(consensusClustered_non_annt.ax_heatmap.xaxis.get_majorticklabels(), rotation=90)
		consensusClustered.savefig(str(matrixPath)+'consensus_Matrix_over_'+str(len(connectivityMatrices))+'_runs_at_k='+str(clusters)+'.png')
		consensusClustered_non_annt.savefig(str(matrixPath)+'non_annotated_consensus_Matrix_over_'+str(len(connectivityMatrices))+'_runs_at_k='+str(clusters)+'.png')
def produce_clustermap(rankings, fname, metric):
    sns.set()
    sns.set_context("paper")

    pp = PdfPages(fname)
    sns.clustermap(rankings, col_cluster=False, metric=metric)
    pp.savefig()
    pp.close()
Example #7
0
def drawClustermap(df, output):
    if args.scaling == 'z_score':
        g = sns.clustermap(df, method=args.cluster_method, metric=args.distance_metric, linewidths=0.5, cmap=args.color, col_cluster=cluster, z_score=0, figsize=figSize)
    elif args.scaling == 'standard':
        g = sns.clustermap(df, method=args.cluster_method, metric=args.distance_metric, linewidths=0.5, cmap=args.color, col_cluster=cluster, standard_scale=0, figsize=figSize)
    else:
        g = sns.clustermap(df, method=args.cluster_method, metric=args.distance_metric, linewidths=0.5, cmap=args.color, col_cluster=cluster, figsize=figSize)
    plt.setp(g.ax_heatmap.get_yticklabels(), rotation=0, size=int(args.yaxis_fontsize), family=args.font)
    plt.setp(g.ax_heatmap.get_xticklabels(), rotation=90, size=int(args.xaxis_fontsize), family=args.font, weight='bold')
    g.savefig(output, format='pdf', dpi=1000, bbox_inches='tight')
Example #8
0
def plot_filter_seg_heat(filter_outs, out_pdf, whiten=True, drop_dead=True):
    b = filter_outs.shape[0]
    f = filter_outs.shape[1]
    l = filter_outs.shape[2]

    s = 5
    while l/float(s) - (l/s) > 0:
        s += 1
    print '%d segments of length %d' % (s,l/s)

    # split into multiple segments
    filter_outs_seg = np.reshape(filter_outs, (b, f, s, l/s))

    # mean across the segments
    filter_outs_mean = filter_outs_seg.max(axis=3)

    # break each segment into a new instance
    filter_seqs = np.reshape(np.swapaxes(filter_outs_mean, 2, 1), (s*b, f))

    # whiten
    if whiten:
        filter_seqs = preprocessing.scale(filter_seqs)

    # transpose
    filter_seqs = np.transpose(filter_seqs)

    if drop_dead:
        filter_stds = filter_seqs.std(axis=1)
        filter_seqs = filter_seqs[filter_stds > 0]

    # downsample sequences
    seqs_i = np.random.randint(0, filter_seqs.shape[1], 500)

    hmin = np.percentile(filter_seqs[:,seqs_i], 0.1)
    hmax = np.percentile(filter_seqs[:,seqs_i], 99.9)

    sns.set(font_scale=0.3)
    if whiten:
        dist = 'euclidean'
    else:
        dist = 'cosine'

    plt.figure()
    sns.clustermap(filter_seqs[:,seqs_i], metric=dist, row_cluster=True, col_cluster=True, linewidths=0, xticklabels=False, vmin=hmin, vmax=hmax)
    plt.savefig(out_pdf)
    #out_png = out_pdf[:-2] + 'ng'
    #plt.savefig(out_png, dpi=300)
    plt.close()
Example #9
0
def get_seaborn_clustermap(dfr, params, title=None, annot=True):
    """Returns a Seaborn clustermap."""
    fig = sns.clustermap(
        dfr,
        cmap=params.cmap,
        vmin=params.vmin,
        vmax=params.vmax,
        col_colors=params.colorbar,
        row_colors=params.colorbar,
        figsize=(params.figsize, params.figsize),
        linewidths=params.linewidths,
        xticklabels=params.labels,
        yticklabels=params.labels,
        annot=annot,
    )
    fig.cax.yaxis.set_label_position("left")
    if title:
        fig.cax.set_ylabel(title)

    # Rotate ticklabels
    fig.ax_heatmap.set_xticklabels(fig.ax_heatmap.get_xticklabels(), rotation=90)
    fig.ax_heatmap.set_yticklabels(fig.ax_heatmap.get_yticklabels(), rotation=0)

    # Return clustermap
    return fig
Example #10
0
def clust_heatmap(gene_list, df_by_gene, num_to_plot=len(gene_list), title='', plot=False, label_map=False):
    if num_to_plot >175:
        sns.set(context= 'poster', font_scale = 0.65/(num_to_plot/100))
    else:
        sns.set(context= 'poster', font_scale = .80, font ='Verdana')
    sns.set_palette('RdBu',4,0.1)
    cell_list = df_by_gene.index.tolist()
    cg = sns.clustermap(df_by_gene[gene_list[0:num_to_plot]].transpose(), metric=metric, method=method, z_score=0, figsize=(30, 25))
    col_order = cg.dendrogram_col.reordered_ind
    cg.ax_heatmap.set_title(title)
    if label_map:
        Xlabs = [cell_list[i] for i in col_order]
        colors = [label_map[cell][0] for cell in Xlabs]
        for xtick, color in zip(cg.ax_heatmap.get_xticklabels(), colors):
            xtick.set_color(color)
            xtick.set_rotation(270)
    if plot:
        plt.show()
    cell_linkage = cg.dendrogram_col.linkage

    link_mat = pd.DataFrame(cell_linkage,
                columns=['row label 1', 'row label 2', 'distance', 'no. of items in clust.'],
                index=['cluster %d' %(i+1) for i in range(cell_linkage.shape[0])])
    if title != '':
        save_name = '_'.join(title.split(' ')[0:2])
        cg.savefig(os.path.join(filename, save_name+'_heatmap.pdf'), bbox_inches='tight')
    else:
        cg.savefig(os.path.join(filename,'Non_group_heatmap_z1_deleted.pdf'), bbox_inches='tight')
    plt.close()
    return cell_linkage, df_by_gene[gene_list[0:num_to_plot]], col_order
def plot_clustermap(dat, cmap='purple', save_fig=False, save_name='Clustermap'):
    """Plot clustermap.

    Parameters
    ----------
    dat : pandas.DataFrame
        Data to create clustermap from.
    """

    # Set up plotting and aesthetics
    sns.set()
    sns.set_context("paper", font_scale=1.5)

    # Set colourmap
    if cmap == 'purple':
        cmap = sns.cubehelix_palette(as_cmap=True)
    elif cmap == 'blue':
        cmap = sns.cubehelix_palette(as_cmap=True, rot=-.3, light=0.9, dark=0.2)

    # Create the clustermap
    cg = sns.clustermap(dat, cmap=cmap, method='complete', metric='cosine', figsize=(12, 10))

    # Fix axes
    cg.cax.set_visible(True)
    _ = plt.setp(cg.ax_heatmap.xaxis.get_majorticklabels(), rotation=60, ha='right')
    _ = plt.setp(cg.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)

    # Save out - if requested
    if save_fig:

        db = check_db(db)
        s_file = os.path.join(db.figs_path, save_name + '.svg')

        cg.savefig(s_file, transparent=True)
def plot_heatmap_with_dendrogram(similarity_matrix, plot_name, show_link):
    """
    Makes a plot of heatmap and dendrogram. Arguments are a similarity matrix
    (as Pandas data frame) and the name of the plot.
    """
    # the distance matrix has to be condensed first
    cond_dist_matrix = pdist.squareform(100 - similarity_matrix)
    # linkage makes the whole mathematics
    Z = linkage(cond_dist_matrix, 'average')
    # uncomment the print statement to see the linkage matrix
    if show_link:
        print(Z)
    sns.set(font='sans-serif', font_scale=0.7)
    # round the figures displayed in the heatmap as to integers
    pairwise_cognacy_displayinheatmap = np.round(
            similarity_matrix, decimals=0).astype(int)
    # create a seaborn clustermap object
    heatncluster = sns.clustermap(
            pairwise_cognacy_displayinheatmap, annot=True, cmap='inferno_r',
            vmax=100, fmt='d', col_linkage=Z, row_linkage=Z)
    plt.setp(heatncluster.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
    plt.setp(heatncluster.ax_heatmap.xaxis.get_majorticklabels(), rotation=45)

    file_name = plot_name + '.png'
    click.echo('Writing ' + file_name, err=True)
    plt.savefig(file_name)
Example #13
0
def plot_heatmap(data, columns=None, chrom="chrom", position="position", vline_color="black", **kwargs):
    """Plots a (clustered) CNV heatmap for multiple samples."""

    # Select all columns by default.
    if columns is None:
        columns = [c for c in data if c not in {chrom, position}]

    # Sort data by position.
    data = data.sort([chrom, position], ascending=True)

    # Plot heatmap.
    g = sns.clustermap(data[columns].T, linewidths=0, col_cluster=False, **kwargs)
    g.ax_heatmap.set_xticks([])

    # Plot chromosome breaks.
    breaks = np.where(~data[chrom].duplicated(take_last=True))[0]
    breaks += 1

    for loc in breaks[:-1]:
        g.ax_heatmap.axvline(loc, color=vline_color)

    # Add chromosome labels.
    label_pos = np.concatenate([[0], breaks])
    label_pos = (label_pos[:-1] + label_pos[1:]) / 2

    g.ax_heatmap.set_xticks(label_pos)
    g.ax_heatmap.set_xticklabels(data[chrom].unique(), rotation=0)

    # Label axes.
    g.ax_heatmap.set_xlabel(chrom)

    return g
Example #14
0
def plot_clustermap(df, output_path, cmap=None, legend_label='',
                    z_score=None, xticklabels=False, yticklabels=True,
                    colors_dict=None, col_colors=None, row_colors=None):
    """Make clustermap figure

    Parameters
    ----------
    df
    df_meta
    output_path

    Returns
    -------
    cg
    """

    cg = sns.clustermap(df, col_colors=col_colors, row_colors=None,
                        cmap=cmap, z_score=z_score,
                        yticklabels=yticklabels, xticklabels=xticklabels)

    if colors_dict:
        for cat in colors_dict.keys():
            for label in colors_dict[cat]:
                cg.ax_col_dendrogram.bar(0, 0, color=colors_dict[cat][label],
                                         label=label, linewidth=0)
        cg.ax_col_dendrogram.legend(loc=(-0.7, -2), ncol=1)

    plt.subplots_adjust(top=1, bottom=0.02, left=0.3, right=0.8)
    fig = plt.gcf()
    fig.set_size_inches([10, 7.5])
    cg.cax.set_position((.025, .1, 0.025, .15))
    cg.cax.text(-0.3, -0.2, legend_label, fontsize=9)
    plt.savefig(output_path, dpi=300)
    return cg
Example #15
0
    def __call__(self, data, path):

        colorbar = self.getColorBar(data)
        n_samples = data.shape[0]
        data = data.iloc[:, :n_samples]
        ax = seaborn.clustermap(data, row_colors=colorbar)
        return ResultBlocks(ResultBlock("""#$mpl %i$#\n""" % ax.cax.figure.number, title="ClusterMapPlot"))
Example #16
0
    def plot_enrichment_multiple(self, multi_gene_list, output_filename):
        enrichment_results_df = self.iterative_enrichment_multilist(multi_gene_list)

        # replace accession numbers with GO term descriptions
        formatted_enrichment_df = enrichment_results_df.merge(self.term_definition, left_index=True,
                                                              right_on='GO term accession')
        formatted_enrichment_df['GO term'] = (formatted_enrichment_df['GO term name'] + '\n[' +
                                              formatted_enrichment_df['GO term accession'] + ']')
        formatted_enrichment_df.drop(self.term_definition.columns, axis=1, inplace=True)
        formatted_enrichment_df.set_index('GO term', inplace=True)

        sns.set(style='whitegrid')
        plt.figure()
        plot = sns.clustermap(formatted_enrichment_df, cmap="Reds_r")
        plt.setp(plot.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
        # plot.set_xlabel(r'$-log_{10}(p)$')
        # plot.set_ylabel('')
        # plot.xaxis.grid(False)
        # plot.yaxis.grid(True)
        # sns.despine(left=True, bottom=True)

        if output_filename:
            plot.savefig(output_filename)
        else:
            plt.show()
Example #17
0
def plot_dist_matrix(matrix, fasta_names, heatmap_out, dendrogram_out):
    """Cluster the distance matrix hierarchically and plot using seaborn.
    Average linkage method is used."""
    # Load required modules for plotting
    import matplotlib
    matplotlib.use('Agg')
    import matplotlib.pyplot as plt
    import seaborn as sns
    import pandas as pd
    from scipy.cluster.hierarchy import dendrogram, linkage

    # Create
    pdm = pd.DataFrame(matrix, index=fasta_names, columns=fasta_names)

    # Plot heatmap
    figsizex = max(10, len(fasta_names) / 4)
    clustergrid = sns.clustermap(pdm, metric='euclidean', method='average',
            figsize=(figsizex, figsizex))
    clustergrid.savefig(heatmap_out)

    # Plot dendrogram
    sns.set_style('white')
    figsizey = max(10, len(fasta_names) / 8)
    f, ax = plt.subplots(figsize=(figsizex, figsizey))
    link = linkage(pdm, metric='euclidean', method='average')
    dendrogram(link, labels=pdm.index, ax=ax)
    no_spine = {'left': True, 'bottom': True, 'right': True, 'top': True}
    sns.despine(**no_spine)
    plt.xticks(rotation=90)
    f.tight_layout()
    plt.savefig(dendrogram_out)
Example #18
0
def plot_transition_clustermap(data_array, gene_names, pseudotimes, n_clusters=10, gradient=False):
    if gradient:
        data_to_plot = zscore(np.gradient(data_array)[1].T, axis=0)
        scale = None
        metric = 'seuclidean'
        row_linkage = linkage(pdist(abs(data_to_plot), metric=metric), method='complete')
    else:
        data_to_plot = data_array.T
        scale = 0
        metric = 'correlation'
        row_linkage = linkage(pdist(data_to_plot, metric=metric), method='complete')
    
    assignments = fcluster(row_linkage, n_clusters, criterion='maxclust')
    cm = sns.clustermap(data_to_plot, col_cluster=False, standard_scale=scale, 
                        yticklabels=gene_names, row_linkage=row_linkage,
                        row_colors=[settings.STATE_COLORS[i] for i in assignments])
    r = np.arange(10, data_array.shape[0], data_array.shape[0]/10)
    plt.setp(cm.ax_heatmap.get_yticklabels(), fontsize=5)
    cm.ax_heatmap.set_xticks(r)
    cm.ax_heatmap.set_xticklabels(['%.1f' % x for x in pseudotimes[r]])
    cm.ax_heatmap.set_xlabel('Pseudotime')
    cm.ax_heatmap.set_ylabel('Gene')
    
    gene_clusters = defaultdict(list)
    for i, cl in enumerate(assignments):
        gene_clusters[settings.STATE_COLORS[cl]].append(gene_names[i])
    return gene_clusters
Example #19
0
def CorrFig(data,outname):
    data.corr().to_csv(outname+'.corr',index=True,header=True,sep='\t')
    seaborn.set_context('notebook', font_scale=1.2)
    fig1 = seaborn.clustermap(data.corr(), method='average', metric='euclidean', figsize=(12,12), cmap='YlGnBu', annot=True)
    plt.setp(fig1.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
    plt.setp(fig1.ax_heatmap.xaxis.get_majorticklabels(), rotation=90)
    plt.savefig(outname+'.corr.pdf')
    return
Example #20
0
def plot_clustermap(df):
    # corr = df.corr()
    # yticks = corr.index
    
    # sns.clustermap(corr, 'yticklabels=yticks')
    cg=sns.clustermap(df.corr())
    # plt.yticks(rotation=0)
    plt.setp(cg.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)    
Example #21
0
def clustermap(corpus, distance_matrix=None, color_leafs=True,
               outputfile=None, fontsize=5,
               save=False, show=False, return_svg=False):
    """
    Draw a square clustermap of the corpus using seaborn's
    `clustermap`.
    
    Parameters
    ----------
    corpus : `Corpus` instance
        The corpus to be plotted.
    distance_matrix : array-like, [n_texts, n_texts]
        A square distance matrix holding the 
        pairwise distances between all the texts in 
        the corpus.
    color_leafs: boolean, default=True,
        If true, will color the text labels on the
        axis according to their category.
    outputfile : str
        The path where the plot should be saved.
    fontsize : int, default=5
        The fontsize of the labels on the axes.
    save : boolean, default=False
        Whether to save the plot to `outputfile`.

    """
    plt.clf()
    # convert to pandas dataframe:
    labels = corpus.titles
    df = pd.DataFrame(data=distance_matrix, columns=labels)
    df = df.applymap(lambda x:int(x*1000)).corr()

    # clustermap plotting:
    cm = sns.clustermap(df)
    ax = cm.ax_heatmap
        # xlabels:
    for idx, label in enumerate(ax.get_xticklabels()):
        label.set_rotation('vertical')
        label.set_fontname('Arial')
        label.set_fontsize(fontsize)
        if color_leafs:
            label.set_color(plt.cm.spectral(corpus.target_ints[idx] / 10.))

    # ylabels:
    for idx, label in enumerate(ax.get_yticklabels()):
        label.set_rotation('horizontal')
        label.set_fontname('Arial')
        label.set_fontsize(fontsize)
        if color_leafs:
            label.set_color(plt.cm.spectral(corpus.target_ints[-idx-1] / 10.)) # watch out: different indexing on this axis
    if save:
        if outputfile:
            outputfile = os.path.expanduser(outputfile)
        cm.savefig(outputfile)
    if show:
        plt.show()
    if return_svg:
        return plt_fig_to_svg(cm)
Example #22
0
def main():
    args = parser.parse_args()
    import numpy as np
    import pandas as pd
    import seaborn as sns
    major_index = args.major_index
    minor_index = args.minor_index
    df = pd.read_table(args.tsv, index_col=[major_index, minor_index], sep=args.delimiter)
    df = np.log2(df) if args.log_normalize else df
    # set our undected samples to our lowest detection
    df[df==-1*np.inf] = df[df!=-1*np.inf].min().min()
    # translate our data so we have no negatives (which would screw up our addition and makes no biological sense)
    if args.translate:
        df+=abs(df.min().min())
    major_counts = df.groupby(level=[major_index]).count()
    # we only want to plot samples with multiple values in the minor index
    cutoff = args.minor_cutoff
    multi = df[df.index.get_level_values(major_index).isin(major_counts[major_counts>=cutoff].dropna().index)]

    # Let's select the most variable minor axis elements
    most_variable = multi.groupby(level=major_index).var().mean(axis=1).order(ascending=False)
    # and group by 20s
    for i in xrange(11):
        dat = multi[multi.index.get_level_values(major_index).isin(most_variable.index[10*i:10*(i+1)])]
        # we want to cluster by our major index, and then under these plot the values of our minor index
        major_dat = dat.groupby(level=major_index).sum()
        seaborn_map = sns.clustermap(major_dat, row_cluster=True, col_cluster=True)
        # now we keep this clustering, but recreate our data to fit the above clustering, with our minor
        # index below the major index (you can think of transcript levels under gene levels if you are
        # a biologist)
        merged_dat = pd.DataFrame(columns=[seaborn_map.data2d.columns])
        for major_val in seaborn_map.data2d.index:
            minor_rows = multi[multi.index.get_level_values(major_index)==major_val][seaborn_map.data2d.columns]
            major_row = major_dat.loc[major_val, ][seaborn_map.data2d.columns]
            merged_dat.append(major_row)
            merged_dat = merged_dat.append(major_row).append(minor_rows)
        merged_map = sns.clustermap(merged_dat, row_cluster=False, col_cluster=False)

        # recreate our dendrogram, this is undocumented and probably a hack but it works
        seaborn_map.dendrogram_col.plot(merged_map.ax_col_dendrogram)

        # for rows, I imagine at some point it will fail to fall within the major axis but fortunately
        # for this dataset it is not true
        seaborn_map.dendrogram_row.plot(merged_map.ax_row_dendrogram)
        merged_map.savefig('{}_heatmap_{}.png'.format(os.path.split(args.tsv.name)[1], i))
Example #23
0
def make_heatmap_w2vrelated(model, rel_wds):
    """
    Given a model (from word2vec) and a list of related words,
    make a square heatmap using the cosine similarity between the given words
    """
    n = len(rel_wds)
    names = [wd[0] for wd in rel_wds]
    data_mat = np.zeros((n,n))
    for i, word1 in enumerate(names):
        for j, word2 in enumerate(names):
            data_mat[i,j] = model.similarity(word1, word2)
            if i == j:
                data_mat[i,j] = 0

    df = pd.DataFrame(data=data_mat,
                     columns=names,
                     index=names)
    sb.clustermap(df, linewidths=.5,)
def graphDendrogram(csv):
    dend_fn = csv
    dend_data = pd.read_csv(dend_fn, na_values = 'n/a')
    dend_data = dend_data.rename(columns = {'Unnamed: 0':'Project1'})
    dend_data = pd.melt(dend_data, id_vars=['Project1'])
    dend_data = dend_data.rename(columns = {'variable':'project2','value':'ANI'})
    dend_data = dend_data.pivot("Project1", "project2", "ANI")
    g = sns.clustermap(dend_data)
    g.savefig(outputfile + "_dendrogram.pdf")     
def heatmap_plot_zscore_bigneuron(df_zscore_features, df_all, output_dir, title=None):

    print "heatmap plot:bigneuron"

    #taiwan
    metric ='nt_type'
    mtypes = np.unique(df_all[metric])
    print mtypes
    mtypes_pal = sns.color_palette("hls", len(mtypes))

    mtypes_lut = dict(zip(mtypes, mtypes_pal))
    mtypes_colors = df_all[metric].map(mtypes_lut)



    linkage = hierarchy.linkage(df_zscore_features, method='ward', metric='euclidean')

    data = df_zscore_features.transpose()
    row_linkage = hierarchy.linkage(data, method='ward', metric='euclidean')
    feature_order = hierarchy.leaves_list(row_linkage)

    #print data.index
    matchIndex = [data.index[x] for x in feature_order]
    #print matchIndex
    data = data.reindex(matchIndex)

    pl.figure()
    g = sns.clustermap(data, row_cluster = False, col_linkage=linkage, method='ward', metric='euclidean',
                       linewidths = 0.0,col_colors = [mtypes_colors],
                       cmap = sns.cubehelix_palette(light=1, as_cmap=True),figsize=(40,10))

    pl.setp(g.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
    pl.setp(g.ax_heatmap.xaxis.get_majorticklabels(), rotation=90)
    #g.ax_heatmap.set_xticklabels([])
    pl.subplots_adjust(left=0.1, bottom=0.1, right=0.9, top=0.95)  # !!!!!

    if title:
        pl.title(title)


    location ="best"
    num_cols=1
    # Legend for row and col colors

    for label in mtypes:
         g.ax_row_dendrogram.bar(0, 0, color=mtypes_lut[label], label=label, linewidth=0.0)
         g.ax_row_dendrogram.legend(loc=location, ncol=num_cols,borderpad=0)

    filename = output_dir + '/zscore_feature_heatmap.png'
    pl.savefig(filename, dpi=300)
    #pl.show()
    print("save zscore matrix heatmap figure to :" + filename)
    pl.close()
    print "done clustering and heatmap plotting"
    return linkage
def cluster_all_map(mat, ylab, out):
    """Returns nothing. Generates a figure where all tissues are clustered together based a Scipy clustering metric provided.

    Args:
        mat (array): Fold change normalized matrix containing fold change values for all three tissue types where the fold change for a given sample
        is tissue_fpkm[i]/tissue_fpkm[controls].mean()
        ylab (list): Y axis labels generated
        out (str): The title of the Seaborn clustermap generated out.pdf'

    Returns:
        Fold change normalized clustermap containing fold change values for all three tissue types where the fold change for a given sample
        is tissue_fpkm[i]/tissue_fpkm[controls].mean(). The Seaborn clustermap will be labeled as <out>.pdf

    """
    heart = ["#3498db"]
    brain = ["#e74c3c"]
    quad = ["#2ecc71"]
    wt = ["#8FBC8F"]
    het = ["#B22222"]
    aso = ["#FFD700"]
    ko = ["#FF69B4"]
    white = ['#FFFFFF']

    color_leg = ["#3498db", "#e74c3c", "#2ecc71", "#FFFFFF", "#8FBC8F", "#B22222", "#FFD700", "#FF69B4"]
    legend_lab = ["heart", "brain", "quad", " ", "wt", "het", "aso", "ko"]
    xlabel = array(["wt", "wt", "wt", "Het", "Het", "aso", "aso", "ko", "ko",
                    "wt", "wt", "wt", "Het", "Het", "aso", "aso", "ko", "ko",
                    "wt", "wt", "Het", "Het", "aso", "aso", "ko", "ko", ])

    sample_type = (sns.color_palette(wt, 3) +
                   sns.color_palette(het, 2) +
                   sns.color_palette(aso, 2) +
                   sns.color_palette(ko, 2) +
                   sns.color_palette(wt, 3) +
                   sns.color_palette(het, 2) +
                   sns.color_palette(aso, 2) +
                   sns.color_palette(ko, 2) +
                   sns.color_palette(wt, 2) +
                   sns.color_palette(het, 2) +
                   sns.color_palette(aso, 2) +
                   sns.color_palette(ko, 2))

    season_colors = (sns.color_palette(heart, 9) +
                     sns.color_palette(brain, 9) +
                     sns.color_palette(quad, 8))

    g = sns.clustermap(mat, annot=False, method='weighted', metric='euclidean', col_colors=[sample_type, season_colors],
                       col_cluster=True, xticklabels=xlabel, yticklabels=ylab)
    plt.setp(g.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
    for C, L in zip([c for c in color_leg], legend_lab):
        g.ax_col_dendrogram.bar(0, 0, color=C, label=L, linewidth=0)
    g.ax_col_dendrogram.legend(loc="upper right", ncol=2)
    plt.suptitle('Fold change filter across Tissues +/- 1 FC')
    plt.savefig(out, format="pdf", dpi=1000)
Example #27
0
def heatmap(output_dir, table: pd.DataFrame,
            metadata: qiime2.CategoricalMetadataColumn=None,
            normalize: bool=True, title: str=None, metric: str='euclidean',
            method: str='average', cluster: str='both',
            color_scheme: str='rocket') -> None:
    if table.empty:
        raise ValueError('Cannot visualize an empty table.')

    if metadata is not None:
        table = _munge_metadata(metadata, table, cluster)

    cbar_label = 'frequency'
    if normalize:
        table = table.apply(lambda x: np.log10(x + 1))
        cbar_label = 'log10 frequency'

    # Hard-coded values for reasonable plots
    scaletron, labelsize, dpi = 50, 8, 100
    sns.set(rc={'xtick.labelsize': labelsize, 'ytick.labelsize': labelsize,
                'figure.dpi': dpi})
    width, height = table.shape[1] / scaletron, table.shape[0] / scaletron

    heatmap_plot = sns.clustermap(table, method=method, metric=metric,
                                  **_clustering_map[cluster],
                                  cmap=color_scheme,
                                  xticklabels=True, yticklabels=True,
                                  cbar_kws={'label': cbar_label})
    if title is not None:
        heatmap_plot.fig.suptitle(title)

    hm = heatmap_plot.ax_heatmap.get_position()
    cbar = heatmap_plot.cax.get_position()
    row = heatmap_plot.ax_row_dendrogram.get_position()
    col = heatmap_plot.ax_col_dendrogram.get_position()

    # Resize the plot to set cell aspect-ratio to square
    heatmap_plot.ax_heatmap.set_position([hm.x0, hm.y0, width, height])
    heatmap_plot.cax.set_position([cbar.x0, hm.y0 + height, cbar.width,
                                   cbar.height])
    heatmap_plot.ax_row_dendrogram.set_position([row.x0, row.y0, row.width,
                                                 height])
    heatmap_plot.ax_col_dendrogram.set_position([col.x0, hm.y0 + height, width,
                                                 col.height])

    # https://stackoverflow.com/a/34697479/3776794
    plt.setp(heatmap_plot.ax_heatmap.xaxis.get_majorticklabels(), rotation=90)
    plt.setp(heatmap_plot.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)

    for ext in ['png', 'svg']:
        img_fp = os.path.join(output_dir, 'feature-table-heatmap.%s' % ext)
        heatmap_plot.savefig(img_fp)

    index_fp = os.path.join(TEMPLATES, 'index.html')
    q2templates.render(index_fp, output_dir, context={'normalize': normalize})
Example #28
0
def plot_nn_weights(w, x_labels, y_labels, fig_path, row_linkage=None, fig_size=(10, 3)):
	plt.figure(figsize=fig_size)
	clmap = sns.clustermap(pd.DataFrame(w, columns=x_labels),
							method='average', metric='cosine', row_linkage=row_linkage,
							col_cluster=False, robust=True, yticklabels=y_labels)
	plt.setp(clmap.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
	plt.setp(clmap.ax_heatmap.xaxis.get_majorticklabels(), rotation=90)
	clmap.cax.set_visible(False)
	plt.savefig(fig_path)
	plt.clf()
	plt.close()
Example #29
0
def cluster_map(data, names):
    """Cluster map of genes"""

    import seaborn as sns
    import pylab as plt
    data = data.ix[names]
    X = np.log(data).fillna(0)
    X = X.apply(lambda x: x-x.mean(), 1)
    cg = sns.clustermap(X,cmap='RdYlBu_r',figsize=(8,10),lw=.5,linecolor='gray')
    mt=plt.setp(cg.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
    mt=plt.setp(cg.ax_heatmap.xaxis.get_majorticklabels(), rotation=90)
    return cg
Example #30
0
def plot_gene_clustermap_by_membership(data_array, memberships):
    groups = list(set(memberships))
    group_means = np.zeros([len(groups), data_array.shape[1]])
    for gi, group in enumerate(groups):
        group_means[gi, :] = data_array[memberships == group, :].mean(axis=0)
    cm = sns.clustermap((group_means - group_means.min(axis=0)).T, col_cluster=False)
    r = np.arange(len(groups)) + 0.5
    cm.ax_heatmap.set_xticks(r)
    cm.ax_heatmap.set_xticklabels(groups)
    cm.ax_heatmap.set_xlabel('Cell type')
    cm.ax_heatmap.set_ylabel('Gene')
    return cm
Example #31
0
print "standardizing by log scale..."
log_df = z + 0.01
log_df = np.log(log_df)

print "standardizing columns to the max in each row..."
std_df = z.div(z.max(axis=1), axis=0)

x = float(sys.argv[2])
y = float(sys.argv[3])

print "making log heat map..."
sns.set(font_scale=1.5)
g = sns.clustermap(log_df,
                   figsize=(x, y),
                   cmap="magma",
                   yticklabels=False,
                   xticklabels=False,
                   col_colors=lut)
plt.savefig("heatmap_log.png", bbox_inches="tight", dpi=600)
plt.clf()

print "making standard heat map..."
g = sns.clustermap(std_df,
                   figsize=(x, y),
                   vmin=0,
                   vmax=1,
                   cmap="magma",
                   yticklabels=False,
                   xticklabels=False,
                   col_colors=lut)
plt.savefig("heatmap_std.png", bbox_inches="tight", dpi=600)
import numpy as np
import pandas as pd
from numpy.random import randn
from scipy import stats
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns

df = sns.load_dataset('flights')
df2 = df.pivot('year', 'month', 'passengers')
print(df2)
sns.clustermap(df2).savefig('cl1.png')
sns.clustermap(df2, col_cluster=False).savefig('cl2.png')
sns.clustermap(df2, standard_scale=0).savefig('cl3.png')
sns.clustermap(df2, standard_scale=1).savefig('cl4.png')
Example #33
0
def jacobian_kinetics(
    adata,
    basis='umap',
    regulators=None,
    effectors=None,
    mode="pseudotime",
    tkey="potential",
    color_map="bwr",
    gene_order_method='raw',
    show_colorbar=False,
    cluster_row_col=[False, True],
    figsize=(11.5, 6),
    standard_scale=1,
    save_show_or_return='show',
    save_kwargs={},
    **kwargs
):
    """Plot the gene expression dynamics over time (pseudotime or inferred real time) in a heatmap.

    Note that by default `potential` estimated with the diffusion graph built from reconstructed vector field will be
    used as the measure of pseudotime.

    Parameters
    ----------
        adata: :class:`~anndata.AnnData`
            an Annodata object.
        basis: `str`
            The reduced dimension basis.
        regulators: `list` or `None` (default: `None`)
            The list of genes that will be used as regulators for plotting the Jacobian heatmap, only limited to genes
            that have already performed Jacobian analysis.
        effectors: `List` or `None` (default: `None`)
            The list of genes that will be used as targets for plotting the Jacobian heatmap, only limited to genes
            that have already performed Jacobian analysis.
        mode: `str` (default: `vector_field`)
            Which data mode will be used, either vector_field or pseudotime. if mode is vector_field, the trajectory predicted by
            vector field function will be used, otherwise pseudotime trajectory (defined by time argument) will be used.
            By default `potential` estimated with the diffusion graph built reconstructed vector field will be used as
            pseudotime.
        tkey: `str` (default: `potential`)
            The .obs column that will be used for timing each cell, only used when mode is not `vector_field`.
        color_map: `str` (default: `BrBG`)
            Color map that will be used to color the gene expression. If `half_max_ordering` is True, the
            color map need to be divergent, good examples, include `BrBG`, `RdBu_r` or `coolwarm`, etc.
        gene_order_method: `str` (default: `half_max_ordering`) [`half_max_ordering`, `maximum`]
            Supports two different methods for ordering genes when plotting the heatmap: either `half_max_ordering`,
            or `maximum`. For `half_max_ordering`, it will order genes into up, down and transit groups by the half
            max ordering algorithm (HA Pliner, et. al, Molecular cell 71 (5), 858-871. e8). While for `maximum`,
            it will order by the position of the highest gene expression.
        show_colorbar: `bool` (default: `False`)
            Whether to show the color bar.
        cluster_row_col: `[bool, bool]` (default: `[False, False]`)
            Whether to cluster the row or columns.
        figsize: `str` (default: `(11.5, 6)`
            Size of figure
        standard_scale: `int` (default: 1)
            Either 0 (rows, cells) or 1 (columns, genes). Whether or not to standardize that dimension, meaning for each row or column,
            subtract the minimum and divide each by its maximum.
        save_show_or_return: {'show', 'save_fig', 'return'} (default: `show`)
            Whether to save_fig, show or return the figure.
        save_kwargs: `dict` (default: `{}`)
            A dictionary that will passed to the save_fig function. By default it is an empty dictionary and the save_fig function
            will use the {"path": None, "prefix": 'kinetic_curves', "dpi": None, "ext": 'pdf', "transparent": True, "close":
            True, "verbose": True} as its parameters. Otherwise you can provide a dictionary that properly modify those keys
            according to your needs.
        kwargs:
            All other keyword arguments are passed to heatmap(). Currently `xticklabels=False, yticklabels='auto'` is passed
            to heatmap() by default.
    Returns
    -------
        Nothing but plots a heatmap that shows the element of Jacobian matrix dynamics over time (potential decreasing).

    Examples
    --------
    >>> import dynamo as dyn
    >>> adata = dyn.sample_data.hgForebrainGlutamatergic()
    >>> adata = dyn.pp.recipe_monocle(adata)
    >>> dyn.tl.dynamics(adata)
    >>> dyn.vf.VectorField(adata, basis='pca')
    >>> valid_gene_list = adata[:, adata.var.use_for_transition].var.index[:2]
    >>> dyn.vf.jacobian(adata, regulators=valid_gene_list[0], effectors=valid_gene_list[1])
    >>> dyn.pl.jacobian_kinetics(adata)
    """

    import pandas as pd
    import seaborn as sns
    import matplotlib.pyplot as plt

    Jacobian_ = "jacobian" if basis is None else "jacobian_" + basis
    Der, cell_indx, jacobian_gene, regulators_, effectors_ = adata.uns[Jacobian_].get('jacobian'), \
                                                              adata.uns[Jacobian_].get('cell_idx'), \
                                                              adata.uns[Jacobian_].get('jacobian_gene'), \
                                                              adata.uns[Jacobian_].get('regulators'), \
                                                              adata.uns[Jacobian_].get('effectors')
    if tkey == "potential" and "potential" not in adata.obs_keys():
        ddhodge(adata)

    adata_ = adata[cell_indx, :]
    time = adata_.obs[tkey]
    jacobian_mat = Der.reshape((-1, Der.shape[2])) if Der.ndim == 3 else Der[None, :]
    n_source_targets_ = Der.shape[0] * Der.shape[1] if Der.ndim == 3 else 1
    targets_, sources_ = (np.repeat(effectors_, Der.shape[1]), np.tile(regulators_, Der.shape[0])) if Der.ndim == 3 \
        else (np.repeat(effectors_, Der.shape[0]), np.repeat(effectors_, Der.shape[0]))
    source_targets_ = [sources_[i] + '->' + targets_[i] for i in range(n_source_targets_)]

    regulators = regulators_ if regulators is None else regulators
    effectors = effectors_ if effectors is None else effectors
    if type(regulators) == str: regulators = [regulators]
    if type(effectors) == str: effectors = [effectors]
    regulators = list(set(regulators_).intersection(regulators))
    effectors = list(set(effectors_).intersection(effectors))
    if len(regulators) == 0 or len(effectors) == 0:
        raise ValueError(f"Jacobian related to source genes {regulators} and target genes {effectors}"
                         f"you provided are existed. Available source genes includes {regulators_} while "
                         f"available target genes includes {effectors_}")
    n_source_targets = len(regulators) * len(effectors)
    targets, sources = np.repeat(effectors, len(regulators)), np.tile(regulators, len(effectors))
    source_targets = [sources[i] + '->' + targets[i] for i in range(n_source_targets)]

    jacobian_mat = jacobian_mat[:, np.argsort(time)]

    if gene_order_method == "half_max_ordering":
        time, all, valid_ind, gene_idx = _half_max_ordering(
            jacobian_mat, time, mode=mode, interpolate=True, spaced_num=100
        )
        all, source_targets = all[np.isfinite(all.sum(1)), :], np.array(source_targets)[gene_idx][np.isfinite(all.sum(1))]

        df = pd.DataFrame(all, index=source_targets_)
    elif gene_order_method == 'maximum':
        jacobian_mat = lowess_smoother(time, jacobian_mat, spaced_num=100)
        jacobian_mat = jacobian_mat[np.isfinite(jacobian_mat.sum(1)), :]

        if standard_scale is not None:
            exprs = (jacobian_mat - np.min(jacobian_mat, axis=standard_scale)[:, None]) / np.ptp(
                jacobian_mat, axis=standard_scale
            )[:, None]
        max_sort = np.argsort(np.argmax(exprs, axis=1))
        df = pd.DataFrame(exprs[max_sort, :], index=np.array(source_targets_)[max_sort])
    elif gene_order_method == "raw":
        jacobian_mat /= np.abs(jacobian_mat).max(1)[:, None]
        df = pd.DataFrame(jacobian_mat, index=np.array(source_targets_))
    else:
        raise Exception('gene order_method can only be either half_max_ordering or maximum')

    heatmap_kwargs = dict(xticklabels=False, yticklabels=1)
    if kwargs is not None:
        heatmap_kwargs = update_dict(heatmap_kwargs, kwargs)

    sns_heatmap = sns.clustermap(
        df.loc[source_targets, :],
        col_cluster=cluster_row_col[0],
        row_cluster=cluster_row_col[1] if len(source_targets) > 2 else False,
        cmap=color_map,
        figsize=figsize,
        center=0,
        **heatmap_kwargs
    )
    if not show_colorbar: sns_heatmap.cax.set_visible(False)

    if save_show_or_return == "save_fig":
        s_kwargs = {"path": None, "prefix": 'jacobian_kinetics', "dpi": None,
                    "ext": 'pdf', "transparent": True, "close": True, "verbose": True}
        s_kwargs = update_dict(s_kwargs, save_kwargs)

        save_fig(**s_kwargs)
    elif save_show_or_return == "show":
        if show_colorbar:
            plt.subplots_adjust(right=0.85)
        plt.tight_layout()
        plt.show()
    elif save_show_or_return == "return":
        return sns_heatmap
Example #34
0
### Heatmaps for Calls made by Hour and Day of Week
byDayofWeekHour = call_data.groupby(
    by=['Day_of_Week', 'Hour']).count()['twp'].unstack(level=-1)

fig8 = plt.figure(figsize=(10, 6))
ax8 = fig8.add_axes([
    .1,
    .1,
    .8,
    .8,
])
ax8 = sns.heatmap(byDayofWeekHour, cmap="coolwarm")
fig8.suptitle('Heatmap: Hour by Day of the Week')

clm = sns.clustermap(byDayofWeekHour, cmap="coolwarm", figsize=(10, 6))
fig9 = clm.fig
fig9.suptitle('Clustermap: Hour by Day of the Week')

### Heatmaps for Calls made by Month and Day of Week
byDayofWeekMonth = call_data.groupby(
    by=['Day_of_Week', 'Month']).count()['twp'].unstack(level=-1)

fig8 = plt.figure(figsize=(10, 6))
ax8 = fig8.add_axes([
    .1,
    .1,
    .8,
    .8,
])
ax8 = sns.heatmap(byDayofWeekMonth, cmap="coolwarm")
Example #35
0
# Create a custom palette to identify the networks
network_pal = sns.cubehelix_palette(len(used_networks),
                                    light=.9, dark=.1, reverse=True,
                                    start=1, rot=-2)
network_lut = dict(zip(map(str, used_networks), network_pal))

# Convert the palette to vectors that will be drawn on the side of the matrix
networks = df.columns.get_level_values("network")
network_colors = pd.Series(networks, index=df.columns).map(network_lut)

# Create a custom colormap for the heatmap values
cmap = sns.diverging_palette(h_neg=210, h_pos=350, s=90, l=30, as_cmap=True)

# Draw the full plot
sns.clustermap(df.corr(), row_colors=network_colors, linewidths=.5,
               col_colors=network_colors, figsize=(13, 13), cmap=cmap)


'''Scatterplot with categorical variables

https://seaborn.pydata.org/examples/scatterplot_categorical.html
'''

sns.set(style="whitegrid", palette="muted")
 
# Load the example iris dataset
iris = sns.load_dataset("iris")
 
# "Melt" the dataset to "long-form" or "tidy" representation
iris = pd.melt(iris, "species", var_name="measurement")
 
Example #36
0
df = df.apply(lambda x: x / x.max(), axis=1)
df = df.drop('total', axis=1)
df.loc['sum'] = df.sum(axis=0)
df = df.sort_values('sum', axis=1, ascending=False)
df = df.drop('sum', axis=0)

df.to_csv(args.output + ".csv")

if args.count > 0:
    df = df.iloc[:, :args.count]
else:
    args.count = df.shape[1]

sz = min(50, max(args.count, df.shape[0])) // 5
g = clustermap(data=df,
               metric='braycurtis',
               col_cluster=False,
               robust=True,
               figsize=(sz + 5, sz + 5))
if args.count > 50:
    g.ax_heatmap.get_xaxis().set_visible(False)
plt.setp(g.ax_heatmap.xaxis.get_majorticklabels(),
         fontsize=min(100, 40 * sz // args.count))
plt.setp(g.ax_heatmap.yaxis.get_majorticklabels(),
         fontsize=min(100, 40 * sz // df.shape[0]))
plt.setp(g.ax_heatmap.yaxis.get_majorticklabels(), rotation=0, va='center')
plt.setp(g.ax_heatmap.xaxis.get_majorticklabels(), rotation=90)
for a in g.ax_row_dendrogram.collections:
    a.set_linewidth(2)
g.savefig(args.output + ".svg")
g.savefig(args.output + ".png")
Example #37
0
import pandas as pd
import numpy as np

# names of columns
drug_conditions = ["marimastat 3 uM", "ibudilast 20 uM", "ibudilast 200 uM", 
                   "cabozantinib 0.1 uM", "cabozantinib 1 uM", "sorafenib 2 uM", "sorafenib 20 uM", 
                   "axitinib 2 uM", "axitinib 20 uM", "tofacitinib 2 uM", "tofacitinib 20 uM", 
                   "thalidomide 0.5 uM", "thalidomide 5 uM", "icatibant 0.1 uM", "icatibant 1 uM"]

# names of rows
cell_lines = ["G523", "G885", "G729", "G564", "G861"]              

# corresponding numerical value for each cell
viability_scores = np.array([[103.2445191,66.64440593,4.739848128,97.90725205,94.42274748,116.9796604,3.906406317,14.56179271,23.33680375,114.614175,117.3194148,92.78114457,104.8391006,99.06876532,99.90973465],
                             [99.54387203,95.89649106,4.679616554,99.55142491,99.892707,98.84118352,3.74480514,5.318624446,6.386772279,99.10143741,66.16415959,99.87811211,99.80021925,103.0671789,103.4136019],
                             [111.7364657,101.337013,13.41437035,115.9142502,109.4053095,116.1193251,9.227651647,84.10387886,55.32228376,115.9941438,115.0353046,93.96947089,112.1451494,94.90497327,109.030808],
                             [100.5542982,100.0080483,54.18581791,95.78376446,100.0588735,98.01859304,2.305208161,57.75735247,33.72282194,98.08674223,98.5647624,116.1383385,100.4812294,112.8439546,100.0594984],
                             [103.7184012,101.7273883,89.18527618,100.145608,61.24720474,103.5849188,2.019981229,46.41365913,4.292586744,101.9055264,89.33413613,102.7615483,100.2794762,111.1432579,105.007406]])
 
# compiles all of the above information into a pandas dataframe
data = pd.DataFrame(data=viability_scores, index=cell_lines, columns=drug_conditions)

print(data)

# make heirarchically clustered heatmap using seaborn
seaborn.set(color_codes=True)
clustered_map = seaborn.clustermap(data)

# save the generated heatmap
clustered_map.savefig("clustered.jpg")
tr_dict = df_tickers['Total Return Index (UBS)'].to_dict()
tr_dict = {v: k for k, v in tr_dict.items()}

df_class = df_tickers['Classification']
df_class = df_class.replace({'DM': '#9FD356', 'EM': '#FA824C'})

# Read Total Return Index
df_tr = pd.read_excel(file_path, index_col=0, sheet_name='Total Return')
df_tr = df_tr.rename(tr_dict, axis=1)

# Comnpute returns
df = df_tr.pct_change(1)
df = df['2009-01-01' <= df.index]
df = df[df.index <= '2020-01-31']
corr = df.corr()

# Chart
sns.clustermap(data=corr,
               method='average',
               metric='euclidean',
               figsize=(10, 10),
               cmap='mako',
               row_colors=df_class,
               col_colors=df_class,
               linewidths=0)
plt.savefig(
    '/Users/gustavoamarante/Dropbox/CQF/Final Project/figures/Correlation and Dendrogam.pdf',
    pad_inches=0)
plt.show()




df[df['Reason']=='Fire'].groupby('Date').count()['twp'].plot()
plt.title('Fire')
plt.tight_layout()

df[df['Reason']=='EMS'].groupby('Date').count()['twp'].plot()
plt.title('EMS')
plt.tight_layout()


dayHour = df.groupby(by=['Day of Week','Hour']).count()['Reason'].unstack()
dayHour.head()

plt.figure(figsize=(12,6))
sns.heatmap(dayHour,cmap='viridis')


sns.clustermap(dayHour,cmap='viridis')

dayMonth = df.groupby(by=['Day of Week','Month']).count()['Reason'].unstack()
dayMonth.head()

plt.figure(figsize=(12,6))
sns.heatmap(dayMonth,cmap='viridis')

sns.clustermap(dayMonth,cmap='viridis')
rois_beta_df["GM_mean"] = rois_avg_df["GM_mean"]

##
# Seaborn
import scipy.cluster.hierarchy as hc
import scipy.spatial as sp

# https://stackoverflow.com/questions/38705359/how-to-give-sns-clustermap-a-precomputed-distance-matrix
DF = rois_beta_df.copy()

DF_corr = DF.corr()
DF_dism = 1 - DF_corr  # ** 2

linkage = hc.linkage(sp.distance.squareform(DF_dism), method='average')
g = sns.clustermap(DF_corr, col_linkage=linkage, row_linkage=linkage)
plt.setp(g.ax_heatmap.get_yticklabels(), rotation=0)  # For y axis
plt.savefig(os.path.join(WD_CLUST, "cor_rois.pdf"))

# Positive / Negatives
# --------------------

beta_pos_msk = comp > 0
beta_neg_msk = comp < 0

print(beta_pos_msk.sum(), beta_neg_msk.sum())

Xscores = np.zeros((X_adni.shape[0], 5))

Xscores[:, 0] = np.dot(X_adni[:, beta_pos_msk], comp[beta_pos_msk]).ravel()
Xscores[:, 1] = X_adni[:, beta_pos_msk].mean(axis=1)
def visualizeConsensus(consensusMat, connectivityMatrices, clusters, colNames,
                       suffix):
    plt.rcParams['font.size'] = '8'
    plt.rcParams['pdf.fonttype'] = 42
    if colNames == 'noXLabels':
        # put concensus matrix into dataframe to build hierarchical clustermap
        dataframe = pd.DataFrame(data=consensusMat)
        dataframe.to_csv(str(matrixPath + 'consensus_matrix_table.txt'),
                         sep="\t")
        # clusters by columns and rows and annotates probablility a particular sample clusters together
        # cluster distance is meausred by average Euclidean Distance in seaborn for hierarchical clustering
        consensusClustered = sns.clustermap(dataframe,
                                            col_cluster=True,
                                            row_cluster=True,
                                            annot=True)
        consensusClustered.savefig(
            str(matrixPath) + 'consensus_Matrix_over_' +
            str(len(connectivityMatrices)) + '_runs_at_k=' + str(clusters) +
            '.' + suffix)

    else:
        # assigns sample names to consensus matrix
        sampleNames = []
        with open(colNames) as input:
            for line in input:
                sampleNames.append(line.rstrip('\n'))
        # put consensus matrix into dataframe to build hierarchical clustermap
        dataframe = pd.DataFrame(data=consensusMat,
                                 index=sampleNames,
                                 columns=sampleNames)
        # clusters by columns and rows and annotates probablility a particular sample clusters together
        # cluster distance is measured by average Euclidean Distance in seaborn for hierarchical clustering
        consensusClustered = sns.clustermap(dataframe,
                                            col_cluster=True,
                                            row_cluster=True,
                                            annot=True)
        ax = consensusClustered.ax_heatmap
        xaxis = []
        for ind in consensusClustered.dendrogram_col.reordered_ind:
            xaxis.append(sampleNames[ind])
        ax.set_xticklabels(xaxis, rotation=90)
        yaxis = []
        for ind in consensusClustered.dendrogram_row.reordered_ind:
            yaxis.append(sampleNames[ind])
        ax.set_yticklabels(yaxis, rotation=0)
        consensusClustered_non_annt = sns.clustermap(dataframe,
                                                     col_cluster=True,
                                                     row_cluster=True,
                                                     annot=False)
        axNA = consensusClustered_non_annt.ax_heatmap
        xaxis = []
        for ind in consensusClustered_non_annt.dendrogram_col.reordered_ind:
            xaxis.append(sampleNames[ind])
        axNA.set_xticklabels(xaxis, rotation=90)
        yaxis = []
        for ind in consensusClustered_non_annt.dendrogram_row.reordered_ind:
            yaxis.append(sampleNames[ind])
        axNA.set_yticklabels(yaxis, rotation=0)

        consensusClustered.savefig(
            str(matrixPath) + 'consensus_Matrix_over_' +
            str(len(connectivityMatrices)) + '_runs_at_k=' + str(clusters) +
            '.' + suffix)
        consensusClustered_non_annt.savefig(
            str(matrixPath) + 'non_annotated_consensus_Matrix_over_' +
            str(len(connectivityMatrices)) + '_runs_at_k=' + str(clusters) +
            '.' + suffix)
        df_ordered_by_clust = dataframe.reindex(index=xaxis, columns=xaxis)
        df_ordered_by_clust.to_csv(str(matrixPath +
                                       'consensus_matrix_table.txt'),
                                   sep="\t")
Example #42
0
def heatmap(
        adata,
        var_names,
        sortby="latent_time",
        layer="Ms",
        color_map="viridis",
        col_color=None,
        palette="viridis",
        n_convolve=30,
        standard_scale=0,
        sort=True,
        colorbar=None,
        col_cluster=False,
        row_cluster=False,
        context=None,
        font_scale=None,
        figsize=(8, 4),
        show=None,
        save=None,
        **kwargs,
):
    """\
    Plot time series for genes as heatmap.

    Arguments
    ---------
    adata: :class:`~anndata.AnnData`
        Annotated data matrix.
    var_names: `str`,  list of `str`
        Names of variables to use for the plot.
    sortby: `str` (default: `'latent_time'`)
        Observation key to extract time data from.
    layer: `str` (default: `'Ms'`)
        Layer key to extract count data from.
    color_map: `str` (default: `'viridis'`)
        String denoting matplotlib color map.
    col_color: `str` or list of `str` (default: `None`)
        String denoting matplotlib color map to use along the columns.
    palette: list of `str` (default: `'viridis'`)
        Colors to use for plotting groups (categorical annotation).
    n_convolve: `int` or `None` (default: `30`)
        If `int` is given, data is smoothed by convolution
        along the x-axis with kernel size n_convolve.
    standard_scale : `int` or `None` (default: `0`)
        Either 0 (rows) or 1 (columns). Whether or not to standardize that dimension
        (each row or column), subtract minimum and divide each by its maximum.
    sort: `bool` (default: `True`)
        Wether to sort the expression values given by xkey.
    colorbar: `bool` or `None` (default: `None`)
        Whether to show colorbar.
    {row,col}_cluster : `bool` or `None`
        If True, cluster the {rows, columns}.
    context : `None`, or one of {paper, notebook, talk, poster}
        A dictionary of parameters or the name of a preconfigured set.
    font_scale : float, optional
        Scaling factor to scale the size of the font elements.
    figsize: tuple (default: `(8,4)`)
        Figure size.
    show: `bool`, optional (default: `None`)
        Show the plot, do not return axis.
    save: `bool` or `str`, optional (default: `None`)
        If `True` or a `str`, save the figure. A string is appended to the default
        filename. Infer the filetype if ending on {'.pdf', '.png', '.svg'}.
    kwargs:
        Arguments passed to seaborns clustermap,
        e.g., set `yticklabels=True` to display all gene names in all rows.

    Returns
    -------
    If `show==False` a `matplotlib.Axis`
    """

    import seaborn as sns

    var_names = [name for name in var_names if name in adata.var_names]

    tkey, xkey = kwargs.pop("tkey", sortby), kwargs.pop("xkey", layer)
    time = adata.obs[tkey].values
    time = time[np.isfinite(time)]

    X = (adata[:, var_names].layers[xkey]
         if xkey in adata.layers.keys() else adata[:, var_names].X)
    if issparse(X):
        X = X.A
    df = pd.DataFrame(X[np.argsort(time)], columns=var_names)

    if n_convolve is not None:
        weights = np.ones(n_convolve) / n_convolve
        for gene in var_names:
            try:
                df[gene] = np.convolve(df[gene].values, weights, mode="same")
            except Exception:
                pass  # e.g. all-zero counts or nans cannot be convolved

    if sort:
        max_sort = np.argsort(np.argmax(df.values, axis=0))
        df = pd.DataFrame(df.values[:, max_sort], columns=df.columns[max_sort])
    strings_to_categoricals(adata)

    if col_color is not None:
        col_colors = to_list(col_color)
        col_color = []
        for _, col in enumerate(col_colors):
            if not is_categorical(adata, col):
                obs_col = adata.obs[col]
                cat_col = np.round(obs_col / np.max(obs_col),
                                   2) * np.max(obs_col)
                adata.obs[f"{col}_categorical"] = pd.Categorical(cat_col)
                col += "_categorical"
                set_colors_for_categorical_obs(adata, col, palette)
            col_color.append(interpret_colorkey(adata, col)[np.argsort(time)])

    if "dendrogram_ratio" not in kwargs:
        kwargs["dendrogram_ratio"] = (
            0.1 if row_cluster else 0,
            0.2 if col_cluster else 0,
        )
    if "cbar_pos" not in kwargs or not colorbar:
        kwargs["cbar_pos"] = None

    kwargs.update(
        dict(
            col_colors=col_color,
            col_cluster=col_cluster,
            row_cluster=row_cluster,
            cmap=color_map,
            xticklabels=False,
            standard_scale=standard_scale,
            figsize=figsize,
        ))

    args = {}
    if font_scale is not None:
        args = {"font_scale": font_scale}
        context = context or "notebook"

    with sns.plotting_context(context=context, **args):
        try:
            cm = sns.clustermap(df.T, **kwargs)
        except Exception:
            logg.warn("Please upgrade seaborn with `pip install -U seaborn`.")
            kwargs.pop("dendrogram_ratio")
            kwargs.pop("cbar_pos")
            cm = sns.clustermap(df.T, **kwargs)

    savefig_or_show("heatmap", save=save, show=show)
    if show is False:
        return cm
rate = n_error_outliers/y_out.size
print("Classification rate = ",100*(1-rate),"%")

import seaborn as sns
sns.pairplot(df)

type(t_out)

plot_data = pd.DataFrame(np.array(t_out).reshape(328,))

import seaborn as sns
sns.pairplot(plot_data)

sns.distplot(plot_data)

sns.clustermap(X)
# extra work not required.

sns.violinplot([X])
# extra work not required.



"""# Problem 2"""

# Load the digit data
digits = datasets.load_digits()
# View the features of the first observation
digits.data[0:1]
# View the target of the first observation
digits.target[0:1]
Example #44
0
def kinetic_heatmap(
    adata,
    genes,
    mode="vector_field",
    basis=None,
    layer="X",
    project_back_to_high_dim=True,
    tkey="potential",
    dist_threshold=1e-10,
    color_map="BrBG",
    gene_order_method='half_max_ordering',
    show_colorbar=False,
    cluster_row_col=[False, False],
    figsize=(11.5, 6),
    standard_scale=1,
    save_show_or_return='show',
    save_kwargs={},
    **kwargs
):
    """Plot the gene expression dynamics over time (pseudotime or inferred real time) in a heatmap.

    Note that by default `potential` estimated with the diffusion graph built from reconstructed vector field will be
    used as the measure of pseudotime.

    Parameters
    ----------
        %(kin_curves.parameters.no_ncol|color|c_palette)s
        color_map: `str` (default: `BrBG`)
            Color map that will be used to color the gene expression. If `half_max_ordering` is True, the
            color map need to be divergent, good examples, include `BrBG`, `RdBu_r` or `coolwarm`, etc.
        gene_order_method: `str` (default: `half_max_ordering`) [`half_max_ordering`, `maximum`]
            Supports two different methods for ordering genes when plotting the heatmap: either `half_max_ordering`,
            or `maximum`. For `half_max_ordering`, it will order genes into up, down and transit groups by the half
            max ordering algorithm (HA Pliner, et. al, Molecular cell 71 (5), 858-871. e8). While for `maximum`,
            it will order by the position of the highest gene expression.
        show_colorbar: `bool` (default: `False`)
            Whether to show the color bar.
        cluster_row_col: `[bool, bool]` (default: `[False, False]`)
            Whether to cluster the row or columns.
        figsize: `str` (default: `(11.5, 6)`
            Size of figure
        standard_scale: `int` (default: 1)
            Either 0 (rows, cells) or 1 (columns, genes). Whether or not to standardize that dimension, meaning for each row or column,
            subtract the minimum and divide each by its maximum.
        save_show_or_return: {'show', 'save_fig', 'return'} (default: `show`)
            Whether to save_fig, show or return the figure.
        save_kwargs: `dict` (default: `{}`)
            A dictionary that will passed to the save_fig function. By default it is an empty dictionary and the save_fig function
            will use the {"path": None, "prefix": 'kinetic_heatmap', "dpi": None, "ext": 'pdf', "transparent": True, "close":
            True, "verbose": True} as its parameters. Otherwise you can provide a dictionary that properly modify those keys
            according to your needs.
        kwargs:
            All other keyword arguments are passed to heatmap(). Currently `xticklabels=False, yticklabels='auto'` is passed
            to heatmap() by default.

    Returns
    -------
        Nothing but plots a heatmap that shows the gene expression dynamics over time.
    """

    import pandas as pd
    import seaborn as sns
    import matplotlib.pyplot as plt

    if tkey == "potential" and "potential" not in adata.obs_keys():
        ddhodge(adata)

    exprs, valid_genes, time = fetch_exprs(
        adata, basis, layer, genes, tkey, mode, project_back_to_high_dim
    )

    exprs = exprs.A if issparse(exprs) else exprs

    if dist_threshold is not None and mode == 'vector_field':
        valid_ind = list(
            np.where(np.sum(np.diff(exprs, axis=0) ** 2, axis=1) > dist_threshold)[0]
            + 1
        )
        valid_ind.insert(0, 0)
        exprs = exprs[valid_ind, :]
        time = time[valid_ind]

    if gene_order_method == "half_max_ordering":
        time, all, valid_ind, gene_idx = _half_max_ordering(
            exprs.T, time, mode=mode, interpolate=True, spaced_num=100
        )
        all, genes = all[np.isfinite(all.sum(1)), :], np.array(valid_genes)[gene_idx][np.isfinite(all.sum(1))]

        df = pd.DataFrame(all, index=genes)
    elif gene_order_method == 'maximum':
        exprs = lowess_smoother(time, exprs.T, spaced_num=100)
        exprs = exprs[np.isfinite(exprs.sum(1)), :]

        if standard_scale is not None:
            exprs = (exprs - np.min(exprs, axis=standard_scale)[:, None]) / np.ptp(
                exprs, axis=standard_scale
            )[:, None]
        max_sort = np.argsort(np.argmax(exprs, axis=1))
        df = pd.DataFrame(exprs[max_sort, :], index=np.array(valid_genes)[max_sort])
    else:
        raise Exception('gene order_method can only be either half_max_ordering or maximum')

    heatmap_kwargs = dict(xticklabels=False, yticklabels=1)
    if kwargs is not None:
        heatmap_kwargs = update_dict(heatmap_kwargs, kwargs)

    sns_heatmap = sns.clustermap(
        df,
        col_cluster=cluster_row_col[0],
        row_cluster=cluster_row_col[1],
        cmap=color_map,
        figsize=figsize,
        **heatmap_kwargs
    )
    if not show_colorbar: sns_heatmap.cax.set_visible(False)

    if save_show_or_return == "save":
        s_kwargs = {"path": None, "prefix": 'kinetic_heatmap', "dpi": None,
                    "ext": 'pdf', "transparent": True, "close": True, "verbose": True}
        s_kwargs = update_dict(s_kwargs, save_kwargs)

        save_fig(**s_kwargs)
    elif save_show_or_return == "show":
        if show_colorbar:
            plt.subplots_adjust(right=0.85)
        plt.tight_layout()
        plt.show()
    elif save_show_or_return == "return":
        return sns_heatmap
plt.legend()
plt.savefig(output_file)
plt.show()
plt.close(f)

#

# Plot dissimilarity matrices
num_models = len(models)
model_names = [models[k][1] for k in selected_scores.keys()]
ss = np.concatenate([v[0][None, :] for v in selected_scores.values()], axis=0)
sl = np.concatenate([v[0][None, :] for v in selected_labels.values()], axis=0)
df = pd.DataFrame(ss.transpose(), columns=model_names)

# Create a categorical palette to identify the networks
network_pal = sns.husl_palette(len(model_names), s=.45)
network_lut = dict(zip(map(str, model_names), network_pal))

# Convert the palette to vectors that will be drawn on the side of the matrix
network_colors = pd.Series(model_names, index=df.columns).map(network_lut)

# Draw the full plot
sns.clustermap(df.corr(),
               center=0,
               cmap="RdBu",
               row_colors=network_colors,
               col_colors=network_colors,
               linewidths=.75,
               figsize=(13, 13))
plt.show()
Example #46
0
    def cn_heatmap(self,
                   df,
                   cell_font_size=3,
                   max_cn=4,
                   method='ward',
                   cmap='bwr',
                   figsize=(15, 20),
                   xlabel='Contigs',
                   ylabel='Cells',
                   **kwargs):
        """
        Create a heatmap from a copy number matrix

        df: triple indexed dataframe with as columns ('contig', start, end ), as rows cells/samples

        cell_font_size (int): font size of the cell labels

        max_cn (int) : dataframe will be clipped to this value. (Maximum copy number shown)

        method (str) : clustering metric

        cmap (str) : colormap used

        figsize(tuple) : Size of the figure

        xlabel (str) : Label for the x-axis, by default this is Contigs

        ylabel (str) : Label for the x-axis, by default this is Cells

        **kwargs : Arguments which will be passed to seaborn.clustermap

        """

        try:
            clmap = sns.clustermap(df.sort_index(1)[self.contigs],
                                   col_cluster=False,
                                   method=method,
                                   cmap=cmap,
                                   vmax=max_cn,
                                   vmin=0,
                                   yticklabels=True,
                                   figsize=figsize,
                                   **kwargs)
            ax_heatmap = clmap.ax_heatmap
        except Exception as e:
            print('Falling back on heatmap without clustering')
            fig, ax_heatmap = plt.subplots(figsize=figsize)
            clmap = sns.heatmap(df.sort_index(1)[self.contigs],
                                cmap=cmap,
                                vmax=max_cn,
                                vmin=0,
                                yticklabels=True,
                                ax=ax_heatmap)

        prev = None
        xtick_pos = []
        xtick_label = []
        last_idx = 0
        for idx, (contig, start,
                  end) in enumerate(df.sort_index(1)[self.contigs].columns):
            if prev is not None and prev != contig:
                ax_heatmap.axvline(idx - 0.5, c='k', lw=1.5, zorder=10)
                xtick_pos.append((idx + last_idx) / 2)
                xtick_label.append(prev)
                last_idx = idx
            prev = contig

        ax_heatmap.set_xticks(xtick_pos)
        ax_heatmap.set_xticklabels(xtick_label, rotation=0, fontsize=8)
        ax_heatmap.set_xlabel(xlabel, labelpad=20)
        ax_heatmap.set_ylabel(ylabel, labelpad=20)

        return clmap
plt.tight_layout()
#%%
df[df['Reason']=='Fire'].groupby('Date').count()['twp'].plot()
plt.tight_layout()

#%%
df[df['Reason']=='EMS'].groupby('Date').count()['twp'].plot()
plt.tight_layout()

#%%
day_hour = df.groupby(by=['Day of Week','Hour']).count()['Reason'].unstack()

#%%
plt.figure(figsize=(12,6))
sns.heatmap(day_hour, cmap='viridis')

#%%
sns.clustermap(day_hour, cmap='viridis')

#%%
day_month = df.groupby(by=['Day of Week', 'Month']).count()['Reason'].unstack()

#%%
plt.figure(figsize=(12, 6))
sns.heatmap(day_month, cmap='viridis')

#%%
sns.clustermap(day_month, cmap='viridis')

#%%
Example #48
0
plt.show()




'''
3.6 seaborn.heatmap

seaborn.heatmap() 主要是用于绘制热力图,也就类似于色彩矩阵。
'''
# 生成 10x10 的随机矩阵
matrix_data = np.random.rand(10, 10)

# 绘图
sns.heatmap(data=matrix_data)

plt.show()




'''
3.7 seaborn.clustermap

seaborn.clustermap() 可以将矩阵数据集绘制为层次聚类热图。
'''
iris_data.pop("species")  #去掉了花的类别列

# 绘图
sns.clustermap(iris_data)
plt.show()
Example #49
0
sfinal_feat = pd.concat([sFeatMatAll[combi], conds2], axis=1)

#make a colormap to assign colours - based on class (ie clozapine10 is separate)
cmap1 = sns.color_palette("tab20", np.unique(sfinal_feat['drug']).shape[0])

#make a clustergram
#1. make lut for drug colors
#2. map the lut onto the clustergram
lut = dict(zip(np.unique(sfinal_feat['drug']), cmap1))

#add in row colors to the dataframe
row_colors = sfinal_feat['drug'].map(lut)  #map onto the feature Matrix

#make clustergram
cg=sns.clustermap(sfinal_feat.iloc[:,:-3], metric  = 'euclidean', cmap = 'inferno', \
                  row_colors = row_colors)
plt.setp(cg.ax_heatmap.yaxis.set_ticklabels\
         (sfinal_feat['drug'][cg.dendrogram_row.reordered_ind]))
plt.setp(cg.ax_heatmap.yaxis.get_majorticklabels(), rotation=0, fontsize=8)
plt.setp(cg.ax_heatmap.xaxis.get_majorticklabels(), rotation=90, fontsize=10)
col = cg.ax_col_dendrogram.get_position()
cg.ax_col_dendrogram.set_position(
    [col.x0, col.y0, col.width * 1, col.height * 1])
#save fig
plt.savefig(os.path.join(directoryA[0:-7], 'Figures', 'Agar_stats_LDA_clustergram1.tif'), \
            dpi =150, bbox_inches = 'tight', pad_inches = 1)
plt.show()

#make list of the final order of the drugs
drug_order = list(sfinal_feat['drug'][cg.dendrogram_row.reordered_ind])
conc_order = list(
Example #50
0
    louvain = attr_df.loc[i, 'louvain']  #louvain of sample
    cell_type = attr_df.loc[i, 'biosample_cell_type']  #cell type

    l_color = louvain_colors[louvain]
    c_color = cell_type_colors[cell_type]
    attr_df.loc[i, 'louvain_colors'] = l_color
    attr_df.loc[i, 'cell_type_colors'] = c_color
#print(attr_df.head())

#print(len(louvain)) #8 clusters
#print(len(cell_type)) #9 cell)_type
cmap = sns.diverging_palette(220, 20, as_cmap=True)
g = sns.clustermap(features_df,
                   cmap=cmap,
                   row_cluster=True,
                   col_cluster=False,
                   row_colors=attr_df[['louvain_colors', 'cell_type_colors']],
                   linewidths=0,
                   xticklabels=False,
                   yticklabels=False)
#for some reason, it cant take two legends....
#legend_louvain = [mpatches.Patch(color=c, label=l) for c,l in attr_df[['louvain_colors','louvain']].drop_duplicates().values]
#l2=g.ax_heatmap.legend(loc='upper left',bbox_to_anchor=(0.05,1.3),handles=legend_louvain,frameon=True)
#l2.set_title(title='louvain cluster',prop={'size':10})
attr_df['biosample_cell_type'] = encoder.inverse_transform(
    attr_df['biosample_cell_type'].values.tolist())
legend_cell_type = [
    mpatches.Patch(color=k, label=v) for k, v in attr_df[
        ['cell_type_colors', 'biosample_cell_type']].drop_duplicates().values
]
l1 = g.ax_heatmap.legend(loc='upper left',
                         bbox_to_anchor=(1.01, 0.6),
Example #51
0
def main(_):
  print("Loading data...")
  dfs = []
  for filename in os.listdir(FLAGS.data):
    if filename.endswith(".csv"):
      dfs.append(
          pd.read_csv(os.path.join(FLAGS.data, filename), encoding="utf-8"))
  data = pd.concat(dfs)
  print("%d Examples" % (len(set(data["id"]))))
  print("%d Annotations" % len(data))
  
  if not os.path.isdir(FLAGS.plot_dir):
    os.makedirs(FLAGS.plot_dir)

  with open(FLAGS.emotion_file, "r") as f:
    all_emotions = f.read().splitlines()
  all_emotions_neutral = all_emotions + ["neutral"]
  print("%d emotion Categories" % len(all_emotions))

  print("%d unique raters" % len(data["rater_id"].unique()))
  print("%.3f marked unclear" %
        (data["example_very_unclear"].sum() / len(data)))

  # Since the ones marked as difficult have no labels, exclude those
  data = data[data[all_emotions_neutral].sum(axis=1) != 0]

  print("Distribution of number of labels per example:")
  print(data[all_emotions_neutral].sum(axis=1).value_counts() / len(data))
  print("%.2f with more than 3 labels" %
        ((data[all_emotions_neutral].sum(axis=1) > 3).sum() /
         len(data)))  # more than 3 labels

  print("Label distributions:")
  print((data[all_emotions_neutral].sum(axis=0).sort_values(ascending=False) /
         len(data) * 100).round(2))

  print("Plotting label correlations...")
  ratings = data.groupby("id")[all_emotions].mean()

  # Compute the correlation matrix
  corr = ratings.corr()

  # Generate a mask for the upper triangle
  mask = np.zeros_like(corr, dtype=np.bool)
  mask[np.triu_indices_from(mask)] = True

  # Set up the matplotlib figure
  fig, _ = plt.subplots(figsize=(11, 9))

  # Generate a custom diverging colormap
  cmap = sns.diverging_palette(220, 10, as_cmap=True)

  # Draw the heatmap with the mask and correct aspect ratio
  sns.heatmap(
      corr,
      mask=mask,
      cmap=cmap,
      vmax=.3,
      center=0,
      square=True,
      linewidths=.5,
      cbar_kws={"shrink": .5})
  fig.savefig(
      FLAGS.plot_dir + "/correlations.pdf",
      dpi=500,
      format="pdf",
      bbox_inches="tight")

  print("Plotting hierarchical relations...")
  z = linkage(
      pdist(ratings.T, metric="correlation"),
      method="ward",
      optimal_ordering=True)
  fig = plt.figure(figsize=(11, 4), dpi=400)
  plt.xlabel("")
  plt.ylabel("")
  dendrogram(
      z,
      labels=ratings.columns,
      leaf_rotation=90.,  # rotates the x axis labels
      leaf_font_size=12,  # font size for the x axis labels
      color_threshold=1.05,
  )
  fig.savefig(
      FLAGS.plot_dir + "/hierarchical_clustering.pdf",
      dpi=600,
      format="pdf",
      bbox_inches="tight")

  sent_color_map = {
      "positive": "#BEECAF",
      "negative": "#94bff5",
      "ambiguous": "#FFFC9E"
  }
  with open(FLAGS.sentiment_dict) as f:
    sent_dict = json.loads(f.read())
  sent_colors = {}
  for e in all_emotions:
    if e in sent_dict["positive"]:
      sent_colors[e] = sent_color_map["positive"]
    elif e in sent_dict["negative"]:
      sent_colors[e] = sent_color_map["negative"]
    else:
      sent_colors[e] = sent_color_map["ambiguous"]

  # Generate a mask for the upper triangle
  mask = np.zeros_like(corr, dtype=np.bool)
  mask[np.diag_indices(mask.shape[0])] = True

  # Generate a custom diverging colormap
  cmap = sns.diverging_palette(220, 10, as_cmap=True)

  row_colors = pd.Series(
      corr.columns, index=corr.columns, name="sentiment").map(sent_colors)

  # Draw the heatmap with the mask and correct aspect ratio
  g = sns.clustermap(
      corr,
      mask=mask,
      cmap=cmap,
      vmax=.3,
      vmin=-0.3,
      center=0,
      row_linkage=z,
      col_linkage=z,
      col_colors=row_colors,
      linewidths=.1,
      cbar_kws={
          "ticks": [-.3, -.15, 0, .15, .3],
          "use_gridspec": False,
          "orientation": "horizontal",
      },
      figsize=(10, 10))

  g.ax_row_dendrogram.set_visible(False)
  g.cax.set_position([.34, -0.05, .5, .03])

  for label in sent_color_map:
    g.ax_col_dendrogram.bar(
        0, 0, color=sent_color_map[label], label=label, linewidth=0)

  g.ax_col_dendrogram.legend(
      title="Sentiment", loc="center", bbox_to_anchor=(1.1, .5))

  g.savefig(FLAGS.plot_dir + "/hierarchical_corr.pdf", dpi=600, format="pdf")

  print("Calculating agreements...")
  unique_labels = data.groupby("id").apply(CheckAgreement, 1,
                                           all_emotions_neutral).to_dict()
  data["unique_labels"] = data["id"].map(unique_labels)
  agree_dict_2 = data.groupby("id").apply(CheckAgreement, 2,
                                          all_emotions_neutral).to_dict()
  data["agree_2"] = data["id"].map(agree_dict_2)
  agree_dict = data.groupby("id").apply(CheckAgreement, 3,
                                        all_emotions_neutral).to_dict()
  data["agree_3"] = data["id"].map(agree_dict)
  agree_dict = data.groupby("id").apply(CheckAgreement, 1, all_emotions_neutral,
                                        1).to_dict()
  data["no_agree"] = data["id"].map(agree_dict)

  filtered_2 = data[data["agree_2"].str.len() > 0]
  print(
      "%d (%d%%) of the examples have 2+ raters agreeing on at least one emotion label"
      % (len(filtered_2["id"].unique()), (len(filtered_2) / len(data) * 100)))

  filtered_3 = data[data["agree_3"].str.len() > 0]
  print(
      "%d (%d%%) of the examples have 3+ raters agreeing on at least one emotion label"
      % (len(filtered_3["id"].unique()), (len(filtered_3) / len(data) * 100)))

  print("Plotting number of labels...")
  data["num_unique_prefilter"] = data["unique_labels"].apply(CountLabels)
  data["num_unique_postfilter"] = data["agree_2"].apply(CountLabels)
  unique_ex = data.drop_duplicates("id")
  df = pd.DataFrame({
      "count":
          unique_ex["num_unique_prefilter"].tolist() +
          unique_ex["num_unique_postfilter"].tolist(),
      "type": ["pre-filter"] * len(unique_ex) + ["post-filter"] * len(unique_ex)
  })

  fig = plt.figure(dpi=600)
  ax = sns.countplot(
      data=df, x="count", hue="type", palette=["skyblue", "navy"])
  plt.xlim(-.5, 7.5)
  plt.legend(loc="center right", fontsize="x-large")
  plt.ylabel("Number of Examples", fontsize="x-large")
  plt.xlabel("Number of Labels", fontsize="x-large")
  plt.draw()
  labels = [item.get_text() for item in ax.get_yticklabels()]
  ax.set_yticklabels(["%dk" % (int(int(label) / 1000)) for label in labels])
  plt.tight_layout()

  fig.savefig(
      FLAGS.plot_dir + "/number_of_labels.pdf",
      dpi=600,
      format="pdf",
      bbox_inches="tight")

  print("Proportion of agreement per label:")
  print(
      filtered_2[all_emotions_neutral].sum(axis=0).sort_values(ascending=False)
      / len(data))
Example #52
0
    if len(taxon_all) < 2:
        taxon = "unknown"
    else:
        taxon = taxa[index].split(';')[1].split("_")[-1]
    if toi != None:
        if toi not in taxon:
            df.drop([index], inplace=True, axis=0)
            continue

    if taxon in taxa_colors:
        row_colors.append(taxa_colors[taxon])
    else:
        row_colors.append("w")

print "plotting..."
sns.set(font_scale=1)
g = sns.clustermap(df,
                   figsize=(8, 8),
                   col_colors=col_colors,
                   col_cluster=False,
                   yticklabels=False,
                   xticklabels=False,
                   cmap="magma_r")

# adjust axis labels
plt.setp(g.ax_heatmap.get_xticklabels(), rotation=90)
plt.setp(g.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)

plt.savefig("figure.png", bbox_inches='tight', dpi=300)
plt.show()
Example #53
0
            vertex_label_size=5,
            vertex_frame_width=0,
            vertex_size=20,
            edge_width=1.,
            target='%s/reports/Figure_4.pdf' % wd)
print '[INFO] Network exported: ', network_i.summary()

# -- Betas heatmap
cmap = sns.diverging_palette(220, 10, n=9, as_cmap=True)

plot_df = lm_betas_kinases.loc[:, [m in met_name for m in lm_betas_kinases]]
plot_df.columns = [met_name[m] for m in plot_df]
plot_df.index = [acc_name[i].split(';')[0] for i in plot_df.index]

sns.set(style='white', palette='pastel')
sns.clustermap(plot_df.T, figsize=(15, 20), cmap=cmap, linewidth=.5)
plt.savefig('%s/reports/Figure_Supp_4_kinases_dynamic_betas.pdf' % wd,
            bbox_inches='tight')
plt.close('all')

plot_df = lm_betas_tfs.loc[:, [m in met_name for m in lm_betas_tfs]]
plot_df.columns = [met_name[m] for m in plot_df]
plot_df.index = [acc_name[i].split(';')[0] for i in plot_df.index]
plot_df = plot_df[plot_df.std(1) != 0]

sns.set(style='white', palette='pastel')
sns.clustermap(plot_df.T, figsize=(15, 20), cmap=cmap, linewidth=.5)
plt.savefig(
    '%s/reports/Figure_Supp_4_transcription_factors_dynamic_betas.pdf' % wd,
    bbox_inches='tight')
plt.close('all')
z=pd.read_csv(sys.argv[1], sep='\t', index_col=0)

# add colored x-labels
lut=[]
for sample in z.columns.values:
        if "2014-09" in sample: lut.append(sys.argv[3])
        elif "2015-06" in sample: lut.append(sys.argv[4])
        elif "2016-02" in sample: lut.append(sys.argv[5])
        elif "2017-02" in sample: lut.append(sys.argv[6])
	else: lut.append('w')

# make heat map
sns.set(font_scale=0.6)
size=float(sys.argv[2])
g = sns.clustermap(z, figsize=(size,size), col_colors=lut, row_colors=lut, col_cluster=True, xticklabels=False, yticklabels=False, cmap="magma")


plt.subplots_adjust(left=0, right=1, top=0.99, bottom=0.01)

ratio=0.6
h_adjust=0.08
w_adjust=-0.05

hm = g.ax_heatmap.get_position()
xden = g.ax_col_dendrogram.get_position()
yden = g.ax_row_dendrogram.get_position()
col = g.ax_col_colors.get_position()
row = g.ax_row_colors.get_position()
legend = g.cax.get_position()
Example #55
0
def plot_heatmap(data,
                 vmin=0,
                 vmax=100,
                 cm=None,
                 col_colors=None,
                 row_colors=None,
                 sorted_labels=None,
                 annot=True,
                 col_cluster=False,
                 row_cluster=False):
    # seaborn
    dpi = 72.27
    fontsize_x_pt = 8
    fontsize_y_pt = 10

    # compute the matrix height in points and inches
    matrix_height_pt = fontsize_y_pt * data.shape[0]
    matrix_height_in = matrix_height_pt / dpi
    matrix_width_pt = fontsize_x_pt * data.shape[1]
    matrix_width_in = matrix_width_pt / dpi

    # compute the required figure height
    top_margin = 0.04  # in percentage of the figure height
    bottom_margin = 0.04  # in percentage of the figure height
    coeff = 2
    figure_height = coeff * matrix_height_in / (1 - top_margin - bottom_margin)
    figure_width = coeff * matrix_width_in / (1 - top_margin - bottom_margin)
    ccr = 0.8 * col_colors.shape[
        0] / figure_height if col_colors is not None else 0
    # build the figure instance with the desired height
    # comput the matrix height in points and inches
    if cm is None:
        cm = plt.cm.get_cmap('gist_heat')  # plasma viridis
        cm = colors.LinearSegmentedColormap('hot_r',
                                            plt.cm.revcmap(cm._segmentdata))
        cm.set_bad('lightgray')
        cm.set_under('blue')
    if sorted_labels is not None:
        data = data.ix[sorted_labels]
    if sns.__version__ == "0.9.dev0+k":
        splot = sns.clustermap(
            data,
            col_cluster=col_cluster,
            row_cluster=row_cluster,
            figsize=(figure_width, figure_height),
            col_colors=col_colors,
            row_colors=row_colors,
            cmap=cm,
            mask=(data == 0),
            vmin=vmin,
            vmax=vmax,
            col_colors_ratio=ccr,
            xticklabels=1,  # print all labels
            annot=annot,
            annot_kws={'fontsize': 3},
            fmt='.2f')
    else:
        splot = sns.clustermap(
            data,
            col_cluster=col_cluster,
            row_cluster=row_cluster,
            figsize=(figure_width, figure_height),
            col_colors=col_colors,
            row_colors=row_colors,
            cmap=cm,
            mask=(data == 0),
            vmin=vmin,
            vmax=vmax,
            annot=annot,
            annot_kws={'fontsize': 3},
            fmt='.2f',
            xticklabels=1  # print all labels
        )

    splot.cax.set_visible(False)  # TODO
    plt.setp(splot.ax_row_dendrogram, visible=False)  # TODO
    plt.setp(splot.ax_col_dendrogram, visible=False)  # TODO
    splot.ax_heatmap.yaxis.set_ticks_position('left')
    splot.ax_heatmap.yaxis.set_label_position('left')
    splot.ax_heatmap.set_xlabel(data.columns.name, fontsize=10)
    splot.ax_heatmap.set_ylabel(data.index.name, fontsize=10)

    splot.ax_heatmap.set_yticks(numpy.arange(data.shape[0]) + 0.5, minor=False)
    plt.setp(splot.ax_heatmap.get_yticklabels(), rotation=0)
    plt.setp(splot.ax_heatmap.get_xticklabels(), rotation=90)
    plt.setp(splot.ax_heatmap.get_yticklabels(), fontsize=8)
    plt.setp(splot.ax_heatmap.get_xticklabels(), fontsize=6)
    return splot
Example #56
0
sns.stripplot(x="day", y="total_bill", data=tips)
sns.stripplot(x="day", y="total_bill", data=tips,jitter=True) # adds jitter to better visualize 

#--- swarm plot
sns.swarmplot() 
sns.swarmplot(x="day", y="total_bill", data=tips)

#------------------------------------------#
#----------- MATRIX PLOTS -----------------#
#------------------------------------------#
#---- HEATMAP
sns.heatmap()
sns.heatmap(tips.corr(), cmap='RdBu_r') 

#--- CLUSTER MAP 
sns.clustermap()



#------------------------------------------#
#----------- GENERAL PLOT -----------------#
#------------------------------------------#
sns.factorplot()
sns.factorplot(x='sex',y='total_bill',data=tips,kind='bar') # 'kind' parameter decides type of plot

#----------- GENERAL GRIDS ---------------#
#--- pairgrid
sns.PairGrid(iris) # Just the Grid
g = sns.PairGrid(iris)
g.map_diag(plt.hist)
g.map_upper(plt.scatter)
Example #57
0
def clustermap(adata,
               obs_keys=None,
               use_raw=True,
               show=None,
               save=None,
               **kwargs):
    """Hierarchically-clustered heatmap [Waskom16]_.

    Wraps `seaborn.clustermap <https://seaborn.pydata.org/generated/seaborn.clustermap.html>`_ for :class:`~scanpy.api.AnnData`.

    Parameters
    ----------
    adata : :class:`~scanpy.api.AnnData`
        Annotated data matrix.
    obs_keys : `str`
        Categorical annotation to plot with a different color map.
        Currently, only a single key is supported.
    use_raw : `bool`, optional (default: `True`)
        Use `raw` attribute of `adata` if present.
    show : bool, optional (default: `None`)
         Show the plot.
    save : `bool` or `str`, optional (default: `None`)
        If `True` or a `str`, save the figure. A string is appended to the
        default filename. Infer the filetype if ending on \{'.pdf', '.png', '.svg'\}.
    **kwargs : keyword arguments
        Keyword arguments passed to `seaborn.clustermap <https://seaborn.pydata.org/generated/seaborn.clustermap.html>`_.

    Returns
    -------
    If `show == False`, a `seaborn.ClusterGrid` object.

    Notes
    -----
    The returned object has a savefig() method that should be used if you want
    to save the figure object without clipping the dendrograms.

    To access the reordered row indices, use:
    clustergrid.dendrogram_row.reordered_ind

    Column indices, use: clustergrid.dendrogram_col.reordered_ind

    Examples
    --------
    Soon to come with figures. In the meanwile, see
    https://seaborn.pydata.org/generated/seaborn.clustermap.html.

    >>> import scanpy.api as sc
    >>> adata = sc.datasets.krumsiek11()
    >>> sc.pl.clustermap(adata, obs_keys='cell_type')
    """
    if not isinstance(obs_keys, (str, type(None))):
        raise ValueError('Currently, only a single key is supported.')
    sanitize_anndata(adata)
    X = adata.raw.X if use_raw and adata.raw is not None else adata.X
    df = pd.DataFrame(X, index=adata.obs_names, columns=adata.var_names)
    if obs_keys is not None:
        row_colors = adata.obs[obs_keys]
        utils.add_colors_for_categorical_sample_annotation(adata, obs_keys)
        # do this more efficiently... just a quick solution
        lut = dict(
            zip(row_colors.cat.categories, adata.uns[obs_keys + '_colors']))
        row_colors = adata.obs[obs_keys].map(lut)
        g = sns.clustermap(df, row_colors=row_colors, **kwargs)
    else:
        g = sns.clustermap(df, **kwargs)
    show = settings.autoshow if show is None else show
    if show: pl.show()
    else: return g
data.index = data.iloc[:, 0]
data = data.iloc[:, 2:]
clname = list(data.columns)
data = data[[
    'q_A',
    'q_A_unmedicated',
    'q_A_medicated',
    'q_B',
    'q_B_unmedicated',
    'q_B_medicated',
    'q_C',
    'q_C_unmedicated',
    'q_C_medicated',
]]

#First create the clustermap figure
g = sns.clustermap(data, row_colors=np.random.randn(94, 3), figsize=(13, 8))
# set the gridspec to only cover half of the figure
#g.gs.update(left=0.05, right=0.45)
#
##create new gridspec for the right part
#gs2 = matplotlib.gridspec.GridSpec(1,1, left=0.6)
## create axes within this new gridspec
#ax2 = g.fig.add_subplot(gs2[0])
## plot boxplot in the new axes
#sns.boxplot(data=iris, orient="h", palette="Set2", ax = ax2)
plt.show()

np.random.randint(0, 256, 3)
Example #59
0
# 
# ## Correlations in data

# In[5]:

# Spearman is recommended for ordinal data.
correlations = df.corr(method='spearman')
sns.heatmap(correlations,
           square=True);


# Note that if we were to scale the data, the correlation matrix would be unchanged.

# In[6]:

cg = sns.clustermap(correlations, square=True)
plt.setp(cg.ax_heatmap.yaxis.get_majorticklabels(),
        rotation=0);  # Fix rotation of y-labels.


# The expected clusters emerged. Party ID got grouped with economics more than with moral attitudes. Economics and race line up with one another.

# ## Principal component analysis

# In[7]:

from sklearn.pipeline import Pipeline
from sklearn.decomposition import PCA
from sklearn.preprocessing import Imputer, StandardScaler

imp = Imputer(strategy='mean')
Example #60
0
#save the dictionary values to a list
data = list(dict.values())
#Convert the list to an array
an_array = np.array(data, dtype=np.float64)

#Set the array in a dataframe with sample names as columns and annotations as index
df = pd.DataFrame(data=an_array, index=flat_list, columns=args.samples)
#Add a reference sample column to the dataframe only containing 100%
df[args.ref_sample] = [100] * len(df)
#Print the length of the dataframe
print('length dataframe: ', len(df))
#Save the dataframe as csv file
df.to_csv(args.output[:-4] + '.csv')

#Create heatmap of the dataframe
g = sns.clustermap(df, cmap="vlag")
plt.setp(g.ax_heatmap.yaxis.get_majorticklabels(), rotation=0)
#Save and show the heatmap
plt.savefig(args.output, bbox_inches="tight")
plt.show()

#Check the name of the reference sample
#Based on the name of the reference sample, extract the rows where the replicates of the reference are equal to 100 and all the other samples are unequal to 100.
if args.ref_sample == 'PO1':
    new_df = df[(df[args.ref_sample] == 100)
                & (df[args.ref_sample[:-1] + '2'] == 100) &
                (df[args.ref_sample[:-1] + '3'] == 100) & (df['PR1'] != 100) &
                (df['PR2'] != 100) & (df['PR3'] != 100)]
elif args.ref_sample == 'PR1':
    new_df = df[(df[args.ref_sample] == 100)
                & (df[args.ref_sample[:-1] + '2'] == 100) &