Python numpy.cumprod() 使用实例

The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.

Example 1

def analyse_data(input_dir):

    shapes = []
    relative_volumes = []
    for folder in get_sub_folders(input_dir):
        print(folder)
        for sub_folder in get_sub_folders(os.path.join(input_dir, folder)):

            image_type = get_image_type_from_folder_name(sub_folder)

            # do not save the raw data (too heavy)
            if image_type != '.OT':
                continue

            path = os.path.join(input_dir, folder, sub_folder)
            filename = next(filename for filename in os.listdir(path) if get_extension(filename) == '.nii')
            path = os.path.join(path, filename)
            im = nib.load(path)
            image = im.get_data()
            shape = image.shape
            shapes.append(shape)
            relative_volumes.append(100 * np.sum(image) / np.cumprod(shape)[-1])
    return shapes, relative_volumes

# train 

Example 2

def test_basic(self):
        ba = [1, 2, 10, 11, 6, 5, 4]
        ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]]
        for ctype in [np.int16, np.uint16, np.int32, np.uint32,
                      np.float32, np.float64, np.complex64, np.complex128]:
            a = np.array(ba, ctype)
            a2 = np.array(ba2, ctype)
            if ctype in ['1', 'b']:
                self.assertRaises(ArithmeticError, np.cumprod, a)
                self.assertRaises(ArithmeticError, np.cumprod, a2, 1)
                self.assertRaises(ArithmeticError, np.cumprod, a)
            else:
                assert_array_equal(np.cumprod(a, axis=-1),
                                   np.array([1, 2, 20, 220,
                                             1320, 6600, 26400], ctype))
                assert_array_equal(np.cumprod(a2, axis=0),
                                   np.array([[1, 2, 3, 4],
                                             [5, 12, 21, 36],
                                             [50, 36, 84, 180]], ctype))
                assert_array_equal(np.cumprod(a2, axis=-1),
                                   np.array([[1, 2, 6, 24],
                                             [5, 30, 210, 1890],
                                             [10, 30, 120, 600]], ctype)) 

Example 3

def reshape_workaround(data, shape_out):  # type: (TensorOp, Sequence[int]) -> TensorOp
    """Limited workaround for tensor reshape operation."""
    shape_in = data.shape.lengths

    if np.prod(shape_in) != np.prod(shape_out):
        raise ValueError('Total size of input (%d) and output (%d) dimension mismatch.',
                         np.prod(shape_in), np.prod(shape_out))

    ndims_out = len(shape_out)
    if ndims_out == 1:
        tensor = ng.flatten(data)
    elif ndims_out == 2:
        cumprods = list(np.cumprod(shape_in))
        flatten_at_idx = cumprods.index(shape_out[0]) + 1
        tensor = ng.flatten_at(data, flatten_at_idx)
    else:
        raise NotImplementedError('Reshape can only support flatten to 1d or 2d.')

    return ng.cast_axes(tensor, make_pos_axes(shape_out)) 

Example 4

def _decade_mortality_table(year,
                            url_template='https://www.ssa.gov/oact/NOTES/as120/LifeTables_Tbl_7_{}.html'):
	assert int(year) % 10 == 0
	url = url_template.format(year)
	soup = BeautifulSoup(urlopen(url).read(), 'lxml')
	table = soup.find('table', border=1)
	rows = []
	for row in table.find_all('tr'):
		row_datum = [cell.text.strip() for cell in row.find_all('td')]
		if len(row_datum) == 15 and row_datum[0] != '':
			rows.append({
				'year_of_birth': int(year),
				'age': int(row_datum[0]),
				'm_prob_survive_that_year': 1 - float(row_datum[1]),
				'f_prob_survive_that_year': 1 - float(row_datum[9]),
			})
	df = pd.DataFrame(rows).sort_values(by='age')
	for sex in 'mf':
		df[sex + '_prob_alive'] = np.cumprod(df[sex + '_prob_survive_that_year']).astype(np.float64)
	df['as_of_year'] = df['year_of_birth'] + df['age']
	return df[['year_of_birth', 'as_of_year', 'm_prob_alive', 'f_prob_alive']] 

Example 5

def read_feature(filename):
    """Read feature dump by C3D

    Parameters
    ----------
    filename : str
        Fullpath of file to read

    Outputs
    -------
    x : ndarray
        numpy array of features

    Note: It accomplishes the same purpose of this code:
        C3D/examples/c3d_feature_extraction/script/read_binary_blob.m

    """
    s_parr, d_parr = array.array('i'), array.array('f')
    with open(filename, 'r') as f:
        s_parr.fromfile(f, 5)
        s = np.array(s_parr)
        m = np.cumprod(s)[-1]

        d_parr.fromfile(f, m)
    return s, np.array(d_parr) 

Example 6

def __init__(self, frame_sizes, n_rnn, dim, learn_h0, q_levels,
                 weight_norm):
        super().__init__()

        self.dim = dim
        self.q_levels = q_levels

        ns_frame_samples = map(int, np.cumprod(frame_sizes))
        self.frame_level_rnns = torch.nn.ModuleList([
            FrameLevelRNN(
                frame_size, n_frame_samples, n_rnn, dim, learn_h0, weight_norm
            )
            for (frame_size, n_frame_samples) in zip(
                frame_sizes, ns_frame_samples
            )
        ])

        self.sample_level_mlp = SampleLevelMLP(
            frame_sizes[0], dim, q_levels, weight_norm
        ) 

Example 7

def test_basic(self):
        ba = [1, 2, 10, 11, 6, 5, 4]
        ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]]
        for ctype in [np.int16, np.uint16, np.int32, np.uint32,
                      np.float32, np.float64, np.complex64, np.complex128]:
            a = np.array(ba, ctype)
            a2 = np.array(ba2, ctype)
            if ctype in ['1', 'b']:
                self.assertRaises(ArithmeticError, np.cumprod, a)
                self.assertRaises(ArithmeticError, np.cumprod, a2, 1)
                self.assertRaises(ArithmeticError, np.cumprod, a)
            else:
                assert_array_equal(np.cumprod(a, axis=-1),
                                   np.array([1, 2, 20, 220,
                                             1320, 6600, 26400], ctype))
                assert_array_equal(np.cumprod(a2, axis=0),
                                   np.array([[1, 2, 3, 4],
                                             [5, 12, 21, 36],
                                             [50, 36, 84, 180]], ctype))
                assert_array_equal(np.cumprod(a2, axis=-1),
                                   np.array([[1, 2, 6, 24],
                                             [5, 30, 210, 1890],
                                             [10, 30, 120, 600]], ctype)) 

Example 8

def test_basic(self):
        ba = [1, 2, 10, 11, 6, 5, 4]
        ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]]
        for ctype in [np.int16, np.uint16, np.int32, np.uint32,
                      np.float32, np.float64, np.complex64, np.complex128]:
            a = np.array(ba, ctype)
            a2 = np.array(ba2, ctype)
            if ctype in ['1', 'b']:
                self.assertRaises(ArithmeticError, np.cumprod, a)
                self.assertRaises(ArithmeticError, np.cumprod, a2, 1)
                self.assertRaises(ArithmeticError, np.cumprod, a)
            else:
                assert_array_equal(np.cumprod(a, axis=-1),
                                   np.array([1, 2, 20, 220,
                                             1320, 6600, 26400], ctype))
                assert_array_equal(np.cumprod(a2, axis=0),
                                   np.array([[1, 2, 3, 4],
                                             [5, 12, 21, 36],
                                             [50, 36, 84, 180]], ctype))
                assert_array_equal(np.cumprod(a2, axis=-1),
                                   np.array([[1, 2, 6, 24],
                                             [5, 30, 210, 1890],
                                             [10, 30, 120, 600]], ctype)) 

Example 9

def addVariable(self, var_name, var_dims, kind='Var', **kwargs):
        if var_name in self.var_dict:
            print "error: %s is a duplicated variable"%var_name
        var_name_parts = LPCompiler.var_name_regex.match(var_name)
        new_var = {
            'start' : self.total_var_length,
            'dims'  : var_dims,
            'cumdims': np.cumprod([1]+var_dims),
            'length': np.prod(var_dims),
            'name'  : var_name,
            'idx'   : var_name_parts.group('var').split(','),
            'lbl'   : var_name_parts.group('lbl').split(','),
            'kind'  : kind,
            'min_value' : 0 if 'min_value' not in kwargs else kwargs['min_value']
        }
        self.var_dict[var_name] = new_var
        if kind == 'Param':
            for i in range(new_var['start'], new_var['start']+new_var['length']):
                self.int_flag.append([i, 1])
        self.total_var_length += new_var['length'] 

Example 10

def parse_struc(img):
    nbs = neighbors(img.shape)
    acc = np.cumprod((1,)+img.shape[::-1][:-1])[::-1]
    img = img.ravel()
    pts = np.array(np.where(img==2))[0]
    buf = np.zeros(131072, dtype=np.int64)
    num = 10
    nodes = []
    for p in pts:
        if img[p] == 2:
            nds = fill(img, p, num, nbs, acc, buf)
            num += 1
            nodes.append(nds)

    edges = []
    for p in pts:
        for dp in nbs:
            if img[p+dp]==1:
                edge = trace(img, p+dp, nbs, acc, buf)
                edges.append(edge)
    return nodes, edges
    
# use nodes and edges build a networkx graph 

Example 11

def test_basic(self):
        ba = [1, 2, 10, 11, 6, 5, 4]
        ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]]
        for ctype in [np.int16, np.uint16, np.int32, np.uint32,
                      np.float32, np.float64, np.complex64, np.complex128]:
            a = np.array(ba, ctype)
            a2 = np.array(ba2, ctype)
            if ctype in ['1', 'b']:
                self.assertRaises(ArithmeticError, np.cumprod, a)
                self.assertRaises(ArithmeticError, np.cumprod, a2, 1)
                self.assertRaises(ArithmeticError, np.cumprod, a)
            else:
                assert_array_equal(np.cumprod(a, axis=-1),
                                   np.array([1, 2, 20, 220,
                                             1320, 6600, 26400], ctype))
                assert_array_equal(np.cumprod(a2, axis=0),
                                   np.array([[1, 2, 3, 4],
                                             [5, 12, 21, 36],
                                             [50, 36, 84, 180]], ctype))
                assert_array_equal(np.cumprod(a2, axis=-1),
                                   np.array([[1, 2, 6, 24],
                                             [5, 30, 210, 1890],
                                             [10, 30, 120, 600]], ctype)) 

Example 12

def test_basic(self):
        ba = [1, 2, 10, 11, 6, 5, 4]
        ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]]
        for ctype in [np.int16, np.uint16, np.int32, np.uint32,
                      np.float32, np.float64, np.complex64, np.complex128]:
            a = np.array(ba, ctype)
            a2 = np.array(ba2, ctype)
            if ctype in ['1', 'b']:
                self.assertRaises(ArithmeticError, np.cumprod, a)
                self.assertRaises(ArithmeticError, np.cumprod, a2, 1)
                self.assertRaises(ArithmeticError, np.cumprod, a)
            else:
                assert_array_equal(np.cumprod(a, axis=-1),
                                   np.array([1, 2, 20, 220,
                                             1320, 6600, 26400], ctype))
                assert_array_equal(np.cumprod(a2, axis=0),
                                   np.array([[1, 2, 3, 4],
                                             [5, 12, 21, 36],
                                             [50, 36, 84, 180]], ctype))
                assert_array_equal(np.cumprod(a2, axis=-1),
                                   np.array([[1, 2, 6, 24],
                                             [5, 30, 210, 1890],
                                             [10, 30, 120, 600]], ctype)) 

Example 13

def cumprod(x, axis=None):
    """Return the cumulative product of the elements along a given axis.

    Wraping of numpy.cumprod.

    Parameters
    ----------
    x
        Input tensor variable.

    axis
        The axis along which the cumulative product is computed.
        The default (None) is to compute the cumprod over the flattened array.

    .. versionadded:: 0.7

    """
    return CumprodOp(axis=axis)(x) 

Example 14

def summarizeVdToDocTopicCount(Vd):
    ''' Create DocTopicCount matrix from given stick-breaking parameters Vd

        Returns
        --------
        DocTopicCount : 2D array, size D x K
    '''
    assert not np.any(np.isnan(Vd))
    PRNG = np.random.RandomState(0)
    DocTopicCount = np.zeros(Vd.shape)
    for d in xrange(Vd.shape[0]):
        N_d = 100 + 50 * PRNG.rand()
        Pi_d = Vd[d, :].copy()
        Pi_d[1:] *= np.cumprod(1.0 - Vd[d, :-1])
        np.maximum(Pi_d, 1e-10, out=Pi_d)
        Pi_d /= np.sum(Pi_d)
        DocTopicCount[d, :] = N_d * Pi_d
    return DocTopicCount 

Example 15

def rho2beta(rho, returnSize='K+1'):
    ''' Calculate probability for all components including remainder.

    Returns
    --------
    beta : 1D array, size equal to 'K' or 'K+1', depending on returnSize
        beta[k] := probability of topic k
    '''
    rho = np.asarray(rho, dtype=np.float64)
    if returnSize == 'K':
        beta = rho.copy()
        beta[1:] *= np.cumprod(1 - rho[:-1])
    else:
        beta = np.append(rho, 1.0)
        beta[1:] *= np.cumprod(1.0 - rho)
    return beta 

Example 16

def discounts(self, periods_length, periods_num, libors, flat=False):
        """
        Return the calculated discounts for each period, flat discounts don't include the spread:
            if flat:
                period_rate = (libors[i - 1]) / periods_num
            else:
                period_rate = (libors[i - 1] + spread) / periods_num

            discounts[i] = discounts[i - 1] / (1 + period_rate)
        :param periods_length:
        :param periods_num:
        :param libors:
        :param flat: whether to calculate a flat discounts or not
        """
        discounts = np.zeros(periods_length)
        discounts[0] = 1
        if flat:
            rates = libors[:-1] + self.spread
        else:
            rates = libors[:-1]

        discounts[1:] = np.cumprod(1 / (1 + (rates / periods_num)), dtype=float)
        return discounts 

Example 17

def get_chunks(x, nbytes_desired):
    nbytes = np.array(x).ravel()[0].nbytes
    size_desired = nbytes_desired / nbytes
    if size_desired >= x.size:
        # desired chunk size is greater or equal than array size, thus we can include the whole array in a single chunk
        return x.shape
    s = x.shape[::-1]
    cp = np.cumprod(s)
    dim = np.argmax(cp >= size_desired)
    s_dim_desired = size_desired / np.prod(s[:dim])
    s_dim = np.round(s_dim_desired)
    if s_dim < 1:
        s_dim = 1
    chunks = np.ones_like(s)
    chunks[:dim] = s[:dim]
    chunks[dim] = s_dim
    result = tuple(chunks[::-1])
    return result 

Example 18

def test_basic(self):
        ba = [1, 2, 10, 11, 6, 5, 4]
        ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]]
        for ctype in [np.int16, np.uint16, np.int32, np.uint32,
                      np.float32, np.float64, np.complex64, np.complex128]:
            a = np.array(ba, ctype)
            a2 = np.array(ba2, ctype)
            if ctype in ['1', 'b']:
                self.assertRaises(ArithmeticError, np.cumprod, a)
                self.assertRaises(ArithmeticError, np.cumprod, a2, 1)
                self.assertRaises(ArithmeticError, np.cumprod, a)
            else:
                assert_array_equal(np.cumprod(a, axis=-1),
                                   np.array([1, 2, 20, 220,
                                             1320, 6600, 26400], ctype))
                assert_array_equal(np.cumprod(a2, axis=0),
                                   np.array([[1, 2, 3, 4],
                                             [5, 12, 21, 36],
                                             [50, 36, 84, 180]], ctype))
                assert_array_equal(np.cumprod(a2, axis=-1),
                                   np.array([[1, 2, 6, 24],
                                             [5, 30, 210, 1890],
                                             [10, 30, 120, 600]], ctype)) 

Example 19

def test_allocation_weighting(self):
        b, n = 5, 10
        u = np.random.rand(b, n)
        s = np.argsort(u, axis=1)

        correct_alloc = np.zeros((b, n)).astype(np.float32)
        for i in range(b):
            cp = np.concatenate([[1], np.cumprod(u[i][s[i]])[:-1]])
            correct_alloc[i][s[i]] = (1 - u[i][s[i]]) * cp

        with self.test_session():
            tf.global_variables_initializer().run()
            Memory.memory_size = n
            calculated_alloc = Memory.calculate_allocation_weighting(Memory, u).eval()
            self.assertAllClose(correct_alloc, calculated_alloc) 

Example 20

def cumproduct(a, axis=None, dtype=None, out=None):
    """
    Return the cumulative product over the given axis.


    See Also
    --------
    cumprod : equivalent function; see for details.

    """
    try:
        cumprod = a.cumprod
    except AttributeError:
        return _wrapit(a, 'cumprod', axis, dtype, out)
    return cumprod(axis, dtype, out) 

Example 21

def fill_diagonal(a, val, wrap=False):
    """Fills the main diagonal of the given array of any dimensionality.

    For an array `a` with ``a.ndim > 2``, the diagonal is the list of
    locations with indices ``a[i, i, ..., i]`` all identical. This function
    modifies the input array in-place, it does not return a value.

    Args:
        a (cupy.ndarray): The array, at least 2-D.
        val (scalar): The value to be written on the diagonal.
            Its type must be compatible with that of the array a.
        wrap (bool): If specified, the diagonal is "wrapped" after N columns.
            This affects only tall matrices.

    Examples
    --------
    >>> a = cupy.zeros((3, 3), int)
    >>> cupy.fill_diagonal(a, 5)
    >>> a
    array([[5, 0, 0],
           [0, 5, 0],
           [0, 0, 5]])

     .. seealso:: :func:`numpy.fill_diagonal`
    """
    # The followings are imported from the original numpy
    if a.ndim < 2:
        raise ValueError('array must be at least 2-d')
    end = None
    if a.ndim == 2:
        step = a.shape[1] + 1
        if not wrap:
            end = a.shape[1] * a.shape[1]
    else:
        if not numpy.alltrue(numpy.diff(a.shape) == 0):
            raise ValueError('All dimensions of input must be of equal length')
        step = 1 + numpy.cumprod(a.shape[:-1]).sum()

    # Since the current cupy does not support a.flat,
    # we use a.ravel() instead of a.flat
    a.ravel()[:end:step] = val 

Example 22

def cumprod(a, axis=None, dtype=None, out=None):
    """Returns the cumulative product of an array along a given axis.

    Args:
        a (cupy.ndarray): Input array.
        axis (int): Axis along which the cumulative product is taken. If it is
        not specified, the input is flattened.
        dtype: Data type specifier.
        out (cupy.ndarray): Output array.

    Returns:
        cupy.ndarray: The result array.

    .. seealso:: :func:`numpy.cumprod`

    """
    return _cum_core(a, axis, dtype, out, _cumprod_kern, _cumprod_batch_kern)


# TODO(okuta): Implement diff


# TODO(okuta): Implement ediff1d


# TODO(okuta): Implement gradient


# TODO(okuta): Implement cross


# TODO(okuta): Implement trapz 

Example 23

def __init__(self, shape, dtype, buffer=None, offset=0, strides=None):
        itemsize = dtype().itemsize
        shape = tuple(np.array(shape).ravel().astype(np.uint64))
        if strides is None:
            # This magic came from http://stackoverflow.com/a/32874295
            strides = itemsize * np.r_[1, np.cumprod(shape[::-1][:-1],
                                                     dtype=np.int64)][::-1]
        self.shape   = shape
        self.dtype   = dtype
        self.buffer  = buffer
        self.offset  = offset
        self.strides = strides
        self.base    = None
        self.flags   = {'WRITEABLE':    True,
                        'ALIGNED':      buffer % (itemsize == 0
                                                  if buffer is not None
                                                  else True),
                        'OWNDATA':      False,
                        'UPDATEIFCOPY': False,
                        'C_CONTIGUOUS': self.nbytes == strides[0] * shape[0],
                        'F_CONTIGUOUS': False,
                        'SPACE':        'cuda'}
        class CTypes(object):
            def __init__(self, parent):
                self.parent = parent
            @property
            def data(self):
                return self.parent.data
        self.ctypes = CTypes(self)
        if self.buffer is None:
            self.buffer = raw_malloc(self.nbytes, space='cuda')
            self.flags['OWNDATA'] = True
            self.flags['ALIGNED'] = True
            memset(self, 0)
        else:
            self.buffer += offset 

Example 24

def set_evaluation_feedback(self, feedbacks):
        """Set feedback for the last behavior.

        Parameters
        ----------
        feedbacks : list of float
            feedback for each step or for the episode, depends on the problem
        """
        visited_states = self.policy.visited_states
        actions_taken = self.policy.actions_taken
        n_steps = len(visited_states)
        assert n_steps == len(feedbacks)
        assert n_steps == len(actions_taken)
        gammas = np.hstack(
            ((1,), np.cumprod(np.ones(n_steps - 1) * self.gamma)))
        diff = 0.0
        for t in range(n_steps):
            s = visited_states[t]
            a = actions_taken[t]
            ret = sum(feedbacks[t:] * gammas[:n_steps - t])

            self.returns[s][a].append(ret)
            last_Q = self.Q[s][a]
            self.Q[s][a] = np.mean(self.returns[s][a])
            diff = max(diff, np.abs(last_Q - self.Q[s][a]))
        self.done = any(feedbacks > 0) and diff < 1e-3 

Example 25

def discount(rewards, gamma, timestamps):
    dt = np.diff(timestamps.squeeze())
    x = rewards.squeeze()
    g = np.power(gamma, dt)
    y = np.zeros_like(x)
    for n in range(len(y)):
        y[n] = x[n] + np.sum(x[n + 1:] * np.cumprod(g[n:]))
    return y 

Example 26

def __func__(arr):
        arr = arr.copy()
        arr[np.isnan(arr)] = 1
        return np.cumprod(arr, dtype=float) 

Example 27

def cumproduct(a, axis=None, dtype=None, out=None):
    """
    Return the cumulative product over the given axis.


    See Also
    --------
    cumprod : equivalent function; see for details.

    """
    try:
        cumprod = a.cumprod
    except AttributeError:
        return _wrapit(a, 'cumprod', axis, dtype, out)
    return cumprod(axis, dtype, out) 

Example 28

def __len__(self):
        """Returns the number of values handled by the :class:`MultiParameter`
        instance.  It is required, that the `shape` has been set beforehand,
        which specifies the length in each dimension.
        """
        return numpy.cumprod(self.shape)[-1] 

Example 29

def _create_prices(t):
    last_average = 100 if t==0 else source.data['average'][-1]
    returns = asarray(lognormal(mean.value, stddev.value, 1))
    average =  last_average * cumprod(returns)
    high = average * exp(abs(gamma(1, 0.03, size=1)))
    low = average / exp(abs(gamma(1, 0.03, size=1)))
    delta = high - low
    open = low + delta * uniform(0.05, 0.95, size=1)
    close = low + delta * uniform(0.05, 0.95, size=1)
    return open[0], high[0], low[0], close[0], average[0] 

Example 30

def _create_prices(t):
    global last_average
    returns = asarray(lognormal(mean, stddev, 1))
    average =  last_average * cumprod(returns)
    last_average = average

    high = average * exp(abs(gamma(1, 0.03, size=1)))
    low = average / exp(abs(gamma(1, 0.03, size=1)))
    delta = high - low
    open = low + delta * uniform(0.05, 0.95, size=1)
    close = low + delta * uniform(0.05, 0.95, size=1)
    return open[0], high[0], low[0], close[0], average[0] 

Example 31

def _create_prices(t):
    last_average = 100 if t==0 else source.data['average'][-1]
    returns = asarray(lognormal(mean.value, stddev.value, 1))
    average =  last_average * cumprod(returns)
    high = average * exp(abs(gamma(1, 0.03, size=1)))
    low = average / exp(abs(gamma(1, 0.03, size=1)))
    delta = high - low
    open = low + delta * uniform(0.05, 0.95, size=1)
    close = low + delta * uniform(0.05, 0.95, size=1)
    return open[0], high[0], low[0], close[0], average[0] 

Example 32

def _ema(prices, days=10):
    if len(prices) < days or days < 2: return [prices[-1]]
    a = 2.0 / (days+1)
    kernel = ones(days, dtype=float)
    kernel[1:] = 1 - a
    kernel = a * cumprod(kernel)
    # The 0.8647 normalizes out that we stop the EMA after a finite number of terms
    return convolve(prices[-days:], kernel, mode="valid") / (0.8647) 

Example 33

def _create_prices(t):
    last_average = 100 if t==0 else source.data['average'][-1]
    returns = asarray(lognormal(mean.value, stddev.value, 1))
    average =  last_average * cumprod(returns)
    high = average * exp(abs(gamma(1, 0.03, size=1)))
    low = average / exp(abs(gamma(1, 0.03, size=1)))
    delta = high - low
    open = low + delta * uniform(0.05, 0.95, size=1)
    close = low + delta * uniform(0.05, 0.95, size=1)
    return open[0], high[0], low[0], close[0], average[0] 

Example 34

def _grid_distance(self, index):
        """
        Calculate the distance grid for a single index position.

        This is pre-calculated for fast neighborhood calculations
        later on (see _calc_influence).
        """
        # Take every dimension but the first in reverse
        # then reverse that list again.
        dimensions = np.cumprod(self.map_dimensions[1::][::-1])[::-1]

        coord = []
        for idx, dim in enumerate(dimensions):
            if idx != 0:
                value = (index % dimensions[idx-1]) // dim
            else:
                value = index // dim
            coord.append(value)

        coord.append(index % self.map_dimensions[-1])

        for idx, (width, row) in enumerate(zip(self.map_dimensions, coord)):
            x = np.abs(np.arange(width) - row) ** 2
            dims = self.map_dimensions[::-1]
            if idx:
                dims = dims[:-idx]
            x = np.broadcast_to(x, dims).T
            if idx == 0:
                distance = np.copy(x)
            else:
                distance += x.T

        return distance 

Example 35

def test_cumprod(self):
        self._check_accum_op('cumprod') 

Example 36

def test_cummethods_bool(self):
        # GH 6270
        # looks like a buggy np.maximum.accumulate for numpy 1.6.1, py 3.2
        def cummin(x):
            return np.minimum.accumulate(x)

        def cummax(x):
            return np.maximum.accumulate(x)

        a = pd.Series([False, False, False, True, True, False, False])
        b = ~a
        c = pd.Series([False] * len(b))
        d = ~c
        methods = {'cumsum': np.cumsum,
                   'cumprod': np.cumprod,
                   'cummin': cummin,
                   'cummax': cummax}
        args = product((a, b, c, d), methods)
        for s, method in args:
            expected = Series(methods[method](s.values))
            result = getattr(s, method)()
            assert_series_equal(result, expected)

        e = pd.Series([False, True, nan, False])
        cse = pd.Series([0, 1, nan, 1], dtype=object)
        cpe = pd.Series([False, 0, nan, 0])
        cmin = pd.Series([False, False, nan, False])
        cmax = pd.Series([False, True, nan, True])
        expecteds = {'cumsum': cse,
                     'cumprod': cpe,
                     'cummin': cmin,
                     'cummax': cmax}

        for method in methods:
            res = getattr(e, method)()
            assert_series_equal(res, expecteds[method]) 

Example 37

def cumproduct(a, axis=None, dtype=None, out=None):
    """
    Return the cumulative product over the given axis.


    See Also
    --------
    cumprod : equivalent function; see for details.

    """
    try:
        cumprod = a.cumprod
    except AttributeError:
        return _wrapit(a, 'cumprod', axis, dtype, out)
    return cumprod(axis, dtype, out) 

Example 38

def p2(x, coef):
    X = np.empty(len(coef))
    X[0] = 1
    X[1:] = x
    y = np.cumprod(X)   # y = [1, x, x**2,...]
    return np.dot(coef, y) 

Example 39

def cumproduct(a, axis=None, dtype=None, out=None):
    """
    Return the cumulative product over the given axis.


    See Also
    --------
    cumprod : equivalent function; see for details.

    """
    try:
        cumprod = a.cumprod
    except AttributeError:
        return _wrapit(a, 'cumprod', axis, dtype, out)
    return cumprod(axis, dtype, out) 

Example 40

def get_idx_from_arg(a, arg, axis):
    shp = a.shape
    cp = np.cumprod(shp[::-1])[::-1]
    if axis == len(shp) - 1:
        m = 1
    else:
        m = cp[axis + 1]
    n = cp[0] // cp[axis]
    if m == 1:
        return np.arange(n) * cp[axis] + arg.ravel()
    return np.repeat(np.arange(n) * cp[axis], m) + np.tile(np.arange(m), n) + arg.ravel() * m 

Example 41

def read_feature(filename, keep_shape=False):
    """Read feature (a.k.a blob) dump by C3D.

    Parameters
    ----------
    filename : str
        Fullpath of file to read.
    keep_shape : bool
        Reshape feature to the shape reported.

    Outputs
    -------
    feature : ndarray
        numpy array of features
    s : tuple
        shape of original feature

    Note: It accomplishes the same purpose of this code:
        C3D/examples/c3d_feature_extraction/script/read_binary_blob.m

    """
    s_parr, d_parr = array.array('i'), array.array('f')
    with open(filename, 'rb') as f:
        s_parr.fromfile(f, 5)
        s = np.array(s_parr)
        m = np.cumprod(s)[-1]

        d_parr.fromfile(f, m)

    feature = np.array(d_parr)
    if keep_shape:
        feature = feature.reshape(s)
    return feature, s 

Example 42

def __init__(self, prefix, children, suffix='.dat', root='root', createdirs=True):
        '''
        Parameters
        ----------

        prefix : string
            All paths are prefixed with this string.

        children: sequence of ints
            Creates a directory tree rooted at path given by `root` with levels
            specified by the `children` array: level ``i`` had ``children[i]``
            children. ``children[-1]`` specifies the arity of the leaves.

        suffix : string
            The suffix of the leafs (i.e. files) of the tree.

        root : path
            The path to the root of the tree.

        createdirs : bool.
            If True, actually create the directories. Note: this is not thread-safe.
        '''
        if len(children) == 0:
            raise ValueError("need at least one level")
        self.children = np.asarray(children)
        self.root = root
        self.prefix = prefix
        self.suffix = suffix
        self.depth = len(children)
        self._cap = np.cumprod(self.children[::-1])[::-1]
        self.capacity = self._cap[0]
        self._den = self._cap / self.children
        self.width = int(np.ceil(np.log10(self.capacity)))
        if createdirs:
            self._mktree() 

Example 43

def neighbors(shape, conn=1):
    dim = len(shape)
    block = generate_binary_structure(dim, conn)
    block[tuple([1]*dim)] = 0
    idx = np.where(block>0)
    idx = np.array(idx, dtype=np.uint8).T
    idx = np.array(idx-[1]*dim)
    acc = np.cumprod((1,)+shape[::-1][:-1])
    return np.dot(idx, acc[::-1]) 

Example 44

def neighbors(shape):
    dim = len(shape)
    block = np.ones([3]*dim)
    block[tuple([1]*dim)] = 0
    idx = np.where(block>0)
    idx = np.array(idx, dtype=np.uint8).T
    idx = np.array(idx-[1]*dim)
    acc = np.cumprod((1,)+shape[::-1][:-1])
    return np.dot(idx, acc[::-1]) 

Example 45

def filter(img, msk, idx, bur, tor, mode):
    nbs = neighbors(img.shape)
    acc = np.cumprod((1,)+img.shape[::-1][:-1])[::-1]
    img = img.ravel()
    msk = msk.ravel()

    arg = np.argsort(img[idx])[::-1 if mode else 1]

    for i in arg:
        if msk[idx[i]]!=3:
            idx[i] = 0
            continue
        cur = 0; s = 1;
        bur[0] = idx[i]
        while cur<s:
            p = bur[cur]
            if msk[p] == 2:
                idx[i]=0
                break

            for dp in nbs:
                cp = p+dp
                if msk[cp]==0 or cp==idx[i] or msk[cp] == 4: continue
                if mode and img[cp] < img[idx[i]]-tor: continue
                if not mode and img[cp] > img[idx[i]]+tor: continue
                bur[s] = cp
                s += 1
                if s==msk.size//3:
                    cut = cur//2
                    msk[bur[:cut]] = 2
                    bur[:s-cut] = bur[cut:]
                    cur -= cut
                    s -= cut
    
                if msk[cp]!=2:msk[cp] = 4
            cur += 1
        msk[bur[:s]] = 2

    return idx2rc(idx[idx>0], acc) 

Example 46

def ridge(img, mark, up=True):
    oimg, omark = img, mark
    ndim = img.ndim
    mark[[0,-1],:] = 4
    mark[:,[0,-1]] = 4
    
    nb4 = nbs4(*img.shape)
    nb8 = nbs8(*img.shape)
    acc = np.cumprod((1,)+img.shape[::-1][:-1])[::-1]
    img = img.ravel()
    mark = mark.ravel()

    pts = np.zeros(131072, dtype=np.int64)
    s, bins = collect(img, mark, nb4, pts)
    
    #print(bins)
    aaa=0
    for level in range(len(bins))[::1 if up else -1]:
        
        if bins[level]==0:continue
        aaa+=1
        s, c = clear(mark, pts, s, 0)
        s = step(img, mark, pts, s, level, up, nb4, nb8)
        '''
        if level>250:
            plt.imshow(omark, cmap='gray')
            plt.show()
        '''
    for i in range(len(mark)):
        if mark[i] == 3:mark[i] = 255
        else: mark[i] = 0 

Example 47

def neighbors(shape):
	dim = len(shape)
	block = generate_binary_structure(dim, 1)
	block[tuple([1]*dim)] = 0
	idx = np.where(block>0)
	idx = np.array(idx, dtype=np.uint8).T
	idx = np.array(idx-[1]*dim)
	acc = np.cumprod((1,)+shape[::-1][:-1])
	return np.dot(idx, acc[::-1]) 

Example 48

def draw_graph(img, graph, cn=255, ce=128):
    acc = np.cumprod((1,)+img.shape[::-1][:-1])[::-1]
    img = img.ravel()
    for idx in graph.nodes():
        pts = graph.node[idx]['pts']
        img[np.dot(pts, acc)] = cn
    for (s, e) in graph.edges():
        eds = graph[s][e]
        for i in eds:
            pts = eds[i]['pts']
            img[np.dot(pts, acc)] = ce 

Example 49

def run(self, ips, snap, img, para = None):
        ips.lut = self.buflut
        k, unit = ips.unit
        lev, ds, step = para['thr'], para['ds'], para['step']
        scube = np.cumprod(ips.imgs.shape)[-1] * k**3
        sfront = (ips.imgs[::ds,::ds,::ds]>lev).sum() * ds ** 3 * k**3
        sback = scube - sfront
        print(scube, sfront, sback)
        vts, fs, ns, cs =  marching_cubes_lewiner(ips.imgs[::ds,::ds,::ds], lev, step_size=step)
        area = mesh_surface_area(vts, fs) * (ds**2 * k **2)
        rst = [round(i,3) for i in [scube, sfront, sback, sfront/scube, area, area/sfront]]
        titles = ['Cube Volume', 'Volume', 'Blank', 'Volume/Cube', 'Surface', 'Volume/Surface']
        IPy.table('Volume Measure', [rst], cols=titles) 

Example 50

def _map_global_to_filtered(self, k):
        """
        map global (unfiltered) ND key to local (filtered) 2D key

        Parameters
        ----------
        k: tuple
            Labels associated with the modified element of the non-filtered array.

        Returns
        -------
        tuple
            Positional index (row, column) of the modified data cell.
        """
        assert isinstance(k, tuple) and len(k) == self.la_data.ndim
        dkey = {axis_id: axis_key for axis_key, axis_id in zip(k, self.la_data.axes.ids)}
        # transform global dictionary key to "local" (filtered) key by removing
        # the parts of the key which are redundant with the filter
        for axis_id, axis_filter in self.current_filter.items():
            axis_key = dkey[axis_id]
            if np.isscalar(axis_filter) and axis_key == axis_filter:
                del dkey[axis_id]
            elif not np.isscalar(axis_filter) and axis_key in axis_filter:
                pass
            else:
                # that key is invalid for/outside the current filter
                return None
        # transform (axis:label) dict key to positional ND key
        try:
            index_key = self.filtered_data._translated_key(dkey)
        except ValueError:
            return None
        # transform positional ND key to positional 2D key
        strides = np.append(1, np.cumprod(self.filtered_data.shape[1:-1][::-1], dtype=int))[::-1]
        return (index_key[:-1] * strides).sum(), index_key[-1] 
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注