def plotSortedProfile(original_series,
                      reconstructed_series,
                      x_label,
                      y_label,
                      scale="log",
                      name=None):

    figure_name = "profile"

    if name:
        figure_name = name + "_" + figure_name

    sort_idx = argsort(original_series)[::-1]

    D = original_series.shape[0]

    figure = pyplot.figure()
    axis = figure.add_subplot(1, 1, 1)

    x = linspace(0, D, D)
    axis.plot(x, original_series[sort_idx], zorder=1, label='Original')
    axis.plot(x,
              reconstructed_series[sort_idx],
              zorder=0,
              label='Reconstruction')

    axis.legend()

    axis.set_yscale(scale)
    axis.set_xscale(scale)

    axis.set_xlabel(x_label)
    axis.set_ylabel(y_label)

    data.saveFigure(figure, figure_name)
def plotKLdivergenceHeatmap(KL_all, name=None):

    print("Plotting KL-divergence heatmap (activity of latent units).")

    figure_name = "KL_divergence_heatmap"

    if name:
        figure_name = name + "/" + figure_name

    figure = pyplot.figure()
    axis = figure.add_subplot(1, 1, 1)

    KL_array = array(KL_all)

    print("Dimensions of KL-activations:")
    print(KL_array.shape)

    seaborn.heatmap(log(KL_array.T),
                    xticklabels=True,
                    yticklabels=False,
                    cbar=True,
                    center=None,
                    square=True,
                    ax=axis)

    axis.set_xlabel("Epoch")
    axis.set_ylabel("$log KL(p_i||q_i)$")

    data.saveFigure(figure, figure_name, no_spine=False)
def plotProfile(series,
                x_label,
                y_label,
                scale="linear",
                bar=False,
                name=None):

    figure_name = "profile"

    if name:
        figure_name = name + "_" + figure_name

    D = series.shape[0]

    figure = pyplot.figure()
    axis = figure.add_subplot(1, 1, 1)

    x = linspace(0, D, D)
    if bar:
        axis.bar(x, series)
    else:
        axis.plot(x, series)

    axis.set_yscale(scale)

    axis.set_xlabel(x_label)
    axis.set_ylabel(y_label)

    data.saveFigure(figure, figure_name)
def plotHeatMap(data_set,
                data_set_headers=None,
                clusters=None,
                center=None,
                simple=False,
                name=None):

    figure_name = "heat_map"

    if name:
        figure_name = name + "_" + figure_name

    if data_set_headers and clusters:

        sorted_data_set = empty(data_set.shape)

        N_seen = 0
        for cluster_id, cluster in sorted(clusters.items()):

            subset = []

            for cell in cluster:
                index = where(data_set_headers["cells"] == cell)[0]
                if len(index) == 0:
                    continue
                subset.append(int(index))

            N_subset = len(subset)

            if N_subset == 0:
                continue

            sorted_data_set[N_seen:(N_seen + N_subset)] = data_set[subset]

            N_seen += N_subset

        data_set = sorted_data_set[:N_seen]
        figure_name += "_sorted"

    N, M = data_set.shape

    # figure = pyplot.figure(figsize = (N/500, M/500))
    figure = pyplot.figure()
    axis = figure.add_subplot(1, 1, 1)

    seaborn.heatmap(data_set.T,
                    xticklabels=False,
                    yticklabels=False,
                    cbar=True,
                    square=True,
                    center=center,
                    ax=axis)

    axis.set_xlabel("Cell")
    axis.set_ylabel("Gene")

    data.saveFigure(figure, figure_name, no_spine=False)
def plotLatentSpace(latent_set,
                    latent_set_headers=None,
                    clusters=None,
                    name=None):

    figure_name = "latent_space"

    if name:
        figure_name = name + "/" + figure_name

    N, M = latent_set.shape

    figure = pyplot.figure()
    axis = figure.add_subplot(1, 1, 1)

    if M > 2:
        # TODO Try t-SNE.
        pca = PCA(n_components=2)
        pca.fit(latent_set)
        latent_set = pca.transform(latent_set)

        axis.set_xlabel("PC 1")
        axis.set_ylabel("PC 2")
    else:
        axis.set_xlabel("z_1")
        axis.set_ylabel("z_2")

    for cluster_id in clusters:

        cluster = clusters[cluster_id]
        subset = []

        for cell in cluster:
            index = where(latent_set_headers["cells"] == cell)[0]
            if len(index) == 0:
                continue
            subset.append(int(index))

        if len(subset) == 0:
            continue

        axis.scatter(latent_set[subset, 0],
                     latent_set[subset, 1],
                     c=data.cluster_colours[cluster_id],
                     edgecolors=None,
                     label=cluster_id)

    # axis.legend(loc="best")

    data.saveFigure(figure, figure_name)
def plotLearningCurves(curves, name=None):

    print("Plotting learning curves.")

    figure_name = "learning_curves"

    if name:
        figure_name = name + "/" + figure_name

    figure, (axis_1, axis_2) = pyplot.subplots(2,
                                               sharex=True,
                                               figsize=(6.4, 9.6))

    for i, (curve_set_name, curve_set) in enumerate(sorted(curves.items())):

        colour = palette[i]

        for curve_name, curve in sorted(curve_set.items()):
            if curve_name == "LB":
                curve_name = "$\\mathcal{L}$"
                line_style = "solid"
                axis = axis_1
            elif curve_name == "ENRE":
                curve_name = "$\\log p(x|z)$"
                line_style = "dashed"
                axis = axis_1
            elif curve_name == "KL":
                line_style = "dashed"
                curve_name = "$KL(p||q)$"
                axis = axis_2
            elif curve_name == "KL_all":
                continue
            epochs = arange(len(curve)) + 1
            label = curve_name + " ({} set)".format(curve_set_name)
            axis.plot(curve, color=colour, linestyle=line_style, label=label)

    handles, labels = axis_1.get_legend_handles_labels()
    labels, handles = zip(*sorted(zip(labels, handles), key=lambda t: t[0]))

    axis_1.legend(handles, labels, loc="best")
    axis_2.legend(loc="best")

    # axis_1.set_xlabel("Epoch")
    axis_2.set_xlabel("Epoch")

    data.saveFigure(figure, figure_name)
def plotCountHistogram(data_set, k_min, k_max, name=None):

    figure_name = "count_histogram"

    if name:
        figure_name = name + "_" + figure_name

    k = linspace(0, k_max, k_max + 1)
    C = empty(k_max + 1)

    for i in range(k_max + 1):
        if k[i] < k_max:
            c = (data_set == k[i]).sum()
        if k[i] == k_max:
            c = (data_set >= k_max).sum()
        C[i] = c

    figure = pyplot.figure()
    axis = figure.add_subplot(1, 1, 1)

    axis.bar(k, C)

    axis.set_yscale("log")

    axis.set_xlabel("Counts")
    axis.set_ylabel("Number of counts")

    data.saveFigure(figure, figure_name)

    for i in reversed(range(k_min, k_max + 1)):

        figure = pyplot.figure()
        axis = figure.add_subplot(1, 1, 1)

        if i < k_max:
            C[i] += C[i + 1]
            C[i + 1] = 0

        axis.bar(k[:i + 1], C[:i + 1])

        axis.set_yscale("log")

        axis.set_xlabel("Counts")
        axis.set_ylabel("Number of counts")

        data.saveFigure(figure, figure_name + "_" + str(i))
def plotHistogram(series, x_label, scale="linear", normed=False, name=None):

    figure_name = "histogram"

    if name:
        figure_name = name + "_" + figure_name

    figure = pyplot.figure()
    axis = figure.add_subplot(1, 1, 1)

    seaborn.distplot(series, kde=False, norm_hist=normed, ax=axis)

    axis.set_yscale(scale)

    axis.set_xlabel(x_label)
    # axis.set_ylabel(y_label)

    data.saveFigure(figure, figure_name)