আমার কাছে নিম্নলিখিত কোড রয়েছে:
r = numpy.zeros(shape = (width, height, 9))
এটি width x height x 9
শূন্যে ভরা একটি ম্যাট্রিক্স তৈরি করে । পরিবর্তে, আমি জানতে চাই যে NaN
কোনও সহজ উপায়ের পরিবর্তে সেগুলি শুরু করার কোনও ফাংশন বা উপায় আছে কিনা ।
আমার কাছে নিম্নলিখিত কোড রয়েছে:
r = numpy.zeros(shape = (width, height, 9))
এটি width x height x 9
শূন্যে ভরা একটি ম্যাট্রিক্স তৈরি করে । পরিবর্তে, আমি জানতে চাই যে NaN
কোনও সহজ উপায়ের পরিবর্তে সেগুলি শুরু করার কোনও ফাংশন বা উপায় আছে কিনা ।
উত্তর:
আপনার কাছে কমই ভেক্টর অপারেশনের জন্য লুপের প্রয়োজন need আপনি একটি অনির্বাচিত অ্যারে তৈরি করতে এবং একবারে সমস্ত এন্ট্রিগুলিকে নিয়োগ করতে পারেন:
>>> a = numpy.empty((3,3,))
>>> a[:] = numpy.nan
>>> a
array([[ NaN, NaN, NaN],
[ NaN, NaN, NaN],
[ NaN, NaN, NaN]])
আমি বিকল্পগুলি a[:] = numpy.nan
এখানে সময় মতো করেছি এবং a.fill(numpy.nan)
যেমনটি ব্লেনক পোস্ট করেছেন:
$ python -mtimeit "import numpy as np; a = np.empty((100,100));" "a.fill(np.nan)"
10000 loops, best of 3: 54.3 usec per loop
$ python -mtimeit "import numpy as np; a = np.empty((100,100));" "a[:] = np.nan"
10000 loops, best of 3: 88.8 usec per loop
সময় ndarray.fill(..)
দ্রুত বিকল্প হিসাবে হিসাবে একটি পছন্দ দেখায় । ওটিও, আমি নমপির সুবিধার্থে বাস্তবায়ন পছন্দ করি যেখানে আপনি সেই সময়টিতে পুরো টুকরোকে মান নির্ধারণ করতে পারেন, কোডটির উদ্দেশ্যটি খুব স্পষ্ট।
নোট করুন যে ndarray.fill
এটির কাজটি যথাস্থানে সম্পাদন করে, তাই numpy.empty((3,3,)).fill(numpy.nan)
পরিবর্তে ফিরে আসবে None
।
a = numpy.empty((3, 3,)) * numpy.nan
। এটি সময় নির্ধারণের চেয়ে fill
অ্যাসাইনমেন্ট পদ্ধতির চেয়ে ধীরে ধীরে ধীরে ধীরে এগিয়ে গেছে তবে এটি অননিলাইনার !!
.fill()
পদ্ধতিটি পছন্দ করি তবে অ্যারে বড় হওয়ার সাথে সাথে গতির পার্থক্যটি কার্যতঃ কিছুই হ্রাস পায়।
np.empty([2, 5])
একটি অ্যারে তৈরি করে, তারপরে fill()
সেই অ্যারেটিকে সংশোধন করে তবে কোনও অনুলিপি বা রেফারেন্স দেয় না। আপনি যদি np.empty(2, 5)
কোনও নামে কল করতে চান ("অ্যাসাইনমেন্টটি একটি ভেরিয়েবলের কাছে দেওয়া হয়"), আপনি এটি-তে স্থান নির্ধারণের আগে এটি করতে হবে। একই ধরনের জিনিস আপনি যদি করেন [1, 2, 3].insert(1, 4)
। তালিকাটি তৈরি করা হয় এবং একটি 4 isোকানো হয় তবে তালিকার কোনও রেফারেন্স পাওয়া অসম্ভব (এবং এইভাবে এটি আবর্জনা সংগ্রহ করা হয়েছে বলে ধরে নেওয়া যেতে পারে)। স্ট্রিংয়ের মতো অপরিবর্তনীয় ডেটাগুলিতে, একটি অনুলিপি ফিরে আসে, কারণ আপনি জায়গায় জায়গায় কাজ করতে পারবেন না। পান্ডারা দুজনেই করতে পারেন।
অন্য বিকল্পটি হ'ল numpy.full
নুমপি 1.8+ এ উপলব্ধ একটি বিকল্প
a = np.full([height, width, 9], np.nan)
এটি বেশ নমনীয় এবং আপনি এটি যে কোনও নম্বর দিয়ে এটি পূরণ করতে পারেন।
full
বোঝাতে চেয়েছিল। np.empy((x,y))*np.nan
এটি একটি ভাল রানার-আপ (এবং নমপির পুরানো সংস্করণগুলির জন্য সামঞ্জস্যতা)।
fill
python -mtimeit "import numpy as np; a = np.empty((100,100));" "a.fill(np.nan)" 100000 loops, best of 3: 13.3 usec per loop python -mtimeit "import numpy as np; a = np.full((100,100), np.nan);" 100000 loops, best of 3: 18.5 usec per loop
python -mtimeit "import numpy as np; a = np.empty((1000,1000)); a.fill(np.nan)" 1000 loops, best of 3: 381 usec per loop $ python -mtimeit "import numpy as np; a = np.full((1000,1000), np.nan);" 1000 loops, best of 3: 383 usec per loop
আমি গতির জন্য প্রস্তাবিত বিকল্পগুলি তুলনা করে দেখেছি যে, যথেষ্ট পরিমাণে ভেক্টর / ম্যাট্রিকগুলি পূরণ করার জন্য, সমস্ত বিকল্প ব্যতীত val * ones
এবং array(n * [val])
সমান দ্রুত।
প্লটটি পুনরুত্পাদন করার কোড:
import numpy
import perfplot
val = 42.0
def fill(n):
a = numpy.empty(n)
a.fill(val)
return a
def colon(n):
a = numpy.empty(n)
a[:] = val
return a
def full(n):
return numpy.full(n, val)
def ones_times(n):
return val * numpy.ones(n)
def list(n):
return numpy.array(n * [val])
perfplot.show(
setup=lambda n: n,
kernels=[fill, colon, full, ones_times, list],
n_range=[2 ** k for k in range(20)],
logx=True,
logy=True,
xlabel="len(a)",
)
numpy.full(n, val)
চেয়ে ধীরে ধীরেa = numpy.empty(n) .. a.fill(val)
আপনি কি সাথে পরিচিত numpy.nan
?
আপনি নিজের পদ্ধতি তৈরি করতে পারেন যেমন:
def nans(shape, dtype=float):
a = numpy.empty(shape, dtype)
a.fill(numpy.nan)
return a
তারপর
nans([3,4])
আউটপুট হবে
array([[ NaN, NaN, NaN, NaN],
[ NaN, NaN, NaN, NaN],
[ NaN, NaN, NaN, NaN]])
আমি এই কোডটি একটি মেলিং তালিকার থ্রেডে পেয়েছি ।
আপনি যদি অবিলম্বে পদ্ধতি .empty
বা .full
পদ্ধতিগুলি স্মরণ না করেন তবে আপনি সর্বদা গুণ ব্যবহার করতে পারেন :
>>> np.nan * np.ones(shape=(3,2))
array([[ nan, nan],
[ nan, nan],
[ nan, nan]])
অবশ্যই এটি অন্যান্য যে কোনও সংখ্যাসূচক মানের সাথেও কাজ করে:
>>> 42 * np.ones(shape=(3,2))
array([[ 42, 42],
[ 42, 42],
[ 42, 42]])
তবে @ u0b34a0f6ae এর গৃহীত উত্তরটি দ্রুততর দ্রুত (সিপিইউ চক্রগুলি, নাম্বার সিনট্যাক্স মনে রাখার জন্য মস্তিষ্কের চক্র নয়;):
$ python -mtimeit "import numpy as np; X = np.empty((100,100));" "X[:] = np.nan;"
100000 loops, best of 3: 8.9 usec per loop
(predict)laneh@predict:~/src/predict/predict/webapp$ master
$ python -mtimeit "import numpy as np; X = np.ones((100,100));" "X *= np.nan;"
10000 loops, best of 3: 24.9 usec per loop
আরেকটি বিকল্প হ'ল numpy.broadcast_to(val,n)
যা আকার নির্বিশেষে ধ্রুবক সময়ে ফিরে আসে এবং সর্বাধিক স্মৃতিশক্তি দক্ষ (এটি পুনরাবৃত্ত উপাদানটির একটি দৃশ্য ফেরত দেয়)। সাবধানতা হল যে প্রত্যাবর্তিত মানটি কেবল পঠনযোগ্য।
নীচো শ্ল্যামারের উত্তরের মতো একই মানদণ্ড ব্যবহার করে প্রস্তাবিত অন্যান্য সমস্ত পদ্ধতির পারফরম্যান্সের তুলনা নীচে দেওয়া হয়েছে ।
যেমন বলা হয়েছে, numpy.empty () হল যাওয়ার উপায়। যাইহোক, বস্তুর জন্য, ফিল () আপনার মনে হয় ঠিক যা করতে পারে তা করতে পারে না:
In[36]: a = numpy.empty(5,dtype=object)
In[37]: a.fill([])
In[38]: a
Out[38]: array([[], [], [], [], []], dtype=object)
In[39]: a[0].append(4)
In[40]: a
Out[40]: array([[4], [4], [4], [4], [4]], dtype=object)
চারপাশের একটি উপায় যেমন হতে পারে:
In[41]: a = numpy.empty(5,dtype=object)
In[42]: a[:]= [ [] for x in range(5)]
In[43]: a[0].append(4)
In[44]: a
Out[44]: array([[4], [], [], [], []], dtype=object)
এখনও আরেকটি সম্ভাবনা এখানে উল্লেখ করা হয়নি হ'ল নম্পপি টাইল ব্যবহার করা:
a = numpy.tile(numpy.nan, (3, 3))
দেয়ও
array([[ NaN, NaN, NaN],
[ NaN, NaN, NaN],
[ NaN, NaN, NaN]])
গতির তুলনা সম্পর্কে আমি জানি না।
np.nan
int এ রূপান্তরিত হলে ভুল হয়।