2D ๋ฐฐ์ด์ ๋ํด argmax๋ฅผ ์ํํ๊ณ ์ต๋๊ฐ์ ํ ๋ฐ ์ด ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๋ ํธ๋ฆฌํ ํจ์๊ฐ ์์ผ๋ฉด ์ ๋ง ์ข์ ๊ฒ์ ๋๋ค.
๋๋ ์ข ์ข ๋ค์ ์ฝ๋๋ฅผ ์ฌ์ฌ์ฉํ๊ณ ์์ต๋๋ค.
def argmax2d(X):
n, m = X.shape
x_ = np.ravel(X)
k = np.argmax(x_)
i, j = k // m, k % m
return i, j
๊ฐ๋จํ์ง๋ง ์ด ๊ธฐ๋ฅ์ ์ผ๊ด๋๊ฒ ์ฐพ์์ผ ํ๋ ๊ณณ์์๋ ์ถฉ๋ถํ ๋ถํฌ๋ช
ํฉ๋๋ค.
์ด๊ฒ์ด ์ด๋ฏธ numpy์์ ์ฌ์ฉํ ์ ์๋ค๋ฉด ์ข์ ๊ฒ์
๋๋ค.
์ด ๊ธฐ๋ฅ์ ์ฝ๊ฒ ์ฌ์ฉํ ์ ์๋๋ก numpy์์ PR์ ์ฌ๋ ๋ฐ ์ด์๊ฐ ์์ต๋๊น?
np.unravel_index
์ฌ์ฉํ์ง ์๋ ์ด์ ๋ ๋ฌด์์
๋๊น?
์
np.unravel_index(X.argmax(), X.shape)
๋ณด๋์ค๋ก X
์ฐจ์์ด 2๊ฐ ์ด์์ธ ๊ฒฝ์ฐ์๋ ์๋ํฉ๋๋ค.
argmax2d
์ ํฌ์ ์๋์ง๋ง i, j = a.argmax(axis=(0, 1))
์ํด ์ค๋๋ ์ ์์ต๋๋ค.
@eric-wieser ์ด๋ป๊ฒ ํ๋ํด์ผ ํ๋ค๊ณ ๋งํ๊ฒ ์ต๋๊น? ํ์ฌ a.argmax()
๋ ์ค์นผ๋ผ๋ฅผ ๋ฐํํ๊ณ a.argmax(axis=0)
๋ ๋๋จธ์ง ์ฐจ์์ ๋ชจ์์ ๊ฐ์ง ๋ฐฐ์ด์ ๋ฐํํฉ๋๋ค. a.shape[2]
๋ชจ์์ ๋ฐฐ์ด์ ๋ฐํํ๋ 3d ๋ฐฐ์ด์ ๊ฒฝ์ฐ a.argmax(axis=(0,1))
๋ฅผ ์์ํฉ๋๋ค.
์ด ๋ฌธ์ ๋ ์ ์ณ๋๊ณ , ๊ธฐ๋ณธ ์ ์ ์ ํ ์ธ๋ฑ์ค ๋์ n
๊ธธ์ด ์ธ๋ฑ์ค ํํ์ ์ป๊ธฐ ์ํด ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ์ a.argmax(axis=range(n))
๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ์ฝ๊ฐ ์ด์ํ ๊ฒ์
๋๋ค. ์๋ก์ด ํค์๋๊ฐ ์ถ๋ ฅ ํํ ์ฌ์ด๋ฅผ ์ ํํ ์ ์์๊น์?
๊ทธ๋ ๋ค๋ฉด ์ด ๋ชจ์ ์ธ์ ๊ฒฐ๊ณผ ์ต์
์ด ๊ธฐ์กด axis
ํค์๋์ ํจ๊ป ์๋ํ์ฌ ์ด๋ฏธ ์ค์นผ๋ผ๊ฐ ์๋ ๋ฐํ ๊ฐ์ ์์ฑํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์
๋๊น?
2D ๋ฐฐ์ด์ ํ ์ค ํ๋์ ์ต๋๊ฐ์ด ์๋ ๊ฒฝ์ฐ(๋จ์ํ ์์ ๋ฐฐ์ด์) - argmax๊ฐ ์ด๋ฅผ ๋ณด๊ณ ํ ์ ์๋ ๋ฐฉ๋ฒ์ ๋ฌด์์
๋๊น?
์๋ฅผ ๋ค์ด:
# setup the problem
import numpy as np
x=np.arange(10).reshape([2,5])
x[1,3]=2
# x is this:
# [[0, 1, 2, 3, 4],
# [5, 6, 7, 2, 9]]
# this will behave normally
np.argmax(x==2, axis=1)
# Out: [2,3]
# but this one returns 0 instead of NaN
np.argmax(x==3, axis=1)
# Out: [3,0]
# Expected: [3, nan]
์๋ฅผ ๋ค์ด ์ฌ์ฉ ๊ฐ๋ฅํ ์ต๋๊ฐ์ด ์๋ ๊ฒฝ์ฐ ์ฌ์ฉ์๊ฐ ์ํํ ์์
์ ์ ์ดํ ์ ์๋๋ก ์ถ๊ฐ ์ธ์๊ฐ ์์ผ๋ฉด ์ข์ ๊ฒ์
๋๋ค. np.argmax(x,axis,no_ind=0)
(0์ ์ด์ ๋ฒ์ ๊ณผ์ ํธํ์ฑ์ ์ ์งํ๊ธฐ ์ํ ๊ธฐ๋ณธ๊ฐ์
๋๋ค).
@ thoth291 ์ด๊ฒ์ argmax
์ ๋์์ ๊ดํ ๋ณด๋ค ์ผ๋ฐ์ ์ธ ์ง๋ฌธ์ด ์๋๋๊น? 1d ๋ฐฐ์ด์ axis
ํค์๋ ์ธ์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ ๋์ผํ ์ผ์ด ๋ฐ์ํฉ๋๋ค.
>>> np.argmax([2,2,2])
0
๊ทธ๋ฆฌ๊ณ ์ด๊ฒ์ ๋์ ์ผ ๋์ ๊ด๋ก์ ์ธ ํ๋์
๋๋ค. ๋์ ๋ ๊ฐ ์ค์์ ์ฒซ ๋ฒ์งธ ๊ฐ์ ์ ํํ์ญ์์ค. ๋ง์ฐฌ๊ฐ์ง๋ก ํด๋น ๋ฐฐ์ด์ max
๊ฐ nan
๊ฐ ์๋ ๊ฒฝ์ฐ: 2์
๋๋ค. ์ต๋๊ฐ์ด ์๋ ๊ฒฝ์ฐ ํด๋น ์ธ๋ฑ์ค๊ฐ ์์ด์ผ ํฉ๋๋ค. ์๋๋ฉด ๋ด๊ฐ ๋น์ ์ ์์ ์ ๋์ณค์ต๋๊น?
@adeak , ์ด์ ๋น์ ์ ์ด๋ ๊ฒ ๋งํ์ต๋๋ค - ๋๋ ์ด๊ฒ์ด ์ค์ ๋ก ๋ ์ผ๋ฐ์ ์ธ ์ง๋ฌธ์ด๋ผ๊ณ ์๊ฐํ๊ธฐ ์์ํ์ต๋๋ค.
๋๋ max([2,2,2])
๊ฐ 2
๊ฐ๋ค๋ ๋ฐ ๋์ํ ์ ์์ต๋๋ค.
๊ทธ๋ฌ๋ argmax([2,2,2]) - numpy ๋ฌธ์์ ์ ์์ ๋ฐ๋ฅด๋ฉด the indices corresponding to the first occurrence
๋ฐํํฉ๋๋ค. ์ด๊ฒ์ ๊ตฌํ์ ๊ด์ ์์ ๋ณด๋ฉด ๊ด์ฐฎ์ ๊ฒ ๊ฐ์ง๋ง ์ค์ ๋ก๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌ์์ผ ๋ฟ์ด๋ฉฐ ์ค์ ๋ก ๋ฐ์ํด์ผ ํ๋ ๊ฒ๊ณผ๋ ์๋ฌด ๊ด๋ จ์ด ์์ต๋๋ค. ์ฌ์ค์ ๋ชจ๋ ์ธ๋ฑ์ค๊ฐ ๋ฐํ๋ ์ ์์ผ๋ฉฐ ์ฌ๋ฐ๋ฅธ ๊ฒ์ผ๋ก ์ทจ๊ธ๋์ด์ผ ํฉ๋๋ค. ๋๋ ์์ ๊ฐ ๋ฐฐ์ด์ ๊ฒฝ์ฐ argmax๊ฐ ๋ชจํธํ๋ค๊ณ ๋งํ ์ ์์ต๋๋ค.
์ฆ, ์ ์ด์ ๊ทธ๋ฌํ ๊ฒฐ์ ์ ํผํ๊ณ inf
๋ฅผ ๋ฐํํ์ฌ ๊ทธ๋ฌํ ๊ฒฝ์ฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๊ฒฐ์ ํ๋ ๊ฒ์ ์ฌ์ฉ์์๊ฒ ๋ฌ๋ ค ์์์ ์๋ฆฌ๊ณ ์ถ์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ ์ค์ ๋ก ์ผ์ด๋๋ ์ผ๊ณผ ์๋ฌด ๊ด๋ จ์ด ์์ต๋๋ค.
"argmax์ ์ถ์์ ์ ์์ ์๋ฌด ๊ด๋ จ์ด ์์ต๋๋ค"๋ฅผ ์๋ฏธํฉ๋๊น? ๋๋ _"์๊ณ ๋ฆฌ์ฆ"_๊ณผ _"์ค์ ๋ก ์ผ์ด๋๋ ์ผ"_์ด ๊ฐ์ ๊ฒ์ผ ๋ฟ๋ง ์๋๋ผ ๋ฌธ์์ ์ผ์นํ๊ธฐ๋ฅผ ๋ฐ๋๋๋ค.
@adeak : ๋ต์ฅ์
๊ทธ๋ฌ๋ฉด ์ด ๋ชจ์ ์ธ์ ๊ฒฐ๊ณผ ์ต์ ์ด ๊ธฐ์กด axis ํค์๋์ ํจ๊ป ์ด๋ป๊ฒ ์๋ํ์ฌ ์ด๋ฏธ ์ค์นผ๋ผ๊ฐ ์๋ ๋ฐํ ๊ฐ์ด ๋์ฌ๊น์?
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ ํ์คํ ๋ฐฉ๋ฒ์ด ํ๋ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ์๋ก์:
>>> ret = argmax(np.empty((A, B, C, D, E)), axes=(0, 2))
>>> type(ret)
tuple
>>> len(ret) # == len(axes)
2
>>> ret[0].shape
(B, D, E)
>>> ret[1].shape
(B, D, e)
๊ทธ๊ฒ๊ณผ keepdims๋ฅผ ์ฌ์ฉํ๋ฉด ๋ชจ๋ ์ฐจ์์ ๋ํด arr[argmax(arr, axes, keepdims=True)] == max(arr, keepdims=True)
๋ฅผ ์ป์ ์ ์์ผ๋ฉฐ ์ด๋ ๋์๊ฒ ๋งค์ฐ ๋ฐ๋์งํด ๋ณด์
๋๋ค.
์์ฌ ์ฝ๋์์๋ ๋ค์์ ๊ธฐ๋ํฉ๋๋ค.
def argmax(arr, axes, keepdims)
was_tuple = isinstance(axes, tuple):
if not was_tuple:
axes = (axes,)
shape = np.array(arr.shape)
axis_mask = np.array([i in axes for i in range(arr.ndim)])
shape[axis_mask] = 1
ret = tuple(np.empty(shape) for _ in axes)
# do the actual work
if not keepdims:
ret = tuple(r.reshape(shape[~axis_mask]) for r in ret)
if not was_tuple:
return ret[0]
@eric-wieser - ์ข์ ์บ์น - ์ ๋๋ก ๋ฒ์ญํ ์ ์๋ ๊ฒ๋ณด๋ค ๋น ๋ฅด๊ฒ ์
๋ ฅํ์ต๋๋ค. ๋์ค์ ์กฐ์ฌํ๊ฒ ์ต๋๋ค. "๋ฐ์" ๋์ "๋ฐ์ํด์ผ ํจ"์ผ๋ก ์ฃผ์์ ์
๋ฐ์ดํธํ์ต๋๋ค. ๋์์ด ๋๊ธฐ๋ฅผ ๋ฐ๋๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ์ฌ๊ตฌ์ฑ์ ๋ํ ์ ์์ ๋ฐ์ ์ ์์ต๋๋ค.
์์ ์ argmax([2,2,2])==0 ์ argmax([2,2,2])==1 ๋๋ ๋ค๋ฅธ ๊ฒ๊ณผ ๊ฐ์ผ๋ฉฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์๋ ์ฌ์ฉ์๊ฐ ์ ํํด์ผ ํ๋ค๋ ๊ฒ์
๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ์ด ๊ฒฝ์ฐ์ ๋ฌด์์ ๋ฐํํ ์ง ์ง์ํ๋ ์ถ๊ฐ ํค์๋ default=
๋๋ initial=
์ ํํ๋ก ๋์ฒด ๋ฉ์ปค๋์ฆ์ ์ ๊ณตํด์ผ ํฉ๋๋ค.
@thoth291 : ๋น์ ์ด ๋ ผ์ํ๊ณ ์๋ ๊ฒ์ _2D_ argmax์๋ง ๊ตญํ๋ ๊ฒ์ด ์๋๋ฏ๋ก ์ ๋ฌธ์ ๋ฅผ ๋ง๋๋ ๊ฒ์ด ์ข์ต๋๋ค.
@eric-wieser ๊ฑฑ์ ํ์ง ๋ง์ธ์. ๋ค์ ์ฐ๋ฝํด ์ฃผ์
์ ๊ฐ์ฌํฉ๋๋ค. ๋๋ ๋น์ ์ ์ ์์ ์ดํดํ๋ค๊ณ ์๊ฐํ๋ฉฐ ๊ทธ๊ฒ์ ๋ถ๋ช
ํ๊ณ ์ค์ฉ์ ์ผ๋ก ๋ณด์
๋๋ค. axis
์ธ์์ ์ ํ์ด ๋ฐํ ๊ฐ์ด ๋ฐฐ์ด์ธ์ง ๋๋ ๋ฐฐ์ด์ ํํ์ธ์ง๋ฅผ ๊ฒฐ์ ํ๋ค๋ ์ฌ์ค์ ๋์๊ฒ ์ฝ๊ฐ ๋๋์ต๋๋ค(ํนํ axes=0
vs axes=[0]
). ๊ทธ๋ฌ๋ ๋์ผํ ๋์์ ๋ํ ๊ธฐ์กด ์๊ฐ ๋ง์ด ์๋ค๊ณ ํ์ ํฉ๋๋ค(์ค์ฉ์ฑ์ ์์์ฑ์ ๋ฅ๊ฐํฉ๋๋ค).
~ํ์คํ: ๊ทํ์ ์์์ axes=(0,2)
์ด๋ฉด ๋ฐํ๋๋ ๋ชจ์์ (B,D,E)
์ด์ด์ผ ํฉ๋๋ค. ๋ง์ต๋๊น?
ํ์ธ์ฐจ
๋ ๋ค ์์ , ์ข์ ์บ์น
์ถ ์ธ์์ ์ ํ์ด ๋ฐํ ๊ฐ์ด ๋ฐฐ์ด์ธ์ง ๋๋ ๋ฐฐ์ด์ ํํ์ธ์ง๋ฅผ ๊ฒฐ์ ํ๋ค๋ ์ฌ์ค์ด ์ฝ๊ฐ ๋๋์ต๋๋ค.
์ค์ ๋ฐฐ์ด์ ๋์ผํฉ๋๋ค. ๋๋ ์ด๊ฒ์ด ์ค์ฉ์ฑ๊ณผ ์์์ฑ์ ๋ชจ๋ ์ถฉ์กฑํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ๊ท์น์ axis=(a,)
โ res = (arr,)
๋ฐ axis=a
โ res = arr
์
๋๋ค. ํฌ๊ธฐ๊ฐ 1์ธ ํน์ ์ผ์ด์ค ํํ์ ์ ์ฒด ํธ์ถ ์คํ์ ๊ฑธ์ณ ์ ์ผ์ฑ์ด ์์ด์ผ ํ๋ฏ๋ก ๋์ ์๊ฐ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค.
๋๋ ํน๋ณํ ๊ฒฝ์ฐ ๊ธธ์ด 1 ํํ์ ์๊ฐํ์ง ์์์ ๊ฒ์ ๋๋ค. ์๋ชป๋ ๊ฒ ๊ฐ์ต๋๋ค. ์ค์นผ๋ผ ๋ ํํ์ ๊ฒฝ์ฐ์ ๋ํด ๊ถ๊ธํฉ๋๋ค. ์ค์นผ๋ผ์ ๊ธธ์ด-1 ํํ ์ผ์ด์ค๊ฐ ๋น์ ์ด ์ธ๊ธํ ๋ฐฉ์์ผ๋ก ์๋ก ๋์ํ๋ค๋ ๊ฒ์ด ๋ง์ฐํ๊ฒ ๋ ์ฌ๋์ง๋ง, ์ด์ ์ค์นผ๋ผ -> 1-ํํ -> ์ผ๋ฐ ํํ ์ผ์ด์ค๊ฐ ๊ฐ๋จํ ์ผ๋ฐํ๋ผ๋ ๊ฒ์ด ๋ช ๋ฐฑํฉ๋๋ค. ๊ฐ์ฌํฉ๋๋ค. ๊ทํ์ ์ ์์ ์ ์ ์ผ๋ก ์ง์งํฉ๋๋ค.
๊ฐ์ฅ ์ ์ฉํ ๋๊ธ
np.unravel_index
์ฌ์ฉํ์ง ์๋ ์ด์ ๋ ๋ฌด์์ ๋๊น?์
๋ณด๋์ค๋ก
X
์ฐจ์์ด 2๊ฐ ์ด์์ธ ๊ฒฝ์ฐ์๋ ์๋ํฉ๋๋ค.