Numpy.array আকৃতি (আর, 1) এবং (আর,) মধ্যে পার্থক্য

Question

ইন numpy, কিছু অপারেশন আকারে (R, 1)ফিরে আসে তবে কিছু ফিরে আসে (R,)। এটি ম্যাট্রিক্সের গুণকে আরও ক্লান্তিকর করে তুলবে কারণ সুস্পষ্ট reshapeপ্রয়োজন। উদাহরণস্বরূপ, একটি ম্যাট্রিক্স দেওয়া M, যদি আমরা সারিগুলির সংখ্যাটি numpy.dot(M[:,0], numpy.ones((1, R)))কোথায় করতে চাই তবে R(অবশ্যই একই সমস্যাটি কলাম অনুসারে ঘটে)) আমরা পাবেন matrices are not alignedত্রুটি থেকে M[:,0]আকৃতির হয় (R,)কিন্তু numpy.ones((1, R))আকৃতির হয় (1, R)।

সুতরাং আমার প্রশ্নগুলি হ'ল:

1. আকার (R, 1)এবং এর মধ্যে পার্থক্য কী (R,)। আমি আক্ষরিক জানি এটি সংখ্যাগুলির তালিকা এবং তালিকার তালিকা যেখানে সমস্ত তালিকায় কেবল একটি সংখ্যা থাকে। শুধু ভাবছেন কেন ডিজাইন করবেন numpyনা যাতে এটি সহজ ম্যাট্রিক্সের গুণণের (R, 1)পরিবর্তে আকারের পক্ষে থাকে (R,)।

2. উপরের উদাহরণের জন্য আরও ভাল উপায় আছে? স্পষ্টভাবে এই মত পুনরায় আকার ছাড়াই:numpy.dot(M[:,0].reshape(R, 1), numpy.ones((1, R)))

Comments

এটি সাহায্য করতে পারে। যদিও একটি ব্যবহারিক সমাধান সন্ধানের সাথে নয়।

— কীজার

যথাযথ সমাধান: numpy.ravel (এম [:, 0]) - (আর, 1) থেকে (আর,) রূপান্তর করে

— Andi আর

Answer 1

1. NumPy আকারের অর্থ

আপনি লিখেন, "আমি আক্ষরিক অর্থে জানি এটির তালিকা এবং তালিকার তালিকার তালিকা যেখানে সমস্ত তালিকায় কেবল একটি সংখ্যা থাকে" তবে এটি সম্পর্কে চিন্তাভাবনা করা কিছুটা অপ্রয়োজনীয় উপায়।

নম্পপি অ্যারেগুলি সম্পর্কে ভাবার সেরা উপায় হ'ল এগুলি দুটি অংশ নিয়ে গঠিত, একটি ডেটা বাফার যা কেবল কাঁচা উপাদানগুলির একটি ব্লক, এবং এমন একটি ভিউ যা ডেটা বাফারকে কীভাবে ব্যাখ্যা করতে হয় তা বর্ণনা করে।

উদাহরণস্বরূপ, আমরা যদি 12 টি পূর্ণসংখ্যার অ্যারে তৈরি করি:

>>> a = numpy.arange(12)
>>> a
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

তারপরে aএকটি ডেটা বাফারের সমন্বয়ে এমন কিছু সাজানো থাকে:

┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

এবং এমন একটি দর্শন যা ডেটা ব্যাখ্যা করতে পারে তা বর্ণনা করে:

>>> a.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False
>>> a.dtype
dtype('int64')
>>> a.itemsize
8
>>> a.strides
(8,)
>>> a.shape
(12,)

এখানে আকৃতি (12,) মানে অ্যারের একটি একক সূচক যা 0 থেকে 11 ধারণার দিক থেকে রান দ্বারা সূচীবদ্ধ, তখন আমরা এই একক INDEX লেবেল যদি i, এরে aভালো দেখায়:

i= 0    1    2    3    4    5    6    7    8    9   10   11
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

আমরা যদি একটি অ্যারে পুনরায় আকার তুলি তবে এটি ডেটা বাফারকে পরিবর্তন করে না। পরিবর্তে, এটি একটি নতুন দৃষ্টিভঙ্গি তৈরি করে যা ডেটা ব্যাখ্যা করার জন্য আলাদা উপায়ে বর্ণনা করে। তাহলে পরে:

>>> b = a.reshape((3, 4))

অ্যারের bমতো একই ডেটা বাফার রয়েছে aতবে এখন এটি দুটি সূচকে সূচকযুক্ত যা যথাক্রমে 0 থেকে 2 এবং 0 থেকে 3 পর্যন্ত চলে। যদি আমরা দুটি সূচককে লেবেল করে iএবং j, অ্যারেটি bদেখতে এমন দেখাচ্ছে:

i= 0    0    0    0    1    1    1    1    2    2    2    2
j= 0    1    2    3    0    1    2    3    0    1    2    3
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

যা এর মানে হল যে:

>>> b[2,1]
9

আপনি দেখতে পাচ্ছেন যে দ্বিতীয় সূচকটি দ্রুত পরিবর্তিত হয় এবং প্রথম সূচকটি ধীরে ধীরে পরিবর্তিত হয়। আপনি যদি অন্য উপায়ে এটি পছন্দ করেন তবে আপনি orderপ্যারামিটারটি নির্দিষ্ট করতে পারেন :

>>> c = a.reshape((3, 4), order='F')

যার ফলশ্রুতিতে এই অ্যারের সূচিত হয়:

i= 0    1    2    0    1    2    0    1    2    0    1    2
j= 0    0    0    1    1    1    2    2    2    3    3    3
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

যা এর মানে হল যে:

>>> c[2,1]
5

এটি এখন পরিষ্কার হওয়া উচিত যে অ্যারেটির 1 বা একাধিক আকারের আকারের একটি আকৃতি থাকার অর্থ কী After এর পরে:

>>> d = a.reshape((12, 1))

অ্যারেটি dদুটি সূচক দ্বারা সূচিত হয়, যার প্রথমটি 0 থেকে 11 পর্যন্ত চলে এবং দ্বিতীয় সূচকটি সর্বদা 0:

i= 0    1    2    3    4    5    6    7    8    9   10   11
j= 0    0    0    0    0    0    0    0    0    0    0    0
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

এবং তাই:

>>> d[10,0]
10

দৈর্ঘ্য 1 এর একটি মাত্রা "মুক্ত" (কিছুটা অর্থে), সুতরাং আপনাকে শহরে যেতে বাধা দেওয়ার কিছুই নেই:

>>> e = a.reshape((1, 2, 1, 6, 1))

এইভাবে সূচিযুক্ত একটি অ্যারে প্রদান করা:

i= 0    0    0    0    0    0    0    0    0    0    0    0
j= 0    0    0    0    0    0    1    1    1    1    1    1
k= 0    0    0    0    0    0    0    0    0    0    0    0
l= 0    1    2    3    4    5    0    1    2    3    4    5
m= 0    0    0    0    0    0    0    0    0    0    0    0
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│  0 │  1 │  2 │  3 │  4 │  5 │  6 │  7 │  8 │  9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘

এবং তাই:

>>> e[0,1,0,0,0]
6

দেখুন NumPy অভ্যন্তরীণ ডকুমেন্টেশন কিভাবে অ্যারে প্রয়োগ করা হয় সে সম্পর্কে আরো জানার জন্য।

2. কি করতে হবে?

যেহেতু numpy.reshapeসবেমাত্র একটি নতুন দৃষ্টিভঙ্গি তৈরি হয়েছে, তাই যখনই প্রয়োজন হয় এটি ব্যবহারের বিষয়ে আপনাকে ভয় পাওয়া উচিত নয়। আপনি যখন অন্য কোনও উপায়ে কোনও অ্যারে সূচি দিতে চান তখন এটি সঠিক সরঞ্জাম tool

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

আপনার প্রশ্নের উদাহরণটি হ'ল:

numpy.dot(M[:,0], numpy.ones((1, R)))

তবে এটি বাস্তববাদী নয়। প্রথমত, এই অভিব্যক্তি:

M[:,0].sum()

ফলাফল আরও সহজভাবে গণনা। দ্বিতীয়ত, 0 কলাম সম্পর্কে সত্যিই কিছু আছে? সম্ভবত আপনার যা প্রয়োজন তা হ'ল:

M.sum(axis=0)

Comments

অ্যারে কীভাবে সংরক্ষণ করা হয় তা ভেবে এটি অত্যন্ত সহায়ক হয়েছিল। ধন্যবাদ! আরও ম্যাট্রিক্স গণনার জন্য একটি (2-ডি) ম্যাট্রিক্সের একটি কলাম (বা সারি) অ্যাক্সেস করা অসুবিধাজনক যদিও আমাকে সর্বদা যথাযথভাবে কলামটি পুনরায় আকার দিতে হবে। প্রতিবার আমাকে আকৃতিটি (এন,) থেকে (এন, 1) পরিবর্তন করতে হবে।

— অফলিটারএন্ড নাম্বারগুলি

@ সাম্যলি: আপনার newaxisযদি অন্য অক্ষের প্রয়োজন হয় তবে ব্যবহার করুন , উদাহরণস্বরূপ a[:, j, np.newaxis], এর jতম কলামটি aএবং a[np.newaxis, i]এটি iতম সারির।

— গ্যারেথ রিস

আমি এই মডেলটির মাধ্যমে কাগজে আরও ভাল বোঝার জন্য সূচকগুলি প্লট করার চেষ্টা করছি এবং আমি এটি পেতে চাই না বলে মনে হয়, আমার যদি একটি আকৃতি 2 x 2 x 4 থাকে তবে আমি প্রথম 2 টি বুঝতে পারি 0000000011111111 এবং শেষ 4 টি হতে পারে 0123012301230123 হিসাবে বোঝা মাঝেরটির সাথে কী হয়?

— পাইরেটএপ

এটি ভাবার একটি সহজ উপায় হ'ল নম্পি এখানে প্রত্যাশার মতো ঠিক কাজ করছে তবে পাইথনের টিপলস মুদ্রণ বিভ্রান্তিকর হতে পারে। ইন (R, )মামলা, আকৃতি ndarrayএকটি একক উপাদানের সঙ্গে একটি tuple, তাই একটি trailing কমা দিয়ে পাইথন দ্বারা মুদ্রিত হয়। অতিরিক্ত কমা ব্যতীত, প্রথম বন্ধনে একটি অভিব্যক্তি দিয়ে এটি অস্পষ্ট হবে । একটি ndarrayএকটি একক মাত্রা সঙ্গে দৈর্ঘ্যের একটি কলাম ভেক্টর হিসেবে যদিও হতে পারে R। ইন (R, 1)মামলা, tuple দুটি উপাদান, তাই একটি সারি ভেক্টর (অথবা দৈর্ঘ্যের 1 টি সারি সঙ্গে একটি ম্যাট্রিক্স হিসেবে ভাবা যেতে পারে R।

— মাইকেল ইয়াং

@ অ্যালেক্স-ড্রয়েডএডি: এই প্রশ্ন এবং এর উত্তরগুলি দেখুন।

— গ্যারেথ রিস

Answer 2

মধ্যে পার্থক্য (R,)এবং (1,R)আক্ষরিক সূচকের সংখ্যা আপনার ব্যবহারের জন্য প্রয়োজন হয়। ones((1,R))2-D অ্যারে যা কেবল একটি সারি থাকে। ones(R)একটি ভেক্টর। সাধারণত যদি ভেরিয়েবলের একাধিক সারি / কলাম থাকার জন্য তা বোঝায় না, তবে আপনার উচিত একটি ভেক্টর ব্যবহার করা, একক মাত্রা সহ একটি ম্যাট্রিক্স নয়।

আপনার নির্দিষ্ট ক্ষেত্রে, কয়েকটি বিকল্প আছে:

1) কেবল দ্বিতীয় যুক্তিটিকে ভেক্টর করুন। নিম্নলিখিতটি সূক্ষ্মভাবে কাজ করে:

    np.dot(M[:,0], np.ones(R))

2) আপনি যদি ম্যাট্রিক্স অপারেশনের মত মতলব চান তবে matrixপরিবর্তে ক্লাসটি ব্যবহার করুন ndarray। সমস্ত ম্যাট্রিকগুলি 2-ডি অ্যারেতে বাধ্য করা হয় এবং অপারেটর *উপাদান-ভিত্তিক পরিবর্তে ম্যাট্রিক্স গুণ করে (যাতে আপনার বিন্দুর প্রয়োজন হয় না)। আমার অভিজ্ঞতায়, এটি আরও মূল্যবান যে এটি মূল্যবান তবে আপনি মাতলাব করতে অভ্যস্ত হলে এটি ভাল লাগবে।

Comments

হ্যাঁ. আমি আরও মাতলাবের মতো আচরণের আশা করছিলাম। আমি matrixক্লাসে একবার দেখে নেব । matrixবিটিডাব্লু ক্লাসের ঝামেলা কী ?

— 26:18

সমস্যাটি matrixহ'ল এটি কেবল 2 ডি, এবং এটি অপারেটর '*' কে ওভারলোড করে, এর জন্য লিখিত ফাংশনগুলি ndarrayব্যর্থ হতে পারে যদি একটি ব্যবহার করা হয় matrix।

— ইভান

Answer 3

আকৃতি একটি tuple হয়। যদি মাত্র 1 মাত্রা থাকে তবে আকৃতিটি একটি সংখ্যা হবে এবং কমা পরে কেবল ফাঁকা। 2+ মাত্রার জন্য সমস্ত কমা পরে একটি সংখ্যা থাকবে।

# 1 dimension with 2 elements, shape = (2,). 
# Note there's nothing after the comma.
z=np.array([  # start dimension
    10,       # not a dimension
    20        # not a dimension
])            # end dimension
print(z.shape)

(2)

# 2 dimensions, each with 1 element, shape = (2,1)
w=np.array([  # start outer dimension 
    [10],     # element is in an inner dimension
    [20]      # element is in an inner dimension
])            # end outer dimension
print(w.shape)

(2,1)

Answer 4

এর বেস অ্যারে শ্রেণীর জন্য, 2 ডি অ্যারে 1 ডি বা 3 ডি এর চেয়ে বেশি বিশেষ নয়। কিছু অপারেশন রয়েছে মাত্রাগুলি সংরক্ষণ করে, কিছু যা তাদের হ্রাস করে, অন্যান্য সংযুক্ত করে এমনকি তাদের প্রসারিত করে।

M=np.arange(9).reshape(3,3)
M[:,0].shape # (3,) selects one column, returns a 1d array
M[0,:].shape # same, one row, 1d array
M[:,[0]].shape # (3,1), index with a list (or array), returns 2d
M[:,[0,1]].shape # (3,2)

In [20]: np.dot(M[:,0].reshape(3,1),np.ones((1,3)))

Out[20]: 
array([[ 0.,  0.,  0.],
       [ 3.,  3.,  3.],
       [ 6.,  6.,  6.]])

In [21]: np.dot(M[:,[0]],np.ones((1,3)))
Out[21]: 
array([[ 0.,  0.,  0.],
       [ 3.,  3.,  3.],
       [ 6.,  6.,  6.]])

অন্যান্য এক্সপ্রেশন যা একই অ্যারে দেয়

np.dot(M[:,0][:,np.newaxis],np.ones((1,3)))
np.dot(np.atleast_2d(M[:,0]).T,np.ones((1,3)))
np.einsum('i,j',M[:,0],np.ones((3)))
M1=M[:,0]; R=np.ones((3)); np.dot(M1[:,None], R[None,:])

ম্যাটল্যাব শুরু হয়েছে মাত্র 2 ডি অ্যারে দিয়ে। নতুন সংস্করণগুলি আরও মাত্রা মঞ্জুর করে, তবে নীচের সীমানাটি ২ টি বজায় রাখে But তবে আপনাকে এখনও একটি সারির ম্যাট্রিক্স এবং কলামের মধ্যে পার্থক্যটির দিকে মনোযোগ দিতে হবে, আকৃতির (1,3)v সহ একটি (3,1)। কতবার লিখেছেন [1,2,3].'? আমি লিখি যাচ্ছিল row vectorএবং column vectorঅন্তত ভেক্টরের গাণিতিক অর্থে 1d হচ্ছে না -, কিন্তু যে 2d বাধ্যতা সঙ্গে, সেখানে ম্যাটল্যাব কোনো ভেক্টর নয়।

আপনি কি np.atleast_2d(এছাড়াও _1 ডি এবং _3 ডি সংস্করণগুলি) দেখেছেন?

Answer 5

1) (R, 1)ওভারের আকার পছন্দ না করার কারণ (R,)হ'ল এটি অযথা জিনিসগুলিকে জটিল করে তোলে। তদ্ব্যতীত, (R, 1)দৈর্ঘ্য-আর ভেক্টরের পরিবর্তে ডিফল্টরূপে আকৃতিটি কেন দেওয়া ভাল (1, R)? আপনার অতিরিক্ত মাত্রার প্রয়োজন হলে এটিকে সহজ রাখা এবং স্পষ্ট হওয়া ভাল be

2) আপনার উদাহরণস্বরূপ, আপনি একটি বাহ্যিক পণ্য গণনা করছেন যাতে আপনি কোনও reshapeকল ছাড়াই এটি ব্যবহার করে করতে পারেন np.outer:

np.outer(M[:,0], numpy.ones((1, R)))

Comments

উত্তরের জন্য ধন্যবাদ. 1) M[:,0]মূলত প্রথম উপাদানটির সাথে সমস্ত সারি পাচ্ছে, সুতরাং এটির (R, 1)চেয়ে এটি আরও বেশি বোঝা যায় (1, R)। 2) এটি সর্বদা np.outerম্যাট্রিক্সের জন্য বিন্দুর (1, আর) তখন (আর, 1) দ্বারা প্রতিস্থাপনযোগ্য হয় না ।

— ক্লোইন

1) হ্যাঁ, এটি সম্মেলন হতে পারে তবে এটি অন্যান্য পরিস্থিতিতে এটি কম সুবিধাজনক করে তোলে। কনভেনশনটি এম [1, 1] এর জন্য একটি আকার (1, 1) অ্যারে ফিরিয়ে আনতে পারে তবে এটি সাধারণত স্কেলারের চেয়ে কম সুবিধাজনকও হয়। আপনি যদি সত্যিই ম্যাট্রিক্সের মতো আচরণ করতে চান তবে আপনি কোনও matrixঅবজেক্ট ব্যবহার করা ভাল । 2) আসলে, np.outerআকার কিনা নির্বিশেষে কাজ করে (1, R), (R, 1), অথবা দুই একটি সমন্বয়।

— বোগাট্রন

Answer 6

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

সুতরাং এখানে একটি:

import numpy as np
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])


from sklearn.linear_model import LinearRegression
regr = LinearRegression()
regr.fit(a,b)

এটি ত্রুটি সহ ব্যর্থ হবে:

মানমূল: প্রত্যাশিত 2 ডি অ্যারে, পরিবর্তে 1 ডি অ্যারে পেয়েছে

তবে আমরা যদি যোগ reshapeকরি a:

a = np.array([1,2,3,4]).reshape(-1,1)

এটি সঠিকভাবে কাজ করে!