Numpy: अनुरोध: argmax2d

np.unravel_index उपयोग क्यों नहीं करें?

जैसे

np.unravel_index(X.argmax(), X.shape)

एक बोनस के रूप में, यह तब काम करता है जब X में 2 से अधिक आयाम होते हैं।

argmax2d का प्रशंसक नहीं है, लेकिन मुझे i, j = a.argmax(axis=(0, 1)) द्वारा मनाया जा सकता है

@ एरिक-वाइसर आप कैसे कहेंगे कि व्यवहार करना चाहिए? वर्तमान में a.argmax() एक अदिश देता है, और a.argmax(axis=0) शेष आयामों के आकार के साथ एक सरणी देता है। मैं a.argmax(axis=(0,1)) आकार की एक सरणी वापस करने के लिए एक 3 डी सरणी के लिए a.shape[2] अपेक्षा करता हूं।

यह समस्या एक तरफ है, तो सामान्य मामले में n प्राप्त करने के लिए a.argmax(axis=range(n)) का उपयोग करना थोड़ा अजीब होगा - डिफ़ॉल्ट पूर्णांक रैखिक सूचकांक के बजाय लंबाई सूचकांक टपल। शायद एक नया कीवर्ड आउटपुट प्रस्तुतियों के बीच स्विच कर सकता है?

तो फिर, यह आकार-जागरूक परिणाम विकल्प मौजूदा axis कीवर्ड के साथ कैसे काम करेगा, जिसके परिणामस्वरूप पहले से ही एक गैर-स्केलर वापसी मूल्य है?

क्या होगा यदि आपके 2 डी सरणी में पंक्तियों में से एक अधिकतम नहीं है (यह केवल स्थिर सरणी है) - कैसे 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 को यह संकेत देने के लिए वापस कर दूंगा कि यह उपयोगकर्ता पर निर्भर है कि वह इस तरह के मामले का इलाज कैसे करे।

और वास्तव में जो होता है उससे कोई लेना-देना नहीं है।

क्या आपका मतलब है "आर्गमैक्स की अमूर्त परिभाषा से कोई लेना देना नहीं है"? मुझे निश्चित रूप से आशा है कि _"एल्गोरिदम"_ और _"वास्तव में क्या होता है"_ न केवल एक ही चीज़ हैं, बल्कि यह कि वे दस्तावेज़ों से मेल खाते हैं।

@adeak : कभी जवाब न देने के लिए क्षमा करें

फिर, यह आकार-जागरूक परिणाम विकल्प मौजूदा अक्ष कीवर्ड के साथ कैसे काम करेगा, जिसके परिणामस्वरूप पहले से ही एक गैर-स्केलर वापसी मूल्य है?

मुझे लगता है कि इससे निपटने का एक स्पष्ट तरीका है। उदाहरण के तौर पे:

>>> 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)

उस और कीपडिम्स के साथ, आपको किसी भी आयाम के लिए 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]

@ एरिक-वाइसर - अच्छी पकड़ - मैंने इसे ठीक से अनुवाद करने में सक्षम होने की तुलना में तेज़ी से टाइप किया। बाद में सावधान रहेंगे। टिप्पणी को "होना चाहिए" के बजाय "होना चाहिए" में अपडेट किया गया। आशा है कि यह मदद करता है, अन्यथा - सुधार के लिए सुझावों के लिए खुला।
मुद्दा यह है कि argmax([2,2,2])==0 argmax([2,2,2])==1 या कुछ और जितना अच्छा है और इसे पुस्तकालय के बजाय उपयोगकर्ता द्वारा चुना जाना चाहिए। अन्यथा (उदाहरण के लिए) अतिरिक्त कीवर्ड default= या initial= के रूप में एक फ़ॉलबैक तंत्र प्रदान किया जाना चाहिए जो निर्देश देगा कि इस मामले में क्या वापस करना है।

@ thoth291 : चूंकि आप जो चर्चा कर रहे हैं वह _2D_ argmax के लिए विशिष्ट नहीं है, मेरा सुझाव है कि आप एक नया मुद्दा बनाएं

@ eric-wieser कोई चिंता नहीं, मेरे पास वापस आने के लिए धन्यवाद। मुझे लगता है कि मैं आपका सुझाव समझता हूं, और यह स्पष्ट और व्यावहारिक प्रतीत होता है। तथ्य यह है कि axis तर्क का प्रकार यह निर्धारित करता है कि वापसी मूल्य एक सरणी है या सरणी का एक टपल मेरे लिए थोड़ा आश्चर्यजनक है (विशेष रूप से axes=0 बनाम axes=[0] ), लेकिन मुझे यकीन है कि एक ही व्यवहार के लिए बहुत सारे मौजूदा उदाहरण हैं (भी, व्यावहारिकता शुद्धता को हरा देती है)।

~ बस सुनिश्चित करने के लिए: आपके उदाहरण में यदि axes=(0,2) तो लौटाई गई आकृतियाँ (B,D,E) होनी चाहिए, है ना?

बस तसल्ली के लिए

दोनों सही, अच्छा कैच

तथ्य यह है कि अक्ष तर्क का प्रकार यह निर्धारित करता है कि वापसी मूल्य एक सरणी है या सरणी का एक टपल मेरे लिए थोड़ा आश्चर्यजनक है

ध्यान दें कि वास्तविक सरणी समान है। मुझे लगता है कि यह व्यावहारिकता और शुद्धता दोनों को प्रभावित करता है - नियम यह है कि axis=(a,) → res = (arr,) और axis=a → res = arr । एपिस कि आकार 1 के विशेष मामले टुपल्स ने मुझे एक बुरे विचार के रूप में मारा, क्योंकि उस विशेष आवरण को पूरे कॉल स्टैक को संक्रामक बनना पड़ता है

मैंने कभी विशेष-केस लंबाई -1 टुपल्स के बारे में नहीं सोचा होगा, जो गलत लगता है। मैं अदिश बनाम टपल मामले के बारे में सोच रहा था। यह मेरे लिए अस्पष्ट रूप से हुआ था कि स्केलर और लम्बाई -1 टुपल मामले आपके द्वारा बताए गए तरीके से एक-दूसरे से मेल खाते हैं, लेकिन अब जब आपने इसे लिखा है तो यह स्पष्ट है कि स्केलर -> 1-टुपल -> सामान्य ट्यूपल मामले सीधे सामान्यीकरण हैं। तो धन्यवाद, मैं आपके सुझाव का पूर्ण समर्थन करता हूं।