Example #1
0
def disc_norm():
    x = np.linspace(-3,3,100)
    y = st.norm.pdf(x,0,1)
    fig, ax = plt.subplots()
    fig.canvas.draw()
    
    ax.plot(x,y)
    
    fill1_x = np.linspace(-2,-1.5,100)
    fill1_y = st.norm.pdf(fill1_x,0,1)
    fill2_x = np.linspace(-1.5,-1,100)
    fill2_y = st.norm.pdf(fill2_x,0,1)
    ax.fill_between(fill1_x,0,fill1_y,facecolor = 'blue', edgecolor = 'k',alpha = 0.75)
    ax.fill_between(fill2_x,0,fill2_y,facecolor = 'blue', edgecolor = 'k',alpha = 0.75)
    for label in ax.get_yticklabels():
        label.set_visible(False)
    for tick in ax.get_xticklines():
        tick.set_visible(False)
    for tick in ax.get_yticklines():
        tick.set_visible(False)
    
    plt.rc("font", size = 16)
    plt.xticks([-2,-1.5,-1])
    labels = [item.get_text() for item in ax.get_xticklabels()]
    labels[0] = r"$v_k$"
    labels[1] = r"$\varepsilon_k$"
    labels[2] = r"$v_{k+1}$"
    ax.set_xticklabels(labels)
    plt.ylim([0, .45])

    
    plt.savefig('discnorm.pdf')
    plt.clf()
def plots(i,tcodnt, temp, forecast,added_tcodnt,n_steps,path, rsdlsc,rsdlpctgc, sqrpctgc,a,b,c,d,e):
    fig=mp.figure(figsize=[15,6])#5:2,89mm
    grid=mp.GridSpec(3,36,wspace=1,hspace=0.4)
    ax=mp.subplot(grid[:2,:18])
    cpplot(i,tcodnt, temp, forecast,added_tcodnt,n_steps,path)
    #rscplot(i,tcodnt, rsdlsc, rsdlpctgc, sqrpctgc,path)
    ax=mp.subplot(grid[2,:18])
    im1=colorbar(ax,tcodnt, rsdlsc,i,0,-1,c**2)
    ax.set_yticks([])
    ax=mp.subplot(grid[2,21:35])
    im2=colorbar(ax,tcodnt, rsdlsc,i,a,b,int(c/2))
    ax.set_yticks([])
    ax=mp.subplot(grid[:2,21:35])
    partial_plot_for_ahead_interval(i,tcodnt, temp, forecast,added_tcodnt,n_steps,path,rsdlpctgc,a,b)
    ax1=mp.subplot(grid[:,35])
    clb1=mp.colorbar(im2,cax=ax1,extend='both')
    #clb1.set_label('residuals',fontsize=12,color='grey')
    ax2=mp.subplot(grid[:,18])
    clb2=mp.colorbar(im1,cax=ax2,extend='both')
    clb1.set_label('residuals',fontsize=size)
#    ax=mp.subplot(grid[:2,32:35])
#    partial_plot_for_ahead_interval(i,tcodnt, temp, forecast,added_tcodnt,n_steps,path,rsdlpctgc,d,e)
#    ax=mp.subplot(grid[2,32:35])
#    im3=colorbar(ax,tcodnt, rsdlsc,i,d,e,int(c/5))
#    ax.set_yticks([])
#    ax3=mp.subplot(grid[:,35])
#    clb3=mp.colorbar(im3,cax=ax3,extend='both')
#    clb3.set_label('residuals',fontsize=size,color='grey')
    mp.savefig((str(path)+'\\'+'results'+'\\'+'Accuracy_Graph_%d'+'.jpg')%i,format='jpg',dpi=2000)
def plot_figure(data, row_labels, col_labels, abs_val, plot_bin, labels, time, logInterval):
  colors = ['#0077FF', '#FF0000', '#00FF00', 'magenta']
  cmaps = []
  for i in colors:
    cmaps.append(mpl.colors.LinearSegmentedColormap.from_list('m1',['black',i]))
  dim, rows, cols = data.shape
  vmax = np.amax(data)
  vmin = np.amin(data)
  fig, ax = plt.subplots()
  c = np.zeros([rows, cols, 4])
  for i in range(dim):
    c = np.add(c, cmaps[i]((data[i]-vmin)/(vmax-vmin)))
  c = np.clip(c, 0, 1)
  pc = ax.imshow(c, aspect='auto', interpolation='none')
  #ax.set_title(labels[0])
  fig.text(0.5, 0.04, 'Bin # along rod length', ha='center',
      fontsize=fontsize)
  fig.text(0.0, 0.5, 'Time (s)', va='center', rotation='vertical',
      fontsize=fontsize)
  #ax.add_patch(Rectangle((0.5, time/logInterval), cols-1, 10, edgecolor='w',
  #  facecolor='none'))
  #ax.add_patch(Rectangle((bin_id, 0.5/logInterval), 1, rows-0.5/logInterval,
  #  edgecolor='w', facecolor='none'))
  #plt.savefig('kymo.png', bbox_inches='tight')
  plt.savefig('3rods_1long_kymo.pdf')
  plt.show()
Example #4
0
def make_fish(zoom=False):
    plt.close(1)
    plt.figure(1, figsize=(6, 4))
    plt.plot(plot_limits['pitch'], plot_limits['rolldev'], '-g', lw=3)
    plt.plot(plot_limits['pitch'], -plot_limits['rolldev'], '-g', lw=3)
    plt.plot(pitch.midvals, roll.midvals, '.b', ms=1, alpha=0.7)

    p, r = make_ellipse()  # pitch, off nominal roll
    plt.plot(p, r, '-c', lw=2)

    gf = -0.08  # Fudge on pitch value for illustrative purposes
    plt.plot(greta['pitch'] + gf, -greta['roll'], '.r', ms=1, alpha=0.7)
    plt.plot(greta['pitch'][-1] + gf, -greta['roll'][-1], 'xr', ms=10, mew=2)

    if zoom:
        plt.xlim(46.3, 56.1)
        plt.ylim(4.1, 7.3)
    else:
        plt.ylim(-22, 22)
        plt.xlim(40, 180)
    plt.xlabel('Sun pitch angle (deg)')
    plt.ylabel('Sun off-nominal roll angle (deg)')
    plt.title('Mission off-nominal roll vs. pitch (5 minute samples)')
    plt.grid()
    plt.tight_layout()
    plt.savefig('fish{}.png'.format('_zoom' if zoom else ''))
def plot_scatter_matrix(df, plotdir):
    "Plot scatter matrix."
    print('plotting scatter matrix, this may take a while')
    plt.clf()
    pd_scatter_matrix(df, figsize=(16,16))
    plt.suptitle("Scatter Matrix", fontsize=14)
    plt.savefig(plotdir + 'scatter_matrix.png')
Example #6
0
def scree_plot(pca_obj, fname=None): 
    '''
    Scree plot for variance & cumulative variance by component from PCA. 

    Arguments: 
        - pca_obj: a fitted sklearn PCA instance
        - fname: path to write plot to file

    Output: 
        - scree plot 
    '''   
    components = pca_obj.n_components_ 
    variance = pca.explained_variance_ratio_
    plt.figure()
    plt.plot(np.arange(1, components + 1), np.cumsum(variance), label='Cumulative Variance')
    plt.plot(np.arange(1, components + 1), variance, label='Variance')
    plt.xlim([0.8, components]); plt.ylim([0.0, 1.01])
    plt.xlabel('No. Components', labelpad=11); plt.ylabel('Variance Explained', labelpad=11)
    plt.legend(loc='best') 
    plt.tight_layout() 
    if fname is not None:
        plt.savefig(fname)
        plt.close() 
    else:
        plt.show() 
    return 
def draw_ranges_for_parameters(data, title='', save_path='./pictures/'):
  parameters = data.columns.values.tolist()

  # remove flight name parameter
  for idx, parameter in enumerate(parameters):
    if parameter == 'flight_name':
      del parameters[idx]

  flight_names = np.unique(data['flight_name'])

  print len(flight_names)

  for parameter in parameters:
    plt.figure()

    axis = plt.gca()

    # ax.set_xticks(numpy.arange(0,1,0.1))
    axis.set_yticks(flight_names)
    axis.tick_params(labelright=True)
    axis.set_ylim([94., 130.])
    plt.grid()

    plt.title(title)
    plt.xlabel(parameter)
    plt.ylabel('flight name')

    colors = iter(cm.rainbow(np.linspace(0, 1,len(flight_names))))

    for flight in flight_names:
      temp = data[data.flight_name == flight][parameter]

      plt.plot([np.min(temp), np.max(temp)], [flight, flight], c=next(colors), linewidth=2.0)
    plt.savefig(save_path+title+'_'+parameter+'.jpg')
    plt.close()
Example #8
0
def test_minimized_rasterized():
    # This ensures that the rasterized content in the colorbars is
    # only as thick as the colorbar, and doesn't extend to other parts
    # of the image.  See #5814.  While the original bug exists only
    # in Postscript, the best way to detect it is to generate SVG
    # and then parse the output to make sure the two colorbar images
    # are the same size.
    from xml.etree import ElementTree

    np.random.seed(0)
    data = np.random.rand(10, 10)

    fig, ax = plt.subplots(1, 2)
    p1 = ax[0].pcolormesh(data)
    p2 = ax[1].pcolormesh(data)

    plt.colorbar(p1, ax=ax[0])
    plt.colorbar(p2, ax=ax[1])

    buff = io.BytesIO()
    plt.savefig(buff, format='svg')

    buff = io.BytesIO(buff.getvalue())
    tree = ElementTree.parse(buff)
    width = None
    for image in tree.iter('image'):
        if width is None:
            width = image['width']
        else:
            if image['width'] != width:
                assert False
def do_plot(mode, content, wide):
	global style
	style.apply(mode, content, wide)

	data = np.load("data/prr_AsAu_%s%s.npz"%(content, wide))

	AU, TAU = np.meshgrid(-data["Au_range_dB"], data["tau_range"])
	Zu = data["PRR_U"]
	Zs = data["PRR_S"]

	assert TAU.shape == AU.shape == Zu.shape, "The inputs TAU, AU, PRR_U must have the same shape for plotting!"

	plt.clf()

	if mode in ("sync",):
		# Plot the inverse power ratio, sync signal is stronger for positive ratios
		CSf = plt.contourf(TAU, AU, Zs, levels=(0.0, 0.2, 0.4, 0.6, 0.8, 0.9, 1.0), colors=("1.0", "0.75", "0.5", "0.25", "0.15", "0.0"), origin="lower")
		CS2 = plt.contour(CSf, colors = ("r",)*5+("w",), linewidths=(0.75,)*5+(1.0,), origin="lower", hold="on")
	else:
		CSf  = plt.contourf(TAU, AU, Zs, levels=(0.0, 0.2, 0.4, 0.6, 0.8, 0.9, 1.0), colors=("1.0", "0.75", "0.5", "0.25", "0.15", "0.0"), origin="lower")
		CS2f = plt.contour(CSf, levels=(0.0, 0.2, 0.4, 0.6, 0.8, 1.0), colors=4*("r",)+("w",), linewidths=(0.75,)*4+(1.0,), origin="lower", hold="on")
		#CS2f = plt.contour(TAU, -AU, Zu, levels=(0.9, 1.0), colors=("0.0",), linewidths=(1.0,), origin="lower", hold="on")
		if content in ("unif",):
			CSu  = plt.contourf(TAU, AU, Zu, levels=(0.2, 1.0), hatches=("////",), colors=("0.75",), origin="lower")
			CS2  = plt.contour(CSu, levels=(0.2,), colors = ("r",), linewidths=(1.0,), origin="lower", hold="on")

	style.annotate(mode, content, wide)

	plt.axis([data["tau_range"][0], data["tau_range"][-1], -data["Au_range_dB"][-1], -data["Au_range_dB"][0]])

	plt.ylabel(r"Signal power ratio ($\mathrm{SIR}$)", labelpad=2)
	plt.xlabel(r"Time offset $\tau$ ($/T$)", labelpad=2)

	plt.savefig("pdf/prrc2_%s_%s%s_z.pdf"%(mode, content, wide))
def vis_result(image, seg, gt, title1='Segmentation', title2='Ground truth', savefile=None):
    indices = np.where(seg >= 0.5)
    indices_gt = np.where(gt >= 0.5)

    im_norm = image / image.max()
    rgb_image = color.gray2rgb(im_norm)
    multiplier = [0., 1., 1.]
    multiplier_gt = [1., 1., 0.]

    im_seg = rgb_image.copy()
    im_gt = rgb_image.copy()
    im_seg[indices[0], indices[1], :] *= multiplier
    im_gt[indices_gt[0], indices_gt[1], :] *= multiplier_gt

    fig = plt.figure()
    a = fig.add_subplot(1, 2, 1)
    plt.imshow(im_seg)
    a.set_title(title1)
    a = fig.add_subplot(1, 2, 2)
    plt.imshow(im_gt)
    a.set_title(title2)

    if savefile is None:
        plt.show()
    else:
        plt.savefig(savefile)
    plt.close()
Example #11
0
File: ACGAN.py Project: CODEJIN/GAN
    def Test(self):
        test_Dir = "Result";        
        if not os.path.exists(test_Dir):
            os.makedirs(test_Dir);

        test_Label_List = [0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5];
        test_Label_Pattern = np.zeros((16, 10));
        test_Label_Pattern[np.arange(16), test_Label_List] = 1;            
        feed_Dict = {
            self.noise_Placeholder: np.random.uniform(-1., 1., size=[16, self.noise_Size]),
            self.label_for_Fake_Placeholder: test_Label_Pattern,
            self.is_Training_Placeholder: False
            };   #Batch is constant in the test.
        global_Step, mnist_List = self.tf_Session.run(self.test_Tensor_List, feed_dict = feed_Dict);

        fig = plt.figure(figsize=(4, 4))
        gs = gridspec.GridSpec(4, 4)
        gs.update(wspace=0.05, hspace=0.05)

        for index, mnist in enumerate(mnist_List):
            ax = plt.subplot(gs[index])
            plt.axis('off')
            ax.set_xticklabels([])
            ax.set_yticklabels([])
            ax.set_aspect('equal')
            plt.imshow(mnist.reshape(28, 28), cmap='Greys_r')

        plt.savefig('%s/S%d.png' % (test_Dir, global_Step), bbox_inches='tight');
        plt.close();
Example #12
0
def run_test(fld, seeds, plot2d=True, plot3d=True, add_title="",
             view_kwargs=None, show=False, scatter_mpl=False, mesh_mvi=True):
    interpolated_fld = viscid.interp_trilin(fld, seeds)
    seed_name = seeds.__class__.__name__
    if add_title:
        seed_name += " " + add_title

    try:
        if not plot2d:
            raise ImportError
        from viscid.plot import vpyplot as vlt
        from matplotlib import pyplot as plt
        plt.clf()
        # plt.plot(seeds.get_points()[2, :], fld)
        mpl_plot_kwargs = dict()
        if interpolated_fld.is_spherical():
            mpl_plot_kwargs['hemisphere'] = 'north'
        vlt.plot(interpolated_fld, **mpl_plot_kwargs)
        plt.title(seed_name)

        plt.savefig(next_plot_fname(__file__, series='2d'))
        if show:
            plt.show()

        if scatter_mpl:
            plt.clf()
            vlt.plot2d_line(seeds.get_points(), fld, symdir='z', marker='o')
            plt.savefig(next_plot_fname(__file__, series='2d'))
            if show:
                plt.show()
    except ImportError:
        pass

    try:
        if not plot3d:
            raise ImportError
        from viscid.plot import vlab

        _ = get_mvi_fig(offscreen=not show)

        try:
            if mesh_mvi:
                mesh = vlab.mesh_from_seeds(seeds, scalars=interpolated_fld)
                mesh.actor.property.backface_culling = True
        except RuntimeError:
            pass

        pts = seeds.get_points()
        p = vlab.points3d(pts[0], pts[1], pts[2], interpolated_fld.flat_data,
                          scale_mode='none', scale_factor=0.02)
        vlab.axes(p)
        vlab.title(seed_name)
        if view_kwargs:
            vlab.view(**view_kwargs)

        vlab.savefig(next_plot_fname(__file__, series='3d'))
        if show:
            vlab.show(stop=True)
    except ImportError:
        pass
 def default_run(self):
     """
     Plots the results, saves the figure, and finally displays it from simulating codewords with Sum-prod and Max-prod
     algorithms across variance levels. This combines the results in one plot.
     :return:
     """
     if not os.path.exists("./graphs"):
         os.makedirs("./graphs")
     self.save_time = str(int(time.time()))
     self.simulate(Decoder.SUM_PROD)
     self.compute_error()
     plt.plot([math.log10(x) for x in self.variance_levels], [math.log10(y) for y in self.bit_error_probability],
              "ro-", label="Sum-Prod")
     self.simulate(Decoder.MAX_PROD)
     self.compute_error()
     plt.plot([math.log10(x) for x in self.variance_levels], [math.log10(y) for y in self.bit_error_probability],
              "g^--", label="Max-Prod")
     plt.legend(loc=2)
     plt.title("Hamming Decoder Factor Graph Simulation Results\n" +
               r"$\log_{10}(\sigma^2)$ vs. $\log_{10}(P_e)$" + " for Max-Prod & Sum-Prod Algorithms\n" +
               "Sample Size n = %(codewords)s Codewords \n Variance Levels = %(levels)s"
               % {"codewords": str(self.iterations), "levels": str(self.variance_levels)})
     plt.xlabel("$\log_{10}(\sigma^2)$")
     plt.ylabel(r"$\log_{10}(P_e)$")
     plt.savefig("graphs/%(time)s-max-prod-sum-prod-%(num_codewords)s-codewords-variance-bit_error_probability.png" %
                 {"time": self.save_time,
                  "num_codewords": str(self.iterations)}, bbox_inches="tight")
     plt.show()
  def build_hist(self, coverage, show=False, save=False, save_fn="max_hist_plot"):
    """
    Build a histogram to determine what the maxes look & visualize match_count
    Might be used to determine a resonable threshold

    @param coverage: the average coverage for an single nt
    @param show: Show visualization with match maxes
    @param save_fn: Save to disk with this file name or else it will be the default

    @return: the histogram array
    """
    #import matplotlib
    #matplotlib.use("Agg")
    import matplotlib.pyplot as plt

    maxes = self.match_count.max(1) # get maxes along 1st dim

    h = plt.hist(maxes, bins=self.match_count.shape[0]) # figure out where the majority

    plt.ylabel("Frequency")
    plt.xlabel("Count per index")
    plt.title("Frequency count histogram")

    if show: plt.show()
    if save: plt.savefig(save_fn, dpi=160, frameon=False)

    return h[0]
Example #15
0
def compare_chebhist(dname, mylambda, c, Nbin = 25):


    if mylambda == 'Do not exist':
        print('--!!Warning: eig file does not exist, can not display compare histgram')
    else:
        mylambda = 1 - mylambda
        lmin = max(min(mylambda), -1)
        lmax = min(max(mylambda),  1)

        # print c
        cheb_file_content = '\n'.join([str(st) for st in c])
        x = np.linspace(lmin, lmax, Nbin + 1)
        y = plot_chebint(c, x)
        u = (x[1:] + x[:-1]) / 2
        v =  y[1:] - y[:-1]

        plt.clf()
        plt.hold(True)
        plt.hist(mylambda,Nbin)
        plt.plot(u, v, "r.", markersize=10)
        plt.hold(False)
        plt.show()
        filename = 'data/' + dname + '.png'
        plt.savefig(filename)

        cheb_filename = 'data/' + dname + '.cheb'
        f = open(cheb_filename, 'w+')
        f.write(cheb_file_content)
        f.close()
def plotErrorBars(dict_to_plot, x_lim, y_lim, xlabel, y_label, title, out_file, margin=[0.05, 0.05], loc=2):

    plt.title(title)
    plt.xlabel(xlabel)
    plt.ylabel(y_label)

    if y_lim is None:
        y_lim = [1 * float("Inf"), -1 * float("Inf")]

    max_val_seen_y = y_lim[1] - margin[1]
    min_val_seen_y = y_lim[0] + margin[1]
    print min_val_seen_y, max_val_seen_y
    max_val_seen_x = x_lim[1] - margin[0]
    min_val_seen_x = x_lim[0] + margin[0]
    handles = []
    for k in dict_to_plot:
        means, stds, x_vals = dict_to_plot[k]

        min_val_seen_y = min(min(np.array(means) - np.array(stds)), min_val_seen_y)
        max_val_seen_y = max(max(np.array(means) + np.array(stds)), max_val_seen_y)

        min_val_seen_x = min(min(x_vals), min_val_seen_x)
        max_val_seen_x = max(max(x_vals), max_val_seen_x)

        handle = plt.errorbar(x_vals, means, yerr=stds)
        handles.append(handle)
        print max_val_seen_y
    plt.xlim([min_val_seen_x - margin[0], max_val_seen_x + margin[0]])
    plt.ylim([min_val_seen_y - margin[1], max_val_seen_y + margin[1]])
    plt.legend(handles, dict_to_plot.keys(), loc=loc)
    plt.savefig(out_file)
Example #17
0
def plot_precision_recall_n(y_true, y_scores, model_name):
    '''
    Takes the model, plots precision and recall curves
    '''

    precision_curve, recall_curve, pr_thresholds = precision_recall_curve(y_true, y_scores)
    precision_curve = precision_curve[:-1]
    recall_curve = recall_curve[:-1]
    pct_above_per_thresh = []
    number_scored = len(y_scores)

    for value in pr_thresholds:
        num_above_thresh = len(y_scores[y_scores >= value])
        pct_above_thresh = num_above_thresh / float(number_scored)
        pct_above_per_thresh.append(pct_above_thresh)

    pct_above_per_thresh = np.array(pct_above_per_thresh)
    plt.clf()
    fig, ax1 = plt.subplots()
    ax1.plot(pct_above_per_thresh, precision_curve, 'b')
    ax1.set_xlabel('percent of population')
    ax1.set_ylabel('precision', color='b')
    ax2 = ax1.twinx()
    ax2.plot(pct_above_per_thresh, recall_curve, 'r')
    ax2.set_ylabel('recall', color='r')
    name = model_name
    plt.title(name)
    plt.savefig("Eval/{}.png".format(name))
Example #18
0
def display(spectrum):
	template = np.ones(len(spectrum))

	#Get the plot ready and label the axes
	pyp.plot(spectrum)
	max_range = int(math.ceil(np.amax(spectrum) / standard_deviation))
	for i in range(0, max_range):
		pyp.plot(template * (mean + i * standard_deviation))
	pyp.xlabel('Units?')
	pyp.ylabel('Amps Squared')    
	pyp.title('Mean Normalized Power Spectrum')
	if 'V' in Options:
		pyp.show()
	if 'v' in Options:
		tokens = sys.argv[-1].split('.')
		filename = tokens[0] + ".png"
		input = ''
		if os.path.isfile(filename):
			input = input("Error: Plot file already exists! Overwrite? (y/n)\n")
			while input != 'y' and input != 'n':
				input = input("Please enter either \'y\' or \'n\'.\n")
			if input == 'y':
				pyp.savefig(filename) 
			else:
				print("Plot not written.")
		else:
			pyp.savefig(filename) 
def export(data, F, k):
    '''Write data to a png image
    
    Arguments
    ---------
    data : numpy.ndarray
        array containing the data to be written as png image
    F : float
        feed rate of the current configuration
    k : float
        rate constant of the current configuration
    '''
        
    figsize = tuple(s / 72.0 for s in data.shape)
    fig = plt.figure(figsize=figsize, dpi=72.0, facecolor='white')
    fig.add_axes([0, 0, 1, 1], frameon=False)
    plt.xticks([])
    plt.yticks([])

    plt.imshow(data, cmap=plt.cm.RdBu_r, interpolation='bicubic')
    plt.gci().set_clim(0, 1)

    filename = './study/F{:03d}-k{:03d}.png'.format(int(1000*F), int(1000*k))
    plt.savefig(filename, dpi=72.0)
    plt.close()
	def draw_img_for_viewing_ice(self):
		#print "Press 'p' to save PNG."
		global colmax
		global colmin
		fig = P.figure(num=None, figsize=(13.5, 5), dpi=100, facecolor='w', edgecolor='k')
		cid1 = fig.canvas.mpl_connect('key_press_event', self.on_keypress_for_viewing)
		cid2 = fig.canvas.mpl_connect('button_press_event', self.on_click)
		canvas = fig.add_subplot(121)
		canvas.set_title(self.filename)
		self.axes = P.imshow(self.inarr, origin='lower', vmax = colmax, vmin = colmin)
		self.colbar = P.colorbar(self.axes, pad=0.01)
		self.orglims = self.axes.get_clim()
		canvas = fig.add_subplot(122)
		canvas.set_title("Angular Average")
		
		maxAngAvg = (self.inangavg).max()
		numQLabels = len(eDD.iceHInvAngQ.keys())+1
		labelPosition = maxAngAvg/numQLabels
		for i,j in eDD.iceHInvAngQ.iteritems():
			P.axvline(j,0,colmax,color='r')
			P.text(j,labelPosition,str(i), rotation="45")
			labelPosition += maxAngAvg/numQLabels
			
		P.plot(self.inangavgQ, self.inangavg)
		P.xlabel("Q (A-1)")
		P.ylabel("I(Q) (ADU/srad)")
		pngtag = original_dir + "peakfit-gdvn_%s.png" % (self.filename)
		P.savefig(pngtag)
		print "%s saved." % (pngtag)
		P.close()
Example #21
0
def draw_stat(actual_price, action):
	price_list = []
	x_list = []
	# idx = np.where(actual_price == 0)[0]
	# print idx
	# print actual_price[np.where(actual_price < 2000)]
	# idx = [0] + idx.tolist()
	# print idx
	# for i in range(len(idx)-1):
	# 	price_list.append(actual_price[idx[i]+1:idx[i+1]-1])
	# 	x_list.append(range(idx[i]+i+1, idx[i+1]+i-1))
	# for i in range(len(idx)-1):
	# 	print x_list[i]
	# 	print price_list[i]
	# 	plt.plot(x_list[i], price_list[i], 'r')
	x_list = range(1,50)
	price_list = actual_price[1:50]
	plt.plot(x_list, price_list, 'k')
	for i in range(1, 50):
		style = 'go'
		if action[i] == 1:
			style = 'ro'
		plt.plot(i, actual_price[i], style)
	plt.ylim(2140, 2144.2)
	# plt.show()
	plt.savefig("action.png")
Example #22
0
    def make_bar(
        x,
        y,
        f_name,
        title=None,
        legend=None,
        x_label=None,
        y_label=None,
        x_ticks=None,
        y_ticks=None,
    ):
        fig = plt.figure()

        if title is not None:
            plt.title(title, fontsize=16)
        if x_label is not None:
            plt.ylabel(x_label)
        if y_label is not None:
            plt.xlabel(y_label)
        if x_ticks is not None:
            plt.xticks(x, x_ticks)
        if y_ticks is not None:
            plt.yticks(y_ticks)

        plt.bar(x, y, align="center")

        if legend is not None:
            plt.legend(legend)

        plt.savefig(f_name)
        plt.close(fig)
Example #23
0
def main():
    parser = argparse.ArgumentParser(description="""Compute subset of users who rated at
                                     least 10 movies and plot fraction of users satisfied
                                     as a function of inventory size.""")
    parser.add_argument("infilename",
                        help="Read from this file.", type=open)
    args = parser.parse_args()

    ratings = read_inputs(args.infilename)
    ratings = ratings.drop("timestamp", axis=1)
    movie_rankings = find_movie_rankings(ratings)
    ratings = ratings.drop("rating", axis=1)
    user_rankings = find_user_rankings(ratings, movie_rankings)
    num_users = user_rankings.user_id.unique().size
    num_movies = movie_rankings.shape[0]
    user_rankings = clean_rankings(user_rankings)

    us_levels_100 = find_satisfaction(user_rankings, num_users, num_movies)
    us_levels_90 = find_satisfaction(user_rankings, num_users, num_movies, satisfaction_level=0.9)

    rc('text', usetex=True)
    plt.title('Percent of Users Satisfied vs Inventory Size in the MovieLens Dataset')
    plt.xlabel('Inventory Size')
    plt.ylabel('Percent of Users Satisfied')
    plt.plot(us_levels_100, 'b', label=r'$100\% \ satisfaction$')
    plt.plot(us_levels_90, 'r--', label=r'$90\% \ satisfaction$')
    plt.legend()
    d = datetime.datetime.now().isoformat()
    plt.savefig('user_satisfaction_%s.png' % d)
Example #24
0
def plot_jacobian(A, name, cmap= plt.cm.coolwarm, normalize=True, precision=1e-6):

    """
    Customized visualization of jacobian matrices for observing
    sparsity patterns
    """
    
    plt.figure()
    fig, ax = plt.subplots()
    
    if normalize is True:
        plt.imshow(A, interpolation='none', cmap=cmap,
                   norm = mpl.colors.Normalize(vmin=-1.,vmax=1.))
    else:
        plt.imshow(A, interpolation='none', cmap=cmap)        
    plt.colorbar(format=ticker.FuncFormatter(fmt))
    
    ax.spy(A, marker='.', markersize=0,  precision=precision)
    
    ax.spines['right'].set_visible(True)
    ax.spines['bottom'].set_visible(True)
    ax.xaxis.set_ticks_position('top')
    ax.yaxis.set_ticks_position('left')

    xlabels = np.linspace(0, A.shape[0], 5, True, dtype=int)
    ylabels = np.linspace(0, A.shape[1], 5, True, dtype=int)

    plt.xticks(xlabels)
    plt.yticks(ylabels)

    plt.savefig(name, bbox_inches='tight', pad_inches=0.05)
    
    plt.close()

    return
Example #25
0
    def plot(self, path, num_bins=0):
        """
        draw a histogram to represent the data
        :param num_bins: number of bars, default is (Number different word in the file )/ 2,
                            if it is too large take 50 as default (see '#default of num_bins')
        """
        # plot data
        mu = self.Average  # mean of distribution
        sigma = self.StdE  # standard deviation of distribution
        if num_bins == 0:  # default of num_bins
            num_bins = min([round(self.NumWord / 2), 50])
            # print num_bins
        # the histogram of the data
        n, bins, patches = plt.hist(self.WordCount.values(), num_bins, normed=1, facecolor='green', alpha=0.5)
        # add a 'best fit' line
        y = mlab.normpdf(bins, mu, sigma)
        plt.plot(bins, y, 'r--')
        plt.xlabel('Word Count')
        plt.ylabel('Probability(how many words have this word count)')
        plt.title(r'Histogram of word count: $\mu=' + str(self.Average) + '$, $\sigma=' + str(self.StdE) + '$')

        # Tweak spacing to prevent clipping of ylabel
        plt.subplots_adjust(left=0.15)
        plt.savefig(path)
        plt.close()
Example #26
0
def make_entity_plot(filename, title, fixed_noip, fixed_ip, dynamic_noip, dynamic_ip):
    plt.figure(figsize=(12,5))

    plt.title("Settings comparison - " + title)
    
    plt.xlabel('Time (ms)', fontsize=12)
    plt.xlim([0,62000])

    x = 0
    barwidth = 0.5
    bargroupspacing = 1.5

    fixed_noip_mean,fixed_noip_conf = conf_stats(fixed_noip)
    fixed_ip_mean,fixed_ip_conf = conf_stats(fixed_ip)
    dynamic_noip_mean,dynamic_noip_conf = conf_stats(dynamic_noip)
    dynamic_ip_mean,dynamic_ip_conf = conf_stats(dynamic_ip)

    values = [fixed_noip_mean,fixed_ip_mean,dynamic_noip_mean, dynamic_ip_mean]
    errs = [fixed_noip_conf,fixed_ip_conf,dynamic_noip_conf, dynamic_ip_conf]

    y_pos = numpy.arange(len(values))
    plt.barh(y_pos, values, xerr=errs, align='center', color=['r', 'b', 'r', 'b'],  ecolor='black', alpha=0.7)
    plt.yticks(y_pos, ["Fixed | no I.P.", "Fixed | I.P.", "Dynamic | no I.P.", "Dynamic | I.P."])
    plt.savefig(output_file(filename))
    plt.clf()
def plot_dpi_dpr_distribution(args, dpis, dprs, diagnoses):
    print log.INFO, 'Plotting estimate distributions...'
    diagnoses = np.array(diagnoses)
    diagnoses[(0.25 <= diagnoses) & (diagnoses <= 0.75)] = 0.5

    # Setup plot
    fig, ax = plt.subplots()
    pt.setup_axes(plt, ax)

    biomarkers_str = args.method if args.biomarkers is None else ', '.join(args.biomarkers)
    ax.set_title('DP estimation using {0} at {1}'.format(biomarkers_str, ', '.join(args.visits)))
    ax.set_xlabel('DP')
    ax.set_ylabel('DPR')

    plt.scatter(dpis, dprs, c=diagnoses, edgecolor='none', s=25.0,
                vmin=0.0, vmax=1.0, cmap=pt.progression_cmap,
                alpha=0.5)

    # Plot legend
    # noinspection PyUnresolvedReferences
    rects = [mpl.patches.Rectangle((0, 0), 1, 1, fc=pt.color_cn + (0.5,), linewidth=0),
             mpl.patches.Rectangle((0, 0), 1, 1, fc=pt.color_mci + (0.5,), linewidth=0),
             mpl.patches.Rectangle((0, 0), 1, 1, fc=pt.color_ad + (0.5,), linewidth=0)]
    labels = ['CN', 'MCI', 'AD']
    legend = ax.legend(rects, labels, fontsize=10, ncol=len(rects), loc='upper center', framealpha=0.9)
    legend.get_frame().set_edgecolor((0.6, 0.6, 0.6))

    # Draw or save the plot
    plt.tight_layout()
    if args.plot_file is not None:
        plt.savefig(args.plot_file, transparent=True)
    else:
        plt.show()
    plt.close(fig)
Example #28
0
def plot_wav_fft(wav_filename, desc=None):
    plt.clf()
    plt.figure(num=None, figsize=(6, 4))
    sample_rate, X = scipy.io.wavfile.read(wav_filename)
    spectrum = np.fft.fft(X)
    freq = np.fft.fftfreq(len(X), 1.0 / sample_rate)

    plt.subplot(211)
    num_samples = 200.0
    plt.xlim(0, num_samples / sample_rate)
    plt.xlabel("time [s]")
    plt.title(desc or wav_filename)
    plt.plot(np.arange(num_samples) / sample_rate, X[:num_samples])
    plt.grid(True)

    plt.subplot(212)
    plt.xlim(0, 5000)
    plt.xlabel("frequency [Hz]")
    plt.xticks(np.arange(5) * 1000)
    if desc:
        desc = desc.strip()
        fft_desc = desc[0].lower() + desc[1:]
    else:
        fft_desc = wav_filename
    plt.title("FFT of %s" % fft_desc)
    plt.plot(freq, abs(spectrum), linewidth=5)
    plt.grid(True)

    plt.tight_layout()

    rel_filename = os.path.split(wav_filename)[1]
    plt.savefig("%s_wav_fft.png" % os.path.splitext(rel_filename)[0],
                bbox_inches='tight')
Example #29
0
def make_overview_plot(filename, title, noip_arrs, ip_arrs):
    plt.title("Inner parallelism - " + title)

    
    plt.ylabel('Time (ms)', fontsize=12)

    x = 0
    barwidth = 0.5
    bargroupspacing = 1.5

    for z in zip(noip_arrs, ip_arrs):
        noip,ip = z
        noip_mean,noip_conf = conf_stats(noip)
        ip_mean,ip_conf = conf_stats(ip)

        b_noip = plt.bar(x, noip_mean, barwidth, color='r', yerr=noip_conf, ecolor='black', alpha=0.7)
        x += barwidth

        b_ip = plt.bar(x, ip_mean, barwidth, color='b', yerr=ip_conf, ecolor='black', alpha=0.7)
        x += bargroupspacing

    plt.xticks([0.5, 2.5, 4.5], ['50k', '100k', '200k'], rotation='horizontal')

    fontP = FontProperties()
    fontP.set_size('small')

    plt.legend([b_noip, b_ip], \
        ('no inner parallelism', 'inner parallelism'), \
        prop=fontP, loc='upper center', bbox_to_anchor=(0.5, -0.05), fancybox=True, shadow=True, ncol=2)
   
    plt.ylim([0,62000])
    plt.savefig(output_file(filename))
    plt.clf()
Example #30
0
    def make_line(
        x,
        y,
        f_name,
        title=None,
        legend=None,
        x_label=None,
        y_label=None,
        x_ticks=None,
        y_ticks=None,
    ):
        fig = plt.figure()

        if title is not None:
            plt.title(title, fontsize=16)
        if x_label is not None:
            plt.ylabel(x_label)
        if y_label is not None:
            plt.xlabel(y_label)
        if x_ticks is not None:
            plt.xticks(x, x_ticks)
        if y_ticks is not None:
            plt.yticks(y_ticks)

        if isinstance(y[0], list):
            for data in y:
                plt.plot(x, data)
        else:
            plt.plot(x, y)

        if legend is not None:
            plt.legend(legend)

        plt.savefig(f_name)
        plt.close(fig)
Example #31
0
    fig, ax = plt.subplots()
    sns.barplot(data=rmses_ens2)
    ax.set(ylabel='RMSE', title="mean=%.3f, CI=%.3f-%.3f"%(mean_ens2, CI_ens2[0], CI_ens2[1]))
    plt.xticks()
    plt.savefig("plots/multiply_%s_rmse.pdf"%neuron_type)

    print('rmses: ', rmses_ens, rmses_ens_out, rmses_ens2)
    print('means: ', mean_ens, mean_ens_out, mean_ens2)
    print('confidence intervals: ', CI_ens, CI_ens_out, CI_ens2)
    np.savez('data/multiply_%s_results.npz'%neuron_type, rmses_ens=rmses_ens, rmses_ens_out=rmses_ens_out, rmses_ens2=rmses_ens2)
    return rmses_ens2

# rmses_lif = run(neuron_type=LIF())
# rmses_alif = run(neuron_type=AdaptiveLIFT())
# rmses_wilson = run(neuron_type=WilsonEuler(), dt=0.00005)
# rmses_durstewitz = run(neuron_type=DurstewitzNeuron())
# , load_w="data/multiply_w.npz", load_df="data/multiply_DurstewitzNeuron()_df.npz")

rmses_lif = np.load("data/multiply_LIF()_results.npz")['rmses_ens2']
rmses_alif = np.load("data/multiply_AdaptiveLIFT()_results.npz")['rmses_ens2']
rmses_wilson = np.load("data/multiply_WilsonEuler()_results.npz")['rmses_ens2']
rmses_durstewitz = np.load("data/multiply_DurstewitzNeuron()_results.npz")['rmses_ens2']

rmses = np.vstack((rmses_lif, rmses_alif, rmses_wilson, rmses_durstewitz))
nt_names =  ['LIF', 'ALIF', 'Wilson', 'Durstewitz']
fig, ax = plt.subplots()
sns.barplot(data=rmses.T)
ax.set(ylabel='RMSE')
plt.xticks(np.arange(len(nt_names)), tuple(nt_names), rotation=0)
plt.savefig("figures/multiply_all_rmses.pdf")
        train_source, 
        train_steps, 
        epochs = bc_config.EPOCHS, 
        validation_data = test_source, 
        validation_steps = validation_steps)

timestamp = strftime('%d-%b-%y_%H:%M:%S')

try:
    os.mkdir(bc_config.MODEL_DIR)
except FileExistsError:
    pass

model.save(bc_config.MODEL_DIR + '/' + timestamp + '.h5')

if bc_config.PLOT_LOSSES:
    import matplotlib.pyplot as plt

    plt.plot(history.history['loss'])
    plt.plot(history.history['val_loss'])
    plt.title('Model Loss')
    plt.ylabel('Loss')
    plt.xlabel('Epoch')
    plt.legend(['Train Loss', 'Val. Loss'], loc='upper left')
    try:
        os.mkdir(bc_config.PLOT_DIR)
    except FileExistsError:
        pass
    plt.savefig(bc_config.PLOT_DIR + '/' + timestamp + '.png')
print('done')
Example #33
0
def main(fig_num, invert=False):

    if fig_num == '1':

        # Subplots: http://aplpy.readthedocs.io/en/stable/howto_subplot.html
        fig = plt.figure(
            figsize=(7, 5))  # height > optimal aspect ratio has no effect

        # MOST image alone to show structure (varying dark/bright regions)
        fmost = aplpy.FITSFigure(XMMPATH + '/../most/G309.2-0.6.fits',
                                 figure=fig,
                                 subplot=(1, 2, 1))
        fmost.recenter(ra2deg(13, 46, 40),
                       -62.87,
                       width=18. / 60,
                       height=18. / 60)
        fmost_cmap = 'afmhot'
        if invert:
            fmost_cmap += '_r'
        fmost.show_colorscale(vmin=1e-4,
                              vmax=2e-1,
                              stretch='arcsinh',
                              cmap=fmost_cmap)

        # MOST beam notes:
        # - must specify parameters or else constructor will unsuccessfully
        #   search for FITS keywords BMAJ, BMIN, BPA.
        # - hatching is too sparse at our image size, and so has no effect
        # Reference: Whiteoak & Green, 1996A&AS..118..329W
        fmost.add_beam(major=42. / np.sin(-62.9 * np.pi / 180) * u.arcsecond,
                       minor=42 * u.arcsecond,
                       angle=0,
                       corner='bottom left',
                       hatch=None,
                       pad=1,
                       color='white')
        if invert:
            fmost.beam.set_edgecolor('black')
            fmost.beam.set_facecolor('gray')

        format_ticks_and_labels(fmost, invert=invert)
        #fmost.tick_labels.hide_y()
        #fmost.axis_labels.hide_y()

        # Broadband X-ray image with sparse MOST contours to guide the eye
        # Base image has 2.5" pixels and is smoothed with 2px Gaussian (5")
        fxmm = aplpy.FITSFigure(
            XMMPATH +
            '/repro_merged_no_holes/corrected-800-3300_bin0_gauss2.fits',
            figure=fig,
            subplot=(1, 2, 2))
        fxmm.recenter(ra2deg(13, 46, 40),
                      -62.87,
                      width=18. / 60,
                      height=18. / 60)

        # Weird bug:
        # vmin=9e-6,vmax=5e-5 works w/colorbar, but vmin=1e-5,vmax=5e-5 fails
        fxmm_cmap = 'cubehelix'
        if invert:
            fxmm_cmap += '_r'
        # Idea: log scale here to show faint emission; linear show in full fov
        # image to show sources
        #fxmm.show_colorscale(vmin=0.2e-5, vmax=2e-5, stretch='linear',cmap=fxmm_cmap)
        fxmm.show_colorscale(vmin=2e-6,
                             vmax=4e-5,
                             stretch='log',
                             cmap=fxmm_cmap)

        # TODO get colorbars working for both subplots
        # https://github.com/aplpy/aplpy/issues/119
        # Warning: bottom colorbar not fully implemented =(
        #fxmm.add_colorbar(location='right', log_format=True)
        #fxmm.colorbar.set_font(size='small')
        ## TODO WARNING: tick labeling not good.
        ##fxmm.colorbar.set_axis_label_text(r'Counts $s^{-1}$')  # Give in text
        ##fxmm.colorbar.set_axis_label_font(size='small')

        most = fits.open(XMMPATH + '/../most/G309.2-0.6.fits')
        #lev = np.linspace(0.02, 0.2, 10)
        #lev = np.logspace(np.log10(0.01), np.log10(0.2), 10)
        lev = np.logspace(-2, -0.5,
                          4)  # Sparse log contours, 0.01 to 0.1*sqrt(10)
        lev_color = 'cyan'
        if invert:
            lev_color = 'gray'
        fxmm.show_contour(data=most, levels=lev, colors=lev_color, alpha=1)

        format_ticks_and_labels(fxmm, invert=invert)
        fxmm.tick_labels.hide_y()
        fxmm.axis_labels.hide_y()
        fxmm.refresh()

        fig.tight_layout()
        fig.canvas.draw()
        if invert:
            plt.savefig('fig_snr_xmm_most_invert.pdf', dpi=300)
        else:
            plt.savefig('fig_snr_xmm_most.pdf', dpi=300)

    elif fig_num == '2':

        # Subplots: http://aplpy.readthedocs.io/en/stable/howto_subplot.html
        fig = plt.figure(
            figsize=(8, 10))  # height > optimal aspect ratio has no effect

        cmap = 'afmhot'
        if invert:
            cmap = 'cubehelix_r'
            #cmap += '_r'

        # Broadband X-ray image with point source extractions
        # and interpolation
        f = aplpy.FITSFigure(
            XMMPATH +
            '/repro_merged_no_holes/corrected-800-3300_bin0_gauss2.fits',
            figure=fig,
            subplot=(1, 2, 1))
        g = aplpy.FITSFigure(
            XMMPATH + '/repro_merged/corrected-800-3300_bin0_gauss2.fits',
            figure=fig,
            subplot=(1, 2, 2))

        for aplfig in [f, g]:
            aplfig.recenter(ra2deg(13, 46, 40),
                            -62 - 52. / 60,
                            width=30. / 60,
                            height=36. / 60)
            #aplfig.show_colorscale(vmin=1e-6, vmax=4e-5, stretch='log',cmap=cmap)
            aplfig.show_colorscale(vmin=0.2e-5,
                                   vmax=3e-5,
                                   stretch='linear',
                                   cmap=cmap)
            format_ticks_and_labels(aplfig, invert=invert)
            aplfig.ticks.set_color('black')  # Because of FOV image

            if not invert:
                axleft_ticks = aplfig._ax1.yaxis.get_ticklines()
                axright_ticks = aplfig._ax2.yaxis.get_ticklines()
                axleft_minorticks = aplfig._ax1.yaxis.get_minorticklines()
                axright_minorticks = aplfig._ax2.yaxis.get_minorticklines()

                axleft_ticks[4].set_color('white')
                axleft_ticks[6].set_color('white')
                axright_ticks[5].set_color('white')
                for idx in [18, 20, 22, 24, 26, 28, 30, 32, 34, 36]:
                    axleft_minorticks[idx].set_color('white')
                for idx in [17, 19, 21, 23]:
                    axright_minorticks[idx].set_color('white')

        g.tick_labels.hide_y()
        g.axis_labels.hide_y()

        f.show_regions('regs-plot/all_point_sources.reg')
        #f.show_regions('regs/ann_000_100.reg')
        #f.show_regions('regs-plot/circ_200.reg')
        #f.show_regions('regs-plot/circ_300.reg')
        f.show_regions(
            'regs/src.reg')  # Equivalent to circ_400, but changed color/width
        #f.show_regions('regs-plot/circ_500.reg')
        f.show_regions('regs/bkg.reg')  # Yes, do show background

        #f.image.figure.tight_layout()  # Use the matplotlib figure instance
        fig.tight_layout()
        fig.canvas.draw()
        if invert:
            plt.savefig('fig_snr_fullfov_invert.pdf',
                        dpi=300)  # Drops into CWD
        else:
            plt.savefig('fig_snr_fullfov.pdf', dpi=300)  # Drops into CWD

    elif fig_num == '3':

        fig = plt.figure(figsize=(7, 5))
        cmap_lf = 'cubehelix'
        if invert:
            cmap_lf += '_r'
        cmap_ew = 'afmhot'
        if invert:
            cmap_ew += '_r'

        mg_line = aplpy.FITSFigure(
            XMMPATH + '/repro_merged/mg_lineflux_bin8_gauss2.fits',
            figure=fig,
            subplot=(2, 3, 1))
        si_line = aplpy.FITSFigure(
            XMMPATH + '/repro_merged/si_lineflux_bin8_gauss2.fits',
            figure=fig,
            subplot=(2, 3, 2))
        s_line = aplpy.FITSFigure(XMMPATH +
                                  '/repro_merged/s_lineflux_bin8_gauss2.fits',
                                  figure=fig,
                                  subplot=(2, 3, 3))

        mg_eqw = aplpy.FITSFigure(XMMPATH +
                                  '/repro_merged/mg_eqwidth_bin16_gauss2.fits',
                                  figure=fig,
                                  subplot=(2, 3, 4))
        si_eqw = aplpy.FITSFigure(XMMPATH +
                                  '/repro_merged/si_eqwidth_bin16_gauss2.fits',
                                  figure=fig,
                                  subplot=(2, 3, 5))
        s_eqw = aplpy.FITSFigure(XMMPATH +
                                 '/repro_merged/s_eqwidth_bin16_gauss2.fits',
                                 figure=fig,
                                 subplot=(2, 3, 6))

        mg_line.show_colorscale(vmin=0,
                                vmax=3e-6,
                                stretch='arcsinh',
                                cmap=cmap_lf)
        si_line.show_colorscale(vmin=0,
                                vmax=3e-6,
                                stretch='arcsinh',
                                cmap=cmap_lf)
        s_line.show_colorscale(vmin=0,
                               vmax=3e-6,
                               stretch='arcsinh',
                               cmap=cmap_lf)

        mg_eqw.show_colorscale(vmin=0,
                               vmax=250,
                               stretch='linear',
                               cmap=cmap_ew)
        si_eqw.show_colorscale(vmin=0,
                               vmax=1000,
                               stretch='linear',
                               cmap=cmap_ew)
        s_eqw.show_colorscale(vmin=0,
                              vmax=1000,
                              stretch='linear',
                              cmap=cmap_ew)

        for im in [mg_line, si_line, s_line, mg_eqw, si_eqw, s_eqw]:
            im.recenter(ra2deg(13, 46, 40),
                        -62.87,
                        width=18. / 60,
                        height=18. / 60)
            format_ticks_and_labels(im, invert=invert)
            im.ticks.hide()
            im.tick_labels.hide()
            im.axis_labels.hide()

        most = fits.open(XMMPATH + '/../most/G309.2-0.6.fits')
        lev = [1e-2]
        lev_color = 'cyan'
        if invert:
            lev_color = 'gray'
        for im in [mg_line, si_line, s_line, mg_eqw, si_eqw, s_eqw]:
            im.show_contour(data=most, levels=lev, colors=lev_color, alpha=0.7)

        text_color = 'white'
        if invert:
            text_color = 'black'

        if invert:
            mg_line.add_label(0.96,
                              0.92,
                              '1.3--1.4 keV',
                              relative=True,
                              horizontalalignment='right',
                              size='small',
                              color='black')
            si_line.add_label(0.96,
                              0.92,
                              '1.8--1.9 keV',
                              relative=True,
                              horizontalalignment='right',
                              size='small',
                              color='black')
            s_line.add_label(0.96,
                             0.92,
                             '2.4--2.5 keV',
                             relative=True,
                             horizontalalignment='right',
                             size='small',
                             color='black')
        else:
            mg_line.add_label(0.96,
                              0.92,
                              '1.3--1.4 keV',
                              relative=True,
                              horizontalalignment='right',
                              size='small',
                              color='black',
                              backgroundcolor='white')
            si_line.add_label(0.96,
                              0.92,
                              '1.8--1.9 keV',
                              relative=True,
                              horizontalalignment='right',
                              size='small',
                              color='black',
                              backgroundcolor='white')
            s_line.add_label(0.96,
                             0.92,
                             '2.4--2.5 keV',
                             relative=True,
                             horizontalalignment='right',
                             size='small',
                             color='black',
                             backgroundcolor='white')

        # MEH -- too awkward.


#        mg_line.add_label(0.96, 0.78, '1.3--1.4 keV', relative=True, horizontalalignment='right', size='small', color=text_color)
#        si_line.add_label(0.96, 0.78, '1.8--1.9 keV', relative=True, horizontalalignment='right', size='small', color=text_color)
#        s_line.add_label( 0.96, 0.78, '2.4--2.5 keV', relative=True, horizontalalignment='right', size='small', color=text_color)

        mg_eqw.add_label(0.96,
                         0.92,
                         'Mg EW',
                         relative=True,
                         horizontalalignment='right',
                         size='small',
                         color=text_color)
        si_eqw.add_label(0.96,
                         0.92,
                         'Si EW',
                         relative=True,
                         horizontalalignment='right',
                         size='small',
                         color=text_color)
        s_eqw.add_label(0.96,
                        0.92,
                        'S EW',
                        relative=True,
                        horizontalalignment='right',
                        size='small',
                        color=text_color)

        mg_eqw.add_colorbar(location='bottom')
        mg_eqw.colorbar.set_font(size='small')
        #mg_eqw.colorbar.set_axis_label_text(r'Equivalent width, eV')
        #mg_eqw.colorbar.set_axis_label_font(size='small')
        mg_eqw.colorbar.set_ticks([0, 50, 100, 150, 200, 250])

        si_eqw.add_colorbar(location='bottom')
        si_eqw.colorbar.set_font(size='small')
        #si_eqw.colorbar.set_axis_label_text(r'Equivalent width, eV')
        #si_eqw.colorbar.set_axis_label_font(size='small')
        si_eqw.colorbar.set_ticks([0, 200, 400, 600, 800, 1000])

        s_eqw.add_colorbar(location='bottom')
        s_eqw.colorbar.set_font(size='small')
        #s_eqw.colorbar.set_axis_label_text(r'Equivalent width, eV')
        #s_eqw.colorbar.set_axis_label_font(size='small')
        s_eqw.colorbar.set_ticks([0, 200, 400, 600, 800, 1000])

        # Scalebar label commanding does not work :(
        #s_eqw.add_scalebar(1 * u.arcmin)  # 1 arcminute scalebar
        #s_eqw.scalebar.set_label('1 arcmin.')
        #s_eqw.scalebar.set_corner('top right')
        #s_eqw.scalebar.set_font(size='small')
        #if invert:
        #    s_eqw.scalebar.set_color('black')
        #else:
        #    s_eqw.scalebar.set_color('white')

        fig.tight_layout()
        fig.canvas.draw()
        if invert:
            plt.savefig('fig_lineflux_eqwidth_invert.pdf', dpi=300)
        else:
            plt.savefig('fig_lineflux_eqwidth.pdf', dpi=300)

    elif fig_num == '4':
        # RGB image of Mg line flux, Si/S eq width

        aplpy.make_rgb_image([
            XMMPATH + '/repro_merged/mg_lineflux_bin16_gauss2.fits',
            XMMPATH + '/repro_merged/si_eqwidth_bin16_gauss2.fits',
            XMMPATH + '/repro_merged/s_eqwidth_bin16_gauss2.fits'
        ],
                             'fig_rgb_soft_eqwidth.png',
                             vmin_r=1e-7,
                             vmax_r=1e-6,
                             stretch_r='log',
                             vmin_g=0,
                             vmax_g=800,
                             stretch_g='linear',
                             vmin_b=0,
                             vmax_b=800,
                             stretch_b='linear',
                             make_nans_transparent=True)

        fig = plt.figure(figsize=(3, 5))
        f = aplpy.FITSFigure(XMMPATH +
                             '/repro_merged/mg_lineflux_bin16_gauss2.fits',
                             figure=fig)
        f.recenter(ra2deg(13, 46, 40), -62.87, width=18. / 60, height=18. / 60)
        f.show_rgb('fig_rgb_soft_eqwidth.png')
        format_ticks_and_labels(f, invert=False)
        f.ticks.hide()
        f.tick_labels.hide()
        f.axis_labels.hide()

        most = fits.open(XMMPATH + '/../most/G309.2-0.6.fits')
        lev = [1e-2]
        lev_color = 'magenta'
        f.show_contour(data=most, levels=lev, colors=lev_color, alpha=0.7)

        f.show_regions('regs/core.reg')
        f.show_regions('regs/lobe_ne.reg')
        f.show_regions('regs/lobe_sw.reg')
        f.show_regions('regs/ridge_nw.reg')
        f.show_regions('regs/ridge_se.reg')

        f.add_label(0.52, 0.34, 'Core', relative=True, size=8, color='white')
        f.add_label(0.09,
                    0.74,
                    'Lobe NE',
                    relative=True,
                    size=8,
                    color='white')
        f.add_label(0.87,
                    0.75,
                    'Ridge NW',
                    relative=True,
                    size=8,
                    color='white')
        f.add_label(0.10,
                    0.22,
                    'Ridge SE',
                    relative=True,
                    size=8,
                    color='white')
        f.add_label(0.55,
                    0.05,
                    'Lobe SW',
                    relative=True,
                    size=8,
                    color='white')

        fig.tight_layout()
        fig.canvas.draw()
        plt.savefig('fig_rgb_soft_eqwidth.pdf', dpi=300)

    else:
        raise Exception("Invalid figure number")
Example #34
0
import time

dataset = pd.read_csv("dataset1.txt", header = None,delim_whitespace=True)

X = np.array(dataset[dataset.columns[0:dataset.shape[1]]])

x = np.array(dataset[dataset.columns[0:dataset.shape[1]-1]])
y =np.array(dataset[dataset.columns[dataset.shape[1]-1]])


from sklearn.cross_validation import train_test_split
from sklearn.cluster import KMeans

kmeans = KMeans()
kmeans = kmeans.fit(X)


k  = len(kmeans.cluster_centers_)

labels = kmeans.labels_
centroids = kmeans.cluster_centers_
from matplotlib import pyplot

for i in range(k):
    ds = X[np.where(labels==i)]
    pyplot.plot(ds[:,0],ds[:,1],'o')
    lines = pyplot.plot(centroids[i,0],centroids[i,1],'kx')
    pyplot.setp(lines,ms=15.0)
print("The number of clusters are ",k)
pyplot.savefig("plot3.png")
Example #35
0
fout.close()

# Loss variables
step_list = np.array(step_list)
train_loss_list = np.array(train_loss_list)
# for some reason, dev_loss_list.shape = [Ndev , 4]
dev_loss_list = np.array(dev_loss_list)

# Plot
plt.figure()
plt.plot(step_list, train_loss_list,    label='Train')
plt.plot(step_list, dev_loss_list[:,0], label='Dev')
plt.xlabel('Step')
plt.ylabel('Loss')
plt.legend(loc = 'upper right')
plt.savefig(f'figs/channel/loss2_{seed_no}.png', bbox_inches='tight')


plt.figure()
plt.semilogx(y_test * Re, b_pred[:,0,1],'x', label='TBNN')
plt.semilogx(y_raw * Re, bij_raw[:,0,1],'-',label='DNS')
plt.ylabel(r'$b_{12}$')
plt.xlabel(r'$y^+$')
plt.legend(loc='lower left')
plt.savefig(f'figs/channel/tbnn2_log_{seed_no}.png', bbox_inches='tight')

plt.figure()
plt.plot(y_test, b_pred[:,0,1],'x', label='TBNN')
plt.plot(y_raw, bij_raw[:,0,1],'-',label='DNS')
plt.ylabel(r'$b_{12}$')
plt.xlabel(r'$y$')
Example #36
0
def graph_sas_curve(filename, x, y, title_text, x_lab, y_lab,
                    x_min, x_max, y_min, y_max, **kwargs):
    """
    Outputs graph of x and y to a pdf file. x and y are intended to be functions
    of the magnitude of scattering vector, q, and intensity, I. Values that are
    computed from the graph (outputs)
    and range of R? * qfit written on graph

    @type  x:             numpy array
    @param x:             Function of the scattering vector magnitude, q, used for the
                          x-axis of the plot.
    @type  y:             numpy array
    @param y:             Function of the scattered intensity, I, used for the y-axis
                          of the plot.
    @type  x_lab:         string
    @param x_lab:         Label for the x-axis of the plot.
    @type  y_lab:         string
    @param y_lab:         Label for the y-axis of the plot.
    @type  x_min:         float
    @param x_min:         Minimum value to plot on x-axis.
    @type  x_max:         float
    @param x_max:         Maximum value to plot on x-axis.
    @type  y_min:         float
    @param y_min:         Minimum value to plot on x-axis.
    @type  y_max:         float
    @param y_max:         Maximum value to plot on x-axis.
    @keyword fit_coeffs:  Fit coefficients for a linear fit from a numpy polyfit
                          of the input x and y values.
    @keyword outputs:     Text of values that should be added to plot (e.g. Rg).
    @keyword rq_range:    Text detailing the R*q values over the range of any
                          fit performed on the x, y values.
    @keyword mask:        Numpy style mask to select points used in fit so that
                          these can be highlighted in the plot.
    """

    fit_coeffs = kwargs.get('fitcoeffs', None)
    outputs = kwargs.get('outputs', None)
    rq_range = kwargs.get('rqrange', None)
    mask = kwargs.get('mask', None)

    # Plot the input x, y values and if provided a fit line
    # output is used to display values calculated from fit (Rg, Rxs?, R?*q over
    # fit values) on the plot

    plt.figure(figsize=(8, 6), dpi=300)

    ax = plt.subplot(111, xlabel=x_lab, ylabel=y_lab, title=title_text,
                     xlim=(x_min, x_max), ylim=(y_min, y_max))

    plt.scatter(x, y, s=5)

    for item in ([ax.title, ax.xaxis.label, ax.yaxis.label]):
        item.set_fontsize(15)

    ax.tick_params(axis='both', which='major', labelsize=12)

    # Plot linear fit and highlight points used in its construction
    if fit_coeffs is not None:

        # Plot the fit line along the whole x range shown in teh plot
        fitLine = np.poly1d(fit_coeffs)
        x_points = np.linspace(x_min, x_max, 300)
        plt.plot(x_points, fitLine(x_points))

        # Highlight points used in the fit
        if mask is None:
            plt.scatter(x, y, s=30)
        else:
            plt.scatter(x[mask], y[mask], s=30)

        plt.annotate(outputs + '\n' + rq_range, xy=(0.45, 0.85),
                     xycoords='axes fraction')

    plt.savefig(filename)
Example #37
0
def run(n_neurons=60, t=10, t_test=10, n_trains=10, n_encodes=20, n_tests=10, 
        f=DoubleExp(1e-3, 3e-2), f_out=DoubleExp(1e-3, 1e-1), 
        dt=0.001, neuron_type=LIF(), reg=1e-2, penalty=0.5, load_w=None, load_df=None):

    d_ens = np.zeros((n_neurons, 1))
    f_ens = f
    w_ens = None
    e_ens = None
    w_ens2 = None
    e_ens2 = None
    f_smooth = DoubleExp(1e-2, 2e-1)
    print('\nNeuron Type: %s'%neuron_type)

    if isinstance(neuron_type, DurstewitzNeuron):
        if load_w:
            w_ens = np.load(load_w)['w_ens']
        else:
            print('Optimizing ens1 encoders')
            for nenc in range(n_encodes):
                print("encoding trial %s"%nenc)
                stim_func1, stim_func2 = make_normed_flipped(value=1.4, t=t, N=1, f=f, seed=nenc)
                data = go(d_ens, f_ens, n_neurons=n_neurons, t=t, f=f, stim_func1=stim_func1, stim_func2=stim_func2, neuron_type=neuron_type, w_ens=w_ens, e_ens=e_ens, L=True)
                w_ens = data['w_ens']            
                e_ens = data['e_ens']   
                np.savez('data/multiply_w.npz', w_ens=w_ens, e_ens=e_ens)
                
                fig, ax = plt.subplots()
                sns.distplot(np.ravel(w_ens), ax=ax)
                ax.set(xlabel='weights', ylabel='frequency')
                plt.savefig("plots/tuning/multiply_%s_w_ens.pdf"%neuron_type)
                
                a_ens = f_smooth.filt(data['ens'], dt=dt)
                a_supv = f_smooth.filt(data['supv'], dt=dt)
                for n in range(n_neurons):
                    fig, ax = plt.subplots(1, 1)
                    ax.plot(data['times'], a_supv[:,n], alpha=0.5, label='supv')
                    ax.plot(data['times'], a_ens[:,n], alpha=0.5, label='ens')
                    ax.set(ylim=((0, 40)))
                    plt.legend()
                    plt.savefig('plots/tuning/multiply_ens_nenc_%s_activity_%s.pdf'%(nenc, n))
                    plt.close('all')

    if load_df:
        load = np.load(load_df)
        d_ens = load['d_ens']
        d_out1 = load['d_out1']
        taus_ens = load['taus_ens']
        taus_out1 = load['taus_out1']
        f_ens = DoubleExp(taus_ens[0], taus_ens[1])
        f_out1 =  DoubleExp(taus_out1[0], taus_out1[1])
    else:
        print('Optimizing ens1 filters and decoders')
        stim_func1, stim_func2 = make_normed_flipped(value=1.2, t=t, N=n_trains, f=f, seed=0)
        data = go(d_ens, f_ens, n_neurons=n_neurons, t=t*n_trains, f=f, dt=dt, neuron_type=neuron_type,
            stim_func1=stim_func1, stim_func2=stim_func2, w_ens=w_ens)
        d_ens, f_ens, taus_ens = df_opt(data['x'][:,0]*data['x'][:,1], data['ens'], f, dt=dt, penalty=penalty, reg=reg, name='multiply_%s'%neuron_type)
        d_ens = d_ens.reshape((n_neurons, 1))
        d_out1, f_out1, taus_out1 = df_opt(data['x'], data['ens'], f_out, dt=dt, name='multiply_%s'%neuron_type)
        np.savez('data/multiply_%s_df.npz'%neuron_type, d_ens=d_ens, taus_ens=taus_ens, d_out1=d_out1, taus_out1=taus_out1)

        times = np.arange(0, 1, 0.0001)
        fig, ax = plt.subplots()
        ax.plot(times, f.impulse(len(times), dt=0.0001), label=r"$f^x, \tau_1=%.3f, \tau_2=%.3f$" %(-1./f.poles[0], -1./f.poles[1]))
        ax.plot(times, f_ens.impulse(len(times), dt=0.0001), label=r"$f^{ens}, \tau_1=%.3f, \tau_2=%.3f, d: %s/%s$"
           %(-1./f_ens.poles[0], -1./f_ens.poles[1], np.count_nonzero(d_ens), n_neurons))
        ax.set(xlabel='time (seconds)', ylabel='impulse response', ylim=((0, 10)))
        ax.legend(loc='upper right')
        plt.tight_layout()
        plt.savefig("plots/multiply_%s_filters_ens.pdf"%neuron_type)

        times = np.arange(0, 1, 0.0001)
        fig, ax = plt.subplots()
        ax.plot(times, f_out.impulse(len(times), dt=0.0001), label=r"$f^{out}, \tau=%.3f, \tau_2=%.3f$" %(-1./f_out.poles[0], -1./f_out.poles[1]))
        ax.plot(times, f_out1.impulse(len(times), dt=0.0001), label=r"$f^{out1}, \tau_1=%.3f, \tau_2=%.3f, d: %s/%s$"
           %(-1./f_out1.poles[0], -1./f_out1.poles[1], np.count_nonzero(d_out1), n_neurons))
        ax.set(xlabel='time (seconds)', ylabel='impulse response', ylim=((0, 10)))
        ax.legend(loc='upper right')
        plt.tight_layout()
        plt.savefig("plots/multiply_%s_filters_out1.pdf"%neuron_type)

        a_ens = f_ens.filt(data['ens'], dt=dt)
        x = f.filt(data['x'][:,0]*data['x'][:,1], dt=dt).ravel()
        xhat_ens = np.dot(a_ens, d_ens).ravel()
        rmse_ens = rmse(xhat_ens, x)
        fig, ax = plt.subplots()
        ax.plot(data['times'], x, linestyle="--", label='x')
        ax.plot(data['times'], xhat_ens, label='ens, rmse=%.3f' %rmse_ens)
        ax.set(xlabel='time (s)', ylabel=r'$\mathbf{x}$', title="train ens1")
        plt.legend(loc='upper right')
        plt.savefig("plots/multiply_%s_ens1_train.pdf"%neuron_type)

        a_ens = f_out1.filt(data['ens'], dt=dt)
        x_out = f_out.filt(data['x'], dt=dt)
        xhat_ens_out = np.dot(a_ens, d_out1)
        rmse_ens_out1 = rmse(xhat_ens_out[:,0], x_out[:,0])
        rmse_ens_out2 = rmse(xhat_ens_out[:,1], x_out[:,1])
        fig, ax = plt.subplots()
        ax.plot(data['times'], x_out[:,0], linestyle="--", label='x_0')
        ax.plot(data['times'], x_out[:,1], linestyle="--", label='x_1')
        ax.plot(data['times'], xhat_ens_out[:,0], label='ens_0, rmse=%.3f' %rmse_ens_out1)
        ax.plot(data['times'], xhat_ens_out[:,1], label='ens_1, rmse=%.3f' %rmse_ens_out2)
        ax.set(xlabel='time (s)', ylabel=r'$\mathbf{x}$', title="train ens1")
        plt.legend(loc='upper right')
        plt.savefig("plots/multiply_%s_ens1_out_train.pdf"%neuron_type)

    if isinstance(neuron_type, DurstewitzNeuron):
        if load_w:
            w_ens2 = np.load(load_w)['w_ens2']
        else:
            print('Optimizing ens2 encoders')
            for nenc in range(n_encodes):
                print("encoding trial %s"%nenc)
                stim_func1, stim_func2 = make_normed_flipped(value=1.4, t=t, N=1, f=f, seed=nenc)
                data = go(d_ens, f_ens, n_neurons=n_neurons, t=t, f=f, stim_func1=stim_func1, stim_func2=stim_func2, neuron_type=neuron_type, w_ens=w_ens, w_ens2=w_ens2, e_ens2=e_ens2, L2=True)
                w_ens2 = data['w_ens2']            
                e_ens2 = data['e_ens2']   
                np.savez('data/multiply_w.npz', w_ens=w_ens, e_ens=e_ens, w_ens2=w_ens2, e_ens2=e_ens2)

                fig, ax = plt.subplots()
                sns.distplot(np.ravel(w_ens2), ax=ax)
                ax.set(xlabel='weights', ylabel='frequency')
                plt.savefig("plots/tuning/multiply_%s_w_ens2.pdf"%neuron_type)

                a_ens = f_smooth.filt(data['ens2'], dt=dt)
                a_supv = f_smooth.filt(data['supv2'], dt=dt)
                for n in range(30):
                    fig, ax = plt.subplots(1, 1)
                    ax.plot(data['times'], a_supv[:,n], alpha=0.5, label='supv2')
                    ax.plot(data['times'], a_ens[:,n], alpha=0.5, label='ens2')
                    ax.set(ylim=((0, 40)))
                    plt.legend()
                    plt.savefig('plots/tuning/multiply_ens2_nenc_%s_activity_%s.pdf'%(nenc, n))
                    plt.close('all')

    if load_df:
        load = np.load(load_df)
        d_out2 = load['d_out2']
        taus_out2 = load['taus_out2']
        f_out2 = DoubleExp(taus_out2[0], taus_out2[1])
    else:
        print('Optimizing ens2 filters and decoders')
        stim_func1, stim_func2 = make_normed_flipped(value=1.2, t=t, N=n_trains, f=f, seed=0)
        data = go(d_ens, f_ens, n_neurons=n_neurons, t=t*n_trains, f=f, dt=dt, neuron_type=neuron_type,
            stim_func1=stim_func1, stim_func2=stim_func2, w_ens=w_ens, w_ens2=w_ens2)
        d_out2, f_out2, taus_out2  = df_opt(data['x2'], data['ens2'], f_out, dt=dt, name='multiply_%s'%neuron_type)
        np.savez('data/multiply_%s_df.npz'%neuron_type, d_ens=d_ens, taus_ens=taus_ens, d_out1=d_out1, taus_out1=taus_out1, d_out2=d_out2, taus_out2=taus_out2)

        times = np.arange(0, 1, 0.0001)
        fig, ax = plt.subplots()
        ax.plot(times, f_out.impulse(len(times), dt=0.0001), label=r"$f^{out}, \tau=%.3f, \tau_2=%.3f$" %(-1./f_out.poles[0], -1./f_out.poles[1]))
        ax.plot(times, f_out2.impulse(len(times), dt=0.0001), label=r"$f^{out2}, \tau_1=%.3f, \tau_2=%.3f, d: %s/%s$"
           %(-1./f_out2.poles[0], -1./f_out2.poles[1], np.count_nonzero(d_out2), 30))
        ax.set(xlabel='time (seconds)', ylabel='impulse response', ylim=((0, 10)))
        ax.legend(loc='upper right')
        plt.tight_layout()
        plt.savefig("plots/multiply_%s_filters_out2.pdf"%neuron_type)

        a_ens2 = f_out2.filt(data['ens2'], dt=dt)
        x2 = f_out.filt(data['x2'], dt=dt)
        xhat_ens2 = np.dot(a_ens2, d_out2)
        rmse_ens2 = rmse(xhat_ens2, x2)
        fig, ax = plt.subplots()
        ax.plot(data['times'], x2, linestyle="--", label='x')
        ax.plot(data['times'], xhat_ens2, label='ens2, rmse=%.3f' %rmse_ens2)
        ax.set(xlabel='time (s)', ylabel=r'$\mathbf{x}$', title="train ens2")
        plt.legend(loc='upper right')
        plt.savefig("plots/multiply_%s_ens2_train.pdf"%neuron_type)


    rmses_ens = np.zeros((n_tests))
    rmses_ens_out = np.zeros((n_tests))
    rmses_ens2 = np.zeros((n_tests))
    for test in range(n_tests):
        print('test %s' %test)
        stim_func1, stim_func2 = make_normed_flipped(value=1.0, t=t_test, N=1, f=f, seed=100+test)
        data = go(d_ens, f_ens, n_neurons=n_neurons, t=t_test, f=f, dt=dt, neuron_type=neuron_type,
            stim_func1=stim_func1, stim_func2=stim_func2, w_ens=w_ens, w_ens2=w_ens2)

        a_ens = f_ens.filt(data['ens'], dt=dt)
        x = f.filt(data['x'][:,0]*data['x'][:,1], dt=dt).ravel()
        xhat_ens = np.dot(a_ens, d_ens).ravel()
        rmse_ens = rmse(xhat_ens, x)

        a_ens_out = f_out1.filt(data['ens'], dt=dt)
        x_out = f_out.filt(data['x'], dt=dt)
        xhat_ens_out = np.dot(a_ens, d_out1)
        rmse_ens_out = rmse(xhat_ens_out, x_out)
        rmse_ens_out1 = rmse(xhat_ens_out[:,0], x_out[:,0])
        rmse_ens_out2 = rmse(xhat_ens_out[:,1], x_out[:,1])

        a_ens2 = f_out2.filt(data['ens2'], dt=dt)
        x2 = f_out.filt(data['x2'], dt=dt)
        xhat_ens2 = np.dot(a_ens2, d_out2)
        rmse_ens2 = rmse(xhat_ens2, x2)
        rmses_ens[test] = rmse_ens
        rmses_ens_out[test] = rmse_ens_out
        rmses_ens2[test] = rmse_ens2        
    
        fig, ax = plt.subplots()
        ax.plot(data['times'], x_out[:,0], linestyle="--", label='x_0')
        ax.plot(data['times'], x_out[:,1], linestyle="--", label='x_1')
        ax.plot(data['times'], xhat_ens_out[:,0], label='ens_0, rmse=%.3f' %rmse_ens_out1)
        ax.plot(data['times'], xhat_ens_out[:,1], label='ens_1, rmse=%.3f' %rmse_ens_out2)
        ax.set(xlabel='time (s)', ylabel=r'$\mathbf{x}$', title="test ens1 out")
        plt.legend(loc='upper right')
        plt.savefig("plots/multiply_%s_ens1_out_test_%s.pdf"%(neuron_type, test))
        
        fig, ax = plt.subplots()
        ax.plot(data['times'], x, linestyle="--", label='x')
        ax.plot(data['times'], xhat_ens, label='ens, rmse=%.3f' %rmse_ens)
        ax.set(xlabel='time (s)', ylabel=r'$\mathbf{x}$', title="test ens1")
        plt.legend(loc='upper right')
        plt.savefig("plots/multiply_%s_ens1_test_%s.pdf"%(neuron_type, test))
        
        fig, ax = plt.subplots()
        ax.plot(data['times'], x2, linestyle="--", label='x')
        ax.plot(data['times'], xhat_ens2, label='ens2, rmse=%.3f' %rmse_ens2)
        ax.set(xlabel='time (s)', ylabel=r'$\mathbf{x}$', title="test ens2")
        plt.legend(loc='upper right')
        plt.savefig("plots/multiply_%s_ens2_test_%s.pdf"%(neuron_type, test))
        plt.close('all')

    mean_ens = np.mean(rmses_ens)
    mean_ens_out = np.mean(rmses_ens_out)
    mean_ens2 = np.mean(rmses_ens2)
    CI_ens = sns.utils.ci(rmses_ens)
    CI_ens_out = sns.utils.ci(rmses_ens_out)
    CI_ens2 = sns.utils.ci(rmses_ens2)
    
    fig, ax = plt.subplots()
    sns.barplot(data=rmses_ens2)
    ax.set(ylabel='RMSE', title="mean=%.3f, CI=%.3f-%.3f"%(mean_ens2, CI_ens2[0], CI_ens2[1]))
    plt.xticks()
    plt.savefig("plots/multiply_%s_rmse.pdf"%neuron_type)

    print('rmses: ', rmses_ens, rmses_ens_out, rmses_ens2)
    print('means: ', mean_ens, mean_ens_out, mean_ens2)
    print('confidence intervals: ', CI_ens, CI_ens_out, CI_ens2)
    np.savez('data/multiply_%s_results.npz'%neuron_type, rmses_ens=rmses_ens, rmses_ens_out=rmses_ens_out, rmses_ens2=rmses_ens2)
    return rmses_ens2
Example #38
0
		for i in xrange(M):
			plt.scatter(Xdd[i],Ydd[i],c = colors[i], facecolor='0.5', lw = 0,label = 'cluster'+str(i+1));

		plt.scatter(train1[:,0],train1[:,1],c = 'k',label = 'train class 1');
		plt.scatter(train2[:,0],train2[:,1],c = 'r',label = 'train class 2');

		plt.xlabel('Feature 1')
		plt.ylabel('Feature 2')
		plt.title('Dataset5, k means clustering,iteration:'+str(iter)+'clusters = '+str(M))
		plt.legend(loc='best')

		plt.xlim(xx.min(), xx.max())
		plt.ylim(yy.min(), yy.max())
		plt.xticks(())
		plt.yticks(())
		plt.savefig("kmeansnormal1(b)"+str(iter)+"-"+str(M)+".png", bbox_inches='tight')
		plt.close(fig)
	z = np.zeros((N,M))
	for n in xrange(N):
		minindex = 0
		minval = LA.norm(np.subtract(X_train[n],mu[0])) 
		for i in xrange(M):
			a = LA.norm(np.subtract(X_train[n],mu[i]))
			if(minval>a):
				minval = a
				minindex = i
		z[n][minindex] = 1

	newmu = np.zeros((M,size[1]))

	flag = 0
Example #39
0
n = 10
plt.figure(figsize=(20, 4))
for i in range(1, n):
    # display original
    ax = plt.subplot(2, n, i)
    plt.imshow(x_train[i+4*13*150].reshape(32, 32, 3))
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)

    # display reconstruction
    ax = plt.subplot(2, n, i + n)
    plt.imshow(x_train_noisy[i+4*13*150].reshape(32, 32, 3))
    ax.get_xaxis().set_visible(False)
    ax.get_yaxis().set_visible(False)
plt.show()
plt.savefig('saves/cdA_gblur_noisy_vis.png')

"""Constructing the Model"""
import keras
from keras import losses
from keras.models import Model, load_model
from keras.layers import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D, concatenate

L = 5  # Total number of layers
S = 2  # Number of shared layers
F = [16, 32, 64, 128, 256]     # Number of clean filters including input

# Clean different encoding layers
inp = Input(shape=(32, 32, 3))
enc = inp
for i in range(L-S):
Example #40
0
ax1.spines['bottom'].set_position(('data', 0.0))
ax1.spines['top'].set_color('none')

# buffer layer annotation
#ax1.axvspan(5.0, 30.0, ymin=0.049, alpha=1.0, color=Grey, zorder=0)
#ax1.axvline(x=5.0, color=Grey)
#ax1.axvline(x=30.0, color=Grey)
ax1.text(6.5, 0.15,
         r"Buffer layer")  # , color=Grey) # bbox=dict(facecolor=Grey))
ax1.annotate(s='',
             xy=(5.0, 0.11),
             xytext=(30.0, 0.11),
             arrowprops=dict(arrowstyle='|-|',
                             linewidth=0.75,
                             shrinkA=0.0,
                             shrinkB=0.0,
                             edgecolor=Grey))

# plot mode interactive (1) or pdf (2)
if plot != 2:
    plt.tight_layout()
    plt.show()
else:
    fig.tight_layout()
    #fnam = fnam.replace(".dat", "viscous.pdf")
    plt.savefig(fnamout, transparent=True)
    print('Written file:', fnamout)

fig.clf()
print("Done!")
Example #41
0
def plot(rewards):
    clear_output(True)
    plt.figure(figsize=(20, 5))
    plt.plot(rewards)
    plt.savefig('td3_lstm.png')
 def _plot_and_save_attention(self, att_w, filename):
     plt = self.draw_attention_plot(att_w)
     plt.savefig(filename)
     plt.close()
Example #43
0
        d_mean_list.append( dagger_results['returns']['mean'] )
        d_std_list.append( dagger_results['returns']['std'] )        
            

    c_mean_dict[envname] = np.array(c_mean_list, dtype = np.float32)
    c_std_dict[envname] = np.array(c_std_list, dtype = np.float32)

    d_mean_dict[envname] = np.array(d_mean_list, dtype = np.float32)
    d_std_dict[envname] = np.array(d_std_list, dtype = np.float32)    

    expert_results_fname = os.path.join(expert_results_folder, 'train_' + envname +'.pkl')  
    with open(expert_results_fname, 'rb') as f:
        expert_results = pickle.loads(f.read()) 
    e_mean = np.array(expert_results['returns']['mean'])

    lines0 = plt.errorbar(x, c_mean_dict[envname], c_std_dict[envname],color='r', linewidth=2.0, label='Behavioral Cloning')

    lines1 = plt.errorbar(x, d_mean_dict[envname], d_std_dict[envname], color='g', linewidth=2.0, label='Dagger')

    lines2 = plt.plot(x, e_mean * np.ones_like(d_mean_dict[envname]) )
    plt.setp(lines2, color='b', linewidth=2.0, label='Expert')        

    plt.ylabel('Reward')
    plt.xlabel('# rollouts/ Dagger iterations')    

    plt.legend()

    plt.savefig(os.path.join(out_folder,'%s.png'%(envname)), bbox_inches='tight')

    plt.clf()
                   label=False)
        ax3.set_title('d={}'.format(d_list[2]))

        fig.subplots_adjust(left=None,
                            bottom=None,
                            right=None,
                            top=None,
                            wspace=None,
                            hspace=None)
        fig.legend(loc="lower right", ncol=3)
        fig.text(0.5,
                 0.04,
                 'number of iterations \n ({} pass x {} samples)'.format(1, N),
                 ha='center')
        fig.suptitle('Sharp prior:' + r'$\sigma_0={}$'.format(sigma0))
        plt.savefig('./outputs/KL_HighDim_sharpPrior')

    if 'HD2' in Test:
        # sensitivity to dimension with Flat prior sigma0=1
        sigma0 = 30
        mu0 = 0
        d_list = [30, 70, 100]
        N = 500
        s = 2
        c = 0
        seed = 10

        fig = plt.figure(num, figsize=set_size(ratio=0.5))
        num = num + 1
        ax1 = fig.add_subplot(131)
        XP_HighDim(np.array([ax1]),
Example #45
0
def main(weather_data_dir, katkam_dir):

    weather_files = os.listdir(weather_data_dir)
    df = pd.concat((pd.read_csv(os.path.join(weather_data_dir, f), header=14, parse_dates=['Date/Time']) for f in weather_files))
    df = df[df['Weather'].notnull()]
    weather_df = df[['Date/Time', 'Time', 'Weather']].copy()
    images = katkam_dir + '/*.*'
    x_images = io.imread_collection(images)
    images = pd.DataFrame({'filename': x_images.files, 'img': np.arange(0, len(x_images.files)) })
    images['Date/Time'] = pd.to_datetime(images['filename'].str.extract('-([0-9]+)\.', expand=False), format='%Y%m%d%H%M%S')
    images = images.merge(weather_df, on='Date/Time')
    images['Weather'] = images['Weather'].apply(transform_weather)

    data = []
    target = []
    filenames = []

    # need to do this for loop to get the images out of x_images or else we'd need to load the whole
    # x_images array instead of just the images we have data for
    for i, x in images.iterrows():
        matrix = rgb2gray(x_images[x['img']])
        matrix = np.reshape(matrix, (192*256))
        data.append(matrix)
        target.append(x['Weather'].split(','))
        filenames.append(x['filename'])

    mlb = MultiLabelBinarizer()
    y_enc = mlb.fit_transform(target)

    X_train, X_test, y_train, y_test, idx1, idx2 = train_test_split(np.array(data), y_enc, np.array(filenames))

    model = make_pipeline(
        PCA(250),
        KNeighborsClassifier(n_neighbors=15)
    )

    model.fit(X_train, y_train)
    predicted = model.predict(X_test)
    print("KNN Model Score: %f" % model.score(X_test, y_test))
    result = np.empty(predicted.shape[0], dtype=np.bool)

    for i, (x,y) in enumerate(zip(predicted, y_test)):
        result[i] = np.array_equal(x,y)

    wrong = mlb.inverse_transform(predicted[~result])
    real = mlb.inverse_transform(y_test[~result])
    results_df = pd.DataFrame({'filename': idx2[~result], 'predicted': wrong, 'actual': real})
    aggregated = results_df.groupby(['predicted', 'actual']).count().rename(columns={'filename': 'Predicted Incorrectly'})
    aggregated.plot.bar()
    plt.tight_layout()
    plt.legend()
    plt.savefig('errors.png')

    correct = mlb.inverse_transform(predicted[result])
    real = mlb.inverse_transform(y_test[result])
    results_df = pd.DataFrame({'filename': idx2[result], 'predicted': correct, 'actual': real})
    aggregated = results_df.groupby(['predicted', 'actual']).count().rename(columns={'filename': 'Predicted Correctly'})
    aggregated.plot.bar()
    plt.tight_layout()
    plt.legend()
    plt.savefig('correct.png')
Example #46
0
    ax[0].set_ylabel("Total A \n Concentration \n [mol/L]",fontsize=15)
    ax[1].set_ylabel("Total A \n Sorbed Concent. \n [mol/m3]",fontsize=15)

    ax[2].set_title("Langmuir and Freundlich sorption models",fontsize=15)
    ax[3].set_xlabel("Distance (m)",fontsize=15)
    ax[2].set_ylabel("Total B, C \n Concentration \n [mol/L]",fontsize=15)
    ax[3].set_ylabel("Total B, C \n Sorbed Concent. \n [mol/m3]",fontsize=15)

    ax[0].legend(loc='upper right',fontsize=10)
    ax[1].legend(loc='upper right',fontsize=10)
    ax[0].set_xlim(left=30,right=70)
    ax[1].set_xlim(left=30,right=70)

    ax[2].legend(loc='upper right',fontsize=10)
    ax[3].legend(loc='upper right',fontsize=8)
    ax[2].set_xlim(left=30,right=70)
    ax[3].set_xlim(left=30,right=70)

    # plot adjustments
    plt.tight_layout() 
    plt.subplots_adjust(left=0.20,bottom=0.15,right=0.95,top=0.90)
    plt.suptitle("Amanzi 1D "+root.title()+" Benchmark at 50 years",x=0.57,fontsize=20)
    plt.tick_params(axis='both', which='major', labelsize=15)

    # pyplot.show()
    plt.savefig(root+"_1d.png",format="png")
    # plt.close()

    # finally:
    #     pass 
Example #47
0
	for site in datasetObjects:
		print site, datasetObjects[site].data
		x = datasetObjects[site].getAgeValues()
		y = datasetObjects[site].getElevationValues()
		
		n = len(datasetObjects[site].getAgeValues())
		
		plt.plot(x, y, mapSiteToColour(site) + 's', label=site+" n=%i" % n, markersize=4.0)
		
		datasetModels[site] = siteModelConnectTheDots(datasetObjects[site])
	
	##plt.title("Plot of Elevation by Age\nRaw Data only")
	plt.ylabel('Elevation (m IGLD1985)')
	plt.xlabel('Age Before Present (years)')
	plt.legend(loc=2, prop={'size': 17})
	plt.savefig('./theDataRaw.png')
	plt.close()
	############################################################################
	



	############################################################################
	## create the raw plot with the model included #############################
	for ds in datasetObjects:
		print ds, datasetObjects[ds].data
		x = datasetObjects[ds].getAgeValues()
		y = datasetObjects[ds].getElevationValues()
		plt.plot(x, y, mapSiteToColour(ds) + 's', label="%s, n=%i" % (ds, len(x)), markersize=4.0)

	for d in datasets:
def main():
    with timer('load data'):
        df = pd.read_csv(FOLD_PATH)

    with timer('preprocessing'):
        train_df, val_df = df[df.fold_id != FOLD_ID], df[df.fold_id == FOLD_ID]

        train_augmentation = Compose([
            Flip(p=0.5),
            OneOf(
                [
                    #ElasticTransform(p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),
                    GridDistortion(p=0.5),
                    OpticalDistortion(p=0.5, distort_limit=2, shift_limit=0.5)
                ],
                p=0.5),
            #OneOf([
            #    ShiftScaleRotate(p=0.5),
            ##    RandomRotate90(p=0.5),
            #    Rotate(p=0.5)
            #], p=0.5),
            OneOf([
                Blur(blur_limit=8, p=0.5),
                MotionBlur(blur_limit=8, p=0.5),
                MedianBlur(blur_limit=8, p=0.5),
                GaussianBlur(blur_limit=8, p=0.5)
            ],
                  p=0.5),
            OneOf(
                [
                    #CLAHE(clip_limit=4, tile_grid_size=(4, 4), p=0.5),
                    RandomGamma(gamma_limit=(100, 140), p=0.5),
                    RandomBrightnessContrast(p=0.5),
                    RandomBrightness(p=0.5),
                    RandomContrast(p=0.5)
                ],
                p=0.5),
            OneOf([
                GaussNoise(p=0.5),
                Cutout(num_holes=10, max_h_size=10, max_w_size=20, p=0.5)
            ],
                  p=0.5)
        ])
        val_augmentation = None

        train_dataset = SeverDataset(train_df,
                                     IMG_DIR,
                                     IMG_SIZE,
                                     N_CLASSES,
                                     id_colname=ID_COLUMNS,
                                     transforms=train_augmentation)
        val_dataset = SeverDataset(val_df,
                                   IMG_DIR,
                                   IMG_SIZE,
                                   N_CLASSES,
                                   id_colname=ID_COLUMNS,
                                   transforms=val_augmentation)
        train_loader = DataLoader(train_dataset,
                                  batch_size=BATCH_SIZE,
                                  shuffle=True,
                                  num_workers=2)
        val_loader = DataLoader(val_dataset,
                                batch_size=BATCH_SIZE,
                                shuffle=False,
                                num_workers=2)

        del train_df, val_df, df, train_dataset, val_dataset
        gc.collect()

    with timer('create model'):
        model = smp.Unet('densenet201',
                         encoder_weights='imagenet',
                         classes=N_CLASSES)
        model.to(device)

        criterion = torch.nn.BCEWithLogitsLoss()
        optimizer = torch.optim.Adam(model.parameters(), lr=3e-4)
        scheduler_cosine = CosineAnnealingLR(optimizer,
                                             T_max=CLR_CYCLE,
                                             eta_min=3e-5)
        scheduler = GradualWarmupScheduler(optimizer,
                                           multiplier=1.1,
                                           total_epoch=CLR_CYCLE * 2,
                                           after_scheduler=scheduler_cosine)

        model, optimizer = amp.initialize(model,
                                          optimizer,
                                          opt_level="O1",
                                          verbosity=0)

    with timer('train'):
        train_losses = []
        valid_losses = []

        best_model_loss = 999
        best_model_ep = 0
        checkpoint = 0

        for epoch in range(1, EPOCHS + 1):
            if epoch % (CLR_CYCLE * 2) == 0:
                if epoch != 0:
                    y_val = y_val.reshape(-1, N_CLASSES, IMG_SIZE[0],
                                          IMG_SIZE[1])
                    best_pred = best_pred.reshape(-1, N_CLASSES, IMG_SIZE[0],
                                                  IMG_SIZE[1])
                    for i in range(N_CLASSES):
                        th, score, _, _ = search_threshold(
                            y_val[:, i, :, :], best_pred[:, i, :, :])
                        LOGGER.info(
                            'Best loss: {} Best Dice: {} on epoch {} th {} class {}'
                            .format(round(best_model_loss, 5), round(score, 5),
                                    best_model_ep, th, i))
                checkpoint += 1
                best_model_loss = 999

            LOGGER.info("Starting {} epoch...".format(epoch))
            tr_loss = train_one_epoch(model, train_loader, criterion,
                                      optimizer, device)
            train_losses.append(tr_loss)
            LOGGER.info('Mean train loss: {}'.format(round(tr_loss, 5)))

            valid_loss, val_pred, y_val = validate(model, val_loader,
                                                   criterion, device)
            valid_losses.append(valid_loss)
            LOGGER.info('Mean valid loss: {}'.format(round(valid_loss, 5)))

            scheduler.step()

            if valid_loss < best_model_loss:
                torch.save(
                    model.state_dict(),
                    '{}_fold{}_ckpt{}.pth'.format(EXP_ID, FOLD_ID, checkpoint))
                best_model_loss = valid_loss
                best_model_ep = epoch
                best_pred = val_pred

            del val_pred
            gc.collect()

    with timer('eval'):
        y_val = y_val.reshape(-1, N_CLASSES, IMG_SIZE[0], IMG_SIZE[1])
        best_pred = best_pred.reshape(-1, N_CLASSES, IMG_SIZE[0], IMG_SIZE[1])
        for i in range(N_CLASSES):
            th, score, _, _ = search_threshold(y_val[:, i, :, :],
                                               best_pred[:, i, :, :])
            LOGGER.info(
                'Best loss: {} Best Dice: {} on epoch {} th {} class {}'.
                format(round(best_model_loss, 5), round(score, 5),
                       best_model_ep, th, i))

    xs = list(range(1, len(train_losses) + 1))
    plt.plot(xs, train_losses, label='Train loss')
    plt.plot(xs, valid_losses, label='Val loss')
    plt.legend()
    plt.xticks(xs)
    plt.xlabel('Epochs')
    plt.savefig("loss.png")
Example #49
0
def get_thresholds(in_dat,
                   interactive=False,
                   plot_events=False,
                   fig_path=None,
                   prefix=None):
    """Guess distance threshold for event filtering

    Analyse the events in the first million of Hi-C pairs in the library, plot
    the occurrences of each event type according to number of restriction
    fragments, and ask user interactively for the minimum threshold for uncuts
    and loops.

    Parameters
    ----------
    in_dat: str
        Path to the .pairs file containing Hi-C pairs.
    interactive: bool
        If True, plots are diplayed and thresholds are required interactively.
    plot_events : bool
        Whether to show the plot
    fig_path : str
        Path where the figure will be saved. If None, the figure will be
        diplayed interactively.
    prefix : str
        If the library has a name, it will be shown on plots.
    
    Returns
    -------
    dictionary
        dictionary with keys "uncuts" and "loops" where the values are the
        corresponding thresholds entered by the user.
    """
    thr_uncut = None
    thr_loop = None
    max_sites = 50
    # Map of event -> legend name of event for intrachromosomal pairs.
    legend = {
        "++": "++ (weird)",
        "--": "-- (weird)",
        "+-": "+- (uncuts)",
        "-+": "-+ (loops)",
    }
    colors = {"++": "#222222", "+-": "r", "--": "#666666", "-+": "tab:orange"}
    n_events = {event: np.zeros(max_sites) for event in legend}
    i = 0
    # open the file for reading (just the first 1 000 000 lines)
    with open(in_dat, "r") as pairs:
        for line in pairs:
            # Skip header lines
            if line.startswith("#"):
                continue
            i += 1
            # Only use the first million pairs to estimate thresholds
            if i == 1000000:
                break
            # Process Hi-C pair into a dictionary
            p = process_read_pair(line)
            # Type of event and number of restriction site between reads
            etype = p["type"]
            nsites = p["nsites"]
            # Count number of events for intrachrom pairs
            if etype != "inter" and nsites < max_sites:
                n_events[etype][nsites] += 1

    def plot_event(n_events, legend, name):
        """Plot the frequency of a given event types over distance."""
        plt.xlim([-0.5, 15])
        plt.plot(
            range(n_events[name].shape[0]),
            n_events[name],
            "o-",
            label=legend[name],
            linewidth=2.0,
            c=colors[name],
        )

    if interactive:
        # PLot:
        try:
            plt.figure(0)
            for event in legend:
                plot_event(n_events, legend, event)
            plt.grid()
            plt.xlabel("Number of restriction fragment(s)")
            plt.ylabel("Number of events")
            plt.yscale("log")
            plt.legend()
            plt.show(block=False)

        except Exception:
            logger.error(
                "Unable to show plots, skipping figure generation. Perhaps "
                "there is no Xserver running ? (might be due to windows "
                "environment). Try running without the interactive option.")

        # Asks the user for appropriate thresholds
        print(
            "Please enter the number of restriction fragments separating "
            "reads in a Hi-C pair below or at which loops and "
            "uncuts events will be excluded\n",
            file=sys.stderr,
        )
        thr_uncut = int(input("Enter threshold for the uncuts events (+-):"))
        thr_loop = int(input("Enter threshold for the loops events (-+):"))
        try:
            plt.clf()
        except Exception:
            pass
    else:
        # Estimate thresholds from data
        for event in n_events:
            fixed = n_events[event]
            fixed[fixed == 0] = 1
            n_events[event] = fixed

        all_events = np.log(np.array(list(n_events.values())))
        # Compute median occurences at each restriction sites
        event_med = np.median(all_events, axis=0)
        # Compute MAD, to have a robust estimator of the expected deviation
        # from median at long distances
        mad = np.median(abs(all_events - event_med))
        exp_stdev = mad / 0.67449
        # Iterate over sites, from furthest to frag+2
        for site in range(max_sites)[:1:-1]:
            # For uncuts and loops, keep the last (closest) site where the
            # deviation from other events <= expected_stdev
            if (abs(np.log(n_events["+-"][site]) - event_med[site]) <=
                    exp_stdev):
                thr_uncut = site
            if (abs(np.log(n_events["-+"][site]) - event_med[site]) <=
                    exp_stdev):
                thr_loop = site
        if thr_uncut is None or thr_loop is None:
            raise ValueError(
                "The threshold for loops or uncut could not be estimated. "
                "Please try running with -i to investigate the problem.")
        logger.info("Filtering with thresholds: uncuts={0} loops={1}".format(
            thr_uncut, thr_loop))
        if plot_events:
            try:
                plt.figure(1)
                plt.xlim([-0.5, 15])
                # Draw colored lines for events to discard
                plt.plot(
                    range(0, thr_uncut + 1),
                    n_events["+-"][:thr_uncut + 1],
                    "o-",
                    c=colors["+-"],
                    label=legend["+-"],
                )
                plt.plot(
                    range(0, thr_loop + 1),
                    n_events["-+"][:thr_loop + 1],
                    "o-",
                    c=colors["-+"],
                    label=legend["-+"],
                )
                plt.plot(
                    range(0, 2),
                    n_events["--"][:2],
                    "o-",
                    c=colors["--"],
                    label=legend["--"],
                )
                plt.plot(
                    range(0, 2),
                    n_events["++"][:2],
                    "o-",
                    c=colors["++"],
                    label=legend["++"],
                )
                # Draw black lines for events to keep
                plt.plot(
                    range(thr_uncut, n_events["+-"].shape[0]),
                    n_events["+-"][thr_uncut:],
                    "o-",
                    range(thr_loop, n_events["-+"].shape[0]),
                    n_events["-+"][thr_loop:],
                    "o-",
                    range(1, n_events["--"].shape[0]),
                    n_events["--"][1:],
                    "o-",
                    range(1, n_events["++"].shape[0]),
                    n_events["++"][1:],
                    "o-",
                    label="kept",
                    linewidth=2.0,
                    c="g",
                )
                plt.grid()
                plt.xlabel("Number of restriction site(s)")
                plt.ylabel("Number of events")
                plt.yscale("log")
                # Remove duplicate "kept" entries in legend
                handles, labels = plt.gca().get_legend_handles_labels()
                by_label = OrderedDict(zip(labels, handles))
                plt.legend(by_label.values(), by_label.keys())
                # Show uncut and loop threshold as vertical lines
                plt.axvline(x=thr_loop, color=colors["-+"])
                plt.axvline(x=thr_uncut, color=colors["+-"])

                if prefix:
                    plt.title(
                        "Library events by distance in {}".format(prefix))
                plt.tight_layout()
                if fig_path:
                    plt.savefig(fig_path)
                else:
                    plt.show(block=False)
                # plt.clf()

            except Exception:
                logger.error(
                    "Unable to show plots, skipping figure generation. Is "
                    "an X server running? (might be due to windows "
                    "environment). Try running without the plot option.")
    return thr_uncut, thr_loop
Example #50
0
def plotGradientConfidenceIntervals(giaRegressionsByCombo, keys, giaRegressionDescriptions, outputPathDict):
	def plotInterval(ax, y, xstart, xstop, intervalLabel, colord, colords):
		"""Plot interval at y from xstart to xstop with given color."""   
  
		ax.hlines(y, xstart, xstop, colords, lw=7)
		ax.hlines(y, xstart, xstop, colord, lw=3, label=intervalLabel)
		## plots the interval in the colours of both sites


	outputPath = convertListToRelativePath([outputPathDict[setting] for setting in getCurrentSettingOptions()])
	
	

	y = 0
	## used in spacing out the intervals for each site vertically through the
	## graph
	
	fig,ax = plt.subplots(1)
	
	for combo in keys:
		y += 1
		combo1 = combo.split('-')[0]
		combo2 = combo.split('-')[1].split(':')[0]
		order = combo.split('-')[1].split(':')[1]
		
		if(order == 'forward'):
			direct = combo1
			modelled = combo2
		else:
			direct = combo2
			modelled = combo1
			
		est = giaRegressionsByCombo[combo]['gradientEstimator']	
			
		ciStart = giaRegressionsByCombo[combo]['gradient'][0]
		ciEnd = giaRegressionsByCombo[combo]['gradient'][1]
		
		if(est < 0):
			est = -est
			ciStart = -ciStart
			ciEnd = -ciEnd
			
		if(order == 'forward'):
			plotInterval(ax, y, ciStart, ciEnd, "", mapSiteToColour(direct), mapSiteToColour(modelled))
		else:
			plotInterval(ax, y, ciStart, ciEnd, "",  mapSiteToColour(direct), mapSiteToColour(modelled))			
		
		
		ax.vlines(est, y+0.3, y-0.3, mapSiteToColour(direct), lw=4)
	ax.set_xlabel('GIA (m/year)')
	
	ax.set_xlim([0,0.009])

	plt.yticks(list(np.arange(1, len(keys)+1, 1.0)), [giaRegressionDescriptions[key] for key in keys], rotation=0)

	fileNameIdentifier = "_".join([outputPathDict[setting] for setting in getCurrentSettingOptions()])

	plt.title("95p Confidence intervals on GIA\nfilters: %s" % fileNameIdentifier)

	for item in ax.get_yticklabels():
		item.set_fontsize(8)
	
	outputFilePath = filePathOnRelativePath(outputPath+"gias/", fileName='intervals', ext="png")
	print "Saving gia intervals plot at '%s'" % outputFilePath
	verifyPath(outputPath+"gias/")
	

	
	plt.savefig(outputFilePath,bbox_inches='tight')





	outputFilePath = filePathOnRelativePath(outputPath+"gias/", fileName='%s_intervals' % fileNameIdentifier, ext="png")

	print "Saving gia intervals plot at '%s'" % outputFilePath

	plt.savefig(outputFilePath,bbox_inches='tight')

	plt.close()
Example #51
0
    gamma : float
        Width of Lorententzian component
    kt : float
        Thermal energy. If >0, will compute transitions from vibrationally
        excited states. Default 0.
    n_max : int
        Largest vibrational number in final manifold. If not supplied, a guess 
        is provided, but may not be adequate.
    m_max : int
        Largest vibrational number in orginal manifold. If not supplied, a guess
        is provided, but may not be adequate.
    """
    return amp*vibronic_ls(-x+x0, s, sigma, gamma, e_vib, kt=kt, **kw)


x = np.linspace(1.8, 2.5, 1000)
e0 = 2.17
s = 0.5
sigma = 0.01
gamma = 0.001
e_vib = 0.07
y1 = vibronic_emission(x, 1, e0, s, sigma, gamma, e_vib, 0)
y2 = vibronic_emission(x, 1, e0, s, sigma, gamma, e_vib, 0.025)
y3 = vibronic_emission(x, 1, e0, s, sigma, gamma, e_vib, 0.2)
plt.figure()
plt.plot(x, y1, label="kT=0")
plt.plot(x, y2, label="kT=RT")
plt.plot(x, y3, label="kT=200 meV")
plt.legend()
plt.savefig("fc_emission.png", dpi=150)
Example #52
0
def filter_events(
    in_dat,
    out_filtered,
    thr_uncut,
    thr_loop,
    plot_events=False,
    fig_path=None,
    prefix=None,
):
    """Filter events (loops, uncuts and weirds)

    Filter out spurious intrachromosomal Hi-C pairs from input file. +- pairs
    with reads closer or at the uncut threshold and -+ pairs with reads closer
    or at the loop thresholds are excluded from the ouput file. -- and ++ pairs
    with both mates on the same fragments are also discarded. All others are
    written.

    Parameters
    ----------
    in_dat : file object
        File handle in read mode to the 2D BED file containing Hi-C pairs.
    out_filtered : file object
        File handle in write mode the output filtered 2D BED file.
    thr_uncut : int
        Minimum number of restriction sites between reads to keep an
        intrachromosomal +- pair.
    thr_loop : int
        Minimum number of restriction sites between reads to keep an
        intrachromosomal -+ pair.
    plot_events : bool
        If True, a plot showing the proportion of each type of event will be
        shown after filtering.
    fig_path : str
        Path where the figure will be saved. If None, figure is displayed
        interactively.
    prefix : str
        If the library has a name, it will be shown on plots.
    """
    n_uncuts = 0
    n_loops = 0
    n_weirds = 0
    lrange_intra = 0
    lrange_inter = 0

    # open the files for reading and writing
    with open(in_dat, "r") as pairs, open(out_filtered, "w") as filtered:
        for line in pairs:  # iterate over each line
            # Copy header lines to output
            if line.startswith("#"):
                filtered.write(line)
                continue

            p = process_read_pair(line)
            line_to_write = ("\t".join(
                map(
                    str,
                    (
                        p["readID"],
                        p["chr1"],
                        p["pos1"],
                        p["chr2"],
                        p["pos2"],
                        p["strand1"],
                        p["strand2"],
                        p["frag1"],
                        p["frag2"],
                    ),
                )) + "\n")
            if p["chr1"] == p["chr2"]:
                # Do not report ++ and -- pairs on the same fragment (impossible)
                if p["frag1"] == p["frag2"] and p["strand1"] == p["strand2"]:
                    n_weirds += 1
                elif p["nsites"] <= thr_loop and p["type"] == "-+":
                    n_loops += 1
                elif p["nsites"] <= thr_uncut and p["type"] == "+-":
                    n_uncuts += 1
                else:
                    lrange_intra += 1
                    filtered.write(line_to_write)

            if p["chr1"] != p["chr2"]:
                lrange_inter += 1
                filtered.write(line_to_write)

    if lrange_inter > 0:
        ratio_inter = round(
            100 * lrange_inter / float(lrange_intra + lrange_inter), 2)
    else:
        ratio_inter = 0

    # Log quick summary of operation results
    kept = lrange_intra + lrange_inter
    discarded = n_loops + n_uncuts + n_weirds
    total = kept + discarded
    logger.info("Proportion of inter contacts: {0}% (intra: {1}, "
                "inter: {2})".format(ratio_inter, lrange_intra, lrange_inter))
    logger.info(
        "{0} pairs discarded: Loops: {1}, Uncuts: {2}, Weirds: {3}".format(
            discarded, n_loops, n_uncuts, n_weirds))
    logger.info("{0} pairs kept ({1}%)".format(
        kept, round(100 * kept / (kept + discarded), 2)))

    # Visualize summary if requested by user
    if plot_events:
        try:
            # Plot: make a square figure and axes to plot a pieChart:
            plt.figure(2, figsize=(6, 6))
            # The slices will be ordered and plotted counter-clockwise.
            fracs = [n_uncuts, n_loops, n_weirds, lrange_intra, lrange_inter]
            # Format labels to include event names and proportion
            labels = list(
                map(
                    lambda x: (x[0] + ": %.2f%%") % (100 * x[1] / total),
                    [
                        ("Uncuts", n_uncuts),
                        ("Loops", n_loops),
                        ("Weirds", n_weirds),
                        ("3D intra", lrange_intra),
                        ("3D inter", lrange_inter),
                    ],
                ))
            colors = ["salmon", "lightskyblue", "yellow", "palegreen", "plum"]
            patches, _ = plt.pie(fracs, colors=colors, startangle=90)
            plt.legend(patches, labels, loc=2)
            if prefix:
                plt.title(
                    "Distribution of library events in {}".format(prefix),
                    bbox={
                        "facecolor": "1.0",
                        "pad": 5
                    },
                )
            plt.text(
                0.3,
                1.15,
                "Threshold Uncuts =" + str(thr_uncut),
                fontdict=None,
                withdash=False,
            )
            plt.text(
                0.3,
                1.05,
                "Threshold Loops =" + str(thr_loop),
                fontdict=None,
                withdash=False,
            )

            plt.text(
                -1.5,
                -1.2,
                "Total number of reads =" + str(total),
                fontdict=None,
                withdash=False,
            )
            plt.text(
                -1.5,
                -1.3,
                "Ratio inter/(intra+inter) =" + str(ratio_inter) + "%",
                fontdict=None,
                withdash=False,
            )
            percentage = round(
                100 * float(lrange_inter + lrange_intra) /
                (n_loops + n_uncuts + n_weirds + lrange_inter + lrange_intra))
            plt.text(
                -1.5,
                -1.4,
                "selected reads = {0}%".format(percentage),
                fontdict=None,
                withdash=False,
            )
            if fig_path:
                plt.savefig(fig_path)
            else:
                plt.show()
            plt.clf()
        except Exception:
            logger.error(
                "Unable to show plots. Perhaps there is no Xserver running ?"
                "(might be due to windows environment) skipping figure "
                "generation.")
Example #53
0
import numpy
import matplotlib.pyplot as plt

x = numpy.linspace(-3, 3, 100)
y1 = numpy.sin(x)
y2 = numpy.exp(x)

plt.plot(x, y1, color="green", marker="o")
plt.plot(x, y2, color="blue", marker="+", linewidth=3, linestyle="None")
plt.xlabel("argumenty")
plt.ylabel("wartości")
plt.legend(["sin(x)", "exp(x)"])
plt.ylim([-1, 1])
plt.savefig("wykresik.png")
plt.show()
Example #54
0
from q30 import read_wakati
from collections import Counter
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties
wakati_list = read_wakati()

words = Counter([wakati['surface'] for sentence in wakati_list for wakati in sentence]).most_common()

words_cnt = [int(word[1]) for word in words]
words_ctx = [word[0] for word in words]

plt.hist(words_cnt, bins=50, range=(0, 50))
plt.savefig('fig38.jpg')


###########
# 模範解答 #
###########
from collections import Counter
import matplotlib.pyplot as plt
from q30 import get_neko_morphemes

morphemes_list = get_neko_morphemes()

words = Counter([morpheme["base"] for morphemes in morphemes_list for morpheme in morphemes]).most_common()
_, word_count = list(zip(*words))

plt.rcParams["font.family"] = "IPAexGothic"
plt.hist(word_count, bins=50, range=(1, 50))
plt.savefig("fig38.png")
Example #55
0
def plot():

    import matplotlib.pyplot as plt
    with open('results.pkl') as f:
        results, parser, initial_hypergrad = pickle.load(f)

    # ----- Nice versions of Alpha and beta schedules for paper -----
    fig = plt.figure(0)
    fig.clf()
    ax = fig.add_subplot(411)
    #ax.set_title('Alpha learning curves')
    for cur_results, name in zip(results['log_alphas'][-1].T, parser.names):
        if name[0] == 'weights':
            ax.plot(np.exp(cur_results), 'o-', label=name)
    #ax.set_xlabel('Learning Iteration', fontproperties='serif')
    low, high = ax.get_ylim()
    ax.set_ylim([0, high])
    ax.set_ylabel('Step size', fontproperties='serif')
    ax.set_xticklabels([])
    ax.legend(numpoints=1,
              loc=1,
              frameon=False,
              bbox_to_anchor=(1.0, 0.5),
              prop={
                  'family': 'serif',
                  'size': '12'
              })

    ax = fig.add_subplot(412)
    #ax.set_title('Alpha learning curves')
    for cur_results, name in zip(results['invlogit_betas'][-1].T,
                                 parser.names):
        if name[0] == 'weights':
            ax.plot(logit(cur_results), 'o-', label=name)
    low, high = ax.get_ylim()
    ax.set_ylim([0, 1])
    ax.set_xlabel('Learning Iteration', fontproperties='serif')
    ax.set_ylabel('Momentum', fontproperties='serif')

    ax = fig.add_subplot(413)
    #ax.set_title('Alpha learning curves')
    for cur_results, name in zip(results['log_alphas'][-1].T, parser.names):
        if name[0] == 'biases':
            ax.plot(np.exp(cur_results), 'o-', label=name)
    #ax.set_xlabel('Learning Iteration', fontproperties='serif')
    low, high = ax.get_ylim()
    ax.set_ylim([0, high])
    ax.set_ylabel('Step size', fontproperties='serif')
    ax.set_xticklabels([])
    ax.legend(numpoints=1,
              loc=1,
              frameon=False,
              bbox_to_anchor=(1.0, 0.5),
              prop={
                  'family': 'serif',
                  'size': '12'
              })

    ax = fig.add_subplot(414)
    #ax.set_title('Alpha learning curves')
    for cur_results, name in zip(results['invlogit_betas'][-1].T,
                                 parser.names):
        if name[0] == 'biases':
            ax.plot(logit(cur_results), 'o-', label=name)
    low, high = ax.get_ylim()
    ax.set_ylim([0, 1])
    ax.set_xlabel('Learning Iteration', fontproperties='serif')
    ax.set_ylabel('Momentum', fontproperties='serif')

    fig.set_size_inches((6, 8))
    #plt.show()
    plt.savefig('alpha_beta_paper.png')
    plt.savefig('alpha_beta_paper.pdf', pad_inches=0.05, bbox_inches='tight')

    fig.clf()
    fig.set_size_inches((6, 8))
    # ----- Primal learning curves -----
    ax = fig.add_subplot(311)
    ax.set_title('Primal learning curves')
    for i, y in enumerate(results['learning_curves']):
        ax.plot(y['learning_curve'], 'o-', label='Meta iter {0}'.format(i))
    ax.set_xlabel('Epoch number')
    ax.set_ylabel('Negative log prob')
    #ax.legend(loc=1, frameon=False)

    ax = fig.add_subplot(312)
    ax.set_title('Meta learning curves')
    losses = ['train_loss', 'valid_loss', 'tests_loss']
    for loss_type in losses:
        ax.plot(results[loss_type], 'o-', label=loss_type)
    ax.set_xlabel('Meta iter number')
    ax.set_ylabel('Negative log prob')
    ax.legend(loc=1, frameon=False)

    ax = fig.add_subplot(313)
    ax.set_title('Meta-gradient magnitude')
    ax.plot(results['meta_grad_magnitude'],
            'o-',
            label='Meta-gradient magnitude')
    ax.plot(results['meta_grad_angle'], 'o-', label='Meta-gradient angle')
    ax.set_xlabel('Meta iter number')
    ax.set_ylabel('Meta-gradient Magnitude')
    ax.legend(loc=1, frameon=False)

    plt.savefig('learning_curves.png')

    # ----- Learning curve info -----
    fig.clf()
    ax = fig.add_subplot(311)
    ax.set_title('Primal learning curves')
    for i, y in enumerate(results['learning_curves']):
        ax.plot(y['grad_norm'], 'o-', label='Meta iter {0}'.format(i))
    ax.set_xlabel('Epoch number')
    #ax.legend(loc=1, frameon=False)
    ax.set_title('Grad norm')

    ax = fig.add_subplot(312)
    for i, y in enumerate(results['learning_curves']):
        ax.plot(y['weight_norm'], 'o-', label='Meta iter {0}'.format(i))
    ax.set_xlabel('Epoch number')
    ax.legend(loc=1, frameon=False)
    ax.set_title('Weight norm')

    ax = fig.add_subplot(313)
    for i, y in enumerate(results['learning_curves']):
        ax.plot(y['velocity_norm'], 'o-', label='Meta iter {0}'.format(i))
    ax.set_xlabel('Epoch number')
    ax.set_title('Velocity norm')
    ax.legend(loc=1, frameon=False)
    plt.savefig('extra_learning_curves.png')

    # ----- Alpha and beta schedules -----
    fig.clf()
    ax = fig.add_subplot(211)
    ax.set_title('Alpha learning curves')
    for i, y in enumerate(results['log_alphas']):
        ax.plot(y, 'o-', label="Meta iter {0}".format(i))
    ax.set_xlabel('Primal iter number')
    #ax.set_ylabel('Log alpha')
    ax.legend(loc=1, frameon=False)

    ax = fig.add_subplot(212)
    ax.set_title('Beta learning curves')
    for y in results['invlogit_betas']:
        ax.plot(y, 'o-')
    ax.set_xlabel('Primal iter number')
    ax.set_ylabel('Inv logit beta')
    plt.savefig('alpha_beta_curves.png')

    # ----- Init scale and L2 reg -----
    fig.clf()
    ax = fig.add_subplot(211)
    ax.set_title('Init scale learning curves')
    for i, y in enumerate(zip(*results['log_param_scale'])):
        if parser.names[i][0] == 'weights':
            ax.plot(y, 'o-', label=parser.names[i])
    ax.set_xlabel('Meta iter number')
    ax.set_ylabel('Log param scale')
    ax.legend(loc=1, frameon=False)

    ax = fig.add_subplot(212)
    ax.set_title('Init scale learning curves')
    for i, y in enumerate(zip(*results['log_param_scale'])):
        if parser.names[i][0] == 'biases':
            ax.plot(y, 'o-', label=parser.names[i])
    ax.set_xlabel('Meta iter number')
    ax.set_ylabel('Log param scale')
    ax.legend(loc=1, frameon=False)

    plt.savefig('scale_and_reg.png')

# Pressure at transit radius as function of wavelength:
sigma = 3.0  # Gauss-convolve for better-looking plots
p   = sip.interp1d(rad1[::-1], press[::-1])
pt1 = p(gaussf(rp1, sigma))
p   = sip.interp1d(rad2[::-1], press[::-1])
pt2 = p(gaussf(rp2, sigma))
p   = sip.interp1d(rad3[::-1], press[::-1])
pt3 = p(gaussf(rp3, sigma))

# Photospheric pressure modulation spectrum:
lw = 1.5
plt.figure(-25)
plt.clf()
ax = plt.subplot(111)
plt.semilogy(1e4/pyrat.spec.wn, pt3, lw=lw, color="orange",
             label=r"$100\times\,{\rm solar}$")
plt.semilogy(1e4/pyrat.spec.wn, pt2, lw=lw, color="sienna",
             label=r"$1.0\times\,{\rm solar}$")
plt.semilogy(1e4/pyrat.spec.wn, pt1, lw=lw, color="k",
             label=r"$0.1\times\,{\rm solar}$")
plt.axvspan(0.74, 1.01, color="0.80")

plt.xlim(0.5, 1.2)
plt.ylim(3, 3e-7)
plt.legend(loc="upper right",  fontsize=15)
plt.ylabel(r"$\rm Pressure\ \ (bar)$",  fontsize=16)
plt.xlabel(r"$\rm Wavelength\ \ (um)$", fontsize=16)
plt.savefig("../plots/WASP49b_clear_spectra.ps")
Example #57
0

#%%
pnl[['yhat_lstm_1','y']].plot(figsize=(20,10))


#%%
sample_yhat = pnl[['yhat_lstm_0','yhat_lstm_1']].values
y_raw = pnl.y.values


#%%
plt.figure(figsize=(10,5))
sns.distplot(y_raw[sample_yhat.argmax(axis=1)==1],color="r",bins=30,kde=True)
sns.distplot(y_raw[sample_yhat.argmax(axis=1)==0],color="b",bins=30,kde=True)
plt.savefig("HIGH_CHG_7")
plt.show()


#%%
from importlib import reload
import model.DataReg as DR
# reload(model.DataReg)
dr = DR.DataReg()
x0,ks = dr.plotROC(sample_yhat[:,1],pnl.y.apply(lambda x: 1 if x>=0 else 0).values)


#%%
x0

Example #58
0
opt = Adam(lr=INIT_LR, decay=INIT_LR/EPOCHS)
model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"])

#train model
print("[INFO] training model...")
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=BS), validation_data=(testX,testY), steps_per_epoch=len(trainX) // BS, epochs = EPOCHS, verbose=1)

#save the model to disk
print("[INFO] serializing network...")
model.save(args["model"])

# save the label binarizer to disk
print("[INFO] serializing label binarizer...")
f = open(args["labelbin"], "wb")
f.write(pickle.dumps(lb))
f.close()

#plot the training loss and accuracy
plt.style.use("ggplot")
plt.figure()
N = EPOCHS
plt.plot(np.arange(0,N), H.history["loss"], label="train_loss")
plt.plot(np.arange(0,N), H.history["val_loss"], label="val_loss")
plt.plot(np.arange(0,N), H.history["acc"], label="train_acc")
plt.plot(np.arange(0,N), H.history["val_acc"], label="val_acc")
plt.title("Training Loss and Accuracy")
plt.xlabel("Epochs #")
plt.ylabel("Loss/Accuracy")
plt.legend(loc="upper left")
plt.savefig(args["plot"])
Example #59
0
data_list_2 = list()

# fig = plt.figure()
fig2 = plt.figure()

# ax = fig.add_subplot(111)
ax = fig2.add_subplot(121)
ax2 = fig2.add_subplot(122)

# for path in paths_list:

for pb_path, shu_path in zip(paths, paths_2):
    no, pb, legend = calculate_graph_data(pb_path)
    esfe, shu, seg = calculate_graph_data(shu_path)

    #legend_str = path[0].split('/')[-1]
    #legend = legend_str.split('_')[0]
    ax.plot(shu[0], shu[1])
    ax2.plot(pb[0], pb[1])

#plt.xlim((-0.6,0))
#plt.ylim((-0.06, 0.02))
#plt.legend(loc = 'lower right')
#plt.title('E.coli MG1655 Pseudo starting at 10^5 CFU/ml after 5 hours Incubation with 1mM Resazurin')
ax.set_xlabel('Voltage vs AgAgCl (V)')
ax.set_ylabel('Current (mA)')
ax2.set_xlabel('Voltage vs AgAgCl (V)')

plt.savefig(os.path.join(directory2, 'MB_ITO_17-5-17.png'), dpi=300)
plt.show()
print "total time", time.time() - start_time
print "Surface temperatures:", surface_temperatures
print "Luminosities:", stars_luminosities
print "Masses:", stars_masses
print "Radii:", stars_radii


plt.figure(1)
plt.plot(surface_temperatures, stars_luminosities)
plt.xscale('log')
plt.yscale('log')
plt.gca().invert_xaxis()
plt.xlabel('Surface Temperatures (K)')
plt.ylabel('Luminosity ($L/L_{sun}$)')
plt.title('Main Sequence: Hertzsprung-Russell Diagram')
plt.savefig("main_sequence.png")

plt.figure(2)
plt.plot(stars_masses, stars_luminosities, '.')
#plt.xscale('log')
plt.yscale('log')
plt.gca().invert_xaxis()
plt.xlabel('Masses ($M/M_{sun}$)')
plt.ylabel('Luminosity ($L/L_{sun}$)')
plt.title('Main Sequence: Luminosity versus Mass')
plt.savefig("main_sequence_luminosities_masses.png")

plt.figure(3)
plt.plot(stars_masses, stars_radii, '.')
#plt.xscale('log')
#plt.yscale('log')