Numpy dizileri ve matrisler arasındaki farklar nelerdir? Hangisini kullanmalıyım?

Her birinin avantajları ve dezavantajları nelerdir?

Gördüğüm kadarıyla, ya biri gerekirse diğerinin yerine çalışabilir, bu yüzden her ikisini de kullanmalı mıyım yoksa bunlardan birine mi yapışmalıyım?

Programın tarzı seçimimi etkiler mi? Ben numpy kullanarak bazı makine öğrenme yapıyorum, bu yüzden gerçekten çok matris, ama aynı zamanda çok sayıda vektör (diziler) vardır.

Resmi belgelere göre, gelecekte kaldırılacağı için artık matris sınıfının kullanılması tavsiye edilmez.

https://numpy.org/doc/stable/reference/generated/numpy.matrix.html

Diğer cevaplar zaten NumPy dizileriyle tüm işlemleri yapabileceğinizi belirtiyor.

Numpy matrisleri kesinlikle 2 boyutlu iken numpy dizileri (ndarrays) N-boyutludur. Matris nesneleri bir ndarray alt sınıfıdır, bu nedenle ndarrayların tüm niteliklerini ve yöntemlerini devralırlar.

Numpy matrislerin ana avantajı, matris çarpımı için uygun bir gösterim sağlamalarıdır: a ve b matris a*bise, matris ürünüdür.

import numpy as np

a = np.mat('4 3; 2 1')
b = np.mat('1 2; 3 4')
print(a)
# [[4 3]
#  [2 1]]
print(b)
# [[1 2]
#  [3 4]]
print(a*b)
# [[13 20]
#  [ 5  8]]

Öte yandan, Python 3.5'ten itibaren, NumPy @operatörü kullanarak infix matris çarpımını destekler , böylece Python> = 3.5'de ndarraylarla aynı matris çarpma rahatlığını elde edebilirsiniz.

import numpy as np

a = np.array([[4, 3], [2, 1]])
b = np.array([[1, 2], [3, 4]])
print(a@b)
# [[13 20]
#  [ 5  8]]

Hem matris nesneleri hem de ndarray'ların .Taktarımı döndürmesi gerekir, ancak matris nesnelerinin de .Hkonjugat aktarımı için olması gerekir ve.I tersi için de vardır.

Buna karşılık, numpy dizileri, işlemlerin eleman olarak uygulandığı kuralına (yeni @operatör hariç ) tutarlı bir şekilde uyar . Böylece, ave bnumpy diziler, o zaman a*böğeye bileşenleri çarpılmasıyla oluşturulan dizidir:

c = np.array([[4, 3], [2, 1]])
d = np.array([[1, 2], [3, 4]])
print(c*d)
# [[4 6]
#  [6 4]]

Matris çarpımının sonucunu elde etmek için kullanın np.dot(veya @yukarıda gösterildiği gibi Python> = 3.5'te):

print(np.dot(c,d))
# [[13 20]
#  [ 5  8]]

**Operatör aynı zamanda farklı davranır:

print(a**2)
# [[22 15]
#  [10  7]]
print(c**2)
# [[16  9]
#  [ 4  1]]

Bu yana abir matris, a**2matris ürün verir a*a. Bu yana cbir ndarray olup, c**2her bir bileşen kare öğeye sahip bir ndarray döndürür.

Matris nesneleri ve ndarrays arasında başka teknik farklılıklar da vardır ( np.ravelöğe seçimi ve sıra davranışı ile ilgili).

Numpy dizilerin ana avantajı, 2 boyutlu matrislerden daha genel olmalarıdır . 3 boyutlu bir dizi istediğinizde ne olur? O zaman bir matris nesnesi değil, bir ndarray kullanmalısınız. Bu nedenle, matris nesnelerini kullanmayı öğrenmek daha fazla iştir - matris nesne işlemlerini ve ndarray işlemlerini öğrenmeniz gerekir.

Hem matrisleri hem de dizileri karıştıran bir program yazmak hayatınızı zorlaştırır, çünkü değişkenlerinizin ne tür bir nesne olduğunu takip etmek zorunda kalırsanız, çarpma beklemediğiniz bir şeyi döndürür.

Buna karşılık, sadece ndarrays ile yapışırsanız, matris nesnelerinin yapabileceği her şeyi ve daha fazlasını yapabilirsiniz, ancak biraz farklı işlevler / gösterimler hariç.

NumPy matris ürün notasyonunun görsel cazibesinden vazgeçmek istiyorsanız (Python> = 3.5'teki ndarraylarla neredeyse zarif bir şekilde elde edilebilir), o zaman NumPy dizilerinin kesinlikle gitmenin yolu olduğunu düşünüyorum.

PS. Tabii ki, gerçekten diğerinin pahasına birini seçmek zorunda değilsiniz, çünkü np.asmatrixve diğerini np.asarraydönüştürmenize izin verir (dizi 2 boyutlu olduğu sürece).

Numpy arasındaki farkların bir özeti vardır arraysNumPy vs matrixes burada .

Scipy.org dizileri kullanmanızı önerir:

* 'dizi' veya 'matris'? Hangisini kullanmalıyım? - Kısa cevap

Diziler kullanın.

• Bunlar standart vektör / matris / tensör türü numpy'dir. Birçok numpy işlevi, matrisleri değil, dizileri döndürür.

• Elemanlar ve lineer cebir işlemleri arasında açık bir ayrım vardır.

• İsterseniz standart vektörlere veya satır / sütun vektörlerine sahip olabilirsiniz.

Dizi türünü kullanmanın tek dezavantajı, iki tensörü (skaler ürün, matris vektör çarpımı vb.) Çarpmak (azaltmak) dotyerine kullanmak zorunda olmanızdır *.

Sadece unutbu'nun listesine bir dava eklemek için.

Numpy ndarrays benim için numpy matrisleri veya matlab gibi matris dilleri ile karşılaştırıldığında en büyük pratik farklılıklardan biri, boyutun küçültme işlemlerinde korunmamasıdır. Matrisler her zaman 2d'dir, örneğin bir dizinin ortalamasının bir boyutu daha azdır.

Örneğin, bir matris veya dizinin demean satırları:

matris ile

>>> m = np.mat([[1,2],[2,3]])
>>> m
matrix([[1, 2],
        [2, 3]])
>>> mm = m.mean(1)
>>> mm
matrix([[ 1.5],
        [ 2.5]])
>>> mm.shape
(2, 1)
>>> m - mm
matrix([[-0.5,  0.5],
        [-0.5,  0.5]])

dizi ile

>>> a = np.array([[1,2],[2,3]])
>>> a
array([[1, 2],
       [2, 3]])
>>> am = a.mean(1)
>>> am.shape
(2,)
>>> am
array([ 1.5,  2.5])
>>> a - am #wrong
array([[-0.5, -0.5],
       [ 0.5,  0.5]])
>>> a - am[:, np.newaxis]  #right
array([[-0.5,  0.5],
       [-0.5,  0.5]])

Ayrıca dizileri ve matrisleri karıştırmanın birçok "mutlu" hata ayıklama saatine yol açtığını düşünüyorum. Ancak, scipy.sparse matrisleri her zaman çarpma gibi operatörler açısından matrislerdir.

Diğerlerinin de belirttiği gibi, belki de ana avantajı, matrixmatris çarpımı için uygun bir gösterim sağlamasıydı.

Bununla birlikte, Python 3.5'te nihayet matris çarpımı için özel bir infix operatörü vardır :@ .

Son NumPy sürümlerinde ndarrays ile kullanılabilir :

A = numpy.ones((1, 3))
B = numpy.ones((3, 3))
A @ B

Yani bugünlerde, daha da fazlası, şüphe duyduğunuzda, sadık kalmalısınız ndarray.