def test_trim_old(self):
x = ma.arange(100)
assert_equal(mstats.trimboth(x).count(), 60)
assert_equal(mstats.trimtail(x,tail='r').count(), 80)
x[50:70] = masked
trimx = mstats.trimboth(x)
assert_equal(trimx.count(), 48)
assert_equal(trimx._mask, [1]*16 + [0]*34 + [1]*20 + [0]*14 + [1]*16)
x._mask = nomask
x.shape = (10,10)
assert_equal(mstats.trimboth(x).count(), 60)
assert_equal(mstats.trimtail(x).count(), 80)
def test_trim_old(self):
x = ma.arange(100)
assert_equal(mstats.trimboth(x).count(), 60)
assert_equal(mstats.trimtail(x,tail='r').count(), 80)
x[50:70] = masked
trimx = mstats.trimboth(x)
assert_equal(trimx.count(), 48)
assert_equal(trimx._mask, [1]*16 + [0]*34 + [1]*20 + [0]*14 + [1]*16)
x._mask = nomask
x.shape = (10,10)
assert_equal(mstats.trimboth(x).count(), 60)
assert_equal(mstats.trimtail(x).count(), 80)
def trimmean(x, alpha, inclusive=(False, False), axis=None):
"""Compute the `alpha`-trimmed mean of an array `x`.
Parameters
----------
x : array_like
The array on which to operate.
alpha : float or int
A number between 0 and 100, left inclusive indicating the
percentage of values to cut from `x`.
inclusive : tuple of bools, optional
Whether to round (True, True) or truncate the values
(False, False). Defaults to truncation. Note that this is different
from ``scipy.stats.mstats.trimboth``'s default.
axis : int or None, optional
The axis over which to operate. None flattens the array
Returns
-------
m : Series
The `alpha`-trimmed mean of `x` along axis `axis`.
"""
assert 0 <= alpha < 100, 'alpha must be in the interval [0, 100)'
assert len(inclusive) == 2, 'inclusive must have only 2 elements'
if isinstance(x, (numbers.Number)) or (hasattr(x, 'size') and
x.size == 1):
return float(x)
assert axis is None or 0 <= axis < x.ndim, \
'axis must be None or less than x.ndim: {0}'.format(x.ndim)
trimmed = trimboth(x, alpha / 100.0, inclusive, axis).mean(axis)
index = None
if isinstance(x, DataFrame):
index = {0: x.columns, 1: x.index, None: None}[axis]
return Series(trimmed, index=index)
def forward(self, bottom, top):
"""Forward: either using max pooling or average pooling
"""
num_ = bottom[0].data.shape[0]
if DEBUG:
print("Number of samples input: {}".format(num_))
bottom_data_ = bottom[0].data.reshape(num_, -1)
# pooling mask is of the same size as input
# then backward could be calculated as matrix multiplication
self._pooling_mask = np.zeros(bottom[0].data.shape)
# max pooling
if self._pooling == 'MAX':
# perform max pooling
pooled_data_ = np.max(bottom_data_, axis=0)
self._max_ids = np.argmax(bottom_data_, axis=0).reshape(
bottom[0].shape[1:])
# set the pooling_mask
for i in range(len(self._max_ids)):
self._pooling_mask[self._max_ids[i], i] = 1.0
elif self._pooling == 'AVE':
# perform average pooling
trim_ = float(self._layer_params.get('trim', 0.0))
if trim_ == 0.0:
pooled_data_ = np.mean(bottom_data_, axis=0)
self._pooling_mask = np.ones(self._pooling_mask.shape)
self._pooling_mask *= (1.0 / float(num_))
else:
# trimmed mean, with percentage of trim_
trimmed_data_ = trimboth(
bottom_data_, proportiontocut=trim_, axis=0)
pooled_data_ = trimmed_data_.mean(axis=0)
trimmed_count_ \
= trimmed_data_.mask.astype(np.float32)[:, 1].sum()
self._pooling_mask \
= (1 - trimmed_data_.mask).astype(np.float32)
if DEBUG:
print self._pooling_mask
self._pooling_mask /= trimmed_count_
elif self._pooling == 'GAUSSIAN':
# Fit a gaussian distribution
sigma_clip = 0.05
bottom_mean_ = np.mean(bottom_data_, axis=0)
bottom_var_ = np.cov(bottom_data_.transpose())
self._gaussian_weights = multivariate_normal.pdf(
bottom_data_, bottom_mean_, bottom_var_, allow_singular=True)
if DEBUG:
print("Before clipping: {}".format(
(self._gaussian_weights > 0).sum()))
# print(self._gaussian_weights)
# clip samples far away from the mean
self._gaussian_weights /= self._gaussian_weights.max()
if DEBUG:
print self._gaussian_weights
self._gaussian_weights[
np.where(self._gaussian_weights < sigma_clip)] = 0
if DEBUG:
print('Number of bbox activated: {}'.format(
(self._gaussian_weights > 0).sum()))
# print(self._gaussian_weights)
self._gaussian_weights /= self._gaussian_weights.sum()
self._pooling_mask = np.ones(self._pooling_mask.shape)
pooled_data_ = bottom_data_ * self._gaussian_weights[:, np.newaxis]
pooled_data_ = pooled_data_.sum(axis=0)
for i in range(len(self._gaussian_weights)):
self._pooling_mask[i, ...] *= self._gaussian_weights[i]
else:
print("WRONG POOLING TYPE")
pooled_data_ = np.zeros((1, bottom_data_.shape[1]))
if DEBUG:
print('Pooling Mask: {}'.format(self._pooling_mask))
top[0].data[0, ...] = pooled_data_.reshape(bottom[0].data.shape[1:])
