1 ডি নাম্পার অ্যারেতে নিম্পির সাথে স্থানীয় ম্যাক্সিমা / মিনিমা সন্ধান করা

Question

আপনি কি নাম্পি / স্কিপি থেকে এমন একটি মডিউল ফাংশন প্রস্তাব করতে পারেন যা 1 ডি নাম্পার অ্যারেতে স্থানীয় ম্যাক্সিমার / মিনিমা খুঁজে পেতে পারে? স্পষ্টতই সরলতম পদ্ধতির নিকটতম প্রতিবেশীদের দিকে নজর দেওয়া, তবে আমি একটি স্বীকৃত সমাধান পেতে চাই যা নাম্বার ডিস্ট্রোর অংশ।

Comments

সম্ভবত NumPy এ একটি মসৃণ বহুমাত্রিক অ্যারের স্থানীয় মিনিমা কীভাবে খুঁজে পাওয়া যায় তার একটি নকল ? ।

— সোভেন মারনাচ

না এটি 2 ডি-তে রয়েছে (আমি 1 ডি সম্পর্কে কথা বলছি) এবং এতে কাস্টম ফাংশন জড়িত। আমার নিজস্ব নিজস্ব বাস্তবায়ন আছে, তবে আমি ভাবছিলাম যে এর চেয়ে আরও ভাল কোনও আছে কি না, তা নিম্পি / স্কিপি মডিউলগুলির সাথে আসে।

— নভি

হতে পারে আপনি এই প্রশ্নটি অন্তর্ভুক্ত করতে আপডেট করতে পারেন যে (1) আপনার কাছে 1 ডি অ্যারে রয়েছে এবং (2) আপনি কী ধরণের স্থানীয় সর্বনিম্ন সন্ধান করছেন। দুটি সংলগ্ন এন্ট্রিগুলির চেয়ে ছোট একটি এন্ট্রি?

— সোভেন মারনাচ

আপনি scipy.signal.find_peaks_cwt এ একবার দেখতে পারেন যদি আপনি শব্দ নিয়ে ডেটা নিয়ে কথা বলছেন

— লক্ষ্যা গার্গ

Answer 1

আপনি যদি aতাদের প্রতিবেশীদের তুলনায় 1 ডি অ্যারেতে সমস্ত এন্ট্রি সন্ধান করছেন তবে আপনি চেষ্টা করতে পারেন

numpy.r_[True, a[1:] < a[:-1]] & numpy.r_[a[:-1] < a[1:], True]

আপনি এই পদক্ষেপটি ব্যবহারের আগে আপনার অ্যারেটি মসৃণ করতে পারেন numpy.convolve()।

আমি মনে করি না এর জন্য একটি উত্সর্গীকৃত কার্য আছে is

Comments

হুম, আমাকে মসৃণ করতে হবে কেন? গোলমাল দূর করতে? এটি আকর্ষণীয় মনে হচ্ছে। আমার কাছে মনে হচ্ছে আমি আপনার উদাহরণ কোডে 1 এর পরিবর্তে অন্য একটি পূর্ণসংখ্যা ব্যবহার করতে পারি। আমি গ্রেডিয়েন্ট গণনা করার কথাও ভাবছিলাম। যাইহোক যদি এটির চেয়ে খারাপ কোনও ফাংশন না থাকে।

— নাভি

@ নাভি: সমস্যাটি হ'ল "স্থানীয় ন্যূনতম" ধারণাটি ব্যবহারের ক্ষেত্রে ব্যবহারের ক্ষেত্রে বিভিন্নভাবে পরিবর্তিত হয়, সুতরাং এই উদ্দেশ্যে একটি "স্ট্যান্ডার্ড" ফাংশন সরবরাহ করা কঠিন। স্মুথিং কেবল নিকটবর্তী প্রতিবেশী থেকে আরও বেশি বিবেচনায় নিতে সহায়তা করে। 1 এর পরিবর্তে পৃথক পূর্ণসংখ্যার ব্যবহার 3, বলুন বিস্ময়কর হবে কারণ এটি উভয় দিকের তৃতীয়-পরবর্তী উপাদানটিকেই বিবেচনা করবে, তবে প্রত্যক্ষ নেহিগবার্স নয়।

— সোভেন মারনাচ

@ সোভেন মারনাচ: আপনি যে রেসিপিটি সংযুক্ত করছেন সেটি সিগন্যালটিকে বিলম্বিত করে। এখানে একটি দ্বিতীয় রেসিপি রয়েছে যা স্কিপি থেকে ফিল্টফিল্ট ব্যবহার করে ign সিগন্যাল

— বব্রোববব

কেবল এটির জন্য, এর <সাথে প্রতিস্থাপন করা >আপনাকে

— মিনিমার

@SvenMarnach আমি আমার সমস্যার এখানে পোস্ট সমাধানের জন্য আপনার উপরে সমাধান ব্যবহার করেছেন stackoverflow.com/questions/57403659/... কিন্তু আমি আউটপুট পেয়েছি [False False]কি এখানে সমস্যা হতে পারে?

— Msquare

Answer 2

SciPy> = 0.11 এ

import numpy as np
from scipy.signal import argrelextrema

x = np.random.random(12)

# for local maxima
argrelextrema(x, np.greater)

# for local minima
argrelextrema(x, np.less)

উত্পাদন

>>> x
array([ 0.56660112,  0.76309473,  0.69597908,  0.38260156,  0.24346445,
    0.56021785,  0.24109326,  0.41884061,  0.35461957,  0.54398472,
    0.59572658,  0.92377974])
>>> argrelextrema(x, np.greater)
(array([1, 5, 7]),)
>>> argrelextrema(x, np.less)
(array([4, 6, 8]),)

দ্রষ্টব্য, এইগুলি স্থানীয় সর্বাধিক / মিনিটের মধ্যে x এর সূচকগুলি। মানগুলি পেতে, চেষ্টা করুন:

>>> x[argrelextrema(x, np.greater)[0]]

scipy.signalএছাড়াও উপলব্ধ argrelmaxএবং argrelminযথাক্রমে সর্বোচ্চ এবং সর্বনিম্ন খোঁজার জন্য।

Comments

12 এর তাৎপর্য কী?

— মার্শমালো

@ মার্শম্যালো: np.random.random(12)12 টি এলোমেলো মান উত্পন্ন করে, তারা ফাংশনটি প্রদর্শনের জন্য ব্যবহৃত হয় argrelextrema।

— sebix

যদি ইনপুট হয় test02=np.array([10,4,4,4,5,6,7,6]), তবে এটি কাজ করে না। এটি স্থানীয় মিনিমা হিসাবে পরপর মানগুলি স্বীকৃতি দেয় না।

— লিওস 313

আপনাকে ধন্যবাদ, ক্লেব আমি অন্যান্য সমস্যাগুলি উল্লেখ করতে চাই: অ্যারের চূড়ান্ত পয়েন্টগুলি সম্পর্কে কী? অ্যারের শেষ উপাদানটিও স্থানীয় ন্যূনতম হওয়ায় প্রথম উপাদানটিও স্থানীয় সর্বাধিক। এবং, এছাড়াও, এটি কতটা পরপর মান প্রতিষ্ঠিত হয় তা ফিরিয়ে দেয় না। যাইহোক, আমি এই প্রশ্নের কোডটিতে একটি সমাধান প্রস্তাব করেছি এখানে । ধন্যবাদ!!

— Leos313

আপনাকে ধন্যবাদ, এটি আমি এখনও অবধি খুঁজে পাওয়া সেরা সমাধানগুলির মধ্যে একটি

— নওফাল ই

Answer 3

খুব বেশি শব্দ না করে এমন রেখাচিত্রগুলির জন্য, আমি নিম্নলিখিত ছোট কোড স্নিপেটটি সুপারিশ করছি:

from numpy import *

# example data with some peaks:
x = linspace(0,4,1e3)
data = .2*sin(10*x)+ exp(-abs(2-x)**2)

# that's the line, you need:
a = diff(sign(diff(data))).nonzero()[0] + 1 # local min+max
b = (diff(sign(diff(data))) > 0).nonzero()[0] + 1 # local min
c = (diff(sign(diff(data))) < 0).nonzero()[0] + 1 # local max


# graphical output...
from pylab import *
plot(x,data)
plot(x[b], data[b], "o", label="min")
plot(x[c], data[c], "o", label="max")
legend()
show()

দ্য +1গুরুত্বপূর্ণ, কারণ diffমূল সূচক সংখ্যা হ্রাস করা হয়।

Comments

নেস্টেড ন্যাপি ফাংশনগুলির দুর্দান্ত ব্যবহার! তবে মনে রাখবেন যে এটি অ্যারের উভয় প্রান্তে ম্যাক্সিমাকে মিস করে না :)

— ড্যানোডোনভান

যদি পুনরাবৃত্তিযোগ্য মান থাকে তবে এটি অদ্ভুত আচরণ করবে। উদাহরণস্বরূপ, আপনি অ্যারেটি গ্রহণ করলে [1, 2, 2, 3, 3, 3, 2, 2, 1]স্থানীয় ম্যাক্সিমার স্পষ্টতই মাঝখানে 3 এর মাঝখানে থাকে। তবে আপনি যে ফাংশনগুলি সরবরাহ করেছেন তা যদি আপনি সূচকগুলিতে ম্যাক্সিমামগুলি 2,6 সূচকগুলিতে পান এবং মিনিমামগুলি সূচকগুলিতে 1,3,5,7 পান তবে এটি আমার কাছে খুব একটা বোঝায় না।

— কোরেম

ব্যবহার +1পরিবর্তে এটি এড়াতে । np.diff()np.gradient()

— ankostis

আমি জানি যে এই থ্রেডটি বহু বছরের পুরনো, তবে এটি যুক্তিযুক্ত যে আপনার বক্ররেখা খুব গোলমাল হলে, আপনি মসৃণ করার জন্য সর্বদা প্রথমে লো-পাস ফিল্টারিং চেষ্টা করতে পারেন। আমার পক্ষে কমপক্ষে, আমার বেশিরভাগ স্থানীয় সর্বাধিক / মিনিট ব্যবহারগুলি কয়েকটি স্থানীয় অঞ্চলে (ই, জি, বড় চূড়া এবং উপত্যকাগুলির মধ্যে, ডাটাতে প্রতিটি পরিবর্তনের নয়) গ্লোবাল সর্বাধিক / মিনিটের জন্য হয়

— মার্কম্যান

Answer 4

আরেকটি পদ্ধতির (আরও শব্দ, কম কোড) সাহায্য করতে পারে:

স্থানীয় ম্যাক্সিমা এবং মিনিমার অবস্থানগুলিও প্রথম ডেরাইভেটিভের শূন্য ক্রসিংয়ের অবস্থান। সরাসরি স্থানীয় ম্যাক্সিমা এবং মিনিমা সন্ধান করার চেয়ে শূন্য ক্রসিংগুলি খুঁজে পাওয়া সাধারণত সহজ।

দুর্ভাগ্যক্রমে, প্রথম ডেরাইভেটিভ শব্দটি "প্রশস্ত" করে তোলে, সুতরাং যখন উল্লেখযোগ্য গোলমাল মূল ডেটাতে উপস্থিত হয়, তখন প্রথম ডেরাইভেটিভ কেবল তখনই ব্যবহার করা যায় যখন মূল ডেটা কিছুটা স্মুথিং প্রয়োগ করা হয়েছিল।

যেহেতু স্মুথিং, সহজ অর্থে, একটি কম পাস ফিল্টার, স্মুথিং প্রায়শই একটি কনভলিউশন কার্নেল ব্যবহার করে সবচেয়ে ভাল হয় (ভাল, খুব সহজেই করা হয়), এবং "শেপিং" যে কার্নেলটি বৈশিষ্ট্য-সংরক্ষণ / বাড়ানোর ক্ষমতা বাড়ানোর জন্য বিস্ময়কর পরিমাণ সরবরাহ করতে পারে । একটি সর্বোত্তম কার্নেল সন্ধানের প্রক্রিয়াটি বিভিন্ন উপায়ে ব্যবহার করে স্বয়ংক্রিয় করা যেতে পারে, তবে সবচেয়ে ভাল হতে পারে সহজ ব্রুট ফোর্স (ছোট কার্নেলগুলি সন্ধানের জন্য প্রচুর দ্রুত)। একটি ভাল কার্নেল মূল হিসাবে মূল ডেটাটি বিকৃত করবে, তবে এটি সুদের শীর্ষগুলি / উপত্যকার স্থানগুলিকে প্রভাবিত করবে না।

ভাগ্যক্রমে, প্রায়শই একটি উপযুক্ত SWAG ("শিক্ষিত অনুমান") এর মাধ্যমে উপযুক্ত কার্নেল তৈরি করা যায়। স্মুথিং কার্নেলের প্রস্থটি মূল উপাত্তের প্রস্থের প্রত্যাশিত "আকর্ষণীয়" শীর্ষের চেয়ে কিছুটা প্রশস্ত হওয়া উচিত এবং এর আকারটি সেই শিখরের সাথে মিলিত হবে (একটি একক-আকারযুক্ত তরঙ্গলিটি)। কার্নেলগুলি সংরক্ষণের জন্য (কোনও ভাল স্মুথিং ফিল্টার কী হওয়া উচিত) এর জন্য কার্নেল উপাদানগুলির যোগফলের পরিমাণ 1.00 এর সমান হওয়া উচিত এবং কার্নেলটি তার কেন্দ্রের সম্পর্কে প্রতিসাম্যপূর্ণ হওয়া উচিত (এর অর্থ এটির মধ্যে একটি অদ্ভুত সংখ্যক উপাদান থাকবে)।

একটি সর্বোত্তম স্মুথিং কার্নেল দেওয়া (বা বিভিন্ন ডেটা সামগ্রীর জন্য অনুকূল কয়েকটি সংখ্যক কার্নেল), স্মুথিংয়ের ডিগ্রি কনভ্যুশনাল কার্নেলের ("লাভ") এর জন্য একটি স্কেলিং ফ্যাক্টর হয়ে যায়।

স্মুথিংয়ের "সঠিক" (অনুকূল) ডিগ্রি নির্ধারণ (কনভোলশন কার্নেল লাভ) এমনকি স্বয়ংক্রিয় করা যেতে পারে: স্মুথড ডেটার মানক বিচ্যুতির সাথে প্রথম ডেরাইভেটিভ ডেটার স্ট্যান্ডার্ড বিচ্যুতি তুলনা করুন। স্মুথিং ক্যামের ডিগ্রি পরিবর্তনের সাথে দুটি মানক বিচ্যুতির অনুপাত কীভাবে কার্যকর স্মুথিং মানগুলির পূর্বাভাস দিতে ব্যবহৃত হবে। কয়েকটি ম্যানুয়াল ডেটা সঞ্চালিত হয় (যা সত্যিকারের প্রতিনিধি) যা প্রয়োজন তা হওয়া উচিত।

উপরে বর্ণিত সমস্ত পূর্বের সমাধানগুলি প্রথম ডেরাইভেটিভ গণনা করে তবে তারা এটিকে কোনও পরিসংখ্যান পরিমাপ হিসাবে বিবেচনা করে না, বা উপরের সমাধানগুলি বৈশিষ্ট্য সংরক্ষণ / উন্নত স্মুথিং সম্পাদন করার চেষ্টা করে না (সূক্ষ্ম শিখর "গোলমালের উপরে" লাফিয়ে উঠতে সহায়তা করে)।

অবশেষে, খারাপ খবর: "সত্যিকারের" শিখরগুলি সন্ধান করা একটি রাজকীয় ব্যথা হয়ে ওঠে যখন শব্দের মধ্যে এমন বৈশিষ্ট্যও রয়েছে যা আসল শৃঙ্গার (ওভারল্যাপিং ব্যান্ডউইথ) মতো লাগে। পরবর্তী আরও জটিল সমাধানটি সাধারণত দীর্ঘতর কনভলিউশন কার্নেল ("বৃহত্তর কার্নেল অ্যাপারচার") ব্যবহার করে যা সংলগ্ন "বাস্তব" শৃঙ্গগুলির (যেমন শীর্ষে উপস্থিতির জন্য সর্বনিম্ন বা সর্বাধিক হার) এর মধ্যে সম্পর্কের বিষয়টি বিবেচনা করে বা একাধিক ব্যবহার করে কনভলিউশনটি বিভিন্ন প্রস্থের কার্নেলগুলি ব্যবহার করে পাস হয় (তবে কেবল এটি দ্রুত হয়: এটি একটি মৌলিক গাণিতিক সত্য যা ক্রমানুসারে সঞ্চালিত লিনিয়ার কনভোলিউশনগুলি সর্বদা একক সংশ্লেষণে একত্রে মিশ্রিত করা যায়)। তবে প্রায়শই প্রথমে দরকারী কার্নেলের (বিভিন্ন প্রস্থের) ক্রমগুলি খুঁজে পাওয়া এবং একত্রে চূড়ান্ত কার্নেলটি সরাসরি একক পদক্ষেপে সন্ধান করার চেয়ে একত্রে একত্রিত করা সহজ হয় far

আশা করি এটি গুগল (এবং সম্ভবত একটি ভাল পরিসংখ্যান পাঠ্য) ফাঁক পূরণ করতে যথেষ্ট তথ্য সরবরাহ করে info আমি সত্যিই আমার একটি কাজ উদাহরণ, বা একটি লিঙ্ক প্রদান করার সময় ছিল চান। কেউ যদি অনলাইনে একটি করে আসে তবে দয়া করে এটি এখানে পোস্ট করুন!

Answer 5

সায়পাই সংস্করণ ১.১ অনুসারে আপনি ফাইন্ড_পিক্সও ব্যবহার করতে পারেন । নীচে ডকুমেন্টেশন থেকে নেওয়া দুটি উদাহরণ রয়েছে।

heightআর্গুমেন্টটি ব্যবহার করে , একটি নির্দিষ্ট প্রান্তিকের উপরে যে কোনও একটি ম্যাক্সিমাকে নির্বাচন করতে পারে (উদাহরণস্বরূপ, সমস্ত অ-নেতিবাচক ম্যাক্সিমা; এটি খুব কার্যকর হতে পারে যদি কাউকে শোরগোলের বেসলাইনটি মোকাবেলা করতে হয়; আপনি যদি মিনিমা খুঁজে পেতে চান তবে কেবল আপনার ইনপুটকে গুণান দ্বারা -1):

import matplotlib.pyplot as plt
from scipy.misc import electrocardiogram
from scipy.signal import find_peaks
import numpy as np

x = electrocardiogram()[2000:4000]
peaks, _ = find_peaks(x, height=0)
plt.plot(x)
plt.plot(peaks, x[peaks], "x")
plt.plot(np.zeros_like(x), "--", color="gray")
plt.show()

আর একটি অত্যন্ত সহায়ক যুক্তি হল distance, যা দুটি শৃঙ্গের মধ্যে সর্বনিম্ন দূরত্ব নির্ধারণ করে:

peaks, _ = find_peaks(x, distance=150)
# difference between peaks is >= 150
print(np.diff(peaks))
# prints [186 180 177 171 177 169 167 164 158 162 172]

plt.plot(x)
plt.plot(peaks, x[peaks], "x")
plt.show()

Answer 6

কাজটি করতে স্কিপি বিল্ট-ইন ফাংশন সিগন্যাল.ফাইন্ড_পিক্স_সিডব্লিউটি ব্যবহার করবেন না কেন ?

from scipy import signal
import numpy as np

#generate junk data (numpy 1D arr)
xs = np.arange(0, np.pi, 0.05)
data = np.sin(xs)

# maxima : use builtin function to find (max) peaks
max_peakind = signal.find_peaks_cwt(data, np.arange(1,10))

# inverse  (in order to find minima)
inv_data = 1/data
# minima : use builtin function fo find (min) peaks (use inversed data)
min_peakind = signal.find_peaks_cwt(inv_data, np.arange(1,10))

#show results
print "maxima",  data[max_peakind]
print "minima",  data[min_peakind]

ফলাফল:

maxima [ 0.9995736]
minima [ 0.09146464]

শুভেচ্ছা সহ

Comments

বিভাগটি না করে (যথাযথ ক্ষতি হ্রাসের সাথে), ম্যাক্সিমা থেকে মিনিমে যাওয়ার জন্য কেন কেবল -1 দিয়ে গুণ করবেন না?

— লিভিয়াস

আমি '1 / ডেটা' কে 'ডেটা * -1' এ পরিবর্তন করার চেষ্টা করেছি, তবে তারপরে এটি একটি ত্রুটি বাড়াচ্ছে, আপনি কীভাবে আপনার পদ্ধতিটি বাস্তবায়ন করবেন তা ভাগ করে নিতে পারেন?

— একটি STEFANI

সম্ভবত কারণ আমরা শেষ ব্যবহারকারীদের অতিরিক্ত স্কিপি ইনস্টল করতে চাই না।

— দামিয়ান ইয়ারিক

Answer 7

আপডেট: আমি গ্রেডিয়েন্টে খুশি ছিলাম না তাই এটি ব্যবহারের জন্য আরও নির্ভরযোগ্য foundnumpy.diff । এটি আপনি যা চান তা করে কিনা আমাকে জানান know

গোলমাল ইস্যু সম্পর্কিত, গাণিতিক সমস্যাটি হল ম্যাক্সিমা / মিনিমা সনাক্ত করা যদি আমরা শব্দটি দেখতে চাই আমরা কনভলভের মতো কিছু ব্যবহার করতে পারি যা আগে উল্লেখ করা হয়েছিল।

import numpy as np
from matplotlib import pyplot

a=np.array([10.3,2,0.9,4,5,6,7,34,2,5,25,3,-26,-20,-29],dtype=np.float)

gradients=np.diff(a)
print gradients


maxima_num=0
minima_num=0
max_locations=[]
min_locations=[]
count=0
for i in gradients[:-1]:
        count+=1

    if ((cmp(i,0)>0) & (cmp(gradients[count],0)<0) & (i != gradients[count])):
        maxima_num+=1
        max_locations.append(count)     

    if ((cmp(i,0)<0) & (cmp(gradients[count],0)>0) & (i != gradients[count])):
        minima_num+=1
        min_locations.append(count)


turning_points = {'maxima_number':maxima_num,'minima_number':minima_num,'maxima_locations':max_locations,'minima_locations':min_locations}  

print turning_points

pyplot.plot(a)
pyplot.show()

Comments

আপনি কি জানেন যে এই গ্রেডিয়েন্টটি কীভাবে গণনা করা হয়? আপনার যদি শোরগোলের ডেটা থাকে তবে গ্রেডিয়েন্টটি অনেকগুলি পরিবর্তন করে, তবে এর অর্থ এই নয় যে সর্বাধিক / মিনিট রয়েছে।

— নাভি

হ্যাঁ আমি জানি, তবে কোলাহলপূর্ণ ডেটা একটি আলাদা সমস্যা। এটির জন্য আমার ধারণা কনভলভ ব্যবহার।

— মাইক ভেলা

আমি যে প্রকল্পে কাজ করছি তার জন্য আমার অনুরূপ কিছু প্রয়োজন ছিল এবং উপরে উল্লিখিত নাম্পি.ডিফ পদ্ধতিটি ব্যবহার করেছি, আমি ভেবেছিলাম যে আমার ডেটার জন্য উপরের কোডটি দুটি ম্যাক্সিমা এবং মিনিমা বাদ দিয়েছে, উভয়টির মধ্যবর্তী শব্দটি পরিবর্তন করে যদি যথাক্রমে <= এবং> = এ বিবৃতি দেওয়া হয়, আমি সমস্ত পয়েন্ট ধরতে সক্ষম হয়েছি।

Answer 8

যদিও এই প্রশ্নটি আসলেই পুরানো। আমি বিশ্বাস করি নিম্পিতে (একটি লাইনার) আরও সহজ পদ্ধিতি রয়েছে।

import numpy as np

list = [1,3,9,5,2,5,6,9,7]

np.diff(np.sign(np.diff(list))) #the one liner

#output
array([ 0, -2,  0,  2,  0,  0, -2])

স্থানীয় সর্বাধিক বা নূন্যতম সন্ধানের জন্য আমরা তালিকাগুলির মানগুলির মধ্যে পার্থক্য (3-1, 9-3 ...) ইতিবাচক থেকে নেতিবাচক (সর্বাধিক) বা নেতিবাচক থেকে ধনাত্মক (মিনিট) পর্যন্ত পরিবর্তিত হয় তা সন্ধান করতে চাই। অতএব, প্রথমে আমরা পার্থক্যটি খুঁজে পাই। তারপরে আমরা সাইনটি সন্ধান করি এবং তারপরে আমরা আবার পার্থক্যটি নিয়ে সাইন ইন পরিবর্তনগুলি পাই। (ক্যালকুলাসে প্রথম এবং দ্বিতীয় ডেরাইভেটিভের মতো বাছাই করুন, কেবল আমাদের কাছে পৃথক ডেটা রয়েছে এবং অবিচ্ছিন্ন ফাংশন নেই।)

আমার উদাহরণের আউটপুটটিতে এক্সট্রিমার (তালিকার প্রথম এবং শেষ মান) নেই does এছাড়াও, যেমন ক্যালকুলাসের মতো, দ্বিতীয় ব্যয়টি যদি নেতিবাচক হয় তবে আপনার সর্বোচ্চ থাকে এবং যদি এটি ইতিবাচক হয় তবে আপনার একটি মিনিট রয়েছে।

সুতরাং আমরা নিম্নলিখিত ম্যাচআপ আছে:

[1,  3,  9,  5,  2,  5,  6,  9,  7]
    [0, -2,  0,  2,  0,  0, -2]
        Max     Min         Max

Comments

আমি মনে করি যে এটি (ভাল!) উত্তরটি ২০১২ সালের আরসির উত্তর হিসাবে একই? আমি যদি তার সমাধানটি সঠিকভাবে পড়ছি তবে কলারটি মিনি, ম্যাক্স বা উভয় চায় কিনা তার উপর নির্ভর করে তিনি তিনটি এক-লাইন সমাধান সরবরাহ করেন।

— ব্র্যান্ডন রোডস

Answer 9

আমি এর পাশাপাশি সমাধানগুলির কোনওটিই কার্যকর হয়নি যেহেতু আমি একই সাথে পুনরাবৃত্তি করা মানগুলির কেন্দ্রে শৃঙ্গগুলি খুঁজে পেতে চেয়েছিলাম। উদাহরণস্বরূপ, ইন

ar = np.array([0,1,2,2,2,1,3,3,3,2,5,0])

উত্তরটি হওয়া উচিত

array([ 3,  7, 10], dtype=int64)

আমি একটি লুপ ব্যবহার করে এটি করেছি। আমি জানি এটি খুব পরিষ্কার নয়, তবে এটি কাজটি করে gets

def findLocalMaxima(ar):
# find local maxima of array, including centers of repeating elements    
maxInd = np.zeros_like(ar)
peakVar = -np.inf
i = -1
while i < len(ar)-1:
#for i in range(len(ar)):
    i += 1
    if peakVar < ar[i]:
        peakVar = ar[i]
        for j in range(i,len(ar)):
            if peakVar < ar[j]:
                break
            elif peakVar == ar[j]:
                continue
            elif peakVar > ar[j]:
                peakInd = i + np.floor(abs(i-j)/2)
                maxInd[peakInd.astype(int)] = 1
                i = j
                break
    peakVar = ar[i]
maxInd = np.where(maxInd)[0]
return maxInd 

Answer 10

import numpy as np
x=np.array([6,3,5,2,1,4,9,7,8])
y=np.array([2,1,3,5,3,9,8,10,7])
sortId=np.argsort(x)
x=x[sortId]
y=y[sortId]
minm = np.array([])
maxm = np.array([])
i = 0
while i < length-1:
    if i < length - 1:
        while i < length-1 and y[i+1] >= y[i]:
            i+=1

        if i != 0 and i < length-1:
            maxm = np.append(maxm,i)

        i+=1

    if i < length - 1:
        while i < length-1 and y[i+1] <= y[i]:
            i+=1

        if i < length-1:
            minm = np.append(minm,i)
        i+=1


print minm
print maxm

minmএবং maxmযথাক্রমে মিনিমা এবং ম্যাক্সিমার সূচকগুলি রয়েছে। একটি বিশাল ডেটা সেটের জন্য, এটি প্রচুর ম্যাক্সিমাম / মিনিমা দেবে যাতে সেক্ষেত্রে প্রথমে বক্রটি মসৃণ করুন এবং তারপরে এই অ্যালগরিদমটি প্রয়োগ করুন।

Comments

এটি আকর্ষণীয় দেখাচ্ছে। কোনও গ্রন্থাগার নেই। এটা কিভাবে কাজ করে?

— জন কেটজিক

শুরুর দিক থেকে বক্ররেখার দিকে তাকান এবং দেখুন আপনি ক্রমাগত উপরের দিকে বা নীচের দিকে চলে যাচ্ছেন, একবার আপনি উপরে থেকে নীচে পরিবর্তিত হওয়ার অর্থ এটি আপনি একটি ম্যাক্সিমা পেয়েছেন, যদি আপনি নীচে উপরে যাচ্ছেন তবে আপনি একটি মিনিমা পেয়েছেন।

— prtkp

Answer 11

মূলত একটি দ্বৈত অপারেটর ব্যবহার করে অন্য একটি সমাধান:

import numpy as np
from scipy.ndimage import rank_filter

def find_local_maxima(x):
   x_dilate = rank_filter(x, -1, size=3)
   return x_dilate == x

এবং মিনিমার জন্য:

def find_local_minima(x):
   x_erode = rank_filter(x, -0, size=3)
   return x_erode == x

এছাড়াও, থেকে scipy.ndimageআপনি প্রতিস্থাপন করতে পারেন rank_filter(x, -1, size=3)সঙ্গে grey_dilationএবং rank_filter(x, 0, size=3)সঙ্গে grey_erosion। এটির জন্য স্থানীয় বাছাইয়ের প্রয়োজন হবে না, তাই এটি কিছুটা দ্রুত।

Comments

এটি এই সমস্যার জন্য সঠিকভাবে কাজ করে। এখানে সমাধানটি নিখুঁত (+1)

— লিওস 313

Answer 12

আরেকটা:

def local_maxima_mask(vec):
    """
    Get a mask of all points in vec which are local maxima
    :param vec: A real-valued vector
    :return: A boolean mask of the same size where True elements correspond to maxima. 
    """
    mask = np.zeros(vec.shape, dtype=np.bool)
    greater_than_the_last = np.diff(vec)>0  # N-1
    mask[1:] = greater_than_the_last
    mask[:-1] &= ~greater_than_the_last
    return mask