আমি কীভাবে একটি এনপাই অ্যারেতে N সর্বাধিক মান সূচক পেতে পারি?

Question

NumPy এর মাধ্যমে অ্যারের সর্বাধিক মানের সূচক পাওয়ার জন্য একটি উপায় প্রস্তাব করে np.argmax।

আমি অনুরূপ একটি জিনিস চাই, তবে Nসর্বাধিক মানগুলির সূচকগুলি ফিরিয়ে দিচ্ছি ।

উদাহরণস্বরূপ, যদি আমি একটি অ্যারে আছে, [1, 3, 2, 4, 5], function(array, n=3)সূচকের ফিরে আসবে [4, 3, 1]যা উপাদান মিলা [5, 4, 3]।

Comments

সম্ভাব্য সদৃশ পাইথন + + numpy: কার্যকর উপায় ন্যুনতম / সর্বাধিক এন মূল্যবোধ ও সূচকের একটি ম্যাট্রিক্স থেকে নেওয়া

— সেভেন Marnach

আপনার প্রশ্নটি সত্যই সঠিকভাবে সংজ্ঞায়িত হয়নি। উদাহরণস্বরূপ, কি সূচকের (আপনি আশা) জন্য হতে হবে array([5, 1, 5, 5, 2, 3, 2, 4, 1, 5]), কণা n= 3? সব কোনটি বিকল্প মত [0, 2, 3], [0, 2, 9], ...সঠিক এক হতে হবে? আপনার নির্দিষ্ট প্রয়োজনীয়তা সম্পর্কে আরও বিস্তারিত জানাতে দয়া করে। ধন্যবাদ

— খাবেন

@ আবার, এই সুনির্দিষ্ট ক্ষেত্রে কোনটি ফেরত আসবে বলে আমি সত্যিই চিন্তা করি না। এমনকি যদি প্রথমটির মুখোমুখি হওয়াটিকে ফিরিয়ে দেওয়া যৌক্তিক বলে মনে হয় তবে এটি আমার প্রয়োজন হয় না।

— অ্যালেক্সিস মাতিরেউ

argsortযদি আপনি প্রত্যাবর্তিত অশালীন ক্রমের ক্রমটি যত্ন না করেন তবে এটি একটি কার্যকর বিকল্প হতে পারে। আমার উত্তর নীচে দেখুন।

— নীল নীল

Answer 1

আমি যে সহজতম সাথে আসতে পেরেছি তা হ'ল:

In [1]: import numpy as np

In [2]: arr = np.array([1, 3, 2, 4, 5])

In [3]: arr.argsort()[-3:][::-1]
Out[3]: array([4, 3, 1])

এটি অ্যারে সম্পূর্ণ সাজানোর জড়িত। আশ্চর্যজনকভাবে numpyআংশিক বাছাই করার জন্য যদি অন্তর্নির্মিত উপায় সরবরাহ করে; এখনও পর্যন্ত আমি এটির সন্ধান করতে পারিনি।

যদি এই সমাধানটি খুব ধীর হয়ে যায় (বিশেষত ছোটের জন্য n), তবে সাইথনে কোনও কোড কোডিংয়ের দিকে নজর দেওয়া উচিত ।

Comments

লাইন 3 সমান হিসাবে লেখা যেতে পারে arr.argsort()[-1:-4:-1]? আমি এটি দোভাষীর মাধ্যমে চেষ্টা করেছি এবং এটি একই ফলাফলটি নিয়ে আসে তবে আমি ভাবছি এটি কোনও উদাহরণের মাধ্যমে ভেঙে গেছে কিনা।

— abroekhof

@ অ্যাব্রোয়েখফ হ্যাঁ এটি কোনও তালিকা বা অ্যারের সমতুল্য হওয়া উচিত। বিকল্পভাবে, এটি ব্যবহার করে বিপরীত ছাড়াই করা যেতে পারে np.argsort(-arr)[:3], যা আমি আরও পঠনযোগ্য এবং বিন্দুতে খুঁজে পাই।

— জিজ্ঞাসা

[:: - 1] এর অর্থ কী? @NPE

— 1a1a11a

@ 1a1a11a এর অর্থ একটি অ্যারের বিপরীত হওয়া (আক্ষরিক অর্থে, বিপরীতমুখী ক্রম থেকে নিয়ন্ত্রিত

— নূন্যতম

arr.argsort()[::-1][:n]আরও ভাল কারণ এটি n=0পুরো অ্যারের পরিবর্তে খালি ফিরে আসে

— ora

Answer 2

আরও নবীন সংস্করণ (1.8 এবং উপরে) এর argpartitionজন্য ডাকে একটি ফাংশন রয়েছে । চারটি বৃহত্তম উপাদানের সূচকগুলি পেতে, করুন

>>> a = np.array([9, 4, 4, 3, 3, 9, 0, 4, 6, 0])
>>> a
array([9, 4, 4, 3, 3, 9, 0, 4, 6, 0])
>>> ind = np.argpartition(a, -4)[-4:]
>>> ind
array([1, 5, 8, 0])
>>> a[ind]
array([4, 9, 6, 9])

বিপরীতে argsort, এই ফাংশনটি সবচেয়ে খারাপ ক্ষেত্রে লিনিয়ার সময়ে চলে, তবে প্রত্যাবর্তিত সূচকগুলি সাজানো হয় না, যেমন মূল্যায়নের ফলাফল থেকে দেখা যায় a[ind]। আপনারও যদি এটির প্রয়োজন হয় তবে তাদের পরে বাছাই করুন:

>>> ind[np.argsort(a[ind])]
array([1, 8, 5, 0])

এই ভাবে সাজানো ক্রমে শীর্ষ- কে উপাদানগুলি পেতে ও ( এন + কে লগ কে ) সময় নেয়।

Comments

@varela ইন্ট্রোস लेक्ट অ্যালগরিদম argpartitionব্যবহার করে লিনিয়ার টাইমে হে (এন) চালায় । পরবর্তী ধরণটি কেবল কে উপাদানগুলিকে পরিচালনা করে, যাতে এটি (কে লগ কে) এ চলে।

— ফ্রেড ফু

যদি কেউ ভাবছেন যে ঠিক কীভাবে np.argpartitionএবং এর বোন অ্যালগরিদম np.partitionসেখানে কাজ করে তবে লিঙ্কযুক্ত প্রশ্নের আরও বিস্তারিত ব্যাখ্যা রয়েছে: স্ট্যাকওভারফ্লো

— রামন মার্টিনেজ

@ ফ্রেডফু: আপনি কেন -4 ব্যবহার করলেন? পশ্চাদপদ শুরু করার জন্য আপনি কি তা করেছেন? (যেহেতু কে ইতিবাচক বা নেতিবাচক হওয়ায় আমার পক্ষে একই কাজ করে! এটি কেবল প্রথমে ক্ষুদ্রতম সংখ্যাগুলি মুদ্রণ করে!

— রিকা

@ এলকেটি ব্যবহার করুন a=np.array([9, 4, 4, 3, 3, 9, 0, 4, 6, 0])কারণ সাধারণ অজগর তালিকাগুলি তালিকা অনুসারে সূচকে সমর্থন করে নাnp.array

— মারওয়ান ওকশা

@ উমসিংহাল np.argpartitionএকটি alচ্ছিক axisযুক্তি নিয়েছে। প্রতিটি সারির শীর্ষ এন মানগুলির সূচকগুলি সন্ধান করতে:np.argpartition(a, -n, axis=1)[-n:]

— রাল্ফ

Answer 3

সহজ এখনও:

idx = (-arr).argsort()[:n]

যেখানে n হ'ল সর্বাধিক মানের সংখ্যা।

Comments

এটি কি 2 ডি অ্যারের জন্য করা যেতে পারে? যদি তা না হয় তবে আপনি কীভাবে জানেন?

— অ্যান্ড্রু হুন্ড

@ অ্যান্ড্রুহান্ট: কেবল (-আরার) ব্যবহার করুন .আর্গসর্ট (অক্ষ = -1) [:,: n]

— MiniQuark

arr[arr.argsort()[-n:]]অ্যারে

— অবহেলা করার

Answer 4

ব্যবহার করুন:

>>> import heapq
>>> import numpy
>>> a = numpy.array([1, 3, 2, 4, 5])
>>> heapq.nlargest(3, range(len(a)), a.take)
[4, 3, 1]

নিয়মিত পাইথন তালিকার জন্য:

>>> a = [1, 3, 2, 4, 5]
>>> heapq.nlargest(3, range(len(a)), a.__getitem__)
[4, 3, 1]

আপনি যদি পাইথন 2 ব্যবহার করেন তবে এর xrangeপরিবর্তে ব্যবহার করুন range।

উত্স: হ্যাপক - গাদা সারি অ্যালগোরিদম

Comments

সব এখানে একটি লুপ কোন প্রয়োজন নেই: heapq.nlargest(3, xrange(len(a)), a.take)। পাইথন তালিকার জন্য আমরা এর .__getitem__পরিবর্তে ব্যবহার করতে পারি .take।

— অশ্বিনী চৌধুরী চৌধুরী

এন-মাত্রিক অ্যারে জন্য Aসাধারণভাবে: heapq.nlargest(3, range(len(A.ravel())), A.ravel().take)। (আমি আশা করি এই শুধুমাত্র ভিউ-এ কাজ করে, এছাড়াও (দেখুন ravel vs flatten] ( stackoverflow.com/a/28930580/603003 ।))

— ComFreek

Answer 5

আপনি যদি বহুমাত্রিক অ্যারে নিয়ে কাজ করছেন বলে মনে হয় তবে আপনাকে সূচকগুলি সমতল এবং আনারভেল করতে হবে:

def largest_indices(ary, n):
    """Returns the n largest indices from a numpy array."""
    flat = ary.flatten()
    indices = np.argpartition(flat, -n)[-n:]
    indices = indices[np.argsort(-flat[indices])]
    return np.unravel_index(indices, ary.shape)

উদাহরণ স্বরূপ:

>>> xs = np.sin(np.arange(9)).reshape((3, 3))
>>> xs
array([[ 0.        ,  0.84147098,  0.90929743],
       [ 0.14112001, -0.7568025 , -0.95892427],
       [-0.2794155 ,  0.6569866 ,  0.98935825]])
>>> largest_indices(xs, 3)
(array([2, 0, 0]), array([2, 2, 1]))
>>> xs[largest_indices(xs, 3)]
array([ 0.98935825,  0.90929743,  0.84147098])

Answer 6

আপনি যদি কে-থ্রি বৃহত্তম উপাদানগুলি ব্যবহার করতে পারেন তার ক্রম সম্পর্কে যত্নশীল না হন argpartitionযা পুরো ধরণের চেয়ে ভাল সম্পাদন করা উচিত argsort।

K = 4 # We want the indices of the four largest values
a = np.array([0, 8, 0, 4, 5, 8, 8, 0, 4, 2])
np.argpartition(a,-K)[-K:]
array([4, 1, 5, 6])

ক্রেডিট এই প্রশ্নে যেতে ।

আমি কয়েকটি পরীক্ষা চালিয়েছি এবং এটি অ্যারের আকার এবং কে বৃদ্ধির মান হিসাবে argpartitionআউটপোরফর্মগুলির মত দেখাচ্ছে argsort।

Answer 7

বহুমাত্রিক অ্যারেগুলির জন্য আপনি axisপ্রত্যাশিত অক্ষের সাথে পার্টিশনটি প্রয়োগ করতে কীওয়ার্ডটি ব্যবহার করতে পারেন ।

# For a 2D array
indices = np.argpartition(arr, -N, axis=1)[:, -N:]

এবং আইটেমগুলি দখল করার জন্য:

x = arr.shape[0]
arr[np.repeat(np.arange(x), N), indices.ravel()].reshape(x, N)

তবে মনে রাখবেন যে এটি একটি সাজানো ফলাফল ফিরিয়ে দেবে না। np.argsort()সেক্ষেত্রে আপনি অভিযুক্ত অক্ষ বরাবর ব্যবহার করতে পারেন :

indices = np.argsort(arr, axis=1)[:, -N:]

# Result
x = arr.shape[0]
arr[np.repeat(np.arange(x), N), indices.ravel()].reshape(x, N)

এখানে একটি উদাহরণ:

In [42]: a = np.random.randint(0, 20, (10, 10))

In [44]: a
Out[44]:
array([[ 7, 11, 12,  0,  2,  3,  4, 10,  6, 10],
       [16, 16,  4,  3, 18,  5, 10,  4, 14,  9],
       [ 2,  9, 15, 12, 18,  3, 13, 11,  5, 10],
       [14,  0,  9, 11,  1,  4,  9, 19, 18, 12],
       [ 0, 10,  5, 15,  9, 18,  5,  2, 16, 19],
       [14, 19,  3, 11, 13, 11, 13, 11,  1, 14],
       [ 7, 15, 18,  6,  5, 13,  1,  7,  9, 19],
       [11, 17, 11, 16, 14,  3, 16,  1, 12, 19],
       [ 2,  4, 14,  8,  6,  9, 14,  9,  1,  5],
       [ 1, 10, 15,  0,  1,  9, 18,  2,  2, 12]])

In [45]: np.argpartition(a, np.argmin(a, axis=0))[:, 1:] # 1 is because the first item is the minimum one.
Out[45]:
array([[4, 5, 6, 8, 0, 7, 9, 1, 2],
       [2, 7, 5, 9, 6, 8, 1, 0, 4],
       [5, 8, 1, 9, 7, 3, 6, 2, 4],
       [4, 5, 2, 6, 3, 9, 0, 8, 7],
       [7, 2, 6, 4, 1, 3, 8, 5, 9],
       [2, 3, 5, 7, 6, 4, 0, 9, 1],
       [4, 3, 0, 7, 8, 5, 1, 2, 9],
       [5, 2, 0, 8, 4, 6, 3, 1, 9],
       [0, 1, 9, 4, 3, 7, 5, 2, 6],
       [0, 4, 7, 8, 5, 1, 9, 2, 6]])

In [46]: np.argpartition(a, np.argmin(a, axis=0))[:, -3:]
Out[46]:
array([[9, 1, 2],
       [1, 0, 4],
       [6, 2, 4],
       [0, 8, 7],
       [8, 5, 9],
       [0, 9, 1],
       [1, 2, 9],
       [3, 1, 9],
       [5, 2, 6],
       [9, 2, 6]])

In [89]: a[np.repeat(np.arange(x), 3), ind.ravel()].reshape(x, 3)
Out[89]:
array([[10, 11, 12],
       [16, 16, 18],
       [13, 15, 18],
       [14, 18, 19],
       [16, 18, 19],
       [14, 14, 19],
       [15, 18, 19],
       [16, 17, 19],
       [ 9, 14, 14],
       [12, 15, 18]])

Comments

আমার মনে হয় আপনি এখানে ব্যবহার করে সূচকগুলি সহজ করতে পারবেন np.take_along_axis(আপনি যখন এই প্রশ্নের উত্তর দিয়েছিলেন সম্ভবত এটি উপস্থিত ছিল না)

— এরিক

Answer 8

এটি আপনার আসল অ্যারের আকার এবং আপনার নির্বাচনের আকারের উপর নির্ভর করে একটি সম্পূর্ণ বাছাইয়ের চেয়ে দ্রুত হবে:

>>> A = np.random.randint(0,10,10)
>>> A
array([5, 1, 5, 5, 2, 3, 2, 4, 1, 0])
>>> B = np.zeros(3, int)
>>> for i in xrange(3):
...     idx = np.argmax(A)
...     B[i]=idx; A[idx]=0 #something smaller than A.min()
...     
>>> B
array([0, 2, 3])

এটি অবশ্যই আপনার মূল অ্যারে নিয়ে হস্তক্ষেপ জড়িত। যা আপনি অনুলিপি করতে পারেন (যদি প্রয়োজন হয়) একটি অনুলিপি তৈরি করে বা মূল মানগুলি প্রতিস্থাপন করে। ... আপনার ব্যবহারের ক্ষেত্রে যে কোনওটি সস্তা।

Comments

FWIW, আপনার সমাধান সমস্ত পরিস্থিতিতে দ্ব্যর্থহীন সমাধান সরবরাহ করবে না। কীভাবে এই দ্ব্যর্থহীন কেসগুলি পরিচালনা করবেন ওপিকে বর্ণনা করা উচিত। ধন্যবাদ

— খাবেন

@eat ওপির প্রশ্নটি কিছুটা অস্পষ্ট। একটি বাস্তবায়ন, তবে এটি ব্যাখ্যার জন্য সত্য নয়। :) এই নির্দিষ্ট সমাধানটি প্রয়োজনীয়তাগুলি নিশ্চিত করে তা নিশ্চিত করার জন্য ওপিতে কেবলমাত্র np.argmax ডকস.সিপি.অর্গ / ডক / নম্পি / রেফারেন্স / জেনারেটেড / নম্পি.আরগম্যাক্স html এর সংজ্ঞাটি উল্লেখ করা উচিত of ওপি'র বর্ণিত পুনর্নির্মাণের যে কোনও সমাধান মেটানো সম্ভব তা সম্ভব ..

— পল

ঠিক আছে, কেউ বাস্তবায়নের argmax(.)বিষয়টিও দ্ব্যর্থহীন বলে বিবেচনা করতে পারে । (আইএমএইচও এটি একরকম সংক্ষিপ্ত সার্কিট যুক্তি অনুসরণ করার চেষ্টা করে তবে দুর্ভাগ্যক্রমে সর্বজনীনভাবে গ্রহণযোগ্য আচরণ প্রদান করতে ব্যর্থ হয়)। ধন্যবাদ

— খাবেন

Answer 9

পদ্ধতিটি np.argpartitionকেবলমাত্র কে সর্বাধিক সূচকগুলি প্রদান করে, স্থানীয় সারণি সম্পাদন করে এবং np.argsortঅ্যারেটি বেশ বড় হলে (সম্পূর্ণ ধরণের সঞ্চালন করা) দ্রুত হয়। তবে প্রত্যাবর্তিত সূচকগুলি আরোহী / অবতরণ ক্রমে নয় । একটি উদাহরণ দিয়ে বলি:

আমরা দেখতে পাচ্ছি যে আপনি যদি কঠোর আরোহী ক্রম শীর্ষ কে সূচকগুলি চান, np.argpartition তা ফিরিয়ে দেবে না।

এনপি.আরগ পার্টিশনের পরে ম্যানুয়ালি বাছাই করা ছাড়াও আমার সমাধানটি পাই টর্চ ব্যবহার করা, torch.topk নিউরাল নেটওয়ার্ক নির্মাণের একটি সরঞ্জাম, সিপিইউ এবং জিপিইউ উভয় সমর্থন সহ নম্পপি-এর মতো এপিআই সরবরাহ করা। এটি এমকেএল সহ নুমপির মতো দ্রুত এবং এটি আপনার যদি বৃহত ম্যাট্রিক্স / ভেক্টর গণনার প্রয়োজন হয় তবে একটি জিপিইউ উত্সাহ দেয়।

কঠোর আরোহণ / উতরাই শীর্ষ কে সূচি কোড হবে:

নোট করুন যে torch.topkএকটি টর্চ টেনসর গ্রহণ করে, এবং শীর্ষস্থানীয় কে এবং মান উভয় প্রকারের সূচকগুলি প্রদান করে torch.Tensor। এনপি-র সাথে অনুরূপ, টর্চ.টপক একটি অক্ষ যুক্তিও গ্রহণ করে যাতে আপনি বহুমাত্রিক অ্যারে / টেনারগুলি পরিচালনা করতে পারেন।

Answer 10

ব্যবহার করুন:

from operator import itemgetter
from heapq import nlargest
result = nlargest(N, enumerate(your_list), itemgetter(1))

এখন resultতালিকায় এন টিপলস ( index, value) থাকবে যেখানে valueসর্বাধিক করা হয়।

Answer 11

ব্যবহার করুন:

def max_indices(arr, k):
    '''
    Returns the indices of the k first largest elements of arr
    (in descending order in values)
    '''
    assert k <= arr.size, 'k should be smaller or equal to the array size'
    arr_ = arr.astype(float)  # make a copy of arr
    max_idxs = []
    for _ in range(k):
        max_element = np.max(arr_)
        if np.isinf(max_element):
            break
        else:
            idx = np.where(arr_ == max_element)
        max_idxs.append(idx)
        arr_[idx] = -np.inf
    return max_idxs

এটি 2 ডি অ্যারে নিয়েও কাজ করে। উদাহরণ স্বরূপ,

In [0]: A = np.array([[ 0.51845014,  0.72528114],
                     [ 0.88421561,  0.18798661],
                     [ 0.89832036,  0.19448609],
                     [ 0.89832036,  0.19448609]])
In [1]: max_indices(A, 8)
Out[1]:
    [(array([2, 3], dtype=int64), array([0, 0], dtype=int64)),
     (array([1], dtype=int64), array([0], dtype=int64)),
     (array([0], dtype=int64), array([1], dtype=int64)),
     (array([0], dtype=int64), array([0], dtype=int64)),
     (array([2, 3], dtype=int64), array([1, 1], dtype=int64)),
     (array([1], dtype=int64), array([1], dtype=int64))]

In [2]: A[max_indices(A, 8)[0]][0]
Out[2]: array([ 0.89832036])

Comments

ভাল কাজ করে তবে আপনার অ্যারেতে ডুপ্লিকেট (সর্বাধিক) মান থাকলে আরও বেশি ফলাফল দেয় k

— Guido

আমি কোডটি কিছুটা সংশোধন করেছি। সূচকগুলির যে তালিকা ফিরে আসে তার দৈর্ঘ্য হুবহু কে। আপনার যদি সদৃশ থাকে তবে সেগুলি একটি একক টুপলে বিভক্ত করা হয়েছে।

— এক্স Æ এ-12

Answer 12

bottleneck একটি আংশিক বাছাইয়ের ফাংশন রয়েছে, কেবলমাত্র এন বৃহত্তম মানগুলি পেতে পুরো অ্যারে বাছাই করার ব্যয়টি খুব দুর্দান্ত।

_{আমি এই মডিউল সম্পর্কে কিছুই জানি না; আমি শুধু গুগল numpy partial sort।}

Comments

আমি বাধা কোনও আংশিক বাছাইয়ের ফাংশন খুঁজে পাই না, সেখানে একটি পার্টিশন ফাংশন আছে, তবে এটি

— সাজায়

Answer 13

সর্বাধিক উপাদান এবং এর অবস্থানগুলি দেখার জন্য নিম্নলিখিতটি একটি খুব সহজ উপায়। এখানে axisডোমেন; axis= 0 অর্থ কলাম ভিত্তিক সর্বাধিক সংখ্যা এবং axis= 1 অর্থ 2D কেসের জন্য সারি ভিত্তিক সর্বাধিক সংখ্যা। এবং উচ্চ মাত্রার জন্য এটি আপনার উপর নির্ভর করে।

M = np.random.random((3, 4))
print(M)
print(M.max(axis=1), M.argmax(axis=1))

Comments

আমি এই লিঙ্কটি jakevdp.github.io/ পাইথনডাটা বিজ্ঞান হ্যান্ডবুক

— উদারপন্থী

Answer 14

আমি এটি ব্যবহার করা সবচেয়ে স্বজ্ঞাত np.unique।

ধারণাটি হ'ল, অনন্য পদ্ধতিটি ইনপুট মানগুলির সূচকগুলি দেয়। তারপরে সর্বাধিক অনন্য মান এবং সূচকগুলি থেকে মূল মানগুলির অবস্থানটি পুনরায় তৈরি করা যেতে পারে।

multi_max = [1,1,2,2,4,0,0,4]
uniques, idx = np.unique(multi_max, return_inverse=True)
print np.squeeze(np.argwhere(idx == np.argmax(uniques)))
>> [4 7]

Answer 15

আমি মনে করি সর্বাধিক সময় দক্ষতার উপায় হ'ল ম্যানুয়ালি অ্যারে দিয়ে পুনরাবৃত্তি হয় এবং কে-আকারের ন্যূনতম apগুণ রাখে, যেমন অন্যান্য লোকেরা উল্লেখ করেছেন।

এবং আমি একটি নিষ্ঠুর শক্তি পদ্ধতির সাথেও উপস্থিত হয়েছি:

top_k_index_list = [ ]
for i in range(k):
    top_k_index_list.append(np.argmax(my_array))
    my_array[top_k_index_list[-1]] = -float('inf')

আরগম্যাক্স এর সূচক পেতে আপনি ব্যবহার করার পরে বৃহত্তম উপাদানটিকে একটি বৃহত্তর নেতিবাচক মানতে সেট করুন। এবং তারপরে আরগম্যাক্সের পরবর্তী কলটি দ্বিতীয় বৃহত্তম উপাদানটি ফিরিয়ে দেবে। এবং আপনি এই উপাদানগুলির মূল মানটি লগ করতে পারেন এবং আপনি চাইলে সেগুলি পুনরুদ্ধার করতে পারেন।

Answer 16

এই কোডটি একটি নপি ম্যাট্রিক্স অ্যারের জন্য কাজ করে:

mat = np.array([[1, 3], [2, 5]]) # numpy matrix

n = 2  # n
n_largest_mat = np.sort(mat, axis=None)[-n:] # n_largest 
tf_n_largest = np.zeros((2,2), dtype=bool) # all false matrix
for x in n_largest_mat: 
  tf_n_largest = (tf_n_largest) | (mat == x) # true-false  

n_largest_elems = mat[tf_n_largest] # true-false indexing 

এটি সত্য-মিথ্যা n_largest ম্যাট্রিক্স সূচক তৈরি করে যা ম্যাট্রিক্স অ্যারে থেকে n_largest উপাদানগুলি বের করতেও কাজ করে