_2006-08-07์ trac ์ฌ์ฉ์ martin_wiechert์ ์๋ณธ ํฐ์ผ http://projects.scipy.org/numpy/ticket/236 , unknown์ ํ ๋น ๋จ _
In [1]:import numpy
In [2]:numpy.version.version
Out[2]:'1.0b1'
In [3]:a = numpy.arange (5)
In [4]:numpy.add.reduceat (a, (1,1))
Out[4]:array([ 1, 10])
_ @ teoliphant ๋ ์ด 2006-08-08์ ์์ฑํ์ต๋๋ค
๋ถํํ๋ NumPy์ reduceat ๋ฉ์๋๋์ด ์ฝ๋ ์ผ์ด์ค์ ๋ํด Numeric์ reduceat ๋ฉ์๋์ ๋์์ ๋ฐ๋ฆ ๋๋ค.
์ธ๋ฑ์ค๊ฐ ๊ฐ์ ๊ฒฝ์ฐ ์์ ์ "identity"์์๋ฅผ ๋ฐํํ๋ ๊ธฐ๋ฅ์ด ์์ต๋๋ค. ์ ์ ๋ ๋์์ ์ฌ๋ผ์ด์ค๊ฐ ๋น ์ํ์ค๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ ์ฒซ ๋ฒ์งธ ์ธ๋ฑ์ค๊ฐ ์ ๊ณตํ๋ ์์๋ฅผ ๋ฐํํ๋ ๊ฒ์ ๋๋ค. ๋ฐ๋ผ์์ด ๊ฒฝ์ฐ reduceat์ ๋ฌธ์ํ ๋ ์ค์ ๋์์ ๋ค์์ ๊ตฌ์ฑํ๋ ๊ฒ์ ๋๋ค.
[a [1], add.reduce (a [1 :])]
์ด๊ฒ์ ๊ธฐ๋ฅ ์์ฒญ์ ๋๋ค.
_trac ์ฌ์ฉ์ martin_wiechert ๋์ด 2006-08-08์ ์์ฑํ์ต๋๋ค _
ํฐ์ผ # 835 ์ฐธ์กฐ
2007-05-12์ @alberts๊ฐ ๋ง์ผ์คํค์ 1.1
๋ก ๋ณ๊ฒฝ ํ์ต๋๋ค.
2009 ๋
3 ์ Unscheduled
์ @cournape๊ฐ ๋ง์ผ์คํค์ Unscheduled
๋ก ๋ณ๊ฒฝ ํ์ต๋๋ค.
๋๋ ์ด๊ฒ์ด # 835์ ๋ฐ์ ํ๊ฒ ๊ด๋ จ๋์ด ์๋ค๊ณ ์๊ฐํฉ๋๋ค : ์ธ๋ฑ์ค ์ค ํ๋๊ฐ len(a)
์ด๋ฉด reduceat
๋ ํด๋น ์ธ๋ฑ์ค์ ์์๋ฅผ ์ถ๋ ฅ ํ ์ ์์ต๋๋ค. ์ด๋ ์ธ๋ฑ์ค len(a)
๊ฐ ๋ํ๋๋ ๊ฒฝ์ฐ์ ํ์ํฉ๋๋ค. ๋๋ ์ธ๋ฑ์ค ๋์์ ๋ฐ๋ณต๋ฉ๋๋ค.
๋ช ๊ฐ์ง ์๋ฃจ์ :
reduceat
์ถ๋ ฅ์ ๊ฐ์ ์ค์ ํ์ง ์๋ ๊ฒฝ์ฐ end - start == 0
end - start == 0
where
ํ๋ผ๋ฏธํฐ์ฒ๋ผ ufunc()
์ถ๋ ฅ ๋ชจ๋์์ ๊ณ์ฐ๋์ด์ผํ๋ ๋ง์คํฌ.์ด ๋ฌธ์ ์ ๋ํด ๋ ์ด์ ์๊ฐ์ด ์์ต๋๊น? end-start == 0 ์ธ ID ๊ฐ (์กด์ฌํ๋ ๊ฒฝ์ฐ)์ผ๋ก ์ถ๋ ฅ์ ์ค์ ํ๋ ์ต์ ์ ๊ด์ฌ์ด ์์ต๋๋ค.
์ ๋์ด ์ค๋ ๊ณต๊ฐ ํธ์์ ์ ์ํ๋๋ก reduceat
๋์์ ๋ณ๊ฒฝ์ ๊ฐ๋ ฅํ์ง์งํฉ๋๋ค. ์ด ์๋ํ Numpy ๊ตฌ์กฐ์ ์ ์ฉ์ฑ์ ๋ฐฉํดํ๋ ๋ช
ํํ ๋ฒ๊ทธ ๋๋ ๋ช
๋ฐฑํ ๋์์ธ ์ค์์ฒ๋ผ ๋ณด์
๋๋ค.
reduceat
๋ ๋ชจ๋ ์ธ๋ฑ์ค์ ๋ํด ์ผ๊ด๋๊ฒ ์๋ํด์ผํฉ๋๋ค. ์ฆ, ๋ชจ๋ ์ธ๋ฑ์ค i์ ๋ํด ufunc.reduceat(a, indices)
๋ ufunc.reduce(a[indices[i]:indices[i+1]])
๋ฐํํด์ผํฉ๋๋ค.
indices[i] == indices[i+1]
๊ฒฝ์ฐ์๋ ๋ง์ฐฌ๊ฐ์ง์
๋๋ค. ๋๋์ด ๊ฒฝ์ฐ, reduceat ๋ฐํํด์ผํ๋ ์ด์ , ์ด๋ค ํฉ๋ฆฌ์ ์ธ ์ด์ ๋ฅผ ๋ณผ ์ a[indices[i]]
๋์ ufunc.reduce(a[indices[i]:indices[i+1]])
.
Pandas ์ ์์ Wes McKinney ์ ์ ์ฌํ ๋๊ธ๋ ์ฌ๊ธฐ๋ฅผ ์ฐธ์กฐ
์, ์ด๊ฑด ์ ๋ง ๋์ฐํ๊ณ ๊นจ์ก์ต๋๋ค.
.
๋ฉ์ผ ๋ง๋ฆฌ์คํธ์ ๋ํ ๋
ผ์๊ฐ ํ์ํ์ง๋ง ์ ์ด๋ ๋๋
๋ค์ ๋ฆด๋ฆฌ์ค์์ ํด๋น ๋ฌธ์ ๋ฅผ FutureWarning์ผ๋ก ๋ง๋๋ ๊ฒ์ ์ ์ ์ผ๋ก ์ฐฌ์ฑ
๋์ค์ ๋ช ๋ฒ์ ๋ฆด๋ฆฌ์ค์์ ๋์์ ์์ ํฉ๋๋ค. ์ฐ๋ฆฌ๋ ๊ฑธ๋ฆด ๋๊ตฐ๊ฐ๊ฐ ํ์ํฉ๋๋ค
ํ ๋ก ์ ์์ํ๊ณ ํจ์น๋ฅผ ์์ฑํ๋ ์ผ์ ์ฃผ๋ํ์ญ์์ค. ์๋ง๋ ๋น์ ์ผ๊น์?
์ง์ง ํด์ฃผ์ ์ ๊ฐ์ฌํฉ๋๋ค. ์ด๊ฒ์ด ๋์์ด๋๋ค๋ฉด ํ ๋ก ์ ์์ํ ์ ์์ง๋ง ๋ถํํ๋ C ์ฝ๋๋ฅผ ํจ์น ํ ์๋ ์์ต๋๋ค.
np.maximum๊ณผ ๊ฐ์ด ID๊ฐ์๋ ufuncs์ ๋ํด ๋ฌด์์ ์๋ํฉ๋๊น?
์ด๋ฌํ ํจ์์ ๊ฒฝ์ฐ ๋น ๊ฐ์๋ ์ด๋ฏธ ์ค๋ฅ์ด๋ฏ๋ก ์ค๋ฅ ์ฌ์ผํฉ๋๋ค.
.reduceat () ๋์ .reduce ()๋ฅผ ์ฌ์ฉํ ๋.
์ฌ์ค, ํ๋์ ๋ชจ๋ ์ฌ์ฉ์๊ฐ ๊ธฐ๋ํ๋ ufunc.reduce(a[indices[i]:indices[i+1]])
์์ ์ผ๊ด์ฑ์ ์ํด ์ฃผ๋๋์ด์ผํฉ๋๋ค. ๋ฐ๋ผ์ ์ด๊ฒ์ ์๋ก์ด ๋์์ธ ๊ฒฐ์ ์ด ํ์ํ์ง ์์ต๋๋ค. ์ ์๊ฒ ์ค๋ ์ง์๋๋ ๋ฒ๊ทธ ์์ ์ฒ๋ผ ๋ณด์
๋๋ค. ์๋ฌด๋ ํ์ฌ์ ์ผ๊ด๋์ง ์์ ํ๋์ ์ ๋นํ ํ ์ ์๋ค๋ฉด.
@njsmith Numpy ๋ชฉ๋ก์ ๋ฑ๋ก ํ ์ ์์ต๋๋ค. ๋ด ์ฃผ์๋ฅผ https://mail.scipy.org/mailman/listinfo/numpy-discussion์ผ๋ก ๋ณด๋์ง ๋ง "ํ์ธ ์์ฒญ ์ด๋ฉ์ผ"์๋ฐ์ง ๋ชปํ์ต๋๋ค. ๊ตฌ๋ ์ ํน๋ณํ ์๊ตฌ ์ฌํญ์ด ํ์ํ์ง ํ์คํ์ง ์์ต๋๋ค ...
@divenex : ์คํธ ํด๋๋ฅผ ํ์ธํ์ จ์ต๋๊น? (๋๋ ํญ์ ๊ทธ๊ฒ์ ์๋๋ค ...) ๊ทธ๋ ์ง ์์ผ๋ฉด ๋๋ ๋ฌด์์ด ์๋ชป ๋ ์ ์๋์ง ํ์ ํ์ง ๋ชปํ๋ค. "์ด๋ฉ์ผ ์ฃผ์ ์์"์ธ์ ๊ตฌ๋ ์์ํ ํน๋ณํ ์๊ตฌ ์ฌํญ์ด ์์ด์ผํฉ๋๋ค. ๊ทธ๋๋ ์ ๋๋ก ์๋ํ์ง ์์ผ๋ฉด ๋ฌธ์ ๋ฅผ ์ ๊ธฐํ๋ฉด ๊ด๋ จ ์์คํ ๊ด๋ฆฌ์๋ฅผ ์ถ์ ํด ๋ณด๊ฒ ์ต๋๋ค. ๋ฌธ์ ๊ฐ ์๋์ง ํ์คํ ์๊ณ ์ถ์ต๋๋ค.
ufunc.reduce(a[indices[i]:indices[i+1]])
์ ์ผ์นํ๋ reduceat
๋ฒ์ ์ ์ ๋ง ์ ๋ง ์ข์ ๊ฒ์
๋๋ค. ํจ์ฌ ๋ ์ ์ฉ ํ ๊ฒ์
๋๋ค! ๋์์ ์ ํํ๋ ์ธ์ ๋๋ ์ ํจ์ ( reduce_intervals
? reduce_segments
? ...?)๋ ์ด์ ๋ฒ์ ์ ๋น ํธํ์ฑ์ ๊นจ๋ ๊ฒ์ ๋ฐฉ์งํฉ๋๋ค.
np.ufunc.reduceat
์ฌ์ฉํ์ง ์์ผ๋ ค๋ ์ ํน์๋ฐ์ ์ ์์ต๋๋ค. indices[i] > indices[i+1]
๊ฒฝ์ฐ๋ฅผ ํผํ๊ธฐ ์ํด ์์ ๋ฐ ๋ ์ธ๋ฑ์ค ์งํฉ์ ์ง์ ํ ์์๋ ๊ฒ์ด ๋ ์ ์ฉ ํด ๋ณด์
๋๋ค. ๋ํ at
๋ผ๋ ์ด๋ฆ์ ๊ธฐ์กด์ ์กด์ฌํ๋ ๊ฒ๋ณด๋ค at
์ ํจ์ฌ ๋ ์ ์ฌ ํจ์ ๋ํ๋
๋๋ค.
๋ด๊ฐ ๋์ฒด๋ก ์ ์ํ๊ณ ์ถ์ ๊ฒ์ np.piecewise_reduce
np.reducebins
, ์๋ง๋ ์์ ํ์ด์ฌ์
๋๋ค.
def reducebins(func, arr, start=None, stop=None, axis=-1, out=None):
"""
Compute (in the 1d case) `out[i] = func.reduce(arr[start[i]:stop[i]])`
If only `start` is specified, this computes the same reduce at `reduceat` did:
`out[i] = func.reduce(arr[start[i]:start[i+1]])`
`out[-1] = func.reduce(arr[start[-1]:])`
If only `stop` is specified, this computes:
`out[0] = func.reduce(arr[:stop[0]])`
`out[i] = func.reduce(arr[stop[i-1]:stop[i]])`
"""
# convert to 1d arrays
if start is not None:
start = np.array(start, copy=False, ndmin=1, dtype=np.intp)
assert start.ndim == 1
if stop is not None:
stop = np.array(stop, copy=False, ndmin=1, dtype=np.intp)
assert stop.ndim == 1
# default arguments that do useful things
if start is None and stop is None:
raise ValueError('At least one of start and stop must be specified')
elif stop is None:
# start only means reduce from one index to the next, and the last to the end
stop = np.empty_like(start)
stop[:-1] = start[1:]
stop[-1] = arr.shape[axis]
elif start is None:
# stop only means reduce from the start to the first index, and one index to the next
start = np.empty_like(stop)
start[1:] = stop[:-1]
start[0] = 0
else:
# TODO: possibly confusing?
start, stop = np.broadcast_arrays(start, stop)
# allocate output - not clear how to do this safely for subclasses
if not out:
sh = list(arr.shape)
sh[axis] = len(stop)
sh = tuple(sh)
out = np.empty(shape=sh)
# below assumes axis=0 for brevity here
for i, (si, ei) in enumerate(zip(start, stop)):
func.reduce(arr[si:ei,...], out=out[i, ...], axis=axis)
return out
๋ค์๊ณผ ๊ฐ์ ์ข์ ์์ฑ์ด ์์ต๋๋ค.
np.add.reduce(arr)
๋ np.piecewise_reduce(np.add, arr, 0, len(arr))
์ ๋์ผํฉ๋๋ค.np.add.reduceat(arr, inds)
๋ np.piecewise_reduce(np.add, arr, inds)
์ ๋์ผํฉ๋๋ค.np.add.accumulate(arr)
๋ np.piecewise_reduce(np.add, arr, 0, np.arange(len(arr)))
์ ๋์ผํฉ๋๋ค.์ด์ __array_ufunc__
๊ธฐ๊ณ๋ฅผ ํต๊ณผํ๊ณ ์ถ์ต๋๊น? ์ฒ๋ฆฌํด์ผํ๋ ๋๋ถ๋ถ์ ํญ๋ชฉ์ ์ด๋ฏธ func.reduce
๋ก ์ฒ๋ฆฌ๋์ด์ผํฉ๋๋ค. ์ ์ผํ ๋ฌธ์ ๋ np.concatenate
๊ณต์ ํ๋ ๋ฌธ์ ์ธ np.empty
๋ผ์ธ์
๋๋ค.
๊ทธ๊ฒ์ API ๊ด์ ์์ ๋์๊ฒ ์ข์ ํด๊ฒฐ์ฑ
์ฒ๋ผ ๋ค๋ฆฝ๋๋ค. reduceat
๋ ์ธํธ์ ์ธ๋ฑ์ค๋ฅผ ์ง์ ํ ์์๋ ๊ฒ๋ง์ผ๋ก๋ ์ถฉ๋ถํฉ๋๋ค. ๊ตฌํ ๊ด์ ์์? ์ด์ ์ ์ ๊ณตํ๋ ๊ฒฝ์ฐ ํ์ฌ PyUFunc_Reduceat
๋ฅผ ๋ ์ธํธ์ inds๋ฅผ ์ง์ํ๋๋ก ๋ณ๊ฒฝํ๋ ๊ฒ์ ๊ทธ๋ฆฌ ์ด๋ ต์ง ์์ต๋๋ค. ์ถ์ ๊ณผ ๊ฐ์ ์ ์ค ์ผ์ด์ค๋ฅผ ํจ์จ์ ์ผ๋ก ์ง์ํ๋ ์ด์ ์ ์ค์ ๋ก ๋ณธ๋ค๋ฉด ๊ทธ๋ ๊ฒํ๋ ๊ฒ๋ ์ด๋ ต์ง ์์ ๊ฒ์
๋๋ค.
Marten์ ~ 1์ ๋น์ทํ ํ ๋ก ์์ ์ด์ ๋น์ทํ ๊ฒ์ ์ ์ํ์ต๋๋ค.
1 ๋
์ ์ ๊ทธ๋ '๋จ๊ณ'์ต์
์ ์ถ๊ฐ ํ ๊ฐ๋ฅ์ฑ๋ ์ธ๊ธํ์ต๋๋ค.
http://numpy-discussion.10968.n7.nabble.com/Behavior-of-reduceat-td42667.html
์ ์์์ ๋ด๊ฐ ์ข์ํ๋ ๊ฒ (๋๊ตฐ๊ฐ๊ฐ ๊ณ์ฐ ์ค์ด๋ฉด +1) :
์ด ์๋ก์ด ๊ธฐ๋ฅ์ ๋ํด ์ด์ฌํ ์๊ฐํ๋ ๊ฒ์ด ์ค์ํ๋ค๊ณ ์๊ฐํ๋ ๊ฒ :
๊ทธ๋ฆฌ๊ณ ์์ ๊ฑฐ ์ฐฝ๊ณ ๋ถ์์์ ๋๋ ๋ ์ข์ํฉ๋๋ค.
Jaime
2017 ๋
4 ์ 13 ์ผ ๋ชฉ์์ผ ์คํ 1:47, Eric Wieser [email protected]
์ผ๋ค :
๋๋ ์๋ง๋ np.ufunc.reduceat๋ฅผ ๋ชจ๋ ํจ๊ป ๋น๋ํ๊ณ ์ถ์ ๊ฒ์ ๋๋ค.
์์ ๋ฐ ๋ ์ธ๋ฑ์ค ์ธํธ๋ฅผ ์ง์ ํ ์์๋ ๊ฒ์ด ๋ ์ ์ฉ ํด ๋ณด์ ๋๋ค.
indices [i]> indices [i + 1] ์ธ ๊ฒฝ์ฐ๋ฅผ ํผํ์ญ์์ค. ๋ํ, ์ด๋ฆ์
์กด์ฌํ๋ ๊ฒ๋ณด๋ค ํจ์ฌ ๋ ํฐ ์ ์ฌ์ฑ๋์ฒด๋ก ์ ์ํ๊ณ ์ถ์ ๊ฒ์ ๊ธฐ๋ณธ์ ์ผ๋ก np.piecewise_reduce์ ๋๋ค.
์์ต๋๋ค :def piecewise_reduce (func, arr, start_indices = None, end_indices = None, axis = -1, out = None) :
start_indices๊ฐ None์ด๊ณ end_indices๊ฐ None ์ธ ๊ฒฝ์ฐ :
start_indices = np.array ([0], dtype = np.intp)
end_indices = np.array (arr.shape [์ถ], dtype = np.intp)
elif end_indices๋ None์ ๋๋ค.
end_indices = np.empty_like (start_indices)
end_indices [:-1] = start_indices [1 :]
end_indices [-1] = arr.shape [์ถ]
elif start_indices๋ None์ ๋๋ค.
start_indices = np.empty_like (end_indices)
start_indices [1 :] = end_indices
end_indices [0] = 0
๊ทธ๋ฐ์:
assert len โโ(start_indices) == len (end_indices)if not out: sh = list(arr.shape) sh[axis] = len(end_indices) out = np.empty(shape=sh) # below assumes axis=0 for brevity here for i, (si, ei) in enumerate(zip(start_indices, end_indices)): func.reduce(arr[si:ei,...], out=alloc[i, ...], axis=axis) return out
๋ค์๊ณผ ๊ฐ์ ์ข์ ์์ฑ์ด ์์ต๋๋ค.
- np.ufunc.reduce๋ np.piecewise_reduce (func, arr, 0,
len (arr))- np.ufunc.accumulate๋`np.piecewise_reduce (func, arr,
np.zeros (len (arr)), np.arange (len (arr)))์, ์ด๊ฒ์ด __array_ufunc__ ๊ธฐ๊ณ๋ฅผ ํต๊ณผํ๊ณ ์ถ์ต๋๊น? ๋๋ถ๋ถ์
์ฒ๋ฆฌํด์ผํ๋ ๊ฒ์ ์ด๋ฏธ func.reduce์ ์ํด ๋ค๋ฃจ์ด ์ ธ์ผํฉ๋๋ค.
์ ์ผํ ๋ฌธ์ ๋ np.empty ์ค์ด๋ฉฐ, ์ด๋ np.concatenate ๋ฌธ์ ์ ๋๋ค.
์ฃผ์.โ
์ด ์ค๋ ๋๋ฅผ ๊ตฌ๋ ํ๊ธฐ ๋๋ฌธ์์ด ๋ฉ์์ง๊ฐ ์ ์ก๋์์ต๋๋ค.
์ด ์ด๋ฉ์ผ์ ์ง์ ๋ต์ฅํ๊ณ GitHub์์ ํ์ธํ์ธ์.
https://github.com/numpy/numpy/issues/834#issuecomment-293867746 ๋๋ ์์๊ฑฐ
์ค
https://github.com/notifications/unsubscribe-auth/ADMGdtjSCodONyu6gCpwofdBaJMCIKa-ks5rvgtrgaJpZM4ANcqc
.
-
(__ /)
(์ฐ)
(> <) Este es Conejo. Copia a Conejo en tu firma y ayรบdale en sus planes
de dominaciรณn mundial.
'์์'๋ฐ '์ค์ง'์ฌ์ฉ
๋๋
'๋จ๊ณ'๋ฅผ ์ ํํด์ผํ ๊น์
๋งค์ฐ ์ข์ ์ฌ์ฉ ์ฌ๋ก์ฒ๋ผ ๋ณด์ ๋๋ค.
์ธ๋ฑ์ค ๋ฐฐ์ด์ด ๋ธ๋ก๋ ์บ์คํธํ๋ ๊ฒ์ด ํฉ๋ฆฌ์ ์ ๋๊น, ์๋๋ฉด 1D ์ฌ์ผํฉ๋๊น?
์ ๋ฐ์ดํธ๋์์ต๋๋ค. > 1d๋ ๋ถ๋ช ํ ๋์์ง๋ง ์ถ์ ๊ณผ ๊ฐ์ ๊ฒฝ์ฐ์๋ 0d์ ๋ฐฉ์ก์ ํ์ฉํด์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
np ํจ์ ์ฌ์ผํฉ๋๊น, ์๋๋ฉด ufunc ๋ฉ์๋ ์ฌ์ผํฉ๋๊น? (๋๋ ๊ทธ๊ฒ์ ์ ํธํ๋ ๊ฒ ๊ฐ์์
๋ฐฉ๋ฒ์ผ๋ก)
๋ชจ๋ ufunc ๋ฉ์๋๋ __array_ufunc__
์์ ์ฒ๋ฆฌํด์ผ ํ ๋ ํ๋์ ๊ฒ์
๋๋ค.
reduceat
์ ์ฃผ์ ๋๊ธฐ๋ ์ต๋ ์๋๋ฅผ ์ํด reduce
์ด์์ ๋ฃจํ๋ฅผ ํผํ๋ ๊ฒ์
๋๋ค. ๋ฐ๋ผ์ reduce
์ด์์ for ๋ฃจํ ๋ํผ๊ฐ Numpy์ ๋งค์ฐ ์ ์ฉํ ์ถ๊ฐ๊ฐ ๋ ์ง ์์ ํ ํ์ ํ์ง ๋ชปํฉ๋๋ค. reduceat
์ฃผ ๋ชฉ์ ์ ์๋ฐฐ๋ฉ๋๋ค.
๋ํ reduce
์ด์์ ๋ฃจํ์ ๋ํ ๋น ๋ฅธ ๋ฒกํฐํ ๋ ๋์ฒด๋ก์ reduceat
์กด์ฌ ๋ฐ API์ ๋ํ ๋
ผ๋ฆฌ๋ ๊นจ๋ํ๊ณ ์ ์ฉํฉ๋๋ค. ๋๋ ๊ทธ๊ฒ์ ๋น๋ํ์ง ์๊ณ ์คํ๋ ค ๊ณ ์น ๊ฒ์
๋๋ค.
reduceat
์๋์ ๊ด๋ จํ์ฌ ๊ฐ๋จํ ์๋ฅผ ๊ณ ๋ คํด ๋ณด๊ฒ ์ต๋๋ค.ํ์ง๋ง reduceat
์ฌ์ฉํ๋ ์ ์ฝ๋์์๋ ์ค์ ์ฌ๋ก์ ๋น์ทํฉ๋๋ค.
n = 10000
arr = np.random.random(n)
inds = np.random.randint(0, n, n//10)
inds.sort()
%timeit out = np.add.reduceat(arr, inds)
10000 loops, best of 3: 42.1 ยตs per loop
%timeit out = piecewise_reduce(np.add, arr, inds)
100 loops, best of 3: 6.03 ms per loop
์ด๊ฒ์ 100 ๋ฐฐ ์ด์์ ์์ฐจ์ด๋ฉฐ reduceat
ํจ์จ์ฑ ์ ์ง์ ์ค์์ฑ์ ๋ณด์ฌ์ค๋๋ค.
์์ฝํ๋ฉด ์๋ก์ด ๊ธฐ๋ฅ์ ๋์
ํ๋ ๊ฒ๋ณด๋ค reduceat
์์ ์ ์ฐ์ ์ํฉ๋๋ค.
start_indices
๋ฐ end_indices
๋ ๊ฒฝ์ฐ์ ๋ฐ๋ผ ์ ์ฉํ์ง๋ง ์ค๋ณต๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ผ๋ฉฐ ๊ฐ๋ฅํ ์ถ๊ฐ๋ก ๋ณผ ์ ์์ง๋ง ํ์ฌ reduceat
๋ถ์ผ์น์ ๋ํ ์์ ์ฌํญ์ ์๋๋๋ค. ํ๋.
์์ ๋ฐ ์ค์ง ์ธ๋ฑ์ค๊ฐ ๋ค๋ฅธ ๋ฐฐ์ด์์ ์ค๋ ๊ฒ์ ํ์ฉํ์ง ์๋๋ค๊ณ ์๊ฐํฉ๋๋ค.
C๋ก ๊ตฌํ๋๋ฉด ํจ์จ์ฑ์ ํฐ ์ฐจ์ด๋ฅผ ๋ง๋ค ๊ฒ์
๋๋ค.
2017 ๋ 4 ์ 13 ์ผ 23:40์ divenex [email protected] ์ ๋ค์๊ณผ ๊ฐ์ด ์ผ์ต๋๋ค.
reduceat์ ์ฃผ์ ๋๊ธฐ๋ reduce for ๋ฃจํ๋ฅผ ํผํ๋ ๊ฒ์ ๋๋ค.
์ต๋ ์๋. ๊ทธ๋์ ๋๋ for ๋ฃจํ์ ๋ํผ๊ฐ ํ์คํ์ง ์์ต๋๋ค.
reduce๋ Numpy์ ๋งค์ฐ ์ ์ฉํ ์ถ๊ฐ ๊ธฐ๋ฅ์ ๋๋ค. ๋ฐ๋ ํ ๊ฒ์ด๋ค
์ฃผ๋ ๋ชฉ์ ์ผ๋ก ์ค์ด์ญ์์ค.๋ํ ์กด์ฌ์ API๋ฅผ ์ค์ด๊ธฐ์ํ ๋ก์ง์ ๋น ๋ฅธ ๋ฒกํฐํ๋ก
๋ฃจํ์ ๋ํ ๊ต์ฒด๋ ๊นจ๋ํ๊ณ ์ ์ฉํฉ๋๋ค. ๋ด๊ฐ ์์ ๊ฒ
๋ ์ด์ ์ฌ์ฉํ์ง ์๊ณ ์์ ํ์ญ์์ค.๊ฐ์ ์๋์ ๊ด๋ จํ์ฌ ๊ฐ๋จํ ์๋ฅผ ๊ณ ๋ คํด ๋ณด๊ฒ ์ต๋๋ค.
๋ด ์ฝ๋์ reduceat๋ฅผ ์ฌ์ฉํ๋ ์ค์ ์ฌ๋ก๊ฐ ์์ต๋๋ค.n = 10000
arr = np.random.random (n)
inds = np.random.randint (0, n, n // 10)
inds.sort ()
% timeit out = np.add.reduceat (arr, inds) 10000 ๋ฃจํ, ์ต๊ณ 3 : 42.1 ยตs ๋ฃจํ ๋น
% timeit out = piecewise_reduce (np.add, arr, inds) 100 ๋ฃจํ, ์ต๊ณ 3 : 6.03 ms ๋ฃจํ ๋น์ด๊ฒ์ 100 ๋ฐฐ ์ด์์ ์์ฐจ์ด๋ฉฐ ์ค์์ฑ์ ๋ณด์ฌ์ค๋๋ค.
ํจ์จ์ฑ์ ๋ณด์กดํ๋ ๊ฒ.์์ฝํ๋ฉด, ์ ๋ ์๋ก์ด
๊ธฐ๋ฅ.start_indices ๋ฐ end_indices๋ฅผ ๊ฐ๋ ๊ฒ์ ๊ฒฝ์ฐ์ ๋ฐ๋ผ ์ ์ฉํ์ง๋ง
์ค๋ณต๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ผ๋ฉฐ ๊ฐ๋ฅํ ์ถ๊ฐ ํญ๋ชฉ์ผ๋ก ๋ณด ๊ฒ ์ง๋ง ์์ ์ฌํญ์ ์๋๋๋ค.
์ผ๊ด๋์ง ์์ ๋์์์ ํ์ฌ ๊ฐ์.โ
๋๊ธ์ ๋ฌ์ ๊ธฐ ๋๋ฌธ์ ์์ ํ ๊ฒ์ ๋๋ค.
์ด ์ด๋ฉ์ผ์ ์ง์ ๋ต์ฅํ๊ณ GitHub์์ ํ์ธํ์ธ์.
https://github.com/numpy/numpy/issues/834#issuecomment-293898215 ๋๋ ์์๊ฑฐ
์ค
https://github.com/notifications/unsubscribe-auth/AAEz6xPex0fo2y_MqVHbNP5YNkJ0CBJrks5rviW-gaJpZM4ANcqc
.
์ด๊ฒ์ 100 ๋ฐฐ ์ด์์ ์์ฐจ์ด๋ฉฐ, ํจ์จ์ฑ์ ์ ์งํ๋ ๊ฒ์ ์ค์์ฑ์ ๋ณด์ฌ์ค๋๋ค.
๊ฐ์ฌํฉ๋๋ค. reduce
ํธ์ถ์ ์ฒซ ๋ฒ์งธ ๋จ๊ณ์ ๊ด๋ จ๋ ์ค๋ฒ ํค๋๋ฅผ ๊ณผ์ ํ๊ฐ ํ ๊ฒ ๊ฐ์ต๋๋ค ( reduceat
๋ํด ํ ๋ฒ๋ง ๋ฐ์ ํจ).
์์ ํจ์์ ๋ํ ์ฃผ์ฅ์ ์๋์ง๋ง ์์ํ ํ์ด์ฌ์ผ๋ก ๊ตฌํํ๋ ๊ฒ์ ๋ํ ์ฃผ์ฅ์ ๋๋ค.
๊ทธ๋ฌ๋ ์ผ๊ด์ฑ์๋ ๋์์์ ํ์ฌ ๊ฐ์์ ๋ํ ์์ ์ฌํญ์ ์๋๋๋ค.
๋ฌธ์ ๋ ์ค๋ซ๋์ ์ฌ์ฉ๋์ด ์จ ์ฝ๋์ ๋์์ ๋ณ๊ฒฝํ๋ ๊ฒ์ด ๊น๋ค ๋กญ๋ค๋ ๊ฒ์ ๋๋ค.
๋ ๋ค๋ฅธ ๊ฐ๋ฅํ ํ์ฅ : indices[i] > indices[j]
์ด๋ฉด ์ญ์ ๊ณ์ฐํฉ๋๋ค.
for i, (si, ei) in enumerate(zip(start, stop)):
if si >= ei:
func.reduce(arr[si:ei,...], out=out[i, ...], axis=axis)
else:
func.reduce(arr[ei:si,...], out=out[i, ...], axis=axis)
func.inverse(func.identity, out[i, ...], out=out[i, ...])
์ฌ๊ธฐ์ np.add.inverse = np.subtract
, np.multiply.inverse = np.true_divide
. ๊ฒฐ๊ณผ์ ์ผ๋ก
func.reduce(func.reduceat(x, inds_from_0)) == func.reduce(x))
์๋ฅผ ๋ค๋ฉด
a = [1, 2, 3, 4]
inds = [0, 3, 1]
result = np.add.reduceat(a, inds) # [6, -5, 9] == [(1 + 2 + 3), -(3 + 2), (2 + 3 + 4)]
๋ฌธ์ ๋ ์ค๋ซ๋์ ์ฌ์ฉ๋์ด ์จ ์ฝ๋์ ๋์์ ๋ณ๊ฒฝํ๋ ๊ฒ์ด ๊น๋ค ๋กญ๋ค๋ ๊ฒ์ ๋๋ค.
์ด๊ฒ์ด ๋ถ๋ถ์ ์ผ๋ก ๋๋ ์ ์ ๋ฉ์ผ ์ค๋ ๋์์ ์ถ๊ฐ ์ฐจ์์ด 2 ๋๋ 3 ์ธ ์ธ๋ฑ์ค์ 2 ์ฐจ์ ๋ฐฐ์ด์ ํน๋ณํ ์๋ฏธ๋ฅผ ๋ถ์ฌํ๋๋ก ์ ์ํ ์ด์ ์
๋๋ค. ๊ทธ๋ฐ ๋ค์ (ํจ๊ณผ์ ์ผ๋ก) ์ฌ๋ผ์ด์ค ์คํ์ผ๋ก ํด์๋ฉ๋๋ค. ๊ทธ๋ฌ๋ ์ด๊ฒ์ ๋ํ ๋ค์ ์ง์ ๋ถํ๊ณ ๋ฌผ๋ก reduce_by_slice
, slicereduce
๋๋ reduceslice
๋ฉ์๋๊ฐ์์ ์ ์์์ ์๊ณ ์์ต๋๋ค.
์ถ์ ๋ง์ ufunc์์ ์๋ํ๋ ๋ชจ๋ ๊ฒ์ด __array_ufunc__
ํตํด ์ ๋ฌ๋๊ณ ์ฌ์ ์ ๋ ์ ์๋๋ก ๋ฉ์๋ ์ฌ์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
์ฌ์ค, ์ ๊ฐ ์๊ฐํ๋ ๋ค๋ฅธ ์ ์์ด ํจ์ฌ ๋ซ๋ค๊ณ ์๊ฐํฉ๋๋ค. reduceat
๊ตฌํ๋ ๊ฒ๋ณด๋ค slice
์ธ์ (๋๋ start
, stop
, step
)์์ ufunc.reduce
!? @ eric-wieser๊ฐ ์ธ๊ธํ๋ฏ์ด ์ด๋ฌํ ๊ตฌํ์ reduceat
์์ ํ ํ๊ธฐ ํ ์ ์์์ ์๋ฏธํฉ๋๋ค.
add.reduce(array, slice=slice(indices[:-1], indices[1:])
(์ด์ ๋น ์ฌ๋ผ์ด์ค์ ๋ํด ์์๋๋ ๋์๊ณผ ์ผ์นํ๋๋ก ์์ ๋กญ๊ฒ ๋ง๋ค ์ ์์ต๋๋ค.)
์ฌ๊ธฐ์์ ์ฌ๋ผ์ด์ค๊ฐ 0-d์ด๋ฉด ๋ธ๋ก๋ ์บ์คํธํ๊ณ ์ถ์ ํํ์ด ์ฌ์ฉ ๋ ๊ฒฝ์ฐ ์ฌ๋ผ์ด์ค์ ํํ์ ์ ๋ฌํ๋ ๊ฒ์ ๊ณ ๋ คํ ์๋ ์์ต๋๋ค.
ํธ์ง : ์์ slice(indices[:-1], indices[1:])
๋ฅผ ์ฌ๋ผ์ด์ค ํํ์ ๋ํ ํ์ฅ์ ํ์ฉํ๋๋ก ๋ง๋ค์์ต๋๋ค ( slice
๋ ์์์ ๋ฐ์ดํฐ๋ฅผ ๋ณด์ ํ ์ ์์ผ๋ฏ๋ก ์ ์๋ํฉ๋๋ค).
๊ฐ์ฅ ๋
ผ๋ฆฌ์ ์ธ ๋์์ธ ์๋ฃจ์
์ธ reduce
์ ์ ์ ํ 100 % ๋ฒกํฐํ ๋ ๋ฒ์ ์ผ๋ก ๋ง๋ค๊ธฐ ์ํด reduceat
๋ํ ์์ ์ฌํญ์ ์ฐพ์ ์ ์์ต๋๋ค. ๋๋ ์ฝ๋๊ฐ ๊นจ์ง๋ ๊ฒ์ ๋ฐฉ์งํ๊ธฐ ์ํด (์๋ ์ฐธ์กฐ) reducebins
๊ฐ์ ์ด๋ฆ์ ๋๋ฑํ ๋ฉ์๋๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค. ์ด๋ ๋จ์ํ reduceat
์ ์์ ๋ ๋ฒ์ ์
๋๋ค. ์ฌ์ค, ๋๋ reduceat
์ ์ด๋ฆ์ด at
ํจ์์ ๋ ๋ง์ ์ฐ๊ฒฐ์ ์ ๋ฌํ๋ค๋ @ eric-wieser์ ๋์ํฉ๋๋ค.
์ฝ๋๋ฅผ ๊นฐ ํ์๊ฐ ์๋ค๋ ๊ฒ์ ์ดํดํฉ๋๋ค. ๊ทธ๋ฌ๋ ๋๋ ๊ทธ๊ฒ์ด ๋จ์ํ ๋
ผ๋ฆฌ์ ์ผ๋ก ๋ง์ด๋์ง ์๋๋ค๋ ์ ์ ๊ฐ์ํ ๋, ๋ง์ ์ฝ๋๊ฐ ์ค๋๋ ํ๋์ ์์กดํ๊ณ ์๋ค๋ ๊ฒ์ ์์ํ๊ธฐ ์ด๋ ต๋ค๊ณ ๋งํด์ผํ๋ฉฐ, ๋จ์ํ ์ค๋ ์ง์๋๋ ๋ฒ๊ทธ๋ผ๊ณ ๋ถ๋ฅผ ๊ฒ์
๋๋ค. reduceat
์ฌ์ฉํ๋ ์ฝ๋๋ indices
์ ๋์ผ์ค ๊ฒฐ๊ณผ๋ฅผ ํผํ๊ธฐ ์ํด out[:-1] *= np.diff(indices) > 0
์ฌ์ฉํ์ฌ ์ถ๋ ฅ์ ์์ ํ๋ค๊ณ ์์ํฉ๋๋ค reduceat
out[:-1] *= np.diff(indices) > 0
. ๋ฌผ๋ก ์ด์ ๋์ / ๋ฒ๊ทธ๊ฐ ์๋ ํ๋๋ก ์ฌ์ฉ ๋ ์ฌ์ฉ์ ์ฌ๋ก์ ๊ด์ฌ์ด์์ ๊ฒ์
๋๋ค.
@mhvk slice
์๋ฃจ์
์ด slice
๊ตฌ์กฐ์ ๋ํ ๋นํ์ค ์ฌ์ฉ์ ๋์
ํ๊ธฐ ๋๋ฌธ์ ๋๋ ์์ ํ ํ์ ํ์ง ๋ชปํฉ๋๋ค. ๋์ฑ์ด ๊ทธ๊ฒ์ ํ๋์ ์ถ์ ๋ฐ๋ผ ufunc๋ฅผ ์ ์ฉํ์ฌ _ "a์ ์ฐจ์์ 1๋งํผ ๊ฐ์์ํค๋ reduce
์ ํ์ฌ ๋์์ธ ์์ด๋์ด์ ์ผ์นํ์ง ์์ ๊ฒ์
๋๋ค."_
๋ํ start
๋ฐ end
์ธ๋ฑ์ค ๋ชจ๋์ ๋ํด ์ค๋๋ ฅ์๋ ์ฌ์ฉ์ ์ฌ๋ก๋ฅผ ๋ณด์ง ๋ชปํ์ต๋๋ค. ์ค์ ๋ก np.histogram
์ ๊ฐ๋
์ ์ผ๋ก ์ ์ฌํ ํ์ฌ reduceat
๋ฉ์๋์ ๋ฉ์ง ๋์์ธ ๋
ผ๋ฆฌ๋ฅผ ๋ณผ ์ ์์ต๋๋ค. ์ฌ๊ธฐ์ bins
๋ _ "๋น ๊ฐ์ฅ์๋ฆฌ๋ฅผ ์ ์ํ๊ณ "_๋ ๋ค์์ผ๋ก ๋์ฒด๋ฉ๋๋ค. indices
, Bins Edge๋ ๋ํ๋ด์ง ๋ง ๊ฐ์ด ์๋ ์ธ๋ฑ์ค ๊ณต๊ฐ์ ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ reduceat
๋ ๊ฐ bin ๊ฐ์ฅ์๋ฆฌ ์์ ํฌํจ ๋ ์์์ ํจ์๋ฅผ ์ ์ฉํฉ๋๋ค. ํ์คํ ๊ทธ๋จ์ ๋งค์ฐ ๋๋ฆฌ ์ฌ์ฉ๋๋ ๊ตฌ์ฑ์ด์ง๋ง ํ์ํ์ง ์์ผ๋ฉฐ Numpy์๋ ์ผ์ชฝ ๋ฐ ์ค๋ฅธ์ชฝ ๊ฐ์ฅ์๋ฆฌ์ ๋ ๋ฒกํฐ๋ฅผ ์ ๋ฌํ๋ ์ต์
์ด ํฌํจ๋์ด ์์ง ์์ต๋๋ค. ๊ฐ์ ์ด์ ๋ก ๋๋ reduceat
๋๋ ๊ทธ ๊ต์ฒด์์ ์์ชฝ ๊ฐ์ฅ์๋ฆฌ์ ๋ํ ๊ฐํ ํ์์ฑ์ด ์๋์ง ์์ฌํฉ๋๋ค.
reduceat์ ์ฃผ๋ ๋๊ธฐ๋ ์ต๋ ์๋๋ฅผ ์ํด ๋ฃจํ ์ค๋ฒ ๊ฐ์๋ฅผ ํผํ๋ ๊ฒ์ ๋๋ค. ๋ฐ๋ผ์ for ๋ฃจํ์ ๋ํผ๊ฐ Numpy์ ๋งค์ฐ ์ ์ฉํ ์ถ๊ฐ ๊ธฐ๋ฅ์ด ๋ ์ง ์์ ํ ํ์ ํ์ง ๋ชปํฉ๋๋ค. ๊ทธ๊ฒ์ ์ฃผ๋ ๋ชฉ์ ์์ ๊ฐ์ ํ ๊ฒ์ ๋๋ค.
์ฌ๊ธฐ @divenex์ ๋์ํฉ๋๋ค. reduceat
์ธ๋ฑ์ค๋ฅผ ์ ๋ ฌํ๊ณ ์ค์ฒฉํด์ผํ๋ค๋ ์ฌ์ค์ ๋ฃจํ๊ฐ ๋ฐ์ดํฐ์ ๋ํ ๋จ์ผ ํจ์ค๋ก ์บ์ ํจ์จ์ ์ธ ๋ฐฉ์์ผ๋ก ๊ณ์ฐ ๋ ์ ์๋๋ก ๋ณด์ฅํ๋ ํฉ๋ฆฌ์ ์ธ ์ ์ฝ ์กฐ๊ฑด์
๋๋ค. ๊ฒน์น๋ ๋น์ ์ํ ๊ฒฝ์ฐ ์ํ๋ ์์
์ ๊ณ์ฐํ๋ ๋ ๋์ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค (์ : ๋กค๋ง ์ฐฝ ์ง๊ณ).
๋ํ ๊ฐ์ฅ ๊นจ๋ํ ํด๊ฒฐ์ฑ
์ ๊ณ ์ API๋ฅผ ์ฌ์ฉํ์ฌ reducebins
์ ๊ฐ์ ์๋ก์ด ๋ฉ์๋๋ฅผ ์ ์ํ๊ณ (๊ทธ๋ฆฌ๊ณ reduceat
๋ ์ด์ ์ฌ์ฉํ์ง ์์) reduce
๋ ์ด๋ฏธ ๋ค๋ฅธ ์ผ์ํฉ๋๋ค.
์๋ ํ์ธ์ ์ฌ๋ฌ๋ถ,
๋๋ ์ด๊ฒ์ด ๋ฒ๊ทธ๋ผ๋ ํ ๋ก ์ ์น์ธ์ดํ๊ณ ์ถ๋ค. ์ด๊ฒ์ ๋ ์คํธ๋ง ์ ๋์ ์ ๋๋ค.
For i in ``range(len(indices))``, `reduceat` computes
``ufunc.reduce(a[indices[i]:indices[i+1]])``, which becomes the i-th
generalized "row" parallel to `axis` in the final result (i.e., in a
2-D array, for example, if `axis = 0`, it becomes the i-th row, but if
`axis = 1`, it becomes the i-th column). There are three exceptions to this:
* when ``i = len(indices) - 1`` (so for the last index),
``indices[i+1] = a.shape[axis]``.
* if ``indices[i] >= indices[i + 1]``, the i-th generalized "row" is
simply ``a[indices[i]]``.
* if ``indices[i] >= len(a)`` or ``indices[i] < 0``, an error is raised.
๋ฐ๋ผ์ reduceat
์ ๋์์ ๋ณ๊ฒฝํ๋ ค๋ ๋ชจ๋ ์๋์ ๋ฐ๋ํฉ๋๋ค.
๋น ๋ฅธ github ๊ฒ์์ ํจ์์ ๋ง์ ์ฉ๋๋ฅผ ๋ณด์ฌ์ค๋๋ค. ์ฌ๊ธฐ์๋ ๋ชจ๋ ์ฌ๋๋ค์ด ๋ชจ๋ ์๊ฒฉํ๊ฒ ์ฆ๊ฐํ๋ ์ธ๋ฑ์ค ๋ง ์ฌ์ฉํ๋ค๊ณ ํ์ ํฉ๋๊น?
์ ํจ์์ ๋์๊ณผ ๊ด๋ จํ์ฌ ๋ณ๋์ ์์ / ์ค์ง ๋ฐฐ์ด์ด ์์ผ๋ฉด ๊ธฐ๋ฅ์ด ์ฌ๊ฐํ๊ฒ ๋ฐฉํด๋ฅผ๋ฐ๋๋ค๊ณ ์ฃผ์ฅํฉ๋๋ค. ๊ท์น์ ์ผ๋ก ๋ฐฐ์ด๋์ง ์์ ๊ฒน์น๋ ์ฐฝ์์ ๊ฐ์ ์ธก์ ํ๋ ค๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ด ์์ต๋๋ค (๋ฐ๋ผ์ ๋กค๋ง ์ฐฝ์ด ์๋ํ์ง ์์). ์๋ฅผ ๋ค์ด, ๊ด์ฌ ์์ญ์ ๋ช ๊ฐ์ง ๋ ๋ฆฝ์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก ๊ฒฐ์ ๋ฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ @divenex ๋ Python ๋ฐ๋ณต์ ๋ํ ์ฑ๋ฅ ์ฐจ์ด๊ฐ ์ฃผ์์ต๋๋ค .
๊ท์น์ ์ผ๋ก ๋ฐฐ์ด๋์ง ์์ ๊ฒน์น๋ ์ฐฝ์์ ๊ฐ์ ์ธก์ ํ๋ ค๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ด ์์ต๋๋ค (๋ฐ๋ผ์ ๋กค๋ง ์ฐฝ์ด ์๋ํ์ง ์์).
์,ํ์ง๋ง reduceat
์ํด ๊ตฌํ ๋ ๊ฒ๊ณผ ๊ฐ์ ์์งํ ๋ฃจํ๋ฅผ ์ฌ์ฉํ๊ณ ์ถ์ง๋ ์์ ๊ฒ์
๋๋ค. ๋ฐ์ดํฐ์ ๋ํ ๋จ์ผ ์ ํ ํจ์ค๋ก ์ํ ํ ์ ์๋๋ก ์ด๋ค ๋ฐฉ์ ์ผ๋ก๋ ์ค๊ฐ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๋ ์์ฒด ๋กค๋ง ์๋์ฐ ๊ณ์ฐ์ ๊ตฌํํ๋ ค๊ณ ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ด์ ์ฐ๋ฆฌ๋ reduceat
๋ณด๋ค ํจ์ฌ ๋ ๋ณต์กํ ์๊ณ ๋ฆฌ์ฆ์ ๋ํด ์ด์ผ๊ธฐํ๊ณ ์์ต๋๋ค.
@shoyer ROI ์ค ์ผ๋ถ๋ง ๊ฒน์น๋ ๊ฒฝ์ฐ๋ฅผ ์์ํ ์ ์์ต๋๋ค. ์ด๋ฌํ ๊ฒฝ์ฐ ์ฌ์ฉ์ ์ ์ ์๊ณ ๋ฆฌ์ฆ์ ์์ฑํ๋ ๊ฒ์ ์์ฒญ๋ ๊ณผ์์
๋๋ค. ์ฐ๋ฆฌ์ ์ฃผ์ ์ฌ์ฉ์ ๊ธฐ๋ฐ์ ์ผ๋ฐ์ ์ผ๋ก ์๊ฐ์ด ๋ถ์กฑํ๊ณ ์ ๋ ์ต์ ์ด ์๋ "์ถฉ๋ถํ ์ข์"์๋ฃจ์
์ ํ์๋กํ๋ ๊ณผํ์๋ผ๋ ์ฌ์ค์ ์์ง ๋ง์ญ์์ค. np.reduceat
์ ๋ณต์ก์ฑ๊ณผ ๊ด๋ จ๋ ๋ฎ์ ์์ ์์ธ์ ์์ํ Python ์ฝ๋๋ก ๋ ๋์ ์๋ฃจ์
์ ์ป๋ ๊ฒ์ด ์ด๋ ต๊ฑฐ๋ ๋ถ๊ฐ๋ฅํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์ฌ์ฉ์๊ฐ ์์ฑํ๋ ค๋ ์ ์ผํ ์ฝ๋์
๋๋ค.
@jni ๋ฌผ๋ก ์
๋๋ค. ์์์ ์์ ๋ฐ ์ค์ง๊ฐ์๋ ๊ทธ๋ฃน์ผ๋ก ์ค์ด๋ ๊ฒ์ด ์ ์ฉ ํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ๊ฒ์ ๋์๊ฒ ๋ฒ์๊ฐ ํฌ๊ฒ ์ฆ๊ฐํ ๊ฒ์ฒ๋ผ ๋๊ปด์ง๋ฉฐ reduceat
(์ฐ๋ฆฌ๊ฐ ์ ๋ ์ ๊ฑฐํ์ง ์๋๋ผ๋ ํ์คํ ์ ๊ฑฐํ๊ณ ์ถ์) ๋์ ์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ๋ ์ ํฉํ ๊ฒ ๊ฐ์ต๋๋ค.
์์์ ์์ ๋ฐ ์ค์ง๊ฐ์๋ ๊ทธ๋ฃน์ผ๋ก ์ค์ด๋ ๊ฒ์ด ์ ์ฉ ํ ์ ์์ต๋๋ค. ํ์ง๋ง ์ ๊ฒ๋ ๋ฒ์๊ฐ ํฌ๊ฒ ๋์ด๋ ๊ฒ ๊ฐ์์
์ด๊ฒ์ ๋์๊ฒ ๋งค์ฐ ์ฌ์ํ ๊ฒ ๊ฐ์ต๋๋ค. ์ง๊ธ ๋น์ฅ์ ๋ณธ์ง์ ์ผ๋ก ind1 = indices[i], ind2 = indices[i + 1]
๋ฅผ ์ํํ๋ ์ฝ๋๊ฐ ์์ต๋๋ค. ๋์ผํ ๋ฐฐ์ด ๋์ ๋ ๊ฐ์ ๋ค๋ฅธ ๋ฐฐ์ด์ ์ฌ์ฉํ๋๋ก ๋ณ๊ฒฝํ๋ ๊ฒ์ ๋งค์ฐ ์ ์ ๋
ธ๋ ฅ์ด ํ์ํฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ฐ์ ๋ฒ์๋ฅผ ์ ๋ฌํ ๋ ๋จ์ผ ํจ์ค ๋์์ ์ง๊ธ๊ณผ ๊ฑฐ์ ๋๊ฐ์ด ๋นจ๋ผ์ผํฉ๋๋ค. ์ ์ผํ ์ค๋ฒ ํค๋๋ nditer์ ๋ํ ํ๋ ์ด์์ ์ธ์์ ๋๋ค.
์ด๊ฒ์ ๋์๊ฒ ๋งค์ฐ ์ฌ์ํ ๊ฒ ๊ฐ์ต๋๋ค.
๋ฐ๋ก ๊ทธ๊ฑฐ์ฃ . ๋ํ ์ฌ์ฉ์๊ฐ reduceat
(๋ค๋ฅธ ๋ชจ๋ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ์ฌ)๋ฅผ ์ฌ์ฉํ๋ ๊ธฐ๋ฅ์ด์ง๋ง ์ค๋ณต์ ์ง์ํ์ง ์๋ ์๋ก์ด ๊ธฐ๋ฅ์ ์ฌ์ฉํ๋ฉด ์์ค๋ฉ๋๋ค.
๋ํ ๋ ๊ฐ์ ์ธ๋ฑ์ค ํ์์ ์ด์ (๊ธฐ๊ดดํ) ๋์์ ๋ชจ๋ฐฉ ํ ์ ์์ต๋๋ค.
def reduceat(func, arr, inds):
deprecation_warning()
start = inds
stops = zeros(inds.shape)
stops[:-1] = start[1:]
stops[-1] = len(arr)
np.add(stops, 1, where=ends == starts, out=stops) # reintroduce the "bug" that we would have to keep
return reducebins(func, arr, starts, stops)
๋งค์ฐ ์ ์ฌํ ๋ ๊ฐ์ง ๊ตฌํ์ ์ ์งํ ํ์๊ฐ ์์์ ์๋ฏธํฉ๋๋ค.
์๋ก์ด reducebins
์ ๋ํ starts
๋ฐ stops
์ธ๋ฑ์ค์ ๋ํด ๊ฐ๋ ฅํ๊ฒ ๋ฐ๋ํ์ง๋ ์์ง๋ง ๋ ๋ค ํ์ํ ๊ฒฝ์ฐ ๋ช
๋ฐฑํ ์๋ฅผ ๋ณผ ์๋ ์์ต๋๋ค. ์์ ๋ฐ ๋ bins
๊ฐ์ฅ์๋ฆฌ๋ฅผ ์ถ๊ฐํ์ฌ np.histogram
์ ์ผ๋ฐํํ๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค.
๊ถ๊ทน์ ์ผ๋ก ์ฃผ์ ์ฌ์ฉ์ด ์ํฅ์๋ฐ์ง ์๊ณ ๋จ์ผ ์ธ๋ฑ์ค ๋ฐฐ์ด๋ก ์๋ ์ ํ์์ด reducebins(arr, indices)
๋ฅผ ํธ์ถ ํ ์๋์๋ ํ ๊ด์ฐฎ์ต๋๋ค.
๋ฌผ๋ก ๊ฒน์น์ง ์๋ ๋น์์ ์์ ํด์ผํ๋ ์ํฉ์ด ๋ง์ด ์์ง๋ง์ด ๊ฒฝ์ฐ ์ผ๋ฐ์ ์ผ๋ก ๋น์ด ํ ์์ ์์ง๋ง์ผ๋ก ์ ์ ๋์ง ์์ ๊ฒ์ผ๋ก ์์ํฉ๋๋ค. ์ด๋ฌํ ์ข ๋ฅ์ ์๋๋ฆฌ์ค์ ์ฌ์ฉํ ์์๋ ํจ์๋ Scipy์ ndimage.labeled_comprehension ๋ฐ ndimage.sum ๋ฑ๊ณผ ๊ฐ์ ๊ด๋ จ ํจ์์ ๋๋ค.
๊ทธ๋ฌ๋ ์ด๊ฒ์ reducebins
์ ๋ฒ์์๋ ์๋นํ ๋ค๋ฅธ ๊ฒ ๊ฐ์ต๋๋ค.
๊ทธ๋์, ๋ฌด์์์ํ ์์ฐ ์ด์ฉ์ ๊ฒฝ์ฐ ๊ฒ starts
๋ฐ stops
์์ reducebins
?
๊ทธ๋ ๋ค๋ฉด reducebins์์ ์์ ๋ฐ ์ค์ง์ ๋ํ ์์ฐ์ค๋ฌ์ด ์ฌ์ฉ ์ฌ๋ก๋ ๋ฌด์์ ๋๊น?
๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ๋ฌ์ฑ ํ ์ ์์ง๋ง k
๊ธธ์ด์ ์ด๋ ํ๊ท ์ reducebins(np,add, arr, arange(n-k), k + arange(n-k))
์
๋๋ค. ์ธ๋ฑ์ค ํ ๋น ๋น์ฉ์ ๋ฌด์ํ๋ฉด ์ฑ๋ฅ์ด as_strided
์ ๊ทผ ๋ฐฉ์๊ณผ ๋น์ทํ ๊ฒ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค.
๊ณ ์ ํ๊ฒ reducebins
๋ ๋ค์ํ ๊ธฐ๊ฐ์ ์ด๋ ํ๊ท ์ ํ์ฉํ์ง๋ง as_strided
์์๋ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
๋ ๋ค๋ฅธ ์ฌ์ฉ ์ฌ๋ก-๋จ์ผ ์ธ์ ํ์์ ๋ ๋๋ ์์์ ํฌํจํ๋ ๊ฒ ์ฌ์ด์ ๋ช ํ์ฑ.
์๋ฅผ ๋ค๋ฉด :
a = np.arange(10)
reducebins(np.add, start=[2, 4, 6]) == [2 + 3, 4 + 5, 6 + 7 + 8 + 9] # what `reduceat` does
reducebins(np.add, stop=[2, 4, 6]) == [0 + 1, 2 + 3, 4 + 5] # also useful
๋ ๋ค๋ฅธ ์ฌ์ฉ ์ฌ๋ก-๋จ์ผ ์ธ์ ํ์์ ๋ ๋๋ ์์์ ํฌํจํ๋ ๊ฒ ์ฌ์ด์ ๋ช ํ์ฑ.
๋๋ ์ด๊ฒ์ ์ ์ดํดํ์ง ๋ชปํ๋ค. ์ฌ๊ธฐ์ ์
๋ ฅ ํ
์๋ฅผ ํฌํจ ํ ์ ์์ต๋๊น? ๋ํ : start
/ stop
์ ๊ธฐ๋ณธ๊ฐ์ ๋ฌด์์
๋๊น?
์ด์จ๋ , ๋๋ ๋ณ๋์ ์ฃผ์ฅ์ ๊ฐํ๊ฒ ๋ฐ๋ํ์ง๋ ์์ง๋ง ๊ต์ฒด๊ฐ ๊นจ๋ํ์ง๋ ์์ต๋๋ค. "reducat์ ์ฌ์ฉํ์ง ๋ง๊ณ ๋์ reducebin์ ์ฌ์ฉํ์ญ์์ค"๋ผ๊ณ ๋งํ๊ณ ์ถ์ง๋ง ์ธํฐํ์ด์ค๊ฐ ๋ค๋ฅด๊ฒ ๋ณด์ผ ๋ (์ฝ๊ฐ) ๋ ์ด๋ ต์ต๋๋ค.
์ฌ์ค, ์์ / ์ค์ง ์ต์
์กฐ์ฐจ๋ ๋น ์ฌ๋ผ์ด์ค์ ์ฌ์ฉ ์ฌ๋ก๋ฅผ ๋ค๋ฃจ์ง ์๋๋ค๋ ๊ฒ์ ๊นจ๋ฌ์์ต๋๋ค. ์ด๋ ๊ณผ๊ฑฐ์ ๋์๊ฒ ์ ์ฉํ๋ ๊ฒ์
๋๋ค. ๋ด ์์ฑ / ๋ ์ด๋ธ์ด CSR ํฌ์ ํ๋ ฌ์ ํ์ ํด๋นํ๋ ๊ฒฝ์ฐ ๊ทธ๋ฆฌ๊ณ indptr
์ ๊ฐ์ ์ฌ์ฉํ์ฌ ๊ฐ์ํฉ๋๋ค. reduceat
ํ๋ฉด ๋น ํ์ ๋ฌด์ํ ์ ์์ต๋๋ค. ๋ชจ๋ ๊ต์ฒด์๋ ์ถ๊ฐ ๋ถ๊ธฐ๊ฐ ํ์ํฉ๋๋ค. ๊ทธ๋์, ๋น์ ์ด ์๊ฐํ๋ ๊ต์ฒด๊ฐ ๋ฌด์์ด๋ , reduceat
์ฃผ๋ณ์ ๋จ๊ฒจ์ฃผ์ธ์.
In [2]: A = np.random.random((4000, 4000))
In [3]: B = sparse.csr_matrix((A > 0.8) * A)
In [9]: %timeit np.add.reduceat(B.data, B.indptr[:-1]) * (np.diff(B.indptr) > 1)
1000 loops, best of 3: 1.81 ms per loop
In [12]: %timeit B.sum(axis=1).A
100 loops, best of 3: 1.95 ms per loop
In [16]: %timeit np.maximum.reduceat(B.data, B.indptr[:-1]) * (np.diff(B.indptr) > 0)
1000 loops, best of 3: 1.8 ms per loop
In [20]: %timeit B.max(axis=1).A
100 loops, best of 3: 2.12 ms per loop
๋ง๋ถ์ฌ์, ๋น ์ํ์ค ์์๊ป๋ผ๋ ํ์ด์ฌ์ด ํ๋ ๊ฒ๊ณผ ๊ฐ์ ๋ฐฉ์์ผ๋ก ํด๊ฒฐํ ์ ์์ต๋๋ค : ์ด๊ธฐ ๊ฐ์ ์ ๊ณตํจ์ผ๋ก์จ. ์ด๊ฒ์ ์ค์นผ๋ผ์ด๊ฑฐ๋ indices
์ ๊ฐ์ ๋ชจ์์ ๋ฐฐ์ด ์ผ ์ ์์ต๋๋ค.
์, ์ฒซ ๋ฒ์งธ ์ด์ ์ด ๋น ์กฐ๊ฐ์ ํด๊ฒฐํ๋ ๋ฐ ์์ด์ผํ๋ค๋ ๋ฐ ๋์ํฉ๋๋ค.
์ผ์ด์ค. start = end์ ๊ฒฝ์ฐ ์ถ๋ ฅ์ ์ค์ ํ๋ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
์์๋ฅผ ID๋ก ๋ณ๊ฒฝํ๊ฑฐ๋ ์ถ๋ ฅ ์์๋ฅผ
๋ฐฐ์ด์ ์ง์ ํ์ต๋๋ค. ํ์ฌ์ ๋ฌธ์ ๋ ๋ฎ์ด ์ด๋ค๋ ๊ฒ์
๋๋ค.
๊ด๋ จ์๋ ๋ฐ์ดํฐ
๋๋ ๊ทธ์ ๋ง์ง๋ง ์ฝ๋ฉํธ์ ๋ํด @shoyer ์ ์์ ํ ํจ๊ปํฉ๋๋ค.
out=ufunc.reducebins(a, inds)
๋ฅผ out[i]=ufunc.reduce(a[inds[i]:inds[i+1]])
๋ฅผ ์ ์ธํ ๋ชจ๋ i
์ ๋ํด reduceat
๋ ์ด์ ์ฌ์ฉํ์ง ์์ต๋๋ค.
starts
๋ฐ ends
์ธ๋ฑ์ค์ ๋ํ ํ์ฌ ์ฌ์ฉ ์ฌ๋ก๋ as_strided
๋๋ ์ปจ๋ณผ ๋ฃจ์
๊ณผ ๊ฐ์ ๋์ฒด ํจ์๋ฅผ ์ฌ์ฉํ์ฌ๋ณด๋ค ์์ฐ์ค๋ฝ๊ณ ํจ์จ์ ์ผ๋ก ๊ตฌํ ๋ ๊ฐ๋ฅ์ฑ์ด ๋์ต๋๋ค.
@shoyer :
๋๋ ์ด๊ฒ์ ์ ์ดํดํ์ง ๋ชปํ๋ค. ์ฌ๊ธฐ์ ์ ๋ ฅ ํ ์๋ฅผ ํฌํจ ํ ์ ์์ต๋๊น? ๋ํ : ์์ / ์ค์ง์ ๊ธฐ๋ณธ๊ฐ์ ๋ฌด์์ ๋๊น?
์
๋ ฅ์ผ๋ก ์
๋ฐ์ดํธ๋์์ต๋๋ค. ๊ธฐ๋ณธ๊ฐ ์ ์ด๊ฒ์ ์์ํ ์ฃผ์ ์์ reduce_bins
๊ตฌํ์ ์ฐธ์กฐํ์ญ์์ค. ๊ฑฐ๊ธฐ์๋ ๋
์คํธ๋ง์ ์ถ๊ฐํ์ต๋๋ค. ์ด ๊ตฌํ์ ๊ธฐ๋ฅ์ด ์์ ํ์ง๋ง ํ์ด์ฌ์ด๊ธฐ ๋๋ฌธ์ ๋๋ฆฝ๋๋ค.
๊ทธ๋ฌ๋ ์ธํฐํ์ด์ค๊ฐ ๋ค๋ฅด๊ฒ ๋ณด์ผ ๋ (์ฝ๊ฐ) ๋ ์ด๋ ต์ต๋๋ค.
start
์ธ์๊ฐ ํ๋๋ง ์ ๋ฌ ๋ ๋ ์ธํฐํ์ด์ค๋ ๋์ผํฉ๋๋ค (์ฒ์์ ์์ ํ๊ธฐ ์ํด ์ค์ ํ ID ์ผ์ด์ค ๋ฌด์). ์ด ์ธ ์ค์ ๊ฐ์ ์๋ฏธ์
๋๋ค.
np.add.reduce_at(arr, inds)
reduce_bins(np.add, arr, inds)
reduce_bins(np.add, arr, start=inds)
(๋ฉ์๋ / ํจ์ ๊ตฌ๋ถ์ ๋ด๊ฐ ๋๋ฌด ์ ๊ฒฝ ์ฐ๋ ๊ฒ์ด ์๋๋ฉฐ, ํ์ด์ฌ์์ ์๋ก์ด ufunc ๋ฉ์๋๋ฅผ ํ๋กํ ํ์ ์ผ๋ก ์ ์ ํ ์ ์์ต๋๋ค!)
@jni :
์ฌ์ค, ๋๋ ๋จ์ง ์์ / ์ค์ง ์ต์ ์กฐ์ฐจ๋ ๋น ์ฌ๋ผ์ด์ค์ ์ฌ์ฉ ์ฌ๋ก๋ฅผ ๋ค๋ฃจ์ง ์๋๋ค๋ ๊ฒ์ ๊นจ๋ฌ์์ต๋๋ค. ์ด๊ฒ์ ๊ณผ๊ฑฐ์ ๋์๊ฒ ์ ์ฉํ๋ ๊ฒ์ ๋๋ค.
๋น์ ์ ํ ๋ ธ์ต๋๋ค. ufunc.reduceat
์ ๋๊ฐ์ ๋ฐฉ์์
๋๋ค. start[i] == end[i]
์ ๋ฌํ๋ ๊ฒ๋ง์ผ๋ก๋ ๊ฐ๋ฅํฉ๋๋ค.
๋น ์ํ์ค ์์๊ป๋ผ๋ ์ด๊ธฐ ๊ฐ์ ์ ๊ณตํ์ฌ ํด๊ฒฐํ ์ ์์ต๋๋ค.
์, ์ฐ๋ฆฌ๋ ์ด๋ฏธ ์ด๊ฒ์ ๋ค๋ฃจ์ ๊ณ ufunc.reduce
์ด๋ฏธ ufunc.identity
๋ฅผ ์ฑ์์ ๊ทธ๋ ๊ฒํฉ๋๋ค. ํนํ # 8952๊ฐ ๋ณํฉ ๋ ๊ฒฝ์ฐ ๊ธฐ์กด ufunc.reduecat
์ ์ถ๊ฐํ๋ ๊ฒ์ ์ด๋ ต์ง ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๋น์ ์ด ์ค์ค๋ก ๋งํ๋ฏ์ด, ํ์ฌ ๋์์ _documented_์ด๋ฏ๋ก ๋ณ๊ฒฝํด์๋ ์๋ฉ๋๋ค.
@divenex
๋ง์ง๋ง์ ์ ์ธํ ๋ชจ๋ i์ ๋ํด out = ufunc.reducebins (a, inds)๋ฅผ out [i] = ufunc.reduce (a [inds [i] : inds [i + 1]])๋ก ์ ์ํ๊ฒ ์ต๋๋ค.
๊ทธ๋์ len(out) == len(inds) - 1
? ์ด๊ฒ์ reduceat
์ ํ์ฌ ๋์๊ณผ ๋ค๋ฅด ๋ฏ๋ก ์ฌ๊ธฐ์์ ์ ํ์ ๋ํ
๋ชจ๋ :์ด ํ ๋ก ์ ์ฝ๊ธฐ ์ด๋ ต๊ฒ ๋ง๋ค์ ๊ธฐ ๋๋ฌธ์ ์ด์ ๋๊ธ์ ๊ฒํ ํ๊ณ ์ธ์ฉ ๋ ์ด๋ฉ์ผ ๋ต์ฅ์ ์ญ์ ํ์ต๋๋ค.
@ eric-wieser ์ข์ ์ง์ ์
๋๋ค. ์์ ๋ฌธ์ฅ์์ ๋ง์ง๋ง ์ธ๋ฑ์ค์ ๊ฒฝ์ฐ reducebins
์ ๋์์ด ํ์ฌ reduceat
์์์ ๋ค๋ฅผ ๊ฒ์์ ์๋ฏธํ์ต๋๋ค. ๊ทธ๋ฌ๋์ด ๊ฒฝ์ฐ ๋ง์ง๋ง ๊ฐ์ด ๊ณต์์ ์ผ๋ก ์๋ฏธ๊ฐ ์๊ธฐ ๋๋ฌธ์ ๊ฐ์ด ๋ฌด์์ธ์ง ํ์คํ์ง ์์ต๋๋ค.
ํธํ์ฑ ๋ฌธ์ ๋ฅผ ๋ฌด์ํ๊ณ ์ถ๋ ฅ reducebins
(1D์์)์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ ธ์ผ inds.size-1
๋ฐ๋ก ๊ทธ ๋์ผํ ์ด์ ๋ก, np.diff(a)
ํฌ๊ธฐ ๊ฐ๋๋ค a.size-1
๋ฐ np.histogram(a, bins)
ํฌ๊ธฐ๋ bins.size-1
์
๋๋ค. ๊ทธ๋ฌ๋ ์ด๊ฒ์ reduceat
๋ํ ๋๋กญ ์ธ ๊ต์ฒด๋ฅผ ์ํ๋ ์๊ตฌ์ ์๋ฐฐ๋ฉ๋๋ค.
a.size-1
์ด ์ ๋ต์ด๋ผ๋ ์ค๋๋ ฅ์๋ ์ฃผ์ฅ์ด ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ธ๋ฑ์ค 0
๋ฐ / ๋๋ ์ธ๋ฑ์ค n
๋ ๊ฝค ํฉ๋ฆฌ์ ์ธ ํ๋์ผ๋ก ๋ณด์
๋๋ค. ๊ทธ๋ค ๋ชจ๋ ์ด๋ค ์ํฉ์์๋ ํธ๋ฆฌํด ๋ณด์ด์ง๋ง ๊ต์ฒด๋ฅผํ๋ ๊ฒ์ด ๋งค์ฐ ์ค์ํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
์ฌ๊ธฐ์ ์จ์ด์๋ stop
/ start
๋ํ ๋ ๋ค๋ฅธ ์ฃผ์ฅ์ด ์์ต๋๋ค. ์ํ๋ ๊ฒฝ์ฐ ์์ฃผ ์ ์ ๋น์ฉ์ผ๋ก diff
์ ์ ์ฌํ ๋์์ ๋ง๋ค ์ ์์ต๋๋ค. reduceat
ํ๋ :
a = np.arange(10)
inds = [2, 4, 6]
reduce_bins(a, start=inds[:-1], stop=inds[1:]) # [2 + 3, 4 + 5]
# or less efficiently:
reduce_at(a, inds)[:-1}
reduce_bins(a, start=inds)[:-1]
reduce_bins(a, stop=inds)[1:]
@ eric-wieser ํ์ start
๋ฐ stop
์ธ์๋ ๊ด์ฐฎ์ง ๋ง ๊ทธ์ค ํ๋๋ฅผ ์ ํ์ ์ผ๋ก ๋ง๋๋ ๊ฒ์ ์ข์ํ์ง ์์ต๋๋ค. start
๋ง ์ ๊ณตํ๋ ๊ฒ์ด out[i] = func.reduce(arr[start[i]:])
์๋๋ผ out[i] = func.reduce(arr[start[i]:start[i+1]])
์๋ฏธํ๋ค๋ ๊ฒ์ ๋ถ๋ช
ํ์ง ์์ต๋๋ค.
reducebins
๋ํ ๋ด๊ฐ ์ ํธํ๋ API๋ reduceat
๋น์ทํ์ง๋ง docstring ์ ํผ๋๋๋ "์์ธ"๊ฐ ์์ต๋๋ค. ์ฆ, ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
i in range(len(indices))
๊ฒฝ์ฐ reduceat๋ufunc.reduce(a[indices[i]:indices[i+1]])
๊ณ์ฐํฉ๋๋ค. ์ด๋ ์ต์ข ๊ฒฐ๊ณผ์์ ์ถ์ ํํ ํ i ๋ฒ์งธ ์ผ๋ฐํ ๋ "ํ"์ด๋ฉ๋๋ค (์ : 2 ์ฐจ์ ๋ฐฐ์ด์์, ์๋ฅผ ๋ค์ด axis = 0์ด๋ฉด i ๋ฒ์งธ ํ์ด๋์ง๋ง ์ถ = 1์ด๋ฉด i ๋ฒ์งธ ์ด์ด๋ฉ๋๋ค.
๋๋ ์์๊ฐ ์๋ ์ธ๋ฑ์ค ( 0 <= indices[i] <= a.shape[axis]
)๋ฅผ ์๊ตฌํ๋ ์ธ ๋ฒ์งธ "์์ธ"์ ๋ํด ์ด๋ ์ชฝ์ด๋ ๊ฐ ์ ์๋๋ฐ, ์ด๋ ์์ธ ๋ผ๊ธฐ๋ณด๋ค๋ ์จ ์ ์ฑ ๊ฒ์ฌ์ ๊ฐ๊น๋ค๊ณ ์๊ฐํฉ๋๋ค. ๊ทธ๋ฌ๋ ์๋ง๋ ๊ทธ ์ฌ๋๋ ๊ฐ ์ ์์ต๋๋ค. ์์ ์ง์๊ฐ ๋๊ตฐ๊ฐ์๊ฒ ์ผ๋ง๋ ์ ์ฉ ํ ์ ์๋์ง ์ ์ ์์ผ๋ฉฐ ๊ทธ๋ฌํ ์ง์๋ฅผ ์ ๊ทํํ๊ธฐ ์ํด ์ํ์ํ๋ ๊ฒ์ด ์ด๋ ต์ง ์์ต๋๋ค.
๋์ ์ธ๋ฑ์ค๋ฅผ ์๋์ผ๋ก ์ถ๊ฐํ์ง ์๋ ๊ฒ์ np.histogram
์ ๊ฒฐ๊ณผ์ ๊ฐ์ด ๊ฒฐ๊ณผ ๊ธธ์ด๊ฐ len(a)-1
์ฌ์ผ ํจ์ ์๋ฏธํฉ๋๋ค.
@jni ํฌ์ ํ๋ ฌ์์ ์ฐพ์ ๋ฐฐ์ด์์ ์ค์ ๋ก ๊ณ์ฐํ๋ ค๋ ์๋ฅผ ๋ค์ด ์ฃผ์๊ฒ ์ต๋๊น? ๊ฐ๊ธ์ ์ด๋ฉด ๋ฌด์์๊ฐ ์๋ ์ซ์์ ์์ฒด ํฌํจ (scipy.sparse์ ์์กดํ์ง ์์)์ด ํฌํจ ๋ ๊ตฌ์ฒด์ ์ธ ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
์์ ๋ง ์ ๊ณตํ๋ ๊ฒ์ด out [i] = func.reduce (arr [start [i]๊ฐ ์๋๋ผ out [i] = func.reduce (arr [start [i] : start [i + 1]])๋ผ๋ ๊ฒ์ ๋ถ๋ช ํ์ง ์์ต๋๋ค. :]), ๋ด๊ฐ ์ง์ํ์ ๊ฒ์ ๋๋ค.
๋ด๊ฐํ๋ ค๊ณ ํ๋ ์ฝ๊ธฐ๋ "๊ฐ ๋น์ด์ด ์์น์์ ์์ํ๋ค"๋ ๊ฒ์ด๋ฉฐ, ๋ช ์ ์ ์ผ๋ก ๋ฌ๋ฆฌ ์ง์ ํ์ง ์๋ ํ ๋ชจ๋ ๋น์ด ์ฐ์์ ์ด๋ผ๋ ์๋ฏธ์ ๋๋ค. ์๋ง๋ ๋ ์์ ํ ๋ ์คํธ๋ง์ ์์ฑํ๋ ค๊ณ ๋ ธ๋ ฅํด์ผ ํ ๊ฒ ๊ฐ์ต๋๋ค. ๋ ์ธ์ ๋ชจ๋ ์ ๋ฌํ๋ ๊ฒ์ ๊ธ์งํ๋ ๊ฐ๋ ฅํ ์ธ์๋ฅผ ๋ณผ ์ ์๋ค๊ณ ์๊ฐํ๋ฏ๋ก ์ ์ ํจ์์์์ด๋ฅผ ์ ๊ฑฐํ๊ฒ ์ต๋๋ค.
์์๊ฐ ์๋ ์ธ๋ฑ์ค๊ฐ ํ์ํ ๊ฒฝ์ฐ (0 <= ์ธ๋ฑ์ค [i] <a.shape [axis])
์ฌ๊ธฐ์๋ ๋ฒ๊ทธ (# 835)๋ ์์ต๋๋ค. ์ฌ๋ผ์ด์ค์ด๋ฏ๋ก ์ํ๊ฐ์ด ํฌํจ๋์ด์ผํฉ๋๋ค.
์ฌ๊ธฐ์๋ ๋ฒ๊ทธ๊ฐ ์์ต๋๋ค. ์ฌ๋ผ์ด์ค์ด๋ฏ๋ก ์ํ๊ฐ์ด ํฌํจ๋์ด์ผํฉ๋๋ค.
๊ณ ๋ง์์.
reduceat
ํจ์ ์์ฒด๊ฐ ์๋๋๋ค.;)
:\doc\neps\groupby_additions.rst
์๋ reduceby
ํจ์์ ๋ํ (IMO ์ด๋ฑํ) ์ ์์ด ํฌํจ๋์ด ์์ต๋๋ค.
๊ฐ์ฅ ์ ์ฉํ ๋๊ธ
reduceat
์ ์ฃผ์ ๋๊ธฐ๋ ์ต๋ ์๋๋ฅผ ์ํดreduce
์ด์์ ๋ฃจํ๋ฅผ ํผํ๋ ๊ฒ์ ๋๋ค. ๋ฐ๋ผ์reduce
์ด์์ for ๋ฃจํ ๋ํผ๊ฐ Numpy์ ๋งค์ฐ ์ ์ฉํ ์ถ๊ฐ๊ฐ ๋ ์ง ์์ ํ ํ์ ํ์ง ๋ชปํฉ๋๋ค.reduceat
์ฃผ ๋ชฉ์ ์ ์๋ฐฐ๋ฉ๋๋ค.๋ํ
reduce
์ด์์ ๋ฃจํ์ ๋ํ ๋น ๋ฅธ ๋ฒกํฐํ ๋ ๋์ฒด๋ก์reduceat
์กด์ฌ ๋ฐ API์ ๋ํ ๋ ผ๋ฆฌ๋ ๊นจ๋ํ๊ณ ์ ์ฉํฉ๋๋ค. ๋๋ ๊ทธ๊ฒ์ ๋น๋ํ์ง ์๊ณ ์คํ๋ ค ๊ณ ์น ๊ฒ์ ๋๋ค.reduceat
์๋์ ๊ด๋ จํ์ฌ ๊ฐ๋จํ ์๋ฅผ ๊ณ ๋ คํด ๋ณด๊ฒ ์ต๋๋ค.ํ์ง๋งreduceat
์ฌ์ฉํ๋ ์ ์ฝ๋์์๋ ์ค์ ์ฌ๋ก์ ๋น์ทํฉ๋๋ค.์ด๊ฒ์ 100 ๋ฐฐ ์ด์์ ์์ฐจ์ด๋ฉฐ
reduceat
ํจ์จ์ฑ ์ ์ง์ ์ค์์ฑ์ ๋ณด์ฌ์ค๋๋ค.์์ฝํ๋ฉด ์๋ก์ด ๊ธฐ๋ฅ์ ๋์ ํ๋ ๊ฒ๋ณด๋ค
reduceat
์์ ์ ์ฐ์ ์ํฉ๋๋ค.start_indices
๋ฐend_indices
๋ ๊ฒฝ์ฐ์ ๋ฐ๋ผ ์ ์ฉํ์ง๋ง ์ค๋ณต๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ผ๋ฉฐ ๊ฐ๋ฅํ ์ถ๊ฐ๋ก ๋ณผ ์ ์์ง๋ง ํ์ฌreduceat
๋ถ์ผ์น์ ๋ํ ์์ ์ฌํญ์ ์๋๋๋ค. ํ๋.