Exemplo n.º 1
0
def fancy_dendrogram(*args, **kwargs):
    '''
    Source: https://joernhees.de/blog/2015/08/26/scipy-hierarchical-clustering-and-dendrogram-tutorial/
    '''
    from scipy.cluster import hierarchy
    import matplotlib.pylab as plt
    
    max_d = kwargs.pop('max_d', None)
    if max_d and 'color_threshold' not in kwargs:
        kwargs['color_threshold'] = max_d
    annotate_above = kwargs.pop('annotate_above', 0)

    ddata = hierarchy.dendrogram(*args, **kwargs)

    if not kwargs.get('no_plot', False):
        plt.title('Hierarchical Clustering Dendrogram (truncated)')
        plt.xlabel('sample index or (cluster size)')
        plt.ylabel('distance')
        for i, d, c in zip(ddata['icoord'], ddata['dcoord'], ddata['color_list']):
            x = 0.5 * sum(i[1:3])
            y = d[1]
            if y > annotate_above:
                plt.plot(x, y, 'o', c=c)
                plt.annotate("%.3g" % y, (x, y), xytext=(0, -5),
                             textcoords='offset points',
                             va='top', ha='center')
        if max_d:
            plt.axhline(y=max_d, c='k')
    return ddata
Exemplo n.º 2
0
def results_plot(tpr_vals, fdr_vals, names, fdr_threshold):
    import pandas as pd
    plt.close()
    with sns.axes_style('white', {'legend.frameon': True}):
        plt.rc('font', weight='bold')
        plt.rc('grid', lw=3)
        plt.rc('lines', lw=2)
        plt.rc('axes', lw=2)
        plt.figure(figsize=(12,5))
        rates = []
        labels = []
        models = []
        for t, f, n in zip(tpr_vals, fdr_vals, names):
            rates.extend(t)
            rates.extend(f)
            labels.extend(['TPR']*len(t))
            labels.extend(['FDR']*len(f))
            models.extend([n]*(len(t)+len(f)))
        df = pd.DataFrame({'value': rates, 'Rate': labels, 'Model': models})
        ax = sns.boxplot(x='Model', y='value', hue='Rate', data=df)  # RUN PLOT
        plt.xlabel('', fontsize=18, weight='bold')
        plt.ylabel('Power and FDR', fontsize=18, weight='bold')
        plt.axhline(fdr_threshold, color='red', lw=2, ls='--')
        # ax.tick_params(labelsize=10)
        plt.legend(loc='upper right')
        sns.despine(offset=10, trim=True)
def violin_plot(df, runs_name, attr, tot_same_repeats, yscale='linear'):

    savefolder, colors, legend_elements = generate_common_plotting_params(runs_name)

    plt.rcParams.update({'font.size': 22})


    violin_colors = create_violin_colors(colors, repeat=tot_same_repeats)

    plt.figure(figsize=(25, 10))

    if attr == 'avg_energy':
        plt.axhline(y=2, linewidth=1, color='r')
    elif attr== 'avg_velocity':
        plt.axhline(y=0.05, linewidth=1, color='r')

    chart = sns.violinplot(data=df, width=0.8, inner='quartile', scale='width', linewidth=0.05,
                           palette=violin_colors)  # inner='quartile'
    df.mean().plot(style='_', c='black', ms=30)
    chart.set_xticklabels(chart.get_xticklabels(), rotation=70)
    plt.yscale(yscale)
    #plt.gca().set_ylim(top=20)
    plt.legend(handles=legend_elements)
    plt.title(attr)
    plt.savefig('{}violin_{}.png'.format(savefolder, attr), dpi=300, bbox_inches='tight')
    plt.show()
Exemplo n.º 4
0
def compute_autocorrelation(psd_x, wavenumber_x, x_zero_crossing, display=True):
    """

    :param psd_x:
    :param wavenumber_x:
    :param x_zero_crossing:
    :param display:
    :return:
    """

    autocorrelation = np.fft.ifft(psd_x).real
    autocorrelation /= autocorrelation[0]
    delta_f = 1 / (wavenumber_x[-1] - wavenumber_x[-2])
    distance = np.linspace(0, int(delta_f/2), int(autocorrelation.size /2))

    corr_model = (1 + factor_a * x / x_zero_crossing + one_six * (factor_a * x / x_zero_crossing) ** 2 -
                  one_six * (factor_a * x / x_zero_crossing) ** 3) * \
                 np.exp(-np.abs(factor_a * x / x_zero_crossing))

    if display:
        plt.plot(distance, autocorrelation[:int(autocorrelation.size/2)], lw=2, color='b', label='autocorrelation')
        plt.plot(x, corr_model, lw=2, color='r', label='MODEL')
        plt.legend()
        plt.xlabel("DISTANCE (km)")
        plt.ylabel("AUTOCORRELATION")
        plt.axhline(y=0., color='k', lw=2)
        plt.xlim(0, zero_crossing*3)
        plt.title("AutoCorrelation from spectrum Ahran model for zero crossing = %s" % str(zero_crossing))
        plt.show()

    return autocorrelation[:int(autocorrelation.size/2)], distance
Exemplo n.º 5
0
def showKernel(dataOrMatrix, fileName = None, useLabels = True, **args) :
 
    labels = None
    if hasattr(dataOrMatrix, 'type') and dataOrMatrix.type == 'dataset' :
	data = dataOrMatrix
	k = data.getKernelMatrix()
	labels = data.labels
    else :
	k = dataOrMatrix
	if 'labels' in args :
	    labels = args['labels']

    import matplotlib

    if fileName is not None and fileName.find('.eps') > 0 :
        matplotlib.use('PS')
    from matplotlib import pylab

    pylab.matshow(k)
    #pylab.show()

    if useLabels and labels.L is not None :
	numPatterns = 0
	for i in range(labels.numClasses) :
	    numPatterns += labels.classSize[i]
	    #pylab.figtext(0.05, float(numPatterns) / len(labels), labels.classLabels[i])
	    #pylab.figtext(float(numPatterns) / len(labels), 0.05, labels.classLabels[i])
	    pylab.axhline(numPatterns, color = 'black', linewidth = 1)
	    pylab.axvline(numPatterns, color = 'black', linewidth = 1)
    pylab.axis([0, len(labels), 0, len(labels)])
    if fileName is not None :
        pylab.savefig(fileName)
	pylab.close()
Exemplo n.º 6
0
def my_lines(ax, pos, *args, **kwargs):
    if ax == 'x':
        for p in pos:
            plt.axvline(p, *args, **kwargs)
    else:
        for p in pos:
            plt.axhline(p, *args, **kwargs)
Exemplo n.º 7
0
def results_plot(tpr_vals, fdr_vals, names, fdr_threshold):
    import pandas as pd

    plt.close()
    with sns.axes_style("white", {"legend.frameon": True}):
        plt.rc("font", weight="bold")
        plt.rc("grid", lw=3)
        plt.rc("lines", lw=2)
        plt.rc("axes", lw=2)
        plt.figure(figsize=(12, 5))
        rates = []
        labels = []
        models = []
        for t, f, n in zip(tpr_vals, fdr_vals, names):
            rates.extend(t)
            rates.extend(f)
            labels.extend(["TPR"] * len(t))
            labels.extend(["FDR"] * len(f))
            models.extend([n] * (len(t) + len(f)))
        df = pd.DataFrame({"value": rates, "Rate": labels, "Model": models})
        ax = sns.boxplot(x="Model", y="value", hue="Rate", data=df)  # RUN PLOT
        plt.xlabel("", fontsize=18, weight="bold")
        plt.ylabel("Power and FDR", fontsize=18, weight="bold")
        plt.axhline(fdr_threshold, color="red", lw=2, ls="--")
        # ax.tick_params(labelsize=10)
        plt.legend(loc="upper right")
        sns.despine(offset=10, trim=True)
Exemplo n.º 8
0
def plot_time(iterations):
    iteration = []
    time = []
    timer = Timer()
    mean_time = 0
    for i in range(iterations):
        individuals = 10
        first_operation = Operator(lambda x, y: x + y, '+')
        second_operation = Operator(lambda x, y: x * y, '*')
        operations = [first_operation, second_operation]
        values = [25, 7, 8, 100, 4, 2]
        constants = []
        for value in values:
            constants.append(Constant(value))
        depth = 3
        goal = 459
        timer.start()
        build_programs(individuals, operations, constants, depth, goal, 1000)
        value = timer.stop()
        time.append(value)
        mean_time += value
        iteration.append(i + 1)
    mean_time = mean_time / iterations
    plt.figure()
    plt.title("Tiempo Tomado en 1000 Generaciones", fontsize=20)
    plt.xlabel('Iteración')
    plt.ylabel('Tiempo (segundos)')
    plt.scatter(iteration, time, color='blue')
    plt.axhline(y=mean_time, color='r', linestyle='-')
    plt.show()
Exemplo n.º 9
0
    def vis_modematching(self):
        a = Listizing(self.R1, self.R2, self.L, self.wl, self.fl, self.w1,
                      self.w2, self.t, self.d1, self.d2)

        wlist = np.array(a.get_cavity_w())
        wlist_rev = -1 * self.wlist

        cavR = a.get_cavity_R()
        fullw = a.get_full_w()
        fullR = a.get_full_R()

        #plotting graphs
        fig = plt.figure(figsize=(15, 10))
        fig.subplots_adjust(hspace=0.8)

        data1 = fig.add_subplot(3, 2, 1)
        plt.figure('Resonator')
        plt.title('Beam Contour in Resonator')
        plt.xlabel('distance(mm)')
        plt.ylabel('beam size(µm)')
        plt.plot(self.wlist, '-r')
        plt.plot(self.wlist_rev, '-r')
        plt.axhline(0, color='yellow')

        plt.xlabel('Time(µs)')
        plt.ylabel('Amplitude')
        plt.title('Signal of monochromatic wave')
        data1.plot(time, result, color='red', label='Monochromatic wave')
        plt.legend()
        plt.minorticks_on()

        data2 = fig.add_subplot(3, 2, 2)
        plt.xlabel('Time(µs)')
        plt.ylabel('Amplitude')
        plt.title('Signal with %s kHz Lineshape' % (self.e8.get()))
        data2.plot(time,
                   result2,
                   color='blue',
                   linestyle='solid',
                   label='with Lineshape',
                   linewidth=1.5)
        plt.legend()
        plt.minorticks_on()

        data3 = fig.add_subplot(3, 1, 2)
        plt.xlabel('Time(µs)')
        plt.ylabel('Amplitude')
        plt.title('Build up, Ringdown Signal')
        data2.plot(time,
                   result3,
                   color='green',
                   linestyle='solid',
                   label='ringdown signal',
                   linewidth=1.5)
        plt.legend()
        plt.minorticks_on()

        data4 = fig.add_subplot(3, 1, 3)

        plt.show()
Exemplo n.º 10
0
def show_results(res1, res2, res3, res4, param):

    fig, axes = plt.subplots()
    x2 = [i for i in range(1000)]
    #axes.plot(x2, res1, 'gold', label="20x20")
    #axes.plot(x2, res2, 'orange', label="40x40")
    #axes.plot(x2, res3, 'r', label="80x80")
    axes.plot(x2, res4, 'k', label=r"$\ell = 3 \; (160\times160)$")
    if param != None:
        plt.axhline(
            y=param[0],
            linestyle='--',
            color='k',
            label=
            r"$\mathrm{\mathbb{E}} \left[\Vert u\Vert^2_{L^2} \right]_{MLMC}$")
    #axes.hist(solutions, bins = 40, color = 'blue', edgecolor = 'black')
    plt.style.use('classic')
    axes.legend(loc="best", prop={'size': 13})

    axes.set_ylabel(
        r'$\mathrm{\mathbb{E}} \left[\Vert u \Vert^2_{L^2} \right]$',
        fontsize=14)
    axes.set_xlabel(r'Repetitions, $N$', fontsize=13)

    plt.ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
    axes.tick_params(axis="y", direction='in', which='both')
    axes.tick_params(axis="x", direction='in', which='both')

    plt.tight_layout()
    plt.show()
Exemplo n.º 11
0
def create_fix_speedup(results, fixspeedupFile):
	parse_functions.removing_existing_file(fixspeedupFile)
	print("Creating fix speedup file: " + fixspeedupFile)
	import matplotlib.pylab as plt

	seg = config_generator.fixspeedup_seg

	fig = plt.figure()
	ax = fig.add_subplot(1, 1, 1)
	ax.set_ylim([0, 9])

	for i in range(1,10,1):
		plt.axhline(y = i, color ="black", linestyle ="--", linewidth=0.1, dashes=(5, 10)) 
	
	for entry in results:
		plt.plot(results[entry][seg][0], results[entry][seg][1], config_generator.fixspeedupSymbols[entry], label=config_generator.fixspeedupLabels[entry])

	plt.legend() # show line names
	plt.ylabel('Speedup')
	plt.xlabel('Array Lenght')

	plt.xticks(rotation=30) # rotate
	plt.subplots_adjust(bottom=0.2) # increment border
	
	plt.show()
	plt.savefig(fixspeedupFile, format='eps')
Exemplo n.º 12
0
def mark_cross(center, **kwargs):
    """Mark a cross. Correct for matplotlib imshow funny coordinate system.
    """
    N = 20
    plt.hold(1)
    plt.axhline(y=center[1] - 0.5, **kwargs)
    plt.axvline(x=center[0] - 0.5, **kwargs)
Exemplo n.º 13
0
def create_fix_times(fixTimes, fixFile):
	parse_functions.removing_existing_file(fixFile)
	print("Creating Fix file: " + fixFile)

	seg = config_generator.fixtimes_seg
	import matplotlib.pylab as plt

	fig = plt.figure()
	ax = fig.add_subplot(1, 1, 1)
	ax.set_ylim([0, 80])

	for i in range(10,90,10):
		plt.axhline(y = i, color ="black", linestyle ="--", linewidth=0.1, dashes=(5, 10)) 
	
	for strategy in fixTimes:
		plt.plot(fixTimes[strategy][seg][0], fixTimes[strategy][seg][1], label=config_generator.fixpassLabels[strategy])

	plt.ylabel('Execution Time (ms)')
	plt.xlabel('Array lenght')
	plt.xticks(rotation=30) # rotate
	plt.subplots_adjust(bottom=0.2) # increment border
	plt.legend()
	#plt.subplots_adjust(bottom=0.2, right=0.75) # increment border
	#plt.xticks([]) # hide axis x
	#plt.legend(loc='center left', bbox_to_anchor=(1, 0.5)) # show line names
	
	plt.savefig(fixFile, format='eps')
Exemplo n.º 14
0
def make_axis(a):
    a.spines['top'].set_color('none')
    a.spines['right'].set_color('none')
    a.tick_params(axis='x',
                  which='both',
                  bottom="off",
                  top="off",
                  labelbottom="on")
    a.tick_params(axis="y",
                  which="both",
                  bottom="off",
                  top="off",
                  labelbottom="off",
                  left="off",
                  right="off",
                  labelleft="on")

    plt.axvline(x=0, color='k')

    plt.ylabel("Correlation", fontsize=12)
    plt.ylim([-0.65, 1.])
    plt.yticks([-0.6, -0.4, -0.2, 0., 0.2, 0.4, 0.6, 0.8, 1.], fontsize=12)
    plt.axhline(y=0., color='k', linestyle='-', linewidth=2.)
    plt.xlim([-3., 3.])
    plt.xlabel("Lag [years]", fontsize=12)

    return 0
Exemplo n.º 15
0
def process_mmd_experiment(width_class):
    results_file_name = mmd_experiment.results_file_stub + "_" +  width_class + ".pickle"
    results = pickle.load( open(results_file_name,'rb' ) )
    
    callibration_mmds = np.loadtxt('results/callibration_mmds.csv')
    mean_callibration = np.mean(callibration_mmds)
    
    mmd_squareds = results['mmd_squareds']
    hidden_layer_numbers = results['hidden_layer_numbers']
    hidden_unit_numbers = results['hidden_unit_numbers']
    num_repeats = mmd_squareds.shape[2]
    
    mean_mmds = np.mean( mmd_squareds, axis = 2 )
    std_mmds = np.std( mmd_squareds, axis = 2 ) / np.sqrt(num_repeats)
    
    plt.figure()
    
    for hidden_layer_number, index in zip(hidden_layer_numbers,range(len(hidden_layer_numbers))):
        if hidden_layer_number==1:
            layer_string = ' hidden layer'
        else:
            layer_string = ' hidden layers'
        line_name = str(hidden_layer_number) + layer_string
        plt.errorbar( hidden_unit_numbers, mean_mmds[:,index], yerr = 2.*std_mmds[:,index], label = line_name)
    plt.xlabel('Number of hidden units per layer')
    plt.xlim([0,60])
    plt.ylabel('MMD SQUARED(GP, NN)')
    plt.ylim([0.,0.02])
    plt.axhline(y=mean_callibration, color='r', linestyle='--')
    plt.legend()
    output_file_name = "../figures/mmds_" + width_class + ".pdf"
    plt.savefig(output_file_name)
    embed()
    plt.show()
Exemplo n.º 16
0
def drawGammaR_1(poly,r=1,res=314):
    # Draws a curve gamma_r for a given complex polynomial
    # on the C plane.
    # The function maps points on the unit circle
    # to the complex plane using p: C --> C

    # generate slices of the interval [0,1]
    tspace = np.linspace(0,1,res+1)

    Zs = []
    pZ = []
    
    # map t to the function r = 1

    for t in tspace:
        Zs.append(r*np.exp(2*math.pi*1j*t))
    for z in Zs:
        pZ.append(poly(z))

    X = [x.real for x in pZ]
    Y = [x.imag for x in pZ]

    # plot the figure
    
    ax = plt.subplot()
    ax.plot(X,Y)
    ax.set_xlabel('$Re(z)$')
    ax.set_ylabel('$Im(z)$')
    plt.axhline(color='black')
    plt.axvline(color='black')
    ax.minorticks_on()
    ax.grid(which='minor', alpha=0.5)
    ax.grid(which='major', alpha=0.5)
    ax.set_title(poly.latex_label)
    plt.show()
Exemplo n.º 17
0
def testData(symbols, periods, low, high, portfolio, tradeSize, tradeFee, firstOnly=0, reverse=True, buyOnly=True, plot=False):     
    numSym = len(symbols)
    ress = [[] for sym in symbols]
    for i, sym in enumerate(symbols):
        data = pandas.read_csv(sym+".csv")
        if reverse:
            data = data[::-1]
        if firstOnly>0:
            res = data[:firstOnly].copy()
        else:
            res = data.copy()
        ress[i] = res
        rsiCompute(res, periods)
        buyOrSell(res, low, high)
    tp, nt, nb, ns = computeProfit(ress, symbols, portfolio, tradeSize, tradeFee, buyOnly)
    print("tp = ",tp,", nt = ",nt,", nb = ",nb,", ns = ",ns)
    print("profit % = ", tp/portfolio*100)

#     print(res['rsi'])
    if plot and numSym == 1:
        res = ress[0]
        n = len(res)
        rcParams['figure.figsize'] = 60, 12
        bs = np.array(res['bs'])
        x = np.arange(n)
        markers_onB = x[bs=='B']
        markers_onS = x[bs=='S']
        plt.plot(x, res["Adj Close"], '-bo', label='spy', markevery=markers_onB)
        plt.plot(x, res["rsi"], '-ro', label='RSI', markevery=markers_onS)
        plt.axhline(low)
        plt.axhline(high)
        plt.xlabel('Date')
        plt.ylabel('Price')
        plt.show()
Exemplo n.º 18
0
def transform(gameData):
# refHistory= { ref: { team : [total, games] }
    winData = transformWinLoss(gameData)
    collapsedData = winData.groupby([winData.referee,winData.team]).sum()
    collapsedData['winPercentage'] = collapsedData["teamWin"]/collapsedData["teamPlay"]
    totalData = winData.groupby(winData.team).sum()
    totalData['winPercentage'] = totalData["teamWin"]/totalData["teamPlay"]
    print totalData.sort_index(by='winPercentage', ascending=False)
    plt.figure(figsize=(8, 8))
    #totalData['winPercentage'].plot(kind='bar', alpha=0.5)
    #plt.show()
    #plt.clf()
    print totalData.index.values
    for team in totalData.index.values:
        print "doing %s" % team
        teamData = winData.loc[winData['team'] == team ].groupby(winData.referee).sum()
        teamData = teamData[teamData['teamPlay'] > 6]
        if teamData.empty:
            continue
        print teamData
        teamData['winPercentage'] = teamData["teamWin"]/teamData["teamPlay"]
        teamData['winPercentage'].plot(kind='bar', alpha=0.5)
        teamAvg = totalData['winPercentage'][team]
        print teamAvg
        plt.ylim([0,1.0])
        plt.axhline(teamAvg, color='k')
        plt.savefig('%s.png' % team)
        plt.clf()
Exemplo n.º 19
0
def plot_ra(s1, s2, idxs=None, epsilon=0.25, fig=None):
    """Computes the RA plot of two groups of samples"""

    ## compute log2 values
    l1 = np.log2(s1 + epsilon)
    l2 = np.log2(s2 + epsilon)

    ## compute A and R
    r = l1 - l2
    a = (l1 + l2) * 0.5

    fig = pl.figure() if fig is None else fig
    pl.figure(fig.number)

    if idxs is None:
        pl.plot(a, r, '.k', markersize=2)
    else:
        pl.plot(a[~idxs], r[~idxs], '.k', markersize=2)
        pl.plot(a[idxs], r[idxs], '.r')

    pl.axhline(0, linestyle='--', color='k')

    pl.xlabel('(log2 sample1 + log2 sample2) / 2')
    pl.ylabel('log2 sample1 - log2 sample2')

    pl.tight_layout()
Exemplo n.º 20
0
def get_OH(OIII4363,OIII4959,OIII5007,Hb):
	Te = np.arange(5000,20000,1)
	t3 = Te/1e4
	ne = 100	# cm^-3
	x = 1e-4*ne*t3**(-0.5)
	C_T = (8.44-1.09*t3+0.5*t3**2.-0.08*t3**3.)*(1.+0.0004*x)/(1.+0.044*x)
	log_OIII_ratio = 1.432/t3+np.log10(C_T)
	log_OIII_ratio_obs = np.log10((OIII4959+OIII5007)/OIII4363)

	Te_obs = []
	plt.clf()
	plt.plot(Te,log_OIII_ratio,color='black',marker='.',linestyle='none')
	plt.yscale('log')
	for i in range(len(OIII4363)):
		plt.axhline(log_OIII_ratio_obs[i],linestyle='--')
		d_ratio = abs(log_OIII_ratio_obs[i]-log_OIII_ratio)
		min_d_ratio = min(d_ratio)
		min_sub = list(d_ratio).index(min_d_ratio)
		Te_obs.append(Te[min_sub])
	plt.xlim(10000,20000)
	plt.ylim(1.,3)
	plt.xlabel('Te')
	plt.ylabel('(OIII4959+5007)/OIII4363')

	Te_obs = np.array(Te_obs)
	t3_obs = Te_obs/1e4
	logOIIIH = np.log10((OIII4959+OIII5007)/Hb)+6.200+1.251+1.251/t3_obs - \
				5*np.log10(t3_obs)-0.014*t3_obs
	t2_obs = -0.577+t3*(2.065-0.498*t3)
	logOIIH = np.log10(OII3727/Hb)+5.961+1.676/t2_obs-0.4*np.log10(t2_obs) - \
				0.034*t2_obs+np.log10(1+1.35*x)
	OH = 10**(logOIIIH-12.)+10**(logOIIIH-12.)
	logOH = 12 + np.log10(OH)

	return Te_obs,logOIIH,logOIIIH,logOH
Exemplo n.º 21
0
def plotPDF(data_samples,
            xlabel_str,
            ylabel_str,
            fig_name='pdf.pdf',
            xais_range=None,
            N=1000):
    # this create the kernel, given an array it will estimate the probability over that values
    kde = gaussian_kde(data_samples)
    # these are the values over wich your kernel will be evaluated
    dist_space = np.linspace(min(data_samples), max(data_samples), N)
    # plot the results
    fig = plt.figure(figsize=(8, 6))
    x = dist_space
    y = kde(dist_space)
    plt.plot(x, y, markersize=0)  # pdf line with no markers
    if xais_range is not None:
        plt.xlim(xais_range[0], xais_range[1])
    # plot a vertical line and a honrizontal line
    i = np.argmax(y)
    xline = x[i]
    yline = y[i]
    plt.axvline(x=xline, linewidth=1, markersize=0, color='b', linestyle='--')
    plt.axhline(y=yline, linewidth=1, markersize=0, color='b', linestyle='--')
    # plt.xticks(list(plt.xticks()[0]) + [xline])
    # plt.yticks(list(plt.yticks()[0]) + [yline])
    plt.xticks(replaceNearestElement(plt.xticks()[0], xline))
    plt.yticks(replaceNearestElement(plt.yticks()[0], yline))

    plt.xlabel(xlabel_str)
    plt.ylabel(ylabel_str)
    plt.savefig(join(WORK_PATH, fig_name))
    # plt.savefig(fig_name)
    plt.close(fig)
Exemplo n.º 22
0
def plot_time_vs_epochs(train_data, test_data):
    timer = Timer()
    number_epochs = []
    time = []
    total_time = 0
    # Build Neural Network
    neural_network = build_network()

    # 200 runs of 100 epochs each
    for i in range(100):
        number_epochs.append(i)
        timer.start()
        for j in range(1000):
            for data in test_data:
                neural_network.feed(data)
        this_time = timer.stop()
        time.append(this_time)
        total_time += this_time
    mean_time = total_time / len(number_epochs)

    # Plot
    plt.figure()
    plt.title("Time Taken in 1000 Epochs", fontsize=20)
    plt.xlabel('Number of Experiment')
    plt.ylabel('Time (seconds)')
    plt.scatter(number_epochs, time, color='blue')
    plt.axhline(y=mean_time, color='r', linestyle='-')
    plt.show()
Exemplo n.º 23
0
    def plotNLLAroundMin(self, NLLEval, minParams, errPosParams, errNegParams):
        numOfXPoints = 200

        minTau = minParams[0]
        tauErrPos = errPosParams[0]
        tauErrNeg = errNegParams[0]

        minNLL = NLLEval([minTau])

        tauWidth = 2 * tauErrPos
        minPlotTau = minTau - tauWidth
        maxPlotTau = minTau + tauWidth

        tauRange = np.linspace(minPlotTau, maxPlotTau, numOfXPoints)

        #stores y values
        NLLVals = []

        for tau in tauRange:
            NLLVals.append(NLLEval([tau]) - minNLL)

        #centers tauRange around tauMin
        tauRange -= minTau

        pl.title(r"$\Delta \tau$ vs. $\Delta NLL$ about minimum")
        pl.xlabel(r"$\Delta \tau$")
        pl.ylabel("$\Delta NLL$")
        pl.axvline(x=tauErrPos, linestyle=':', color='r')
        pl.axvline(x=-tauErrNeg, linestyle=':', color='r')
        pl.axhline(y=0.5, linewidth=0.5, linestyle='--', color='dimgray')
        pl.plot(tauRange, NLLVals)
        pl.show()
Exemplo n.º 24
0
def graficos():
    plt.figure()

    for i in range(3):
        plt.subplot(3, 3, 1 + i)
        plt.grid(True)
        plt.plot(t / hr, x[:, i])

    plt.figure()
    plt.grid(True)
    plt.plot(t / hr, Alt / km)
    plt.axhline(80., c="c")
    plt.axhline(0., c="green")

    plt.figure()
    plt.grid(True)
    plt.plot(x[:, 0], x[:, 1])

    th = np.linspace(0, 2 * np.pi, 500)
    plt.plot(Rtierra * np.cos(th), Rtierra * np.sin(th))
    plt.axis("equal")

    fig = plt.figure()
    ax = plt.axes(projection='3d')
    ax.plot3D(x[:, 0], x[:, 1], x[:, 2])
    plt.show()
Exemplo n.º 25
0
def create_fix_steps(results, fixstepsFile):
	parse_functions.removing_existing_file(fixstepsFile)
	print("Creating fix relation file: " + fixstepsFile)
	import matplotlib.pylab as plt
	import matplotlib.ticker as mtick

	seg = config_generator.fixsteps_seg

	fig = plt.figure()
	ax = fig.add_subplot(1, 1, 1)
	ax.set_ylim([0, 70])
	ax.yaxis.set_major_formatter(mtick.PercentFormatter())

	for i in range(10,80,10):
		plt.axhline(y = i, color ="black", linestyle ="--", linewidth=0.1, dashes=(5, 10)) 

	for entry in results:
		plt.plot(results[entry][seg][0], results[entry][seg][1], config_generator.fixstepsSymbols[entry], label=config_generator.fixstepsLabels[entry])

	plt.legend() # show line names
	plt.ylabel('Percentage')
	plt.xlabel('Array Lenght')

	plt.xticks(rotation=30) # rotate
	plt.subplots_adjust(bottom=0.2) # increment border
	
	plt.show()	
	plt.savefig(fixstepsFile, format='eps')
Exemplo n.º 26
0
def plot_genetic_algorithm_time():
    timer = Timer()
    experiments = []
    time = []
    total_time = 0
    # Build Neural Network
    genetic_algorithm = GeneticFixedTopology(100, 1000)

    # 20 runs of 1000 generations each
    for i in range(20):
        experiments.append(i)
        timer.start()
        genetic_algorithm.run()
        this_time = timer.stop()
        time.append(this_time)
        genetic_algorithm = GeneticFixedTopology(100, 1000)
        total_time += this_time
    mean_time = total_time / len(experiments)

    # Plot
    plt.figure()
    plt.title("Time Taken in 1000 Generations", fontsize=20)
    plt.xlabel('experimento')
    plt.ylabel('tiempo (segundos)')
    plt.scatter(experiments, time, color='blue')
    plt.axhline(y=mean_time, color='r', linestyle='-')
    plt.show()
Exemplo n.º 27
0
Arquivo: pca.py Projeto: id774/sandbox
def test(args):
    data = multivariate_normal([0, 0], [[1, 2], [2, 5]], int(args[1]))
    print(data)
    # PCA
    result = pca(data, base_num=int(args[2]))
    pc_base = result[0]
    print(pc_base)

    # Plotting
    fig = plt.figure()
    fig.add_subplot(1, 1, 1)
    plt.axvline(x=0, color="#000000")
    plt.axhline(y=0, color="#000000")
    # Plot data
    plt.scatter(data[:, 0], data[:, 1])
    # Draw the 1st principal axis
    pc_line = sp.array([-3.0, 3.0]) * (pc_base[1] / pc_base[0])
    plt.arrow(0, 0, -pc_base[0] * 2, -pc_base[1] * 2, fc="r", width=0.15, head_width=0.45)
    plt.plot([-3, 3], pc_line, "r")
    # Settings
    plt.xticks(size=15)
    plt.yticks(size=15)
    plt.xlim([-3, 3])
    plt.tight_layout()
    plt.show()
    plt.savefig("image.png")

    return 0
def printAccCurve(regType='OLS'):
    for time in times:
        curveData = np.array(
            list(
                csv.reader(
                    open(
                        './5-accCurveNoSameTake-' + time + '_' + regType +
                        '.csv', 'r')))).astype(float)
        CIi = []
        CIa = []
        for l in curveData:
            CIi.append(l[0] - (1.96 * (l[1] / math.sqrt(l[5]))))
            CIa.append(l[0] + (1.96 * (l[1] / math.sqrt(l[5]))))

        #plt.axhline(1.2)

        # Set up dashed lines
        for y in np.arange(0.1, 1.11, 0.1):
            plt.axhline(y, color='k', ls='--', alpha=0.25)

        Xs = range(5, 121, 5)

        plt.plot(Xs, curveData[:, 4], label='Maximum')
        plt.plot(Xs, curveData[:, 2], label='Median')
        plt.plot(Xs, curveData[:, 0], label='Mean')
        plt.plot(Xs, CIi, 'k', alpha=0.2, label='95% Confidence Interval')
        plt.plot(Xs, CIa, 'k', alpha=0.2)
        plt.fill_between(Xs, CIi, CIa, facecolor='k', alpha=0.1)
        plt.plot(Xs, curveData[:, 3], label='Minimum')

        plt.title('Accuracy Curves for ' + time + ',' + regType)
        plt.legend(loc='best')
        plt.xlabel('Time Points')
        plt.ylabel('Accuracy')
        plt.show()
Exemplo n.º 29
0
    def standard_plot(self):
        s = [x for x in self.base.steady_state]
        self.base.enz[E_DAGK].v *= MUTANT_DEPLETION

        self.base.attain_steady_state()
        mt_rdga = [x for x in self.base.steady_state]

        self.base.enz[E_DAGK].v /= MUTANT_DEPLETION

        self.base.enz[E_LAZA].v *= MUTANT_DEPLETION

        self.base.attain_steady_state()
        mt_laza = [x for x in self.base.steady_state]

        self.base.enz[E_LAZA].v /= MUTANT_DEPLETION

        ax = self.figure.add_subplot(111)
        ind = np.arange(4)  # the x locations for the groups
        width = 0.35  # the width of the bars

        exp_observations = [1, 1, 1, 2.5]

        val1 = get_ratios(s, mt_rdga)
        val2 = get_ratios(s, mt_laza)
        vals = val1[0], val1[1], val2[0], val2[1]

        legends = ["DAG/PI\n(rdga3)", "PA/PI\n(rdga3)", "DAG/PI\n(laza22)",
                   "PA/PI\n(laza22)"]
        ax.bar(ind, exp_observations, width, color='#3c6df0', label="WT")
        ax.bar(ind + width, vals, width, color='#fe6100', label="MT")
        ax.set_xticks(ind + width / 2)
        plt.axhline(1, linestyle="--")
        plt.axhline(2.5, linestyle="--")
        ax.set_xticklabels(legends)
        plt.legend(loc=0)
Exemplo n.º 30
0
def plot_equilibration(temperature_next,
                       strain_lst,
                       nve_run_time_steps,
                       project_parameter,
                       debug_plot=True):
    if debug_plot:
        for strain in strain_lst:
            job_name = get_nve_job_name(
                temperature_next=temperature_next,
                strain=strain,
                steps_lst=project_parameter['nve_run_time_steps_lst'],
                nve_run_time_steps=nve_run_time_steps)
            ham_nve = project_parameter['project'].load(job_name)
            plt.plot(ham_nve['output/generic/temperature'],
                     label='strain: ' + str(strain))
            plt.axhline(np.mean(ham_nve['output/generic/temperature'][-20:]),
                        linestyle='--',
                        color='red')
            plt.axvline(range(len(ham_nve['output/generic/temperature']))[-20],
                        linestyle='--',
                        color='black')
            plt.legend()
            plt.xlabel('timestep')
            plt.ylabel('Temperature K')
            plt.legend()
            plt.show()
Exemplo n.º 31
0
    def test_cumulative(plot=False):
        # arrange
        endpoints = (44, 666)
        norm_factor = np.pi
        spectrum = spectra.TopHat(norm_factor=norm_factor, endpoints=endpoints)
        x = np.linspace(0, 1000)

        # act
        y = spectrum.cumulative(x)

        # plot
        if plot:
            pylab.axhline(0)
            pylab.axhline(norm_factor)
            pylab.axvline(endpoints[0])
            pylab.axvline(endpoints[1])
            pylab.plot(x, y, color='red')
            pylab.xlim(x[0], x[-1])
            pylab.grid()
            pylab.show()

        # assert
        for point in y:
            assert 0 <= point <= norm_factor
        assert y[-1] == norm_factor

        hy, hx = np.histogram(np.diff(y) / np.diff(x))
        assert hx[0] == 0
        np.testing.assert_approx_equal(
            hx[-1], norm_factor / (endpoints[1] - endpoints[0]))
        assert np.sum(hy[1:-1]) == 2
Exemplo n.º 32
0
def create_scurve(scurves, scurveFile):
	parse_functions.removing_existing_file(scurveFile)
	print("Creating scurve file: " + scurveFile)
	
	import matplotlib.pylab as plt

	fig = plt.figure()
	ax = fig.add_subplot(1, 1, 1)
	ax.set_ylim([0, 9])

	for i in range(1,10,1):
		plt.axhline(y = i, color ="black", linestyle ="--", linewidth=0.1, dashes=(5, 10)) 

	for strategy in scurves:
		length = len(scurves[strategy])
		middle = int(length/2-1)
		markers_on = [0, middle, length-1]
		#plt.plot(scurves[strategy], config_generator.symbols[strategy], color=config_generator.colors[strategy], markevery=marks, label=config_generator.abbreviations[strategy])
		plt.plot(scurves[strategy], config_generator.symbols[strategy], color=config_generator.colors[strategy], markevery=markers_on, label=config_generator.abbreviations[strategy], dashes=(5, 5))

	plt.ylabel('Normalized Times')
	plt.locator_params(nbins=3)
	plt.xticks([]) # hide axis x
	plt.legend() # show line names
	
	plt.savefig(scurveFile, format='eps')
Exemplo n.º 33
0
def mark_cross(center, **kwargs):
    """Mark a cross. Correct for matplotlib imshow funny coordinate system.
    """
    N = 20
    plt.hold(1)
    plt.axhline(y=center[1]-0.5, **kwargs)
    plt.axvline(x=center[0]-0.5, **kwargs)
Exemplo n.º 34
0
def create_hou_curve(houCurve, houFile):
	parse_functions.removing_existing_file(houFile)
	print("Creating Hou file: " + houFile)
	strategy = 'bbsegsort'

	import matplotlib.pylab as plt

	fig = plt.figure()
	ax = fig.add_subplot(1, 1, 1)
	ax.set_ylim([0, 1.5])
	
	for i in numpy.arange(0.25, 1.75, 0.25):
		plt.axhline(y = i, color ="black", linestyle ="--", linewidth=0.1, dashes=(5, 10)) 

	for length in houCurve:
		if(length > 530000):
			continue;

		plt.plot(houCurve[length][0], houCurve[length][1], label=str(length))

	#for seg in houCurve:
#		plt.plot(houCurve[seg], config_generator.symbols[strategy], color=config_generator.colors[strategy], label=config_generator.abbreviations[strategy])

	plt.ylabel('Execution Time (ms)')
	plt.xlabel('Number of Segments')
	plt.xticks(rotation=30) # rotate
	plt.subplots_adjust(bottom=0.2) # increment border

	#plt.legend(loc='center left', bbox_to_anchor=(1, 0.5)) # show line names
	#plt.subplots_adjust(right=0.75) # increment border
	plt.legend()
	plt.savefig(houFile, format='eps')
Exemplo n.º 35
0
    def individual_plot(self):
        s = [x for x in self.base.steady_state]
        s.append(
            self.base.steady_state[I_PMPA] + self.base.steady_state[I_ERPA])
        s.append(
            self.base.steady_state[I_PMPI] + self.base.steady_state[I_ERPI])

        if self.mutant_enzyme != E_NONE:
            self.base.enz[self.mutant_enzyme].v *= MUTANT_DEPLETION

        self.base.attain_steady_state()
        mt = [x for x in self.base.steady_state]
        mt.append(
            self.base.steady_state[I_PMPA] + self.base.steady_state[I_ERPA])
        mt.append(
            self.base.steady_state[I_PMPI] + self.base.steady_state[I_ERPI])

        ax = self.figure.add_subplot(111)
        ind = np.arange(len(LIPID_NAMES) + 2)  # the x locations for the groups
        width = 0.35  # the width of the bars

        ax.bar(ind, np.asanyarray(mt) / np.asanyarray(s), width)
        ax.set_xticks(ind)

        plt.axhline(1, linestyle="--")
        # plt.yscale("log")
        nm = [L_PMPI, L_PI4P, L_PIP2, L_DAG, L_PMPA, L_ERPA, L_CDPDAG,
              L_ERPI, "PA", "PI"]
        ax.set_xticklabels(nm)

        if self.mutant_enzyme != E_NONE:
            self.base.enz[self.mutant_enzyme].v /= MUTANT_DEPLETION
Exemplo n.º 36
0
    def plot_deviations(self):
        '''Plots the p-value and deviation level over time.
        '''

        plt.scatter(self.T, self.P, marker=".")
        plt.plot(self.T, self.M)
        plt.axhline(y=self.dev_threshold, color='r', linestyle='--')
        plt.show()
Exemplo n.º 37
0
 def plot_eigen_spectrum(eig, laser_freq_eV=0.0, file_to_save='eig.png', figuresize=(10,10)):
     plt.figure(figsize=figuresize) # in inches!
     plt.plot(eig.real, 'o', ms=2)
     plt.ylabel(r'$E, eV$', fontsize=26)
     plt.axhline(y=laser_freq_eV, color='r', ls='--')
     plt.axhline(y=0, color='r', ls='--')
     if file_to_save:
         plt.savefig(file_to_save)
         plt.close()
     return None
Exemplo n.º 38
0
def epi_vs_gain_volcano_plot(filtered_gain_snps, filtered_epi_snps, gain_vals, epi_vals, max_p, min_I3):
    gain_I3 = []
    gain_log_p = []
    for snps in filtered_gain_snps:
        gain_I3.append(gain_vals[snps])

        order = switch_snp_key_order(snps)
        if epi_vals.has_key(order[0]):
            gain_log_p.append(epi_vals[order[0]])
        elif epi_vals.has_key(order[1]):
            gain_log_p.append(epi_vals[order[1]])
    gain_log_p = -1 * np.log10(gain_log_p)

    epi_I3 = []
    epi_log_p = []
    for snps in filtered_epi_snps:
        order = switch_snp_key_order(snps)
        if gain_vals.has_key(order[0]):
            epi_I3.append(gain_vals[order[0]])
        elif gain_vals.has_key(order[1]):
            epi_I3.append(gain_vals[order[1]])

        epi_log_p.append(epi_vals[snps])
    epi_log_p = -1 * np.log10(epi_log_p)

    mp.figure(1)
    mp.xlabel("I3")
    mp.ylabel("-log10(P)")
    mp.title("Volcano plot - EPISTASIS and GAIN")
    mp.plot(epi_I3, epi_log_p, "bo")
    mp.plot(gain_I3, gain_log_p, "ro")
    mp.axhline(y=(-1 * np.log10(max_p)), linewidth=2, color="g")
    mp.axvline(x=min_I3, linewidth=2, color="g")
    # label max point
    max_x = np.max(gain_I3)
    max_y = np.max(gain_log_p)
    best_connection = ""
    # label best edge
    for snps in epi_vals:
        if -1 * np.log10(epi_vals[snps]) == max_y:
            best_connection = str(snps)
    mp.text(
        np.max(gain_I3),
        np.max(gain_log_p),
        best_connection,
        fontsize=10,
        horizontalalignment="center",
        verticalalignment="center",
    )
    mp.show()

    print
def plot_episode(args):
    """Plot an episode plucked from the large h5 database"""
    print "plot_episode"
    # load the data file
    tblfilename = "bf_optimize_mavlink.h5"
    h5file = tb.open_file(tblfilename, mode = "a")
    # get the table handle
    table = h5file.root.v2.evaluations

    # selected episode
    episode_row = table.read_coordinates([int(args.epinum)])
    # compare episodes
    episode_row_1 = table.read_coordinates([2, 3, 22, 46]) # bad episodes
    print "row_1", episode_row_1.shape
    # episode_row = table.read_coordinates([3, 87])
    episode_target = episode_row["alt_target"]
    episode_target_1 = [row["alt_target"] for row in episode_row_1]
    print "episode_target_1.shape", episode_target_1
    episode_timeseries = episode_row["timeseries"][0]
    episode_timeseries_1 = [row["timeseries"] for row in episode_row_1]
    print "row", episode_timeseries.shape
    print "row_1", episode_timeseries_1

    sl_start = 0
    sl_end = 2500
    sl_len = sl_end - sl_start
    sl = slice(sl_start, sl_end)
    pl.plot(episode_timeseries[sl,1], "k-", label="alt", lw=2.)
    print np.array(episode_timeseries_1)[:,:,1]
    pl.plot(np.array(episode_timeseries_1)[:,:,1].T, "k-", alpha=0.2)
    # alt_hold = episode_timeseries[:,0] > 4
    alt_hold_act = np.where(episode_timeseries[sl,0] == 11)
    print "alt_hold_act", alt_hold_act[0].shape, sl_len
    alt_hold_act_min = np.min(alt_hold_act)
    alt_hold_act_max = np.max(alt_hold_act)
    print "min, max", alt_hold_act_min, alt_hold_act_max, alt_hold_act_min/float(sl_len), alt_hold_act_max/float(sl_len),

    # pl.plot(episode_timeseries[sl,0] * 10, label="mode")
    pl.axhspan(-100., 1000,
               alt_hold_act_min/float(sl_len),
               alt_hold_act_max/float(sl_len),
               facecolor='0.5', alpha=0.25)
    pl.axhline(episode_target, label="target")
    pl.xlim((0, sl_len))
    pl.xlabel("Time steps [1/50 s]")
    pl.ylabel("Alt [cm]")
    pl.legend()
    if args.plotsave:
        pl.gcf().set_size_inches((10, 3))
        pl.gcf().savefig("%s.pdf" % (sys.argv[0][:-3]), dpi=300, bbox_inches="tight")
    pl.show()
Exemplo n.º 40
0
def diff_plot_bar(lists, list_ids, xticks,
                  rotation=0, xlabel='', ylabel='Accuracy',
                  hline_at=None, legend_title='Method', **kwargs):
    """
    Compare the scores of paired of experiment ids and plot a bar chart or their accuracies.
    :param list1, list2: [1,2,3], [4,5,6] means exp 1 is compared to exp 4, etc ...
    :param list1_id, list2_id: name for the first/ second group of experiments, will appear in legend
    :param xticks: labels for the x-axis, one per pair of experiments, e.g.
    list('abc') will label the first pair 'a', etc. Will appear as ticks on x axis.
    If only two lists are provided a significance test is run for each pair and a * is added if pair is
    significantly different
    :param rotation: angle of x axis ticks
    :param hline_at: draw a horizontal line at y=hline_at. Useful for baselines, etc
    :param kwargs: extra arguments for sns.factorplot
    """
    assert len(set(map(len, lists))) == 1
    assert len(list_ids) == len(lists)

    df_scores, df_reps, df_groups, df_labels = [], [], [], []
    if len(lists) == 2:
        for i, (a, b) in enumerate(zip(*lists)):
            significance_df, names, mean_scores = get_demsar_params([a, b],
                                                                    name_format=['id',
                                                                                 'expansions__vectors__id',
                                                                                 'expansions__vectors__composer',
                                                                                 'expansions__vectors__algorithm',
                                                                                 'expansions__vectors__dimensionality'])
            if significance_df is None:
                continue
            if significance_df.significant[0]:
                xticks[i] += '*'

    for i, exp_ids in enumerate(zip(*lists)):
        data, folds = get_cv_scores_many_experiment(exp_ids)
        df_scores.extend(data)
        df_reps.extend(folds)
        df_labels.extend(len(folds) * [xticks[i]])
        for list_id in list_ids:
            df_groups.extend(len(folds) // len(lists) * [list_id])

    df = pd.DataFrame(dict(Accuracy=df_scores, reps=df_reps, Method=df_groups, labels=df_labels))
    df.rename(columns={'Method': legend_title}, inplace=True)
    g = sns.factorplot(y='Accuracy', hue=legend_title, x='labels', data=df, kind='bar', aspect=1.5, **kwargs);
    g.set_xticklabels(rotation=rotation);
    # remove axis labels
    for ax in g.axes.flat:
        ax.set(xlabel=xlabel, ylabel=ylabel)
    if hline_at is not None:
        plt.axhline(hline_at, color='black')
Exemplo n.º 41
0
def plot_moving_correlation(series, chrons, start, end, 
                            crit=None, window=get_window('boxcar', 31)):

  w = len(window) / 2
  t = range(start + w, end - w + 1)
  
  p = series.ix[start:end].values.flatten()
 
  for col in chrons:
    c = chrons[col].ix[start:end].values
    corrs, pvals = moving_correlation(p, c, window)
    plt.plot(t, corrs, label=col.upper(), markevery=(t[-1]-t[0])/12, **pens[col.upper()])

  if crit is not None:
    plt.axhline(y=crit, linestyle='--', color='black')  
Exemplo n.º 42
0
def plot_all_pair_correlation(dirname=".",target="g_tilde"):
    
    handles=[]
    global folders
    plt.figure(figsize=(20,10))
    global folders
    # plot all energies
    print "Pair correlations"
    for f in folders:
        label=get_label(target,f)
        handles.append(anal.plot_file(f.dir_path+"/pair_correlation_t.dat",label=label,error=True ))
        
    plt.legend(handles=handles)
    plt.axhline(y=1, xmin=0,hold=True)
    
    handles=[]
Exemplo n.º 43
0
def plot_weather(p, ranges, plot_happiness = False, threshold=40.0):

    plts = []

    for date_start, date_end in ranges:
        print "Getting weather data for %s - %s..." % (date_start, date_end)
        station_info, observations = p.get_weather_hourly(94846, date_start, date_end)
        observations = Plenario.get_weather_observations_list(observations, "datetime", ["drybulb_fahrenheit"])
        observations.reverse()

        dates = [x[0] for x in observations]
        datesnorm = normalize_dates(dates)
        temps = [x[1] for x in observations]
        fill_missing_values(temps)


        label = "%s - %s" % (date_start, date_end)

        if plot_happiness:
            Ys = gen_happiness(temps, threshold)
        else:
            Ys = temps

        w_plt, = plt.plot(datesnorm, Ys, label=label)
        plts.append(w_plt)

    if plot_happiness:
        hline = 0
        title = "Weather-related Happiness in Chicago"
        ylabel = "Happiness"
    else:
        hline = 32
        title = "Temperatures in Chicago"
        ylabel = u"Temperature (°F)"

    xlabel = "Week"

    nweeks = (int(datesnorm[-1]) / 604800) + 1

    plt.xticks([w*604800 for w in range(nweeks)], [w for w in range(nweeks)])

    plt.axhline(hline, color="gray", linestyle="--")
    plt.legend(handles=plts, loc="lower left")
    plt.title(title)
    plt.xlabel(xlabel)
    plt.ylabel(ylabel)
    plt.show()
Exemplo n.º 44
0
 def draw_cost_history(self, filename='output/cost.png', compare_dict=None):
     colors = ['blue', 'red', 'yellow', 'green', 'pink']
     f, ax = plt.subplots()
     ax.plot(self.cost_history, lw=1, c='black', label='cost', alpha=0.8)
     df = pd.DataFrame(columns=['rolling mean'], data=self.cost_history)
     df['rolling mean'] = pd.rolling_mean(df['rolling mean'], window=100)
     df.plot(ax=ax, lw=3, c='green')
     if compare_dict is not None:
         for idx, (name, vals) in enumerate(compare_dict.iteritems()):
             c = colors[idx % len(colors)]
             if hasattr(vals, '__iter__'):
                 plt.plot(vals, lw=2, label=name, c=c, alpha=0.6)
             else:
                 plt.axhline(y=vals, lw=2, label=name, c=c, alpha=0.6)
     plt.legend(loc='best')
     plt.savefig(filename, dpi=150)
     plt.close('all')
Exemplo n.º 45
0
def plotDifference(bst, dtest, target = None):
    p = bst.predict(dtest)
    l = 0
    if (target is None):    
        l = dtest.get_label()
    else:
        l = target
    res = np.abs((l-p)/l)
    res = res[~np.isnan(res)]
    res = res[~np.isinf(res)]
    xmax = 0.2
    for y in np.arange(0,xmax,xmax/8):    
        plt.axvline(y, color='g', linestyle='dashed')
    plt.hist(res, range=(0,xmax), bins=50, color='red')
    plt.axvline(res.mean(), color='c', linestyle='dashed', linewidth=2)
    for y in range(200,1600,200):    
        plt.axhline(y, color='g', linestyle='dashed')
Exemplo n.º 46
0
def view_design(g, t, arange):
    """Plot the scaling and wavelet kernel.

    Plot the input scaling function and wavelet kernels, indicates the wavelet
    scales by legend, and also shows the sum of squares G and corresponding
    frame bounds for the transform.

    Parameters
    ----------
    g : list of  function handles for scaling function and wavelet kernels
    t : array of wavelet scales corresponding to wavelet kernels in g
    arange : approximation range

    Returns
    -------
    h : figure handle
    """
    x = np.linspace(arange[0], arange[1], 1e3)
    h = plt.figure()
    
    J = len(g) 
    G = np.zeros(x.size)

    for n in range(J):
        if n == 0:
            lab = 'h'
        else:
            lab = 't=%.2f' % t[n-1]
        plt.plot(x, g[n](x), label=lab)
        G += g[n](x)**2

    plt.plot(x, G, 'k', label='G')

    (A, B, _, _) = framebounds(g, arange[0], arange[1])
    plt.axhline(A, c='m', ls=':', label='A')
    plt.axhline(B, c='g', ls=':', label='B')
    plt.xlim(arange[0], arange[1])

    plt.title('Scaling function kernel h(x), Wavelet kernels g(t_j x) \n'
              'sum of Squares G, and Frame Bounds')
    plt.yticks(np.r_[0:4])
    plt.ylim(0, 3)
    plt.legend()

    return h
Exemplo n.º 47
0
def simSeries(numSeries):
    prob = 0.5
    fracWon = []
    probs = []
    while prob <= 1.0:
        seriesWon = 0
        for i in range(numSeries):
            if playSeries(7, prob):
                seriesWon += 1
        fracWon.append(seriesWon/numSeries)
        probs.append(prob)
        prob += 0.01
    plt.plot(probs, fracWon, linewidth=3)
    plt.xlabel("Probability of Winning a Game")
    plt.ylabel("Probability of Winning a Series")
    plt.axhline(0.95)
    plt.ylim(0.5, 1.1)
    plt.title(str(numSeries) + " Seven-Game Series")
Exemplo n.º 48
0
Arquivo: zero.py Projeto: frodo81/psms
def fplot(x0):
    """plot f(x) in the neighborhood of the initial guess"""
    #build x and f vectors
    points = 200
    xmin = x0 - 5.0
    xmax = x0 + 5.0
    xvec = linspace(xmin,xmax, num=points,endpoint = True)
    fvec = matrix (0, (points, 1), 'd')
    for item, x in enumerate(xvec):
        fvec[item] = Function.fcall(x)
    # graphical commands
    fig = pyplot.figure()
    pyplot.hold(True)
    pyplot.plot(xvec, fvec, 'k')
    pyplot.axhline(linestyle=':',color = 'k')
    pyplot.axvline(linestyle=':',color = 'k')
    pyplot.xlabel('$x$')
    pyplot.ylabel('$f(x)$')
    pyplot.savefig('zeroplot.eps',format='eps')
    pyplot.show()
Exemplo n.º 49
0
def findSeriesLength(teamProb):
    numSeries = 200
    maxLen = 2500
    step = 10
    def fracWon(teamProb, numSeries, seriesLen):
        won = 0
        for series in range(numSeries):
            if playSeries(seriesLen, teamProb):
                won += 1
        return won/numSeries
    winFrac = []
    xVals = []
    for seriesLen in range(1, maxLen, step):
        xVals.append(seriesLen)
        winFrac.append(fracWon(teamProb, numSeries, seriesLen))
    plt.plot(xVals, winFrac, linewidth=3)
    plt.xlabel("Length of Series")
    plt.ylabel("Probability of Winning Series")
    plt.title(str(round(teamProb, 4))+ " Probability of Better Team Winning a Game")
    plt.axhline(0.95)
    plt.ylim(0.5, 1.1)
Exemplo n.º 50
0
def plot_rough(data=None, use_fb=True, levels=20, colorbars=False):
        if data is None: data = read_rough('rough')
        (x, y) = ('fb_x', 'fb_y') if use_fb else ('x', 'y')
        fig = pl.figure()
        #pos = np.genfromtxt("rough_pos")
        pos = None
        print pos
        for n,signal in enumerate(['psd_x', 'psd_y', 'sum_x', 'sum_y']):
                pl.subplot(2,2,n+1)
                pl.contourf(data[x][:,:,0], data[y][:,:,0], data[signal][:,:,0], levels)
                pl.title(signal)
                pl.axis('equal')
                pl.axis('tight')
                if colorbars:
                        pl.colorbar()

                if pos is not None:
                        pl.axvline(pos[0], alpha=0.3)
                        pl.axhline(pos[1], alpha=0.3)

        fig.show()
Exemplo n.º 51
0
def drawxint():
    df = pd.read_csv('out/ana_bd.dat')
    # dftmp = df[['W', 'Q2', 'xsect', 'err', 'fsigchi2']][
    #    (df['fsigchi2'] < 3) & (df['fsigchi2'] > 0) & (df['weightsb'] > 0) & (df['weight3s'] > 0)]

    q2groups = df[(df['fsigchi2'] < 3) & (df['fsigchi2'] > 0.5) & (
        df['fsigstat'] == 'CONVERGED ') & (df['weightsb'] > 0) & (df['weight3s'] > 0) & (df['fsigpar2'] > 0.008) & (df['fsigpar2'] < 0.035)].groupby(df.Q2)
    # xerrs = np.array(48 * [0.0])
    gtitle = '$Q^2 = %.3f$ $GeV^2$'

    for q2, grp in q2groups:
        fig = plt.figure()
        ax1 = fig.add_subplot(111)
        ax1.errorbar(grp.W, grp.xsect, grp.err, ls='none', marker='o', ms=4, color='black')
        ax1.set_ylim(-50, ax1.get_ylim()[1])
        ax1.set_xlim((1.6, 3.0))
        ax1.set_title(gtitle % q2, fontsize=20, y=1.025)
        ax1.set_xlabel('W (GeV)', fontsize=16)
        ax1.set_ylabel('$\sigma$  ($nb^{-1}$)', fontsize=20)
        plt.grid(b=True, which='major', color='black', ls='-')
        plt.grid(b=True, which='minor', color='black', ls='dotted')
        ax1.minorticks_on()
        plt.axhline(0, color='blue', ls='-', linewidth=1.25)

        ax2 = ax1.twinx()
        ax2.set_ylabel('$\~{\chi}^{2}$', color='r', fontsize=20)
        ax2.set_ylim(0, 3)
        ax2.plot(grp.W, grp.fsigchi2, marker='o', ms=4, ls='none', color='r')
        for tickl in ax2.get_yticklabels():
            tickl.set_color('r')

        # ax2 = ax1.twinx()
        # ax2.set_ylabel('$\sigma_{g}$', color='r')
        # ax2.set_ylim(0.008, 0.035)
        # ax2.plot(grp.W, grp.fsigpar2, marker='o', ms=4, ls='none', color='r')
        # for tickl in ax2.get_yticklabels():
        #     tickl.set_color('r')
        # plt.tight_layout()
        plt.show()
        wait()
Exemplo n.º 52
0
    def plot_abc(self, uarg, param):
        """Plot a() and b() functions on the same plot.

        """
        plt.figure(figsize=(8, 4))

        plt.subplot(1, 3, 1)
        plt.plot(uarg, self.afun(uarg, param))
        plt.axhline(0)
        plt.axvline(0)
        plt.ylabel('$a(u)$')
        plt.xlabel('$u$')

        plt.subplot(1, 3, 2)
        plt.plot(uarg, self.bfun(uarg, param))
        plt.axhline(0)
        plt.axvline(0)
        plt.ylabel('$b(u)$')
        plt.xlabel('$u$')

        plt.subplot(1, 3, 3)
        plt.plot(uarg, self.cfun(uarg, param))
        plt.axhline(0)
        plt.axvline(0)
        plt.ylabel('$c(u)$')
        plt.xlabel('$u$')

        plt.tight_layout()
        plt.show()
Exemplo n.º 53
0
    def plotMadMedian(self, events, figsize=(5, 5), save=False,
                      figname='mam-median-evts', figtype='png'):
        """ Plots the median and the medan absolute value of the input
            array events

            **Parameters**

            events : double
                The spike events

            figsize : float
                A tuple of the sizes of the figure

            save : boolean
                Indicates if the figure will be saved

            figname : string
                The name of the saved figure

            figtype : string
                The type of the saved figure (supports png and pdf)
        """
        events_median = np.apply_along_axis(np.median, 0, events)
        events_mad = np.apply_along_axis(mad, 0, events)

        plt.figure(figsize=figsize)
        plt.plot(events_median, color='red', lw=2)
        plt.axhline(y=0, color='black')
        for i in np.arange(0, 400, 100):
            plt.axvline(x=i, c='k', lw=2)
        for i in np.arange(0, 400, 10):
            plt.axvline(x=i, c='grey')
        plt.plot(events_median, 'r', lw=2)
        plt.plot(events_mad, 'b', lw=2)
        if save:
            if figtype == 'pdf':
                plt.savefig(figname+'pdf', dpi=90)
            else:
                plt.savefig(figname+'png')
Exemplo n.º 54
0
def manhattan(subplot, p_values, p=0.05, threshold='bonferroni', title=None, colors=('r', 'g', 'b'),
              min_p_value=1e-16):
    '''Generate a Manahattan plot from a list of 22 p-value data sets. Entry data[i] corresponds
    to chromosome i-1, and should be tuple (snp_bp_coordinate, p_value).'''         
    # Prepare plot
    subplot.set_yscale('log')
    if title:
        P.title(title)
    P.xlabel('Chromosome')
    P.ylabel(r'$p^{-1}$')
    P.hold(True)

    offset = genome_bp_offset()[:NUM_CHROMOSOMES]
    (xmin, xmax) = (np.inf, -np.inf)
    chr_label = []
    for (index, (snp_chr, p_chr)) in enumerate(p_values):
        x = snp_chr + offset[index]
        color = colors[np.mod(index, len(colors))]
        P.scatter(x, 1.0 / np.maximum(min_p_value, p_chr), c=color, marker='o', edgecolor=color)
        xmin = min(xmin, np.min(x))
        xmax = max(xmax, np.max(x))
        chr_label.append('%s' % (index + 1,))
    P.xlim((xmin, xmax))
    # Set the locations and labels of the x-label ticks
    P.xticks(ndimage.convolve(offset, [0.5, 0.5]), chr_label)    
    
    # Calculate significance threshold    
    if threshold == 'bonferroni':
        # Bonferroni correction: divide by the number of SNPs we are considering
        num_snps = sum(len(chr_data[0]) for chr_data in p_values)
        threshold = p / num_snps
    elif isreal(threshold):
        # Custom threshold
        pass
    elif not threshold:
        raise ValueError('Unsupported threshold %s' % (threshold,))
    if threshold is not None:
        # Draw threshold
        P.axhline(y=1.0 / threshold, color='red')
Exemplo n.º 55
0
def graph(dates,pounds,filename):             
           
	plt.xlabel("Date")
	plt.ylabel("Pound")

	fig = plt.figure(facecolor='white')
	ax1 = fig.gca()

	# Add zero line   
	plt.axhline(linewidth=1, color='b')

	# Set font size of labels
	for axis in [ax1.axes.get_xticklabels(),ax1.axes.get_yticklabels()]:
		for xlabel_i in axis:
			xlabel_i.set_fontsize(8)

	right=0.94
	lft=1-right

	fig.subplots_adjust(top=0.97,right=0.94,left=lft)

	# Set size of graph
	F = pylab.gcf()
	DefaultSize = F.get_size_inches()
	F.set_size_inches( (DefaultSize[0]*0.7, DefaultSize[1]*0.7) )

	# Fill in graph
	ax1.fill_between(dates, pounds, facecolor='blue', alpha=0.5)
	
	# Plot dates
	ax1.plot_date(dates, pounds, color='blue', ls='-',marker='None', label='MA (200)')    
	ax1.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%a %d\n%b %Y'))  
	
	# Save to file
	ax1 = plt.gca()   
	plt.savefig(filename) 
	plt.close()
Exemplo n.º 56
0
  def run(self, filename):
    from dials.model.data import ReflectionList, Reflection
    from math import sqrt
    import cPickle as pickle
    import numpy

    rlist = pickle.load(open(filename, "rb"))
    print "read file"

    r_to_use = [r for r in rlist
                    if r.is_valid() and
                       r.bounding_box[1] - r.bounding_box[0] >= 5 and
                       r.bounding_box[3] - r.bounding_box[2] >= 5 and
                       r.intensity / sqrt(r.intensity_variance) > 10]
    print "Filtered list", len(r_to_use)


    px_prd = [r.image_coord_px for r in r_to_use]
    f_prd = [r.frame_number for r in r_to_use]
    px_obs = [r.centroid_position for r in r_to_use]

    x_prd, y_prd = zip(*px_prd)
    x_obs, y_obs, f_obs = zip(*px_obs)

    diff = []
    for xp, yp, zp, xo, yo, zo in zip(x_prd, y_prd, f_prd, x_obs, y_obs, f_obs):
      diff.append(sqrt((xp - xo)**2 + (yp - yo)**2 + (zp - zo)**2))

    x_diff = [p - o for p, o in zip(x_prd, x_obs)]
    y_diff = [p - o for p, o in zip(y_prd, y_obs)]
    f_diff = [p - o for p, o in zip(f_prd, f_obs)]

    from matplotlib import pylab
    pylab.subplot(3, 1, 1)
    pylab.scatter(x_prd, x_diff)
    pylab.axhline(numpy.mean(x_diff))
    pylab.subplot(3, 1, 2)
    pylab.scatter(y_prd, y_diff)
    pylab.axhline(numpy.mean(y_diff))
    pylab.subplot(3, 1, 3)
    pylab.scatter(f_prd, f_diff)
    pylab.axhline(numpy.mean(f_diff))
    pylab.show()

    #from scipy.interpolate import griddata
    points = zip(y_prd, x_prd)
    pickle.dump((points, x_diff, y_diff), open("temp_data.pickle", "wb"))
Exemplo n.º 57
0
nRuns    = 5000;

# The standard deviation in the random walk proposal
stepSize = 0.10;

# Run the PMH algorithm
res = helpParam.pmh(y,initPar,par,nPart,T,x0,helpState.pf,nRuns,stepSize)


##############################################################################
# Plot the results
##############################################################################

# Plot the parameter posterior estimate
# Solid black line indicate posterior mean
plt.subplot(2,1,1);
plt.hist(res[nBurnIn:nRuns], np.floor(np.sqrt(nRuns-nBurnIn)), normed=1, facecolor='#7570B3')
plt.xlabel("par[0]"); plt.ylabel("posterior density estimate")
plt.axvline( np.mean(res[nBurnIn:nRuns]), linewidth=2, color = 'k' )

# Plot the trace of the Markov chain after burn-in
# Solid black line indicate posterior mean
plt.subplot(2,1,2);
plt.plot(np.arange(nBurnIn,nRuns,1),res[nBurnIn:nRuns],color = '#E7298A')
plt.xlabel("iteration"); plt.ylabel("par[0]")
plt.axhline( np.mean(res[nBurnIn:nRuns]), linewidth=2, color = 'k' )

##############################################################################
# End of file
##############################################################################