Ejemplo n.º 1
0
def generate_wordcloud(text):
    # load custom stopword list
    stopwords = set([x.strip() for x in open('stopwords').read().split('\n')])
    print stopwords
    # Generate a word cloud image
    wordcloud = WordCloud(stopwords=stopwords,
                          max_font_size=50,
                          max_words=2000,
                          width=800,
                          height=600,
                          margin=0).generate(text)

    # Display the generated image:
    # the matplotlib way:
    import matplotlib.pyplot as plt
    plt.imshow(wordcloud)
    plt.axis("off")

    # display the image
    # plt.show()

    # save image on disk (+ get rid of the margin trick)
    plt.gca().set_axis_off()
    plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)
    plt.margins(0, 0)
    import matplotlib.ticker as ticker
    plt.gca().xaxis.set_major_locator(ticker.NullLocator())
    plt.gca().yaxis.set_major_locator(ticker.NullLocator())
    plt.savefig('results.png', bbox_inches='tight', pad_inches=0.0)
    def process_image(self, datagen, suffix):
        # prepare iterator
        it = datagen.flow(self.samples, batch_size=1)

        name, extension = os.path.splitext(self.image_path)
        # print(name + suffix + extension)

        # generate samples and plot
        for i in range(9):
            # define subplot
            pyplot.subplot(330 + 1 + i)

            # generate batch of images
            batch = it.next()
            # if i%2 == 0:
            #     continue
            # convert to unsigned integers for viewing
            image = batch[0].astype('uint8')

            new_name = name + suffix + str(i) + extension

            pyplot.imshow(image)
            pyplot.axis('off')

            pyplot.gca().xaxis.set_major_locator(ticker.NullLocator())
            pyplot.gca().yaxis.set_major_locator(ticker.NullLocator())

            pyplot.savefig(new_name, bbox_inches='tight', pad_inches=0, transparent="True")
            pyplot.close

            pyplot.imshow(image)
        pyplot.show()
Ejemplo n.º 3
0
def error_bitmap(sx, mu_axes, sigma_axes):
    """
    Plot bitmaps of the mean relative error and standard deviation of the
    mean relative error.

    Arguments:
    sx -- the observation model.
    mu_axes -- the axis of the mean relative error bitmap.
    sigma_axes -- the axis of the mean relative error standard deviation bitmap.
    cmap -- the colour map of the bitmap.
    """
    # Construct the mean and sigma matrices.
    mu_v, sigma_v = analysis.algorithm.feature_relative_error(sx)
    mu_m, sigma_m = square(mu_v), square(sigma_v)
    # Plot the mean relative error bitmap.
    mu_axes.get_xaxis().set_major_locator(ticker.NullLocator())
    mu_axes.get_yaxis().set_major_locator(ticker.NullLocator())
    mu_im = mu_axes.imshow(mu_m, vmin=0, vmax=1, cmap=ERROR_SCHEME)
    mu_im.set_interpolation(INTERPOLATION)
    # Plot the mean relative error standard deviation bitmap.
    sigma_axes.get_xaxis().set_major_locator(ticker.NullLocator())
    sigma_axes.get_yaxis().set_major_locator(ticker.NullLocator())
    sigma_im = sigma_axes.imshow(sigma_m, vmin=0, vmax=1, cmap=ERROR_SCHEME)
    sigma_im.set_interpolation(INTERPOLATION)
    # Return the mean and relative error images for colour bar plotting.
    return mu_im, sigma_im
def plotSimplex(points, fig=None, vertexlabels=['0', '1', '2'], **kwargs):
    """
    Plot Nx3 points array on the 3-simplex
    (with optionally labeled vertices)

    kwargs will be passed along directly to matplotlib.pyplot.scatter

    Returns Figure, caller must .show()
    """
    if (fig == None):
        fig = plt.figure()
    # Draw the triangle
    l1 = L.Line2D(
        [0, 0.5, 1.0, 0],  # xcoords
        [0, np.sqrt(3) / 2, 0, 0],  # ycoords
        color='k')
    fig.gca().add_line(l1)
    fig.gca().xaxis.set_major_locator(MT.NullLocator())
    fig.gca().yaxis.set_major_locator(MT.NullLocator())
    # Draw vertex labels
    fig.gca().text(-0.05, -0.05, vertexlabels[0])
    fig.gca().text(1.05, -0.05, vertexlabels[1])
    fig.gca().text(0.5, np.sqrt(3) / 2 + 0.05, vertexlabels[2])
    # Project and draw the actual points
    projected = projectSimplex(points)
    plt.scatter(projected[:, 0], projected[:, 1], **kwargs)
    # Leave some buffer around the triangle for vertex labels
    fig.gca().set_xlim(-0.2, 1.2)
    fig.gca().set_ylim(-0.2, 1.2)

    return fig
Ejemplo n.º 5
0
def superimpose_meas_and_objs_on_image(store_to_image, image, meas, objs):
    #Consider first up-scaling the image.
    meas_names = ["Batt_Level", "Num_Poisons", "Num_Foods"]
    objs_names = ["Battery", "Poison", "Food"]

    fig, ax = plt.subplots()
    ax.imshow(image)
    y_pos = [25, 55, 85]  #TODO Generalize
    objcounter = 0
    for obj in objs_names:
        ax.barh(y_pos[objcounter],
                convert_plotted_values_x_axis(objs[objcounter]),
                bar_width,
                align='center',
                color=colors[objcounter],
                ecolor='black')
        objcounter += 1

    ax.text(300, 390, str(meas[0]), fontsize=40, color='blue')
    ax.legend(objs_names, loc='upper right', fontsize=15)

    plt.gca().set_axis_off()
    plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)
    plt.margins(0, 0)
    plt.gca().xaxis.set_major_locator(tick.NullLocator())
    plt.gca().yaxis.set_major_locator(tick.NullLocator())
    plt.savefig(store_to_image, bbox_inches="tight", pad_inches=0)
    plt.close(fig)
Ejemplo n.º 6
0
def scaledimage(W, pixwidth=1, ax=None, grayscale=True):
    """Do intensity plot, similar to MATLAB imagesc()."""
    # W = intensity matrix to visualize
    # pixwidth = size of each W element
    # ax = matplotlib Axes to draw on
    # grayscale = use grayscale color map
    # Rely on caller to .show()

    # N = rows, M = column
    (N, M) = W.shape
    # Need to create a new Axes?
    if(ax is None):
        ax = plt.figure().gca()
    # extents = Left Right Bottom Top
    exts = (0, pixwidth * M, 0, pixwidth * N)
    if(grayscale):
        ax.imshow(W,
                  interpolation='nearest',
                  cmap=cm.gray,
                  extent=exts)
    else:
        ax.imshow(W,
                  interpolation='nearest',
                  extent=exts)

    ax.xaxis.set_major_locator(mt.NullLocator())
    ax.yaxis.set_major_locator(mt.NullLocator())
    return ax
Ejemplo n.º 7
0
def extract_features(dataframe):
    for i, (file, emotion) in enumerate(dataframe.values):
        sample_rate, samples = wavfile.read(file)
        spectrum, freqs, t, im = plt.specgram(samples, Fs=sample_rate)
        plt.gca().set_axis_off()
        plt.subplots_adjust(top=1,
                            bottom=0,
                            right=1,
                            left=0,
                            hspace=0,
                            wspace=0)
        plt.margins(0, 0)
        plt.gca().xaxis.set_major_locator(ticker.NullLocator())
        plt.gca().yaxis.set_major_locator(ticker.NullLocator())
        #plt.show()
        index = file.rfind('/')
        basename = file[(index + 1):-4]
        #plt.savefig(endpoint + '{}_spec.png'.format(basename), bbox_inches='tight', pad_inches=0)
        print(i)
        im = cv2.imread(endpoint + '{}_spec.png'.format(basename))
        try:
            x = len(im)
            input.append(im)
            target.append(encode[emotion])
        except:
            print("no data found at index" + str(i))

    return input, target
def imagesc(W, pixwidth=1, ax=None, grayscale=True):
    '''
    Do intensity plot, similar to MATLAB imagesc()

    W = intensity matrix to visualize
    pixwidth = size of each W element
    ax = matplotlib Axes to draw on 
    grayscale = use grayscale color map

    Rely on caller to .show()

    Simple matrix intensity plot, similar to MATLAB imagesc()
    
    David Andrzejewski ([email protected])
    From: https://gist.github.com/940072
    '''

    # import at last minute to allow user to change settings via previous matplotlib.use()
    from matplotlib import pyplot

    # N = rows, M = column
    (N, M) = W.shape
    # Need to create a new Axes?
    if (ax == None):
        ax = pyplot.figure().gca()
    # extents = Left Right Bottom Top
    exts = (0, pixwidth * M, 0, pixwidth * N)
    if (grayscale):
        ax.imshow(W, interpolation='nearest', cmap=CM.gray, extent=exts)
    else:
        ax.imshow(W, interpolation='nearest', extent=exts)

    ax.xaxis.set_major_locator(MT.NullLocator())
    ax.yaxis.set_major_locator(MT.NullLocator())
    return ax
Ejemplo n.º 9
0
def plot_activation(matrix, step, save_to=None):
    save_to = os.path.join(".", "activations") if save_to is None else save_to
    os.makedirs(save_to, exist_ok=True)
    if len(matrix.shape) != 2:
        raise ValueError('Input "matrix" should have 2 rank, but it is',
                         str(len(matrix.shape)))
    num_label = matrix.shape[1] - 1
    matrix = matrix[matrix[:, num_label].argsort()]
    fig, axes = plt.subplots(ncols=1, nrows=num_label, figsize=(15, 12))
    fig.suptitle("The probability of entity presence (step %s)" % str(step),
                 fontsize=20)
    fig.tight_layout()
    for i, ax in enumerate(axes.flatten()):
        idx = num_label - (i + 1)
        ax.spines['top'].set_color('none')
        ax.spines['bottom'].set_color('none')
        ax.set_ylim(0, 1.05)
        ax.set_ylabel("Capsule " + str(idx))
        ax.yaxis.set_major_locator(ticker.NullLocator())
        if idx > 0:
            ax.xaxis.set_major_locator(ticker.NullLocator())
        else:
            ax.xaxis.set_major_locator(ticker.IndexLocator(base=500, offset=0))
            ax.set_xlabel("Sample index ")
        ax.plot(matrix[:, idx])
        ax_prime = ax.twinx()
        ax_prime.spines['top'].set_color('none')
        ax_prime.spines['bottom'].set_color('none')
    plt.subplots_adjust(hspace=0.2,
                        left=0.05,
                        right=0.95,
                        bottom=0.05,
                        top=.95)
    plt.savefig(os.path.join(save_to, "activation_%s.png" % str(step)))
    plt.close()
Ejemplo n.º 10
0
def risk_bitmap(sx, sy, mu_axes, sigma_axes):
    """
    Plot bitmaps of the mean attributable risk and standard deviation of
    the mean attributable risk.

    Arguments:
    sx -- the observation model of the exposed group.
    sy -- the observation model of the unexposed group.
    mu_axes -- the axes of the mean relative error bitmap.
    sigma_axes -- the axes of the standard deviation mean relative error bitmap.
    cmap -- the colour map of the bitmap.
    """
    # Construct the mean and sigma matrices.
    mu_v, sigma_v = analysis.algorithm.feature_attributable_risk(sx, sy)
    mu_m, sigma_m = square(mu_v), square(sigma_v)
    # Plot the mean relative error bitmap.
    mu_axes.get_xaxis().set_major_locator(ticker.NullLocator())
    mu_axes.get_yaxis().set_major_locator(ticker.NullLocator())
    mu_im = mu_axes.imshow(mu_m, vmin=-1, vmax=1, cmap=RISK_MEAN_SCHEME)
    mu_im.set_interpolation(INTERPOLATION)
    # Plot the mean relative error standard deviation bitmap.
    sigma_axes.get_xaxis().set_major_locator(ticker.NullLocator())
    sigma_axes.get_yaxis().set_major_locator(ticker.NullLocator())
    sigma_im = sigma_axes.imshow(sigma_m,
                                 vmin=0,
                                 vmax=0.25,
                                 cmap=RISK_SE_SCHEME)
    sigma_im.set_interpolation(INTERPOLATION)
    # Return the mean and relative error images for colour bar plotting.
    return mu_im, sigma_im
Ejemplo n.º 11
0
def draw_simplex(pay_mat, save=False, savename='simplex'):

    patches = produce_patches(pay_mat)
    # print(patches)
    final_patches = list(map(s2.project_polygon, patches))

    fig = plt.figure()
    ax = fig.add_subplot(111, aspect='equal')
    ax.set_xlim(-0.18, 1.18)
    ax.set_ylim(-0.18, 1)
    ax.xaxis.set_major_locator(mt.NullLocator())
    ax.yaxis.set_major_locator(mt.NullLocator())
    ax.text(-0.06, -0.05, '0')
    ax.text(1.03, -0.05, '1')
    ax.text(0.49, np.sqrt(3) / 2 + 0.03, '2')

    fig.subplots_adjust(bottom = 0.1)
    fig.subplots_adjust(top = 0.9)
    fig.subplots_adjust(left = 0.1)
    fig.subplots_adjust(right = 1)

    p_0 = pts.Polygon(final_patches[0], ec='black', fc='sandybrown')
    p_1 = pts.Polygon(final_patches[1], ec='black', fc='indianred')
    p_2 = pts.Polygon(final_patches[2], ec='black', fc='lightseagreen')
    ax.add_patch(p_0)
    ax.add_patch(p_1)
    ax.add_patch(p_2)
    plt.legend([p_1, p_2, p_0], ['TR0', 'TR1', 'TR2'])

    if save:
        plt.savefig(savename + '.png')
    else:
        plt.show()
Ejemplo n.º 12
0
def neural_map(ax: plt.Axes, neurons: np.ndarray, axes: bool):
    l = neurons.shape[0]
    if axes:
        major_locator_n = tik.MultipleLocator(l // 2)
        major_formatter_n = tik.FormatStrFormatter('%d')
        minor_locator_n = tik.MultipleLocator(1)

        ax.yaxis.set_major_locator(major_locator_n)
        ax.yaxis.set_major_formatter(major_formatter_n)
        ax.yaxis.set_minor_locator(minor_locator_n)

        ax.xaxis.set_major_locator(major_locator_n)
        ax.xaxis.set_major_formatter(major_formatter_n)
        ax.xaxis.set_minor_locator(minor_locator_n)
    else:
        ax.xaxis.set_major_locator(tik.NullLocator())
        ax.xaxis.set_minor_locator(tik.NullLocator())
        ax.yaxis.set_major_locator(tik.NullLocator())
        ax.yaxis.set_minor_locator(tik.NullLocator())

    ax.imshow(neurons, cmap="hot", interpolation='none')
    ax.set_aspect('equal')

    ma = l - 0.5
    mi = -0.5
    ax.set_xlim(mi, ma)
    ax.set_ylim(mi, ma)

    for i in range(1, l):
        xy = i - 0.5
        ax.plot((mi, ma), (xy, xy), 'red', linestyle='-')
        ax.plot((xy, xy), (mi, ma), 'red', linestyle='-')
def create_data(df_value):
    file, emotion = df_value
    sample_rate, sample = wavfile.read(file)
    segments = np.array_split(sample, 40)
    previous=[]
    segments_new=[]
    for s in segments:
        previous+=list(s)
        segments_new.append(previous)
    assert len(previous)==len(sample) , "size mismatch"
    utterance = []
    for j,s in enumerate(segments_new):
        plt.clf()
        spectrum, freqs, t, im = plt.specgram(s, Fs=sample_rate)
        plt.gca().set_axis_off()
        plt.subplots_adjust(top = 1, bottom = 0, right = 1, left = 0, hspace = 0, wspace = 0)
        plt.margins(0,0)
        plt.gca().xaxis.set_major_locator(ticker.NullLocator())
        plt.gca().yaxis.set_major_locator(ticker.NullLocator())
        index = file.rfind('/')
        basename = file[(index + 1):-4]
        plt.savefig(endpoint + '{}_spec_{}.png'.format(basename, j), dpi=10, bbox_inches='tight', pad_inches=0)
        im = cv2.imread(endpoint + '{}_spec_{}.png'.format(basename, j))
        utterance.append(im)
    label = encode[emotion]
    return utterance, label
Ejemplo n.º 14
0
def save_tight(filepath):
    plt.gca().set_axis_off()
    plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0)

    plt.margins(0, 0)
    plt.gca().xaxis.set_major_locator(ticker.NullLocator())
    plt.gca().yaxis.set_major_locator(ticker.NullLocator())
    plt.savefig(filepath, bbox_inches='tight', pad_inches=0)
Ejemplo n.º 15
0
def plotShapeletFunction(axes, func, x, y):
    z = numpy.zeros((y.size, x.size), dtype=float)
    ev = func.evaluate()
    for i, py in enumerate(y):
        for j, px in enumerate(x):
            z[i,j] = ev(float(px), float(py))
    axes.imshow(z, interpolation='nearest', origin='lower')
    axes.yaxis.set_major_locator(ticker.NullLocator())
    axes.xaxis.set_major_locator(ticker.NullLocator())
Ejemplo n.º 16
0
def wholeImgCLS(gt_info_cls,pred_info_cls, dirpath):
    # truth = np.loadtxt(filename, delimiter=',' )
    fig = plt.figure()
    ax = fig.add_subplot(111, aspect='equal')
    im = Image.open(os.path.join(dirpath, "image")).convert('L')

    ax.set_axis_off()
    print("here")
    fig.subplots_adjust(top=1, bottom=0, right=1, left=0,
                        hspace=0, wspace=0)
    ax.margins(0, 0)
    ax.xaxis.set_major_locator(ticker.NullLocator())
    ax.yaxis.set_major_locator(ticker.NullLocator())

    ax.imshow(im, cmap='gray')
    recList = list()

    # color = {
    #     0: "red",
    #     1: "blue",
    #     2: "yellow"
    # }

    # Adding blue rectangle from gt
    p=patches.Rectangle(
        (gt_info_cls[1], gt_info_cls[2]),
        np.abs(gt_info_cls[3] - gt_info_cls[1]),
        np.abs(gt_info_cls[4] - gt_info_cls[2]),
        fill=False,
        edgecolor="blue",
        linewidth=2
        )
    recList.append(p)

    # Adding red rectangle from pred
    p=patches.Rectangle(
        (pred_info_cls[1], pred_info_cls[2]),
        np.abs(pred_info_cls[3] - pred_info_cls[1]),
        np.abs(pred_info_cls[4] - pred_info_cls[2]),
        fill=False,
        edgecolor="red",
        linewidth=2
        )
    recList.append(p)


    # plot the graph
    for recp in recList:
        ax.add_patch(recp)

    plt.plot()
    # plt.show()
    tmpName = "whole_Line" + str(pred_info_cls[0])+"-"+str(gt_info_cls[0])+".png"

    fig.savefig(os.path.join(dirpath, tmpName), dpi=dpi, bbox_inches='tight', pad_inches=0)
    return tmpName
Ejemplo n.º 17
0
def draw_graph(oriG, active_nodes=set(), title=None, last=False):
    global imgix

    draw_nodes = nx.draw_networkx_nodes
    draw_edges = nx.draw_networkx_edges
    draw_labels = nx.draw_networkx_labels
    draw_edge_labels = nx.draw_networkx_edge_labels

    pos = {i: oriG.node[i]['pos'] for i in oriG}

    fig, ax = plt.subplots(figsize=(12, 8))
    if title is not None:
        ax.set_title(title)

    # draw nodes
    nonactive_nodes = set(oriG.nodes()) - set(active_nodes)
    draw_nodes(oriG, pos=pos, nodelist=nonactive_nodes, node_color='skyblue', ax=ax)
    draw_nodes(oriG, pos=pos, nodelist=[s], node_color='blue', ax=ax)
    draw_nodes(oriG, pos=pos, nodelist=[t], node_color='darkgreen', ax=ax)
    for active_node in active_nodes:
        excess_ratio = calc_excess_ratio(oriG, active_node)
        draw_nodes(oriG, pos=pos, nodelist=[active_node], node_color='red', alpha=excess_ratio, ax=ax)
    nls = {i: oriG.node[i]['d'] if 'd' in oriG.node[i] else i for i in oriG}
    draw_labels(oriG, pos=pos, labels=nls, ax=ax)

    # draw edges
    draw_edges(oriG, pos=pos, edgelist=oriG.edges(), alpha=0.2)
    for u, v in oriG.edges():
        if 'preflow' in oriG[u][v]:
            width = oriG[u][v]['preflow']
        else:
            width = 1
        draw_edges(oriG, pos=pos, edgelist=[(u, v)], width=width, ax=ax)
    els = dict()
    for u, v in oriG.edges():
        if 'preflow' in oriG[u][v]:
            preflow  = oriG[u][v]['preflow']
        else:
            preflow = 0
        capacity = oriG[u][v]['capacity']
        els[u, v] = '{}/{}'.format(preflow, capacity)
    draw_edge_labels(oriG, pos=pos, edge_labels=els, ax=ax)

    # erase locator
    ax.xaxis.set_major_locator(ticker.NullLocator())
    ax.yaxis.set_major_locator(ticker.NullLocator())

    if last:
        plt.savefig('figs/Last.png')
    else:
        plt.savefig('figs/Image{0:04d}.png'.format(imgix)); imgix = imgix + 1

    plt.close()
Ejemplo n.º 18
0
def make_axes(fig):
    # 调整子图间的布局
    fig.subplots_adjust(left=0.1,
                        right=0.95,
                        top=0.9,
                        bottom=0.1,
                        hspace=0.3,
                        wspace=0.8)

    # 绘制左侧一列的绘图区(子图subplot)
    ax1 = plt.subplot2grid((3, 12), (0, 0), colspan=3, fc='greenyellow')

    ax2 = plt.subplot2grid((3, 12), (1, 0), colspan=3, fc='lightgreen')
    ax2.set_xlim(-1, 1)  # 设置X轴坐标限制范围
    ax2.set_ylim(-1, 1)  # 设置X轴坐标限制范围
    ax2.spines['right'].set_visible(False)  # 设置右侧轴不可见
    ax2.spines['top'].set_visible(False)  # 设置上边轴不可见
    ax2.spines['left'].set_position('center')  # 将左侧轴设置到中间显示
    ax2.spines['bottom'].set_position('center')  # 将底部轴设置到中间显示

    ax3 = plt.subplot2grid((3, 12), (2, 0), colspan=3, fc='springgreen')

    # 绘制中间一列的绘图区(子图subplot)
    ax4 = plt.subplot2grid((3, 12), (0, 3), rowspan=2, colspan=6, fc='None')
    # ax4.imshow(mapimg)

    ax5 = plt.subplot2grid((3, 12), (2, 3), colspan=2, fc='aqua', polar=True)

    ax6 = plt.subplot2grid((3, 12), (2, 5),
                           colspan=2,
                           fc='dodgerblue',
                           polar=True)
    ax6.yaxis.set_major_locator(ticker.NullLocator())

    ax7 = plt.subplot2grid((3, 12), (2, 7),
                           colspan=2,
                           fc='royalblue',
                           polar=True)
    ax7.yaxis.set_major_locator(ticker.NullLocator())

    # 绘制右侧一列的绘图区(子图subplot)
    ax8 = plt.subplot2grid((3, 12), (0, 9), colspan=3, fc='plum', polar=True)

    ax9 = plt.subplot2grid((3, 12), (1, 9), colspan=3, fc='mediumpurple')

    ax10 = plt.subplot2grid((3, 12), (2, 9),
                            colspan=3,
                            fc='purple',
                            polar=True)

    return ax1, ax2, ax3, ax4, ax5, ax6, ax7, ax8, ax9, ax10
Ejemplo n.º 19
0
 def __init__(self, axes, tile, **kwargs):
     super().__init__(**kwargs)
     self.tile = tile
     self.axes = axes
     self.axes.xaxis.set_major_locator(ticker.NullLocator())
     self.axes.yaxis.set_major_locator(ticker.NullLocator())
     self.artist = axes.imshow(np.zeros((0, 0)), origin="lower")
     self.rectangle = mp.patches.Rectangle((0, 0), 0, 0, ec='red', fc='None', zorder=5000)
     self.rectangle.set_alpha(0)
     self.axes.add_patch(self.rectangle)
     self.z_slice_max = self.tile.image.shape[2] - 1
     self.z_slice = self.tile.image.shape[2] // 2
     self.shift = self.tile.info["scaling"][0] * 5
     tile.observe('extent', self.request_redraw)
Ejemplo n.º 20
0
def setup(ax):
    ax.cla()
    ax.spines['right'].set_color('none')
    ax.spines['left'].set_color('none')
    ax.yaxis.set_major_locator(ticker.NullLocator())
    ax.spines['top'].set_color('none')
    ax.xaxis.set_ticks_position('none')  # bottom
    ax.xaxis.set_major_locator(ticker.NullLocator())
    ax.tick_params(which='major', width=1.00)
    ax.tick_params(which='major', length=5)
    ax.tick_params(which='minor', width=0.75)
    ax.tick_params(which='minor', length=2.5)
    ax.set_xlim(0, 5)
    ax.set_ylim(0, 1)
Ejemplo n.º 21
0
    def plot(self, filename=None, show=False):
        self.plt.rcParams.update(self.params)
        labelLen = max(len(label) for label in self.labels)
        w, h = 800, 600
        space = 0.01 if self.space_width == None else self.space_width
        border = self.border_width
        width = 1.0 - 2*border
        height = 1.0 - 2*border
        textLineHeight = min(max(h/len(self.labels), 4), self.plt.rcParams.get("font.size", 12))
        maxTextLineWidthEstimate = textLineHeight*labelLen
##        print maxTextLineWidthEstimate
        textAxisWidthRatio = 2.0*maxTextLineWidthEstimate/w
##        print textAxisWidthRatio
        labelsAreaRatio = min(textAxisWidthRatio, 0.4) if self.label_width == None else self.label_width
        x, y = len(self.data.domain.attributes), len(self.data)

        heatmapAreaRatio = min(1.0*y/h*x/w, 0.3) if self.heatmap_width == None else self.heatmap_width
        dendrogramAreaRatio = 1.0 - labelsAreaRatio - heatmapAreaRatio - 2*space if self.dendrogram_width == None else self.dendrogram_width

        self.fig = self.plt.figure()
        self.labels_offset = self.root.height/20.0
        dendrogramAxes = self.plt.axes([border, border, width*dendrogramAreaRatio, height])
        dendrogramAxes.xaxis.grid(True)
        import matplotlib.ticker as ticker

        dendrogramAxes.yaxis.set_major_locator(ticker.NullLocator())
        dendrogramAxes.yaxis.set_minor_locator(ticker.NullLocator())
        dendrogramAxes.invert_xaxis()
        self.plotDendrogram()
        heatmapAxes = self.plt.axes([border + width*dendrogramAreaRatio + space, border, width*heatmapAreaRatio, height], sharey=dendrogramAxes)

        heatmapAxes.xaxis.set_major_locator(ticker.NullLocator())
        heatmapAxes.xaxis.set_minor_locator(ticker.NullLocator())
        heatmapAxes.yaxis.set_major_locator(ticker.NullLocator())
        heatmapAxes.yaxis.set_minor_locator(ticker.NullLocator())
        
        self.plotHeatMap()
        labelsAxes = self.plt.axes([border + width*(dendrogramAreaRatio + heatmapAreaRatio + 2*space), border, width*labelsAreaRatio, height], sharey=dendrogramAxes)
        self.plotLabels()
        labelsAxes.set_axis_off()
        labelsAxes.xaxis.set_major_locator(ticker.NullLocator())
        labelsAxes.xaxis.set_minor_locator(ticker.NullLocator())
        labelsAxes.yaxis.set_major_locator(ticker.NullLocator())
        labelsAxes.yaxis.set_minor_locator(ticker.NullLocator())
        if filename:
            canvas = matplotlib.backends.backend_agg.FigureCanvasAgg(self.fig)
            canvas.print_figure(filename)
        if show:
            self.plt.show()
Ejemplo n.º 22
0
def plotcls(cls_list, dirPath):
    # truth = np.loadtxt(filename, delimiter=',' )
    fig = plt.figure()
    ax = fig.add_subplot(111, aspect='equal')
    im = np.array(Image.open(os.path.join(dirPath, "image")), dtype=np.uint8)
    ax.set_axis_off()
    print("here")
    fig.subplots_adjust(top=1, bottom=0, right=1, left=0,
                        hspace=0, wspace=0)
    ax.margins(0, 0)
    ax.xaxis.set_major_locator(ticker.NullLocator())
    ax.yaxis.set_major_locator(ticker.NullLocator())


    ax.imshow(im.astype(np.uint8), cmap='gray')
    recList = list()

    # Adding blue rectangle from predict
    for element in cls_list:
        pred = element[0]
        gt = element[2]
        recList.append(
            patches.Rectangle(
                (pred[1], pred[2]),
                np.abs(pred[3] - pred[1]),
                np.abs(pred[4] - pred[2]),
                fill=False,
                edgecolor = 'red',
                linewidth=1
            )
        )

        recList.append(
            patches.Rectangle(
                (gt[1], gt[2]),
                np.abs(gt[3] - gt[1]),
                np.abs(gt[4] - gt[2]),
                fill=False,
                edgecolor = 'blue',
                linewidth=1
            )
        )
    # plot the graph
    for p in recList:
        ax.add_patch(p)

    plt.plot()
    # plt.show()
    fig.savefig(os.path.join(dirPath, "cls.png"), dpi=dpi, bbox_inches='tight', pad_inches=0)
Ejemplo n.º 23
0
 def plot(self, W):
     dim = eval('(' + W.label + ')')[0]
     size = int(math.ceil(math.sqrt(dim[0])))
     if len(dim) == 4:
         for i, channel in enumerate(W.data):
             ax = plt.subplot(size, size, i + 1)
             ax.xaxis.set_major_locator(ticker.NullLocator())
             ax.yaxis.set_major_locator(ticker.NullLocator())
             accum = channel[0]
             for ch in channel:
                 accum += ch
             accum /= len(channel)
             ax.imshow(accum)
     else:
         plt.imshow(W.data)
Ejemplo n.º 24
0
def display_color(x, images, labels, save_file=None):
    """
    Display color versions of the MNIST digits in a grid determined by the t-SNE projections. This code is translated
    and adapted from Andrej Karpathy's Matlab code: https://cs.stanford.edu/people/karpathy/cnnembed/

    :param x: t-SNE projections of images
    :param images: Images to be displayed at each location
    :param labels: Image labels
    :param save_file: File path where the resultant image should be saved. If None, it displays to the screen.
    """
    COL = MplColorHelper('nipy_spectral_r', 0, 10)

    N = len(images)
    S = 2000  # Size of final image
    G = np.ones((S, S, 3))  # Placeholder for RGB pixels in final image
    s = 50  # Size of every image thumbnail
    for i in range(N):
        a = np.ceil(x[i, 0] * (S - s) + 1)
        b = np.ceil(x[i, 1] * (S - s) + 1)
        a = a - ((a - 1) % s)
        b = b - ((b - 1) % s)
        a, b = int(a-1), int(b-1)
        if G[a, b, 0] != 1:  # Check if the spot is already filled
            continue
        I = images[i].permute(1, 2, 0).numpy()
        I = resize(I, (s, s))
        J = np.ones((s, s, 3))
        if I.shape[2] == 1:
            eps = 0.0001
            idx = np.where(I < eps)
            J[idx[0], idx[1], :] = [1, 1, 1]
            idx = np.where(I > eps)
            J[idx[0], idx[1], :] = COL.get_rgb(labels[i])[0:3]

        G[a:(a + s), b:(b + s)] = J

    fig = plt.figure()
    ax = plt.Axes(fig, [0., 0., 1.0, 1.0])
    ax.set_axis_off()
    fig.add_axes(ax)
    ax.imshow(G)

    plt.gca().xaxis.set_major_locator(ticker.NullLocator())
    plt.gca().yaxis.set_major_locator(ticker.NullLocator())
    if save_file is None:
        plt.show()
    else:
        plt.savefig(save_file, bbox_inches='tight', pad_inches=0)
def addEllipses():
    alpha = 0.05
    position = [0.16, 0.5, 0.3, 0.3]
    newax = plt.gcf().add_axes(position, zorder=+100)
    newax.patch.set_alpha(0)
    newax.yaxis.set_major_locator(plticker.NullLocator())
    newax.xaxis.set_major_locator(plticker.NullLocator())
    newax.axis('off')
    ellipse = Ellipse((0.3, 0.6),
                      0.3,
                      0.6,
                      edgecolor='None',
                      fc='green',
                      alpha=alpha)
    newax.add_patch(ellipse)

    position = [0.16, 0.15, 0.3, 0.3]
    newax = plt.gcf().add_axes(position, zorder=+100)
    newax.patch.set_alpha(0)
    newax.yaxis.set_major_locator(plticker.NullLocator())
    newax.xaxis.set_major_locator(plticker.NullLocator())
    newax.axis('off')
    ellipse = Ellipse((0.3, 0.6),
                      0.3,
                      0.6,
                      edgecolor='None',
                      fc='blue',
                      alpha=alpha)
    newax.add_patch(ellipse)

    position = [0.61, 0.28, 0.3, 0.3]
    newax = plt.gcf().add_axes(position, zorder=+100)
    newax.patch.set_alpha(0)
    newax.yaxis.set_major_locator(plticker.NullLocator())
    newax.xaxis.set_major_locator(plticker.NullLocator())
    newax.axis('off')
    ellipse = Ellipse((0.3, 0.6),
                      0.3,
                      0.45,
                      edgecolor='None',
                      fc='red',
                      alpha=alpha,
                      angle=45)
    newax.add_patch(ellipse)

    position = [0.78, 0.78, 0.1, 0.1]
    newax = plt.gcf().add_axes(position, zorder=+100)
    newax.patch.set_alpha(0)
    newax.yaxis.set_major_locator(plticker.NullLocator())
    newax.xaxis.set_major_locator(plticker.NullLocator())
    newax.axis('off')
    ellipse = Ellipse((0.5, 0.5),
                      0.3,
                      0.5,
                      edgecolor='None',
                      fc='brown',
                      alpha=alpha)
    newax.add_patch(ellipse)
Ejemplo n.º 26
0
			def plot_results_triple(stkFile, npFinal, file_to_save, picName, predicted_data, true_data, prediction_len):

				df2 = pd.read_csv(file_to_save)
				for i in npFinal:
					df2 = df2.append({'Close':i}, ignore_index=True)

				b1 = len(df2)-150
				b2 = len(df2)-50
				g1 = len(df2)-51
				g2 = len(df2)
				blue = df2[(df2.index >= b1) & (df2.index < b2)]
				gold = df2[(df2.index >= g1) & (df2.index < g2)]

				fig = pyplot.figure(facecolor='white')
				ax = fig.add_subplot(111)
				
				pyplot.plot(gold.index, gold.Close, color='gold')
				ax.plot(blue.index, blue.Close, color='navy')

				dT1 = date.today() - timedelta(days = 150)
				dT2 = date.today()
				dT3 = date.today() + timedelta(days = 50)

				dTime1 = dt.datetime.strftime(dT1, '%Y-%m-%d')
				dTime2 = dt.datetime.strftime(dT2, '%Y-%m-%d')
				dTime3 = dt.datetime.strftime(dT3, '%Y-%m-%d')

				pyplot.text(b1, blue['Close'][b1], dTime1, weight='bold', va='bottom', fontsize=8, rotation=85)
				pyplot.text(b2, gold['Close'][g1], dTime2, weight='bold', va='bottom', fontsize=8, rotation=85)
				pyplot.text((g2-1), gold['Close'][g2-1], dTime3, weight='bold', va='bottom', fontsize=8, rotation=85)

				pyplot.xlabel('Trading Days')
				pyplot.ylabel('Price')

				ax1 = pyplot.axes()
				x_axis = ax1.axes.get_xaxis()
				x_axis.set_label_text('foo')
				x_axis.label.set_visible(False)
				x_axis.set_major_locator(ticker.NullLocator())
				x_axis.set_minor_locator(ticker.NullLocator())
				x_label = x_axis.get_label()
				x_label.set_visible(False)

				picPath = os.getcwd() + "/saved_pngs/"
				picName = picName + "2.png"
				os.chdir(picPath)
				pyplot.savefig(picName, dpi=400, bbox_inches='tight')
				os.chdir("../")
Ejemplo n.º 27
0
def test_locator_set_formatter():
    """
    Test if setting the locator only will update the AutoDateFormatter to use
    the new locator.
    """
    plt.rcParams["date.autoformatter.minute"] = "%d %H:%M"
    t = [
        datetime.datetime(2018, 9, 30, 8, 0),
        datetime.datetime(2018, 9, 30, 8, 59),
        datetime.datetime(2018, 9, 30, 10, 30)
    ]
    x = [2, 3, 1]

    fig, ax = plt.subplots()
    ax.plot(t, x)
    ax.xaxis.set_major_locator(mdates.MinuteLocator((0, 30)))
    fig.canvas.draw()
    ticklabels = [tl.get_text() for tl in ax.get_xticklabels()]
    expected = [
        '30 08:00', '30 08:30', '30 09:00', '30 09:30', '30 10:00', '30 10:30'
    ]
    assert ticklabels == expected

    ax.xaxis.set_major_locator(mticker.NullLocator())
    ax.xaxis.set_minor_locator(mdates.MinuteLocator((5, 55)))
    decoy_loc = mdates.MinuteLocator((12, 27))
    ax.xaxis.set_minor_formatter(mdates.AutoDateFormatter(decoy_loc))

    ax.xaxis.set_minor_locator(mdates.MinuteLocator((15, 45)))
    fig.canvas.draw()
    ticklabels = [tl.get_text() for tl in ax.get_xticklabels(which="minor")]
    expected = ['30 08:15', '30 08:45', '30 09:15', '30 09:45', '30 10:15']
    assert ticklabels == expected
Ejemplo n.º 28
0
def set_legends(fig, ax, image_size, query, ysubtitle, title):
    #remove frame
    bottom_side = ax.spines["bottom"]
    bottom_side.set_visible(False)
    left_side = ax.spines["left"]
    left_side.set_visible(False)
    right_side = ax.spines["right"]
    right_side.set_visible(False)
    top_side = ax.spines["top"]
    top_side.set_visible(False)
    #display tickers
    ax.xaxis.set_major_locator(ticker.NullLocator())
    numlabel = map(lambda x: image_size[0] / 2 + (x) * (image_size[0] + 1),
                   range(len(query)))
    ax.yaxis.set_major_locator(ticker.FixedLocator(numlabel))
    labels = map(lambda x: x, list(sorted(query)))
    ax.yaxis.set_major_formatter(ticker.FixedFormatter(labels))
    #display legends
    plt.suptitle(title, fontsize=15)
    plt.title("Memory", loc='right', fontsize=13)
    if ysubtitle == "":
        plt.ylabel("Inputs", fontsize=15)
        #left_side.set_visible(True)
    else:
        plt.title("Inputs", loc='left', fontsize=13)
        plt.ylabel(ysubtitle, fontsize=15)
Ejemplo n.º 29
0
def dist_var_hist_box(series_var,filename):

    fig = plt.figure(figsize=(16, 10), dpi=80) 
    # Creates one subplot within our figure and uses the classes fig and ax
    fig, (ax_box, ax_hist) = plt.subplots(2, sharex=True, gridspec_kw={"height_ratios": (.15, .85)}, dpi= 80, facecolor='w', edgecolor='k')
    
    sns.boxplot(series_var, ax=ax_box)
    sns.distplot(series_var, ax=ax_hist)
    #ax.set_ylim(0, 100)

    ax_hist.xaxis.set_major_locator(ticker.MultipleLocator(100000.00))
    ax_hist.xaxis.set_minor_locator(ticker.MultipleLocator(50000))
    ax_hist.xaxis.set_major_formatter(ticker.StrMethodFormatter('${x:,.0f}'))
    ax_hist.set_xlabel("House Price at Sale")
    
    ax_hist.yaxis.set_major_formatter(ticker.PercentFormatter())
    ax_hist.yaxis.set_major_locator(ticker.NullLocator())

    ax_box.set(xlabel='')

    fig.suptitle('Distribution of Housing Sales in Ames, Iowa', fontsize=26)

    file_name = filename
    path = './images/'+file_name+'.png'
    plt.savefig(path)
    plt.close(fig) 
    pass
Ejemplo n.º 30
0
def plot_kde(df):
    row = dict(enumerate(range(3), 1))
    column = dict(acute=0, chronic=1)
    with seaborn.axes_style('darkgrid'):
        fig, axes = pyplot.subplots(3, 2, sharex='col')
        for ((model, SAT), group) in df.groupby(['model', 'SAT']):
            i, j = row[SAT], column[model]
            ax = axes[i, j]
            for (b, g
                 ) in group.groupby('birth_seasonal_coefficient_of_variation'):
                ser = g.time[g.observed]
                proportion_observed = len(ser) / len(g)
                if proportion_observed > 0:
                    kde = statsmodels.nonparametric.api.KDEUnivariate(ser)
                    kde.fit(cut=0)
                    x = kde.support
                    y = proportion_observed * kde.density
                else:
                    x, y = [], []
                label = b if i == j == 0 else ''
                ax.plot(x, y, label=label, alpha=0.7)
            ax.yaxis.set_major_locator(ticker.NullLocator())
            if ax.is_first_row():
                ax.set_title(f'{model.capitalize()} model',
                             fontdict=dict(fontsize='medium'))
            if ax.is_last_row():
                ax.set_xlim(left=0)
                ax.set_xlabel('extinction time (y)')
            if ax.is_first_col():
                ylabel = '\ndensity' if i == 1 else ''
                ax.set_ylabel(f'SAT{SAT}{ylabel}')
        leg = fig.legend(loc='center left',
                         bbox_to_anchor=(0.8, 0.5),
                         title='Birth seasonal\ncoefficient of\nvariation')
        fig.tight_layout(rect=(0, 0, 0.82, 1))