Exemplo n.º 1
0
def getCurvVectors(X, MaxOrder, sigma, loop = False, m = 'nearest'):
    """
    Get smoothed curvature vectors up to a particular order
    :param X: An N x d matrix of points in R^d
    :param MaxOrder: The maximum order of torsion to compute (e.g. 3 for position, velocity, and curvature, and torsion)
    :param sigma: The smoothing amount
    :param loop: Treat this trajectory as a topological loop (i.e. add an edge between first and last point?)
    """
    if loop:
        m = 'wrap'
    XSmooth = gf1d(X, sigma, axis=0, order = 0, mode = m)
    Vel = gf1d(X, sigma, axis=0, order = 1, mode = m)
    VelNorm = np.sqrt(np.sum(Vel**2, 1))
    VelNorm[VelNorm == 0] = 1
    Curvs = [XSmooth, Vel]
    for order in range(2, MaxOrder+1):
        Tors = gf1d(X, sigma, axis=0, order=order, mode = m)
        for j in range(1, order):
            #Project away other components
            NormsDenom = np.sum(Curvs[j]**2, 1)
            NormsDenom[NormsDenom == 0] = 1
            Norms = np.sum(Tors*Curvs[j], 1)/NormsDenom
            Tors = Tors - Curvs[j]*Norms[:, None]
        Tors = Tors/(VelNorm[:, None]**order)
        Curvs.append(Tors)
    return Curvs
Exemplo n.º 2
0
def get_derivative_shells(patches,
                          pd,
                          n_shells,
                          shells_fn=get_shells,
                          orders=[0, 1, 2],
                          r_max=None):
    """
    Compute shell descriptors on the raw patch and after derivative
    filters applied to the patch.
    """
    patchesim = np.reshape(patches, (patches.shape[0], pd[0], pd[1]))
    all_shells = []
    for order in orders:
        if order == 0:
            shells = shells_fn(patches, pd, n_shells, r_max)
        else:
            imx = gf1d(patchesim, sigma=1, order=order, axis=2)
            imy = gf1d(patchesim, sigma=1, order=order, axis=1)
            patchesorder = np.sqrt(imx**2 + imy**2)
            shells = shells_fn(np.reshape(patchesorder, patches.shape), pd,
                               n_shells, r_max)
        # Normalize each by the standard deviation so they are comparable
        shells /= np.std(shells)
        all_shells.append(shells)
    return np.concatenate(tuple(all_shells), 1)
Exemplo n.º 3
0
def gau_smooth(arr0,typ='single',krn=75.0/4.0,verbose=False):
	import numpy as np
	from scipy.ndimage.filters import gaussian_filter1d as gf1d
	from scipy.ndimage.filters import gaussian_filter as gf
	N = arr0.ndim
	ktyp = type(krn)
	modes = ['reflect','wrap','wrap']
	if ktyp==float:
		krn = [krn,krn,krn]
	if typ=='single':
		ret = np.zeros(arr0.shape)
		for i in range(3):
			if verbose:
				print('Smoothing type: wrap, component: {}'.format(i))
			ret[i] = gf(arr0[i],sigma=krn,mode='wrap')
		return ret
	elif typ=='piecewise':
		for i in range(3):
			if N==3:
				cax = i
			if N==4:
				cax = i+1
			if verbose:
				print('Axis = {}; k = {}, mode = {}'.format(cax,krn[i],modes[i]))
			clab = 'arr{}'.format(i)
			nlab = 'arr{}'.format(i+1)
			if verbose:
				print(clab,nlab)
			locals()[nlab] = gf1d(locals()[clab],axis=cax,sigma=krn[i],mode=modes[i])
		if verbose:
			print('Returning {}'.format(nlab))
		return	locals()[nlab]
Exemplo n.º 4
0
def plot_spectrum(wavelength,
                  spectrum,
                  ax=None,
                  plot_raw=True,
                  smooth=10,
                  raw_kwargs=dict(markersize=1.,
                                  color='k',
                                  linestyle='',
                                  marker='.'),
                  **kwargs):
    """
    Standardised method for plotting a spectrum on a matplotlib axes. The raw spectrum is plotted
    as dots and a smoothed line is drawn through.

    Args:
        wavelength (np.ndarray): array of wavelengths
        spectra (np.ndarray): array of spectrum values
        ax (matplotlib.axis): An matplotlib axis instance. If none exist then one will be created
        plot_raw (bool): Plot the raw data as black dots
        smooth (float): sigma for Gaussian smoothing
        raw_kwargs (dict): Dictionary of keyword arguments passed to the axes plot method for the
            raw spectrum plot
        **kwargs: Arbitrary keyword arguments passed to the axes plot method for the smoothed
            spectrum plot
    """
    if ax is None:
        ax = plt.gca()
        if ax is None:
            ax = plt.subplot(111)
    if plot_raw:
        print 'plotting'
        ax.plot(wavelength, spectrum, **raw_kwargs)
    if 'linestyle' not in kwargs:
        kwargs['linestyle'] = '-'
    ax.plot(wavelength, gf1d(spectrum, smooth), **kwargs)
Exemplo n.º 5
0
def plot_spectrum(wavelength, spectrum, ax=None, plot_raw=True, smooth=10,
                  raw_kwargs=dict(markersize=1., color='k', linestyle='', marker='.'),
                  **kwargs):
    """
    Standardised method for plotting a spectrum on a matplotlib axes. The raw spectrum is plotted
    as dots and a smoothed line is drawn through.

    Args:
        wavelength (np.ndarray): array of wavelengths
        spectra (np.ndarray): array of spectrum values
        ax (matplotlib.axis): An matplotlib axis instance. If none exist then one will be created
        plot_raw (bool): Plot the raw data as black dots
        smooth (float): sigma for Gaussian smoothing
        raw_kwargs (dict): Dictionary of keyword arguments passed to the axes plot method for the
            raw spectrum plot
        **kwargs: Arbitrary keyword arguments passed to the axes plot method for the smoothed
            spectrum plot
    """
    if ax is None:
        ax = plt.gca()
        if ax is None:
            ax = plt.subplot(111)
    if plot_raw:
        print 'plotting'
        ax.plot(wavelength, spectrum, **raw_kwargs)
    if 'linestyle' not in kwargs:
        kwargs['linestyle'] = '-'
    ax.plot(wavelength, gf1d(spectrum, smooth), **kwargs)
Exemplo n.º 6
0
def plot_rewards(rewards, args):

    plt.cla()
    p = plt.plot(rewards, alpha=0.3)
    plt.plot(gf1d(rewards, sigma=15), c=p[0].get_color())

    plt.title('BipedalWalker-v2: Test MP')
    plt.savefig('./{}_rewards.png'.format(args.env_name))
Exemplo n.º 7
0
def plot_fps():
    data = pd.read_csv('fps_data.csv')
    for col in data.columns:
        p = plt.plot(gf1d(data[col], sigma=5), label=col)
        plt.plot(data[col], alpha=0.2, color=p[0].get_color())

    plt.legend()
    plt.title('FPS per Tracking method', weight='bold')
    plt.show()
Exemplo n.º 8
0
def getCurvVectors(X, MaxOrder, sigma, loop = False):
    m = 'nearest'
    if loop:
        m = 'wrap'
    XSmooth = gf1d(X, sigma, axis=0, order = 0, mode = m)
    Vel = gf1d(X, sigma, axis=0, order = 1, mode = m)
    VelNorm = np.sqrt(np.sum(Vel**2, 1))
    VelNorm[VelNorm == 0] = 1
    Curvs = [XSmooth, Vel]
    for order in range(2, MaxOrder+1):
        Tors = gf1d(X, sigma, axis=0, order=order, mode = m)
        for j in range(1, order):
            #Project away other components
            NormsDenom = np.sum(Curvs[j]**2, 1)
            NormsDenom[NormsDenom == 0] = 1
            Norms = np.sum(Tors*Curvs[j], 1)/NormsDenom
            Tors = Tors - Curvs[j]*Norms[:, None]
        Tors = Tors/(VelNorm[:, None]**order)
        Curvs.append(Tors)
    return Curvs
Exemplo n.º 9
0
def getCurvVectors(X, MaxOrder, sigma, loop=False):
    m = 'nearest'
    if loop:
        m = 'wrap'
    XSmooth = gf1d(X, sigma, axis=0, order=0, mode=m)
    Vel = gf1d(X, sigma, axis=0, order=1, mode=m)
    VelNorm = np.sqrt(np.sum(Vel**2, 1))
    VelNorm[VelNorm == 0] = 1
    Curvs = [XSmooth, Vel]
    for order in range(2, MaxOrder + 1):
        Tors = gf1d(X, sigma, axis=0, order=order, mode=m)
        for j in range(1, order):
            #Project away other components
            NormsDenom = np.sum(Curvs[j]**2, 1)
            NormsDenom[NormsDenom == 0] = 1
            Norms = np.sum(Tors * Curvs[j], 1) / NormsDenom
            Tors = Tors - Curvs[j] * Norms[:, None]
        Tors = Tors / (VelNorm[:, None]**order)
        Curvs.append(Tors)
    return Curvs
Exemplo n.º 10
0
def getAccelerationFeatureStack(X, sigma):
    """
    Compute an extimate of acceleration of each component
    of a feature stack using convolution with a Gaussian derivative
    Parameters
    ----------
    X: ndarray(N, K)
        An array of features
    sigma: int
        Width of the gaussian by which to convolve
    """
    return gf1d(X, sigma, axis=0, order=2, mode='nearest')
Exemplo n.º 11
0
def create_hill_x_input():
    """ Create Input for TenStream caluclations on a gaussian hill"""
    from scipy.ndimage.filters import gaussian_filter as gf
    from scipy.ndimage.filters import gaussian_filter1d as gf1d
    from scipy.interpolate import interp1d

    # Create elevation map for gaussian hill
    Nx, Ny = 3, 31

    DX = .1  # 100m horizontal resolution
    HILL_HEIGHT = 1.5  # 500m hill

    elev = np.zeros((Nx, Ny))
    elev[:, (Ny - 1) / 2] = 1.
    elev = gf1d(elev, HILL_HEIGHT / DX, axis=1)
    elev /= np.max(elev) / HILL_HEIGHT

    # Interpolate atmosphere file on new grid
    afglus = np.loadtxt('afglus_100m.dat')

    z = afglus[:, 0]
    p = afglus[:, 1]

    Nz = np.shape(z)[-1]

    pressure_by_height = interp1d(z, p, kind='linear')

    hhl = np.tile(z, Nx * Ny).reshape(
        (Nx, Ny, Nz))[:, :, ::-1]  # hhl now begins at surface
    hill = hhl.copy()

    # Create surface following sigma coordinates with coordinate stretching in the vertical
    for k in range(Nz):
        hill[:, :,
             k] = hhl[:, :, k] + elev * np.exp(-hhl[:, :, k] / HILL_HEIGHT)

    hill = np.minimum(hill, np.max(z))
    hill = hill[:, :, ::-1]  # hhl now begins at TOA
    p_hill = pressure_by_height(hill)

    lev_coord = p_hill

    create_var('plev', interp_var(p, afglus[:, 1], lev_coord), 'lev')

    lay_coord = (lev_coord[:, :, 1:] + lev_coord[:, :, :-1]) / 2

    create_var('tlay', interp_var(p, afglus[:, 2], lay_coord), 'lay')
    create_var('air', interp_var(p, afglus[:, 3], lay_coord), 'lay')
    create_var('o3vmr', interp_var(p, afglus[:, 4], lay_coord), 'lay')
    create_var('o2vmr', interp_var(p, afglus[:, 5], lay_coord), 'lay')
    create_var('h2ovmr', interp_var(p, afglus[:, 6], lay_coord), 'lay')
    create_var('co2vmr', interp_var(p, afglus[:, 7], lay_coord), 'lay')
    create_var('n2ovmr', interp_var(p, afglus[:, 8], lay_coord), 'lay')
Exemplo n.º 12
0
def data_augmentation(inputs,
                      outputs,
                      input_channels=[],
                      kernels=(3, 5, 7, 11),
                      noises=None):

    if not isinstance(input_channels, list):
        input_channels = [input_channels]

    input_channels = [ip for ip in input_channels if ip in list(inputs)]
    # apply
    repeat_channels = [ip for ip in list(inputs) if ip not in input_channels]

    inputs_ = {ic: np.vstack((inputs[ic],) + \
                             tuple([gf1d(inputs[ic], k, axis = 1) \
                                    for k in kernels])) \
                for ic in input_channels}

    inputs_ = dict(inputs_, **{ic: np.vstack((inputs[ic],) + \
                                             tuple([inputs[ic] \
                                                    for k in kernels])) \
                                for ic in repeat_channels})

    if noises is not None:
        inputs__ = {ic: np.vstack(tuple([inputs[ic] + \
                                         np.random.normal(loc=0.0, scale=n, size = inputs[ic].shape) \
                                    for n in noises])) \
                for ic in input_channels}

        inputs__ = dict(inputs__, **{ic: np.vstack(tuple([inputs[ic] \
                                                    for n in noises])) \
                                for ic in repeat_channels})

        inputs_ = {
            ic: np.vstack((inputs_[ic], inputs__[ic]))
            for ic in inputs_
        }

    # Repeat outputs
    if outputs is not None:
        outputs_ = {oc: np.vstack((outputs[oc],) + \
                                 tuple([outputs[oc] \
                                        for k in kernels])) \
                    for oc in list(outputs)}

        if noises is not None:
            outputs_ = {oc: np.vstack((outputs_[oc],) + \
                                 tuple([outputs[oc] \
                                        for n in noises])) \
                    for oc in list(outputs)}

    return inputs_, outputs_
Exemplo n.º 13
0
def GaussBlurG1(Chro,sigma,sigrange=0,returnPDF=False,normalize=False):
    ''' Outputs a new Chromosome which has converted 0s to 1s in Chro ...
        ... with odds based on a gaussian blur of Chro'''
    blurred = gf1d( [float(i) for i in Chro] , sigma, mode='constant')  # list comprehension needed to convert ints to floats    
    if normalize:
        NormalizePDF(blurred,sum(Chro))
    if returnPDF:
        blurred = [max(0,i) for i in (blurred - Chro)]    # converts 1s in Chro to 0s in blurred #### because Chro is binary, it either doesn't affect (if 0) or pushes it to 0 (if 1 which is always bigger than blurred)
        if sigrange:
#            raise NameError('CHECK FIRST WHETHER CUTOFF METHOD IS CORRECT, IT IS CURRENTLY UNTESTED')
            cutoff = stats.norm.pdf(sigma*sigrange,scale=sigma)     ## I THINK THIS IS CORRECT, UNTESTED THOUGH
            blurred = [0 if i < cutoff else i for i in blurred]     # turn low values to 0 to decrease memory used in numpy array
        return blurred  
    return [1 if nprnd.rand() < nuc else 0 for nuc in Chro+blurred]
Exemplo n.º 14
0
def getCurvVectors(X, MaxOrder, sigma, loop=False, m='nearest'):
    """
    Get smoothed curvature vectors up to a particular order
    Parameters
    ----------
    X: ndarray(N, d)
        An N x d matrix of points in R^d
    MaxOrder: int
        The maximum order of torsion to compute (e.g. 3 for position, velocity, and curvature, and torsion)
    sigma: float
        The smoothing amount
    loop: boolean
        Whether to treat this trajectory as a topological loop (i.e. add an edge between first and last point)
    
    Returns
    -------
    Curvs: A list of ndarray(N, d), starting with the smoothed curve, then followed
           by the smoothed velocity, curvature, torsion, etc. up to the MaxOrder
    """
    if loop:
        m = 'wrap'
    XSmooth = gf1d(X, sigma, axis=0, order=0, mode=m)
    Vel = gf1d(X, sigma, axis=0, order=1, mode=m)
    VelNorm = np.sqrt(np.sum(Vel**2, 1))
    VelNorm[VelNorm == 0] = 1
    Curvs = [XSmooth, Vel]
    for order in range(2, MaxOrder + 1):
        Tors = gf1d(X, sigma, axis=0, order=order, mode=m)
        for j in range(1, order):
            #Project away other components
            NormsDenom = np.sum(Curvs[j]**2, 1)
            NormsDenom[NormsDenom == 0] = 1
            Norms = np.sum(Tors * Curvs[j], 1) / NormsDenom
            Tors = Tors - Curvs[j] * Norms[:, None]
        Tors = Tors / (VelNorm[:, None]**order)
        Curvs.append(Tors)
    return Curvs
Exemplo n.º 15
0
def getOnsetMeans(px, win=20, sigma=1, truncate=4, edge=10, do_plot=False):
    """
    Do a mollified Gaussian derivative followed by
    a moving average to get smoothed local tempo estimates
    """
    x = px[edge:-edge]  # Truncate edges since they seem to be unreliable
    x = gf1d(x, sigma, truncate=truncate, order=1, mode='reflect')
    x = x[truncate * sigma:-truncate * sigma]
    if do_plot:
        plt.figure()
        plt.subplot(211)
        plt.plot(px)
        plt.subplot(212)
        plt.plot(x)
        plt.show()
    M = x.size - win + 1
    X = np.zeros((M, win))
    for k in range(win):
        X[:, k] = x[k:k + M]
    ret = np.mean(X, 1)
    return ret / np.median(ret)
Exemplo n.º 16
0
def G1phase(Chro,G1method=GaussBlurG1,power=gausspow):
    ''' Gaussian blur (or other method) of Chro is made which functions as the blueprint for the chance of nascent
    CENP-A incorporation. 
    The Distribution is only made once at the beginning of G1 phase, meaning that nascent CENP-A does not 
    guide more nascent CENP-A incorporation. This makes the code a lot faster.
    A method was built in to ensure that there is no 'reloading' of CENP-A at any given position'''
    global sendChro    
    if gaussOffset:
        sendChro = np.zeros(ChroL)
        for nuc in xrange(ChroL):
            if Chro[nuc] == 1:
                if nuc >= gaussOffset:     sendChro[nuc-gaussOffset] += 0.5
                if nuc < ChroL-gaussOffset:    sendChro[nuc+gaussOffset] += 0.5
    else: sendChro = Chro
    
    Distrib = gf1d( [float(i) for i in sendChro] , sigma, mode='constant')
    Distrib = [max(0,i) for i in (Distrib - Chro)]
    
    
    if power != 1:                          # >1 makes the distribution favor clusters (at least in theory)
        Distrib = np.power(Distrib,[power]*len(Distrib))
    print sum(Distrib)
    Distrib /= sum(Distrib)/efficiency      # normailizes the distribution to sum to efficiency (i.e. random numbers above efficiency will not lead to CA incorporation)
    Cumulative = np.cumsum(Distrib)         # converts the distribution to a cumulative distribution list
    plt.plot(Distrib)
    print sum(Distrib)
    
    reloads = 0
    for n in xrange(CApool):                # for each molecule in the available pool of CA
        X = nprnd.rand()                    
        if X < efficiency:                  # test if it will be loaded or not
            newPos = np.searchsorted(Cumulative,X)
            while Chro[newPos]:             # ensures that previously loaded sites are not 'reloaded'; this also alleviates the necessity of converting 1s to 0s in GaussBlur
                X = nprnd.rand()/2
                newPos = np.searchsorted(Cumulative,X)
                reloads += 1                # counter to check how often a previously loaded site revisited
            Chro[newPos] = 1                # convert a 0 from the cumulative distribution to 1
    return Chro , reloads
def G1phase(Chro):
    ''' Gaussian blur (or other method) of Chro is made which functions as the blueprint for the chance of nascent
    CENP-A incorporation. 
    The Distribution is only made once at the beginning of G1 phase, meaning that nascent CENP-A does not 
    guide more nascent CENP-A incorporation. This makes the code a lot faster.
    A method was built in to ensure that there is no 'reloading' of CENP-A at any given position'''

    # Create Offset array which will be used to calculate the frequency distribution of nascent CA loading    
    if gaussOffset:
        OffsetChro = np.zeros(ChroL)
        for nuc in xrange(ChroL):
            if Chro[nuc] == 1:
                if nuc >= gaussOffset:     OffsetChro[nuc-gaussOffset] += 0.5
                if nuc < ChroL-gaussOffset:    OffsetChro[nuc+gaussOffset] += 0.5
    else: OffsetChro = np.array(Chro)

    # Create frequency distribution based on gaussian blurred
    Distrib = gf1d( [float(i) for i in OffsetChro] , sigma, mode='constant')     #this line is no longer outsourced to G1_phase_Methods file!
    Distrib = [max(0,i) for i in (Distrib - Chro)]                              # convert 1s in Chro to 0s in Distrib so that there is not reloading of CA at old positions

    if gausspow != 1:                          # >1 makes the distribution favor clusters (at least in theory)
        Distrib = np.power(Distrib,[gausspow]*len(Distrib))
    Distrib /= sum(Distrib)/efficiency      # normailizes the distribution to sum to efficiency (i.e. random numbers above efficiency will not lead to CA incorporation)
    Cumulative = np.cumsum(Distrib)         # converts the distribution to a cumulative distribution list
    
    reloads=0                       # counter to check how often a previously loaded site revisited
    for n in xrange(CApool):                # for each molecule in the available pool of CA
        X = nprnd.rand()                    
        if X < efficiency:                  # test if it will be loaded or not
            newPos = np.searchsorted(Cumulative,X)
            while Chro[newPos]:             # ensures that previously loaded sites are not 'reloaded'; this also alleviates the necessity of converting 1s to 0s in GaussBlur
                X = nprnd.rand()/2
                newPos = np.searchsorted(Cumulative,X)
                reloads += 1                # counter to check how often a previously loaded site revisited
            Chro[newPos] = 1                # convert a 0 from the cumulative distribution to 1
    return Chro , reloads
Exemplo n.º 18
0
        batch_reward.extend([p_r, n_r])

    l2_update, mean_r, std_r = train_step(net, batch_noise, batch_reward)
    p_bar.update(1)
    last_r = eval_indiv(env, net)
    p_bar.set_description('Reward: {}'.format(last_r))
    writer.add_scalar('L2 update', np.mean(l2_update), step)
    writer.add_scalar('Mean reward', mean_r, step)
    writer.add_scalar('Reward std', std_r, step)

    recap['mean_r'].append(mean_r)
    recap['l2_updates'].append(np.mean(l2_update))
    recap['std_r'].append(std_r)

p = plt.plot(recap['mean_r'], alpha=0.3)
plt.plot(gf1d(recap['mean_r'], sigma=5), color=p[0].get_color())
plt.title('Mean reward')
plt.savefig('mean.png')
plt.cla()

p = plt.plot(recap['l2_updates'], alpha=0.3)
plt.plot(gf1d(recap['l2_updates'], sigma=5), color=p[0].get_color())
plt.title('L2 update')
plt.savefig('l2.png')
plt.cla()
p = plt.plot(recap['std_r'], alpha=0.3)
plt.plot(gf1d(recap['std_r'], sigma=5), color=p[0].get_color())
plt.title('Std reward')
plt.savefig('std.png')
plt.cla()
p_bar.close()
Exemplo n.º 19
0
def get_DLNC0(x, sr, hop_length, lag=10, do_plot=False):
    """
    Compute decaying locally adaptive normalize C0 (DLNC0) features

    Parameters
    ----------
    x: ndarray(N)
        Audio samples
    sr: int
        Sample rate
    hop_length: int
        Hop size between windows
    lag: int
        Number of lags to include
    
    Returns
    -------
    X: ndarray(n_win, 12)
        The DLNC0 features
    """
    from scipy.ndimage.filters import gaussian_filter1d as gf1d
    from scipy.ndimage.filters import maximum_filter1d
    import librosa
    X = np.abs(librosa.cqt(x, sr=sr, hop_length=hop_length,
                           bins_per_octave=12))
    # Half-wave rectify discrete derivative
    #X = librosa.amplitude_to_db(X, ref=np.max)
    #X[:, 0:-1] = X[:, 1::] - X[:, 0:-1]
    X = gf1d(X, 5, axis=1, order=1)
    X[X < 0] = 0
    # Retain peaks
    XLeft = X[:, 0:-2]
    XRight = X[:, 2::]
    mask = np.zeros_like(X)
    mask[:, 1:-1] = (X[:, 1:-1] > XLeft) * (X[:, 1:-1] > XRight)
    X[mask < 1] = 0
    # Fold into octave
    n_octaves = int(X.shape[0] / 12)
    X2 = np.zeros((12, X.shape[1]), dtype=X.dtype)
    for i in range(n_octaves):
        X2 += X[i * 12:(i + 1) * 12, :]
    X = X2
    # Compute norms
    if do_plot:
        import librosa.display
        plt.subplot(411)
        librosa.display.specshow(X, sr=sr, x_axis='time', y_axis='chroma')
    norms = np.sqrt(np.sum(X**2, 0))
    if do_plot:
        plt.subplot(412)
        plt.plot(norms)
    norms = maximum_filter1d(norms, size=int(2 * sr / hop_length))
    if do_plot:
        import librosa.display
        plt.plot(norms)
        plt.subplot(413)
        X = X / norms[None, :]
        librosa.display.specshow(X, sr=sr, x_axis='time', y_axis='chroma')
    # Apply LNCO
    decays = np.linspace(0, 1, lag + 1)[1::]
    decays = np.sqrt(decays[::-1])
    XRet = np.zeros_like(X)
    M = X.shape[1] - lag + 1
    for i in range(lag):
        XRet[:, i:i + M] += X[:, 0:M] * decays[i]
    if do_plot:
        plt.subplot(414)
        librosa.display.specshow(XRet, sr=sr, x_axis='time', y_axis='chroma')
        plt.show()
    return XRet
Exemplo n.º 20
0
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import glob
import numpy as np
from scipy.ndimage.filters import gaussian_filter1d as gf1d
plt.style.use('ggplot')

if __name__ == "__main__":

    smoother = lambda x: gf1d(x, sigma=15)

    files = glob.glob('./runs/*csv')
    ppo_files = [f for f in files if 'ppo' in f]
    ppg_files = [f for f in files if 'ppg' in f]

    ppo_df = pd.concat([pd.read_csv(f) for f in ppo_files], axis=1)
    ppg_df = pd.concat([pd.read_csv(f) for f in ppg_files], axis=1)

    ppo_df['min_val'] = ppo_df.min(axis=1)
    ppo_df['max_val'] = ppo_df.max(axis=1)
    ppo_df['mean_val'] = ppo_df.mean(axis=1)

    ppg_df['min_val'] = ppg_df.min(axis=1)
    ppg_df['max_val'] = ppg_df.max(axis=1)
    ppg_df['mean_val'] = ppg_df.mean(axis=1)

    f, ax = plt.subplots(figsize=(20, 14))

    x_ticks = np.arange(0, ppo_df.shape[0])
    plt.fill_between(x_ticks,
Exemplo n.º 21
0
def interpolate_spectrum(wavelength, spectrum, smooth=10):
    func = interp1d(wavelength, spectrum)
    new_wavelength = np.arange(wavelength.min(), wavelength.max(), 1)
    new_spectrum = func(new_wavelength)
    new_spectrum = gf1d(new_spectrum, smooth)
    return new_wavelength, new_spectrum