resample Namespace Reference

Functions
def	unWeighted_resample (weights, N)
def	residual_resample (weights)
def	stratified_resample (weights)
def	systematic_resample (weights)
def	multinomial_resample (weights)
def	estimate_gmm (X, num_components, method='EM')

Function Documentation

estimate_gmm()

def resample.estimate_gmm	(		X,
			num_components,
			method = 'EM'
	)

def estimate_gmm(X, num_components, method='EM'):
    # bring data into shogun representation (note that Shogun data is in column vector form, so transpose)
    features_train=RealFeatures(X.T)
    
    # initialize GMM, passing the desired number of mixture components.
    gmm = GMM(num_components)
    
    # train feature and sample data-points from the trained model.
    gmm.set_features(features_train)
    if method == 'EM': gmm.train_em()
    elif method == 'SMEM': gmm.train_smem()
    
    # return GMM object and sampled data
    return gmm, gmm.sample()

multinomial_resample()

def resample.multinomial_resample

(

weights

)

 This is the naive form of roulette sampling where we compute the
cumulative sum of the weights and then use binary search to select the
resampled point based on a uniformly distributed random number. Run time
is O(n log n). You do not want to use this algorithm in practice; for some
reason it is popular in blogs and online courses so I included it for
reference.
Parameters
----------
weights : list-like of float
    list of weights as floats
Returns
-------
indexes : ndarray of ints
    array of indexes into the weights defining the resample. i.e. the
    index of the zeroth resample is indexes[0], etc.

def multinomial_resample(weights):
    """ This is the naive form of roulette sampling where we compute the
    cumulative sum of the weights and then use binary search to select the
    resampled point based on a uniformly distributed random number. Run time
    is O(n log n). You do not want to use this algorithm in practice; for some
    reason it is popular in blogs and online courses so I included it for
    reference.
   Parameters
   ----------
    weights : list-like of float
        list of weights as floats
    Returns
    -------
    indexes : ndarray of ints
        array of indexes into the weights defining the resample. i.e. the
        index of the zeroth resample is indexes[0], etc.
    """
    cumulative_sum = np.cumsum(weights)
    cumulative_sum[-1] = 1.  # avoid round-off errors: ensures sum is exactly one
    return np.searchsorted(cumulative_sum, random(len(weights)))
 

residual_resample()

def resample.residual_resample

(

weights

)

def residual_resample(weights):
    N = len(weights)
    indexes = np.zeros(N, 'i')
 
    # take int(N*w) copies of each weight, which ensures particles with the
    # same weight are drawn uniformly
    num_copies = (np.floor(N*np.asarray(weights))).astype(int)
    k = 0
    for i in range(N):
        for _ in range(num_copies[i]): # make n copies
            indexes[k] = i
            k += 1
 
    # use multinormal resample on the residual to fill up the rest. This
    # maximizes the variance of the samples
    residual = weights - num_copies     # get fractional part
    residual /= sum(residual)           # normalize
    cumulative_sum = np.cumsum(residual)
    cumulative_sum[-1] = 1. # avoid round-off errors: ensures sum is exactly one
    indexes[k:N] = np.searchsorted(cumulative_sum, random(N-k))
 
    return indexes
 
 
 

Referenced by tools.getGMMFromPosterior().

stratified_resample()

def resample.stratified_resample

(

weights

)

 Performs the stratified resampling algorithm used by particle filters.
This algorithms aims to make selections relatively uniformly across the
particles. It divides the cumulative sum of the weights into N equal
divisions, and then selects one particle randomly from each division. This
guarantees that each sample is between 0 and 2/N apart.
Parameters
----------
weights : list-like of float
    list of weights as floats
Returns
-------
indexes : ndarray of ints
    array of indexes into the weights defining the resample. i.e. the
    index of the zeroth resample is indexes[0], etc.

def stratified_resample(weights):
    """ Performs the stratified resampling algorithm used by particle filters.
    This algorithms aims to make selections relatively uniformly across the
    particles. It divides the cumulative sum of the weights into N equal
    divisions, and then selects one particle randomly from each division. This
    guarantees that each sample is between 0 and 2/N apart.
    Parameters
    ----------
    weights : list-like of float
        list of weights as floats
    Returns
    -------
    indexes : ndarray of ints
        array of indexes into the weights defining the resample. i.e. the
        index of the zeroth resample is indexes[0], etc.
    """
 
    N = len(weights)
    # make N subdivisions, and chose a random position within each one
    positions = (random(N) + range(N)) / N
 
    indexes = np.zeros(N, 'i')
    cumulative_sum = np.cumsum(weights)
    i, j = 0, 0
    while i < N:
        if positions[i] < cumulative_sum[j]:
            indexes[i] = j
            i += 1
        else:
            j += 1
    return indexes
 
 

systematic_resample()

def resample.systematic_resample

(

weights

)

 Performs the systemic resampling algorithm used by particle filters.
This algorithm separates the sample space into N divisions. A single random
offset is used to to choose where to sample from for all divisions. This
guarantees that every sample is exactly 1/N apart.
Parameters
----------
weights : list-like of float
    list of weights as floats
Returns
-------
indexes : ndarray of ints
    array of indexes into the weights defining the resample. i.e. the
    index of the zeroth resample is indexes[0], etc.

def systematic_resample(weights):
    """ Performs the systemic resampling algorithm used by particle filters.
    This algorithm separates the sample space into N divisions. A single random
    offset is used to to choose where to sample from for all divisions. This
    guarantees that every sample is exactly 1/N apart.
    Parameters
    ----------
    weights : list-like of float
        list of weights as floats
    Returns
    -------
    indexes : ndarray of ints
        array of indexes into the weights defining the resample. i.e. the
        index of the zeroth resample is indexes[0], etc.
    """
    N = len(weights)
 
    # make N subdivisions, and choose positions with a consistent random offset
    positions = (random() + np.arange(N)) / N
 
    indexes = np.zeros(N, 'i')
    cumulative_sum = np.cumsum(weights)
    i, j = 0, 0
    while i < N:
        if positions[i] < cumulative_sum[j]:
            indexes[i] = j
            i += 1
        else:
            j += 1
    return indexes
 
 

unWeighted_resample()

def resample.unWeighted_resample	(		weights,
			N
	)

def unWeighted_resample(weights,N):
    # take int(N*w) copies of each weight, which ensures particles with the same weight are drawn uniformly
    num_copies = (np.floor(N*np.asarray(weights))).astype(int)
    indexes = np.zeros(sum(num_copies), 'i')
    k = 0
    for i in range(len(weights)):
        for _ in range(num_copies[i]): # make n copies
            indexes[k] = i
            k += 1
    return indexes
 

Referenced by tools.resampledParamsTable().