NumPy Matrix transpose() – Dizilerin Transpozesi
Giriş: Transpoze Kavramı ve Önemi
Lineer cebir, matematik ve bilgisayar bilimlerinin temel taşlarından biridir. Bu alanın en temel ve yaygın işlemlerinden biri de “transpoze” işlemidir. Bir matrisin transpozesi, o matrisin satırlarının sütun, sütunlarının ise satır olarak yeniden düzenlenmesi anlamına gelir. Matematiksel olarak, $A$ matrisinin transpozesi $A^T$ veya $A’$ ile gösterilir. Eğer $A$ matrisinin $(i, j)$ konumundaki elemanı $a_{ij}$ ise, $A^T$ matrisinin $(j, i)$ konumundaki elemanı yine $a_{ij}$ olacaktır. Yani, orijinal matristeki her bir $a_{ij}$ elemanı, transpoze matriste $a_{ji}$ olarak yer değiştirir.
Örneğin, aşağıdaki 2×3 boyutundaki $A$ matrisini ele alalım:
$A = \begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{pmatrix}$
Bu matrisin transpozesi $A^T$ ise 3×2 boyutunda olacak ve şu şekilde görünecektir:
$A^T = \begin{pmatrix} 1 & 4 \\ 2 & 5 \\ 3 & 6 \end{pmatrix}$
Görüldüğü gibi, $A$ matrisinin birinci satırı ($[1, 2, 3]$) $A^T$ matrisinin birinci sütunu, ikinci satırı ($[4, 5, 6]$) ise $A^T$ matrisinin ikinci sütunu haline gelmiştir. Benzer şekilde, $A$ matrisinin birinci sütunu ($[1, 4]^T$) $A^T$ matrisinin birinci satırı olmuştur.
Transpoze işlemi sadece matematiksel bir merak konusu değildir; bilgisayar bilimleri, veri analizi, makine öğrenimi, görüntü işleme ve istatistik gibi birçok alanda kritik bir rol oynar. Matris çarpımı gibi temel lineer cebir operasyonlarında, veri setlerini belirli bir analize uygun hale getirmede veya algoritmaların performansını optimize etmede transpozeye sıkça başvurulur. Özellikle, modern sayısal hesaplama kütüphaneleri, bu tür işlemleri yüksek verimlilikle gerçekleştirmek için optimize edilmiştir. Python ekosisteminde, bu tür sayısal işlemler için de-facto standart kütüphane ise NumPy’dır.
NumPy ve Diziler (Arrays)
NumPy (Numerical Python), Python’da bilimsel hesaplamalar için temel bir pakettir. Çok boyutlu diziler (array) ve bu diziler üzerinde yüksek performanslı matematiksel işlemler için güçlü araçlar sunar. NumPy’nin temel veri yapısı ndarray (N-dimensional array) olarak adlandırılır. Bu ndarray nesneleri, aynı türden öğeleri içeren homojen, çok boyutlu bir veri yapısıdır. Python’ın standart listelerine kıyasla, NumPy dizileri bellekte daha verimli bir şekilde saklanır ve üzerinde yapılan işlemler çok daha hızlıdır, çünkü büyük ölçüde C veya Fortran’da yazılmış optimize edilmiş kodları kullanır.
Veri bilimciler, makine öğrenimi mühendisleri ve bilimsel araştırmacılar, büyük veri setlerini işlemek, istatistiksel analizler yapmak, matris işlemleri gerçekleştirmek ve karmaşık algoritmaları uygulamak için NumPy’yi yaygın olarak kullanırlar. Bir NumPy dizisi, tek boyutlu bir vektörden, iki boyutlu bir matrise veya üç boyutlu bir tensöre kadar herhangi bir boyutta olabilir. Bu esneklik, transpoze gibi işlemleri farklı boyutlardaki veriler üzerinde kolayca uygulamayı mümkün kılar.
NumPy’da Dizi Transpozesi Yöntemleri
NumPy, bir dizinin transpozesini almak için birkaç farklı ve esnek yöntem sunar. Bu yöntemler, kullanım kolaylığı, performans ve N-boyutlu dizilerdeki esneklik açısından farklılık gösterir. Genel olarak, en sık kullanılan ve en kısa yöntem .T özniteliğidir. Ancak, daha karmaşık eksen takasları veya belirli boyutlar üzerinde kontrol gerektiğinde numpy.transpose() veya numpy.swapaxes() gibi fonksiyonlar devreye girer.
Şimdi, bu yöntemleri detaylı bir şekilde inceleyelim.
.T Özniteliği (Attribute)
.T özniteliği, NumPy dizilerinin transpozesini almak için en basit, en yaygın ve en Pythonik yöntemdir. Bir dizinin doğrudan .T özniteliğine erişerek transpozesini alabilirsiniz. Bu yöntem, özellikle 2 boyutlu (matris) diziler için sezgisel ve hızlıdır.
Kullanım: dizi.T
Örnek 1: 2 Boyutlu Dizi (Matris)
import numpy as np
2x3 boyutunda bir matris oluşturalım
matris = np.array([[1, 2, 3],
[4, 5, 6]])
print("Orijinal Matris:\n", matris)
print("Matrisin Boyutları (Shape):", matris.shape)
.T özniteliğini kullanarak transpozesini alalım
transpoze_matris = matris.T
print("\nTranspoze Matris:\n", transpoze_matris)
print("Transpoze Matrisin Boyutları (Shape):", transpoze_matris.shape)Çıktı:
Orijinal Matris:
[[1 2 3]
[4 5 6]]
Matrisin Boyutları (Shape): (2, 3)
Transpoze Matris:
[[1 4]
[2 5]
[3 6]]
Transpoze Matrisin Boyutları (Shape): (3, 2)Görüldüğü gibi, 2×3 boyutundaki matrisin transpozesi 3×2 boyutunda bir matris olmuştur. Satırlar sütunlara, sütunlar satırlara dönüşmüştür.
Örnek 2: 1 Boyutlu Dizi (Vektör) ile Özel Durum
1 boyutlu dizilerde .T özniteliğinin davranışı, 2 boyutlu dizilerden biraz farklıdır ve bazen kafa karıştırıcı olabilir. NumPy’da 1 boyutlu bir dizi (örneğin, np.array([1, 2, 3])), ne bir satır vektörü ne de bir sütun vektörü olarak özel olarak tanımlanmaz; sadece tek boyutlu bir dizidir. Bu nedenle, 1 boyutlu bir dizinin transpozesi, orijinal dizinin kendisinin bir görünümünü döndürür ve boyutu değişmez.
vektor = np.array([1, 2, 3])
print("Orijinal Vektör:", vektor)
print("Vektörün Boyutları (Shape):", vektor.shape)
transpoze_vektor = vektor.T
print("\nTranspoze Vektör:", transpoze_vektor)
print("Transpoze Vektörün Boyutları (Shape):", transpoze_vektor.shape)Çıktı:
Orijinal Vektör: [1 2 3]
Vektörün Boyutları (Shape): (3,)
Transpoze Vektör: [1 2 3]
Transpoze Vektörün Boyutları (Shape): (3,)Eğer 1 boyutlu bir diziyi “satır vektörü” veya “sütun vektörü” olarak düşünerek transpozesini almak istiyorsanız, öncelikle diziyi en az 2 boyutlu hale getirmeniz gerekir. Bu genellikle reshape metodu veya np.newaxis kullanılarak yapılır.
# 1x3 satır vektörü gibi davranan 2 boyutlu dizi
satir_vektor = np.array([1, 2, 3]).reshape(1, -1)
print("Satır Vektörü:\n", satir_vektor)
print("Satır Vektörünün Boyutları:", satir_vektor.shape)
transpoze_satir_vektor = satir_vektor.T
print("\nTranspoze Satır Vektörü (Sütun Vektörü):\n", transpoze_satir_vektor)
print("Transpoze Satır Vektörünün Boyutları:", transpoze_satir_vektor.shape)Çıktı:
Satır Vektörü:
[[1 2 3]]
Satır Vektörünün Boyutları: (1, 3)
Transpoze Satır Vektörü (Sütun Vektörü):
[[1]
[2]
[3]]
Transpoze Satır Vektörünün Boyutları: (3, 1)Bu örnek, 1 boyutlu dizilerin transpozesiyle ilgili karışıklığı gidermek için önemlidir. .T özniteliği, genel olarak N-boyutlu diziler için de çalışır, ancak eksenlerin sırasını tersine çevirir. Örneğin, (2, 3, 4) boyutundaki bir dizinin transpozesi (4, 3, 2) boyutunda olacaktır.
numpy.transpose() Fonksiyonu
numpy.transpose() fonksiyonu, .T özniteliğine göre daha genel ve esnek bir yöntemdir, özellikle N-boyutlu dizilerde eksenlerin belirli bir sıraya göre yeniden düzenlenmesi gerektiğinde kullanışlıdır. Bu fonksiyon, bir diziyi ve isteğe bağlı olarak eksenlerin yeni sırasını belirten bir axes argümanı alır.
Kullanım: numpy.transpose(dizi, axes=None)
* dizi: Transpozesi alınacak NumPy dizisi.
* axes: Bir demet (tuple) veya liste olarak eksenlerin yeni sırasını belirten indeksler. Eğer None ise (varsayılan), eksenler ters sıraya çevrilir (tıpkı .T özniteliği gibi). Örneğin, 3 boyutlu bir dizi için (0, 1, 2) eksenleri (2, 1, 0) olarak tersine çevrilir.
Örnek 1: 2 Boyutlu Dizi (Matris)
axes=None ile numpy.transpose() kullanmak, .T özniteliği ile aynı sonucu verir.
import numpy as np
matris = np.array([[1, 2, 3],
[4, 5, 6]])
print("Orijinal Matris:\n", matris)
print("Matrisin Boyutları (Shape):", matris.shape)
numpy.transpose() kullanarak transpoze alalım (axes=None)
transpoze_matris_func = np.transpose(matris)
print("\nTranspoze Matris (np.transpose()):\n", transpoze_matris_func)
print("Transpoze Matrisin Boyutları:", transpoze_matris_func.shape)
axes parametresi ile açıkça belirtme (0. eksen 1., 1. eksen 0. olsun)
transpoze_matris_func_explicit = np.transpose(matris, axes=(1, 0))
print("\nTranspoze Matris (np.transpose(axes=(1, 0))):\n", transpoze_matris_func_explicit)
print("Transpoze Matrisin Boyutları:", transpoze_matris_func_explicit.shape)Çıktı:
Orijinal Matris:
[[1 2 3]
[4 5 6]]
Matrisin Boyutları (Shape): (2, 3)
Transpoze Matris (np.transpose()):
[[1 4]
[2 5]
[3 6]]
Transpoze Matrisin Boyutları: (3, 2)
Transpoze Matris (np.transpose(axes=(1, 0))):
[[1 4]
[2 5]
[3 6]]
Transpoze Matrisin Boyutları: (3, 2)Örnek 2: N-Boyutlu Dizi (3 Boyutlu Dizi)
axes parametresinin gücü, N-boyutlu dizilerde kendini gösterir. Örneğin, (derinlik, yükseklik, genişlik) şeklinde bir 3 boyutlu dizimiz olsun ve biz bunu (yükseklik, genişlik, derinlik) veya (genişlik, derinlik, yükseklik) şeklinde yeniden düzenlemek isteyelim.
# 3 boyutlu bir dizi oluşturalım (derinlik, yükseklik, genişlik)
Örneğin, 2 katmanlı, 3x4 piksellik bir görüntü gibi
dizi_3d = np.arange(24).reshape((2, 3, 4))
print("Orijinal 3D Dizi:\n", dizi_3d)
print("Orijinal 3D Dizi Boyutları:", dizi_3d.shape) # (0: derinlik, 1: yükseklik, 2: genişlik)
Varsayılan transpoze (eksenler tersine çevrilir: (2, 1, 0))
transpoze_varsayilan = np.transpose(dizi_3d)
print("\nVarsayılan Transpoze (eksenler tersine çevrilir (2,1,0)):\n", transpoze_varsayilan)
print("Varsayılan Transpoze Boyutları:", transpoze_varsayilan.shape)
Ekseni yeniden sıralayalım: (yükseklik, genişlik, derinlik) -> (1, 2, 0)
Orijinal eksenler: 0=derinlik, 1=yükseklik, 2=genişlik
Yeni sıralama: 1. eksen (yükseklik) ilk, 2. eksen (genişlik) ikinci, 0. eksen (derinlik) üçüncü
transpoze_ozel = np.transpose(dizi_3d, axes=(1, 2, 0))
print("\nÖzel Transpoze (eksenler (1,2,0) sırasına göre):\n", transpoze_ozel)
print("Özel Transpoze Boyutları:", transpoze_ozel.shape)Çıktı:
Orijinal 3D Dizi:
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
Orijinal 3D Dizi Boyutları: (2, 3, 4)
Varsayılan Transpoze (eksenler tersine çevrilir (2,1,0)):
[[[ 0 12]
[ 4 16]
[ 8 20]]
[[ 1 13]
[ 5 17]
[ 9 21]]
[[ 2 14]
[ 6 18]
[10 22]]
[[ 3 15]
[ 7 19]
[11 23]]]
Varsayılan Transpoze Boyutları: (4, 3, 2)
Özel Transpoze (eksenler (1,2,0) sırasına göre):
[[[ 0 1 2 3]
[12 13 14 15]]
[[ 4 5 6 7]
[16 17 18 19]]
[[ 8 9 10 11]
[20 21 22 23]]]
Özel Transpoze Boyutları: (3, 4, 2)Bu örnekte, axes=(1, 2, 0) ifadesi, orijinal dizinin 1. ekseninin yeni dizide 0. eksen, 2. ekseninin yeni dizide 1. eksen ve 0. ekseninin yeni dizide 2. eksen olacağı anlamına gelir. Bu, N-boyutlu verileri (örneğin, bir görüntüdeki piksellerin renk kanallarının sırası gibi) yeniden düzenlemek için son derece güçlü bir araçtır.
.transpose() Metodu
numpy.ndarray.transpose() metodu, numpy.transpose() fonksiyonunun dizi nesnesi üzerinde çağrılan versiyonudur. İşlevsellik olarak numpy.transpose() ile tamamen aynıdır ve aynı axes parametresini alır. Genellikle, bir dizinin kendi metodu olarak çağrılması daha nesne odaklı bir yaklaşımdır.
Kullanım: dizi.transpose(axes=None)
import numpy as np
matris = np.array([[1, 2, 3],
[4, 5, 6]])
print("Orijinal Matris:\n", matris)
.transpose() metodunu kullanarak transpoze alalım
transpoze_matris_method = matris.transpose()
print("\nTranspoze Matris (.transpose()):\n", transpoze_matris_method)
3D dizi üzerinde .transpose() metodu
dizi_3d = np.arange(24).reshape((2, 3, 4))
transpoze_3d_method = dizi_3d.transpose((1, 2, 0))
print("\nÖzel Transpoze (3D, .transpose((1,2,0))):\n", transpoze_3d_method)
print("Özel Transpoze Boyutları:", transpoze_3d_method.shape)Çıktı:
Orijinal Matris:
[[1 2 3]
[4 5 6]]
Transpoze Matris (.transpose()):
[[1 4]
[2 5]
[3 6]]
Özel Transpoze (3D, .transpose((1,2,0))):
[[[ 0 1 2 3]
[12 13 14 15]]
[[ 4 5 6 7]
[16 17 18 19]]
[[ 8 9 10 11]
[20 21 22 23]]]
Özel Transpoze Boyutları: (3, 4, 2)Görüldüğü gibi, dizi.transpose() ve np.transpose(dizi) aynı işlevi yerine getirir. Hangi yöntemin kullanılacağı genellikle kişisel tercihe veya kodlama stiline bağlıdır.
numpy.swapaxes() Fonksiyonu
numpy.swapaxes() fonksiyonu, özellikle N-boyutlu bir dizide belirli iki ekseni takas etmek için tasarlanmıştır. numpy.transpose()‘a göre daha spesifik bir görev için kullanılır ve daha okunabilir bir kod sağlayabilir.
Kullanım: numpy.swapaxes(dizi, axis1, axis2)
* dizi: Eksenleri takas edilecek NumPy dizisi.
* axis1: Takas edilecek birinci eksenin indeksi.
* axis2: Takas edilecek ikinci eksenin indeksi.
Örnek: 3 Boyutlu Dizi
Yukarıdaki 3 boyutlu dizi örneğini ele alalım. Diyelim ki sadece 0. ve 2. eksenleri takas etmek istiyoruz (derinlik ve genişlik).
import numpy as np
dizi_3d = np.arange(24).reshape((2, 3, 4))
print("Orijinal 3D Dizi:\n", dizi_3d)
print("Orijinal 3D Dizi Boyutları:", dizi_3d.shape) # (0: derinlik, 1: yükseklik, 2: genişlik)
0. (derinlik) ve 2. (genişlik) eksenleri takas edelim
Sonuç: (genişlik, yükseklik, derinlik) -> (2, 1, 0)
swapped_dizi = np.swapaxes(dizi_3d, 0, 2)
print("\nEksenleri Takas Edilmiş Dizi (0 ve 2):\n", swapped_dizi)
print("Eksenleri Takas Edilmiş Dizi Boyutları:", swapped_dizi.shape)Çıktı:
Orijinal 3D Dizi:
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
Orijinal 3D Dizi Boyutları: (2, 3, 4)
Eksenleri Takas Edilmiş Dizi (0 ve 2):
[[[ 0 12]
[ 4 16]
[ 8 20]]
[[ 1 13]
[ 5 17]
[ 9 21]]
[[ 2 14]
[ 6 18]
[10 22]]
[[ 3 15]
[ 7 19]
[11 23]]]
Eksenleri Takas Edilmiş Dizi Boyutları: (4, 3, 2)Bu örnekte, np.swapaxes(dizi_3d, 0, 2) işlemi, np.transpose(dizi_3d, axes=(2, 1, 0)) ile aynı sonucu vermiştir. swapaxes daha okunabilir olabilirken, transpose daha genel yeniden sıralama yeteneği sunar.
Transpoze İşleminin Boyutlara Göre Davranışı
NumPy’da transpoze işleminin farklı boyutlardaki diziler üzerindeki etkisini anlamak, doğru ve beklenen sonuçları elde etmek için kritik öneme sahiptir.
1 Boyutlu Diziler (Vektörler)
Yukarıda da belirtildiği gibi, NumPy’da 1 boyutlu bir dizi (örneğin np.array([1, 2, 3])), matematiksel anlamda ne bir satır vektörü ne de bir sütun vektörü olarak özel olarak sınıflandırılır. Sadece (N,) şeklinde bir boyuta sahip bir dizidir. Bu nedenle, .T özniteliği veya np.transpose() fonksiyonu kullanıldığında, 1 boyutlu bir dizinin transpozesi, orijinal dizinin kendisinin bir görünümünü döndürür ve boyutu değişmez.
Eğer bir 1D diziyi bir satır vektörüne ((1, N)) veya bir sütun vektörüne ((N, 1)) dönüştürmek ve ardından transpozesini almak istiyorsanız, reshape veya np.newaxis kullanmanız gerekir:
import numpy as np
a = np.array([1, 2, 3])
a'yı 1x3 boyutlu bir satır vektörüne dönüştür
row_vector = a[np.newaxis, :] # veya a.reshape(1, -1)
print("Satır Vektörü:\n", row_vector)
print("Satır Vektörünün Boyutları:", row_vector.shape)
Satır vektörünün transpozesi (sütun vektörü olur)
column_vector = row_vector.T
print("\nSütun Vektörü:\n", column_vector)
print("Sütun Vektörünün Boyutları:", column_vector.shape)Çıktı:
Satır Vektörü:
[[1 2 3]]
Satır Vektörünün Boyutları: (1, 3)
Sütun Vektörü:
[[1]
[2]
[3]]
Sütun Vektörünün Boyutları: (3, 1)Bu ayrım, özellikle matris çarpımı gibi lineer cebir işlemlerinde önemlidir, çünkü bu işlemler dizilerin boyutlarına (shape) ve nasıl yorumlandıklarına bağlıdır.
2 Boyutlu Diziler (Matrisler)
2 boyutlu diziler, matematiksel matris kavramına doğrudan karşılık gelir. (M, N) boyutundaki bir matrisin transpozesi, (N, M) boyutunda bir matris olur. Bu, satırların sütun, sütunların ise satır haline gelmesi anlamına gelir. Bu durum, .T özniteliği, np.transpose() veya .transpose() metodu kullanılarak standart bir şekilde gerçekleştirilir.
N Boyutlu Diziler
N-boyutlu diziler için transpoze işlemi, eksenlerin sırasının yeniden düzenlenmesi anlamına gelir. Örneğin, (d0, d1, d2, ..., dN-1) boyutundaki bir N-boyutlu dizinin varsayılan transpozesi (yani axes=None ile), eksenlerin sırasını tersine çevirir ve (dN-1, ..., d2, d1, d0) boyutunda bir dizi döndürür.
np.transpose() veya .transpose() metodunun axes parametresi, N-boyutlu dizilerde eksenlerin sırasını tam olarak kontrol etmenizi sağlar. axes parametresi, orijinal eksen indekslerinin (0’dan N-1’e kadar) yeni sırasını belirten bir demet veya liste olmalıdır.
Örnek: Görüntü İşlemede Eksenlerin Yeniden Düzenlenmesi
Görüntü verileri genellikle (yükseklik, genişlik, kanal) veya (kanal, yükseklik, genişlik) şeklinde 3 boyutlu diziler olarak temsil edilir. Makine öğrenimi modelleri veya belirli görüntü işleme algoritmaları, farklı bir eksen sırası bekleyebilir.
Diyelim ki bir görüntümüz (yükseklik, genişlik, kanal) boyutunda (örneğin, (256, 256, 3)). Ancak bir model, (kanal, yükseklik, genişlik) boyutunda (örneğin, (3, 256, 256)) giriş bekliyor. Bu durumda np.transpose() kullanabiliriz:
import numpy as np
(yükseklik, genişlik, kanal) boyutunda bir görüntü dizisi oluşturalım
Örneğin, 256x256 piksel, 3 renk kanallı (RGB)
img_h_w_c = np.random.rand(256, 256, 3)
print("Orijinal Görüntü Boyutları (H, W, C):", img_h_w_c.shape) # (256, 256, 3)
Ekseni (kanal, yükseklik, genişlik) sırasına göre yeniden düzenle
Orijinal eksenler: 0=yükseklik, 1=genişlik, 2=kanal
Yeni sıralama: 2 (kanal) ilk, 0 (yükseklik) ikinci, 1 (genişlik) üçüncü -> (2, 0, 1)
img_c_h_w = np.transpose(img_h_w_c, axes=(2, 0, 1))
print("Yeniden Düzenlenmiş Görüntü Boyutları (C, H, W):", img_c_h_w.shape) # (3, 256, 256)Bu, N-boyutlu dizilerde axes parametresinin ne kadar güçlü ve esnek olduğunu gösterir.
Performans ve Bellek Yönetimi: Görünümler (Views) ve Kopyalar (Copies)
NumPy’da performans, bellek yönetimiyle yakından ilişkilidir. Transpoze işlemleri genellikle bir “görünüm” (view) döndürür, yani orijinal verinin bir kopyasını oluşturmaz. Bunun yerine, orijinal dizinin bellekteki verisine farklı bir bakış açısı sunar. Bu, özellikle büyük dizilerle çalışırken bellek tüketimini azaltır ve işlem hızını artırır, çünkü veri kopyalama pahalı bir işlemdir.
* Görünüm (View): Transpoze işlemi bir görünüm döndürdüğünde, yeni dizi nesnesi orijinal dizinin verilerini paylaşır. Eğer görünüm dizisinde bir değişiklik yaparsanız, bu değişiklik orijinal diziyi de etkileyecektir. .T özniteliği ve transpose() metodunun çoğu kullanımı bir görünüm döndürür.
* Kopya (Copy): Bazı durumlarda (örneğin, bellek düzeni uyumluluğu nedeniyle), NumPy bir kopya oluşturmak zorunda kalabilir. Bir kopya oluşturulduğunda, yeni dizi kendi verilerine sahip olur ve orijinal diziden bağımsızdır. np.copy() fonksiyonu ile açıkça bir kopya oluşturabilirsiniz.
Örnek: Görünüm Davranışı
import numpy as np
original_array = np.array([[1, 2], [3, 4]])
transposed_view = original_array.T
print("Orijinal Dizi:\n", original_array)
print("Transpoze Görünüm:\n", transposed_view)
Görünümde bir değişiklik yapalım
transposed_view[0, 0] = 99
print("\nGörünümde değişiklik sonrası:")
print("Orijinal Dizi:\n", original_array)
print("Transpoze Görünüm:\n", transposed_view)Çıktı:
Orijinal Dizi:
[[1 2]
[3 4]]
Transpoze Görünüm:
[[1 3]
[2 4]]
Görünümde değişiklik sonrası:
Orijinal Dizi:
[[99 2]
[ 3 4]]
Transpoze Görünüm:
[[99 3]
[ 2 4]]Bu örnekte görüldüğü gibi, transposed_view üzerinde yapılan değişiklik, original_array‘i de etkilemiştir, çünkü transposed_view orijinal dizinin bir görünümüdür. Eğer orijinal dizinin etkilenmesini istemiyorsanız, transpoze edilmiş dizinin bir kopyasını almanız gerekir:
original_array = np.array([[1, 2], [3, 4]])
transposed_copy = original_array.T.copy() # .copy() ile açıkça kopya oluştur
print("Orijinal Dizi:\n", original_array)
print("Transpoze Kopya:\n", transposed_copy)
transposed_copy[0, 0] = 99
print("\nKopyada değişiklik sonrası:")
print("Orijinal Dizi:\n", original_array) # Değişmedi
print("Transpoze Kopya:\n", transposed_copy)Çıktı:
Orijinal Dizi:
[[1 2]
[3 4]]
Transpoze Kopya:
[[1 3]
[2 4]]
Kopyada değişiklik sonrası:
Orijinal Dizi:
[[1 2]
[3 4]]
Transpoze Kopya:
[[99 3]
[ 2 4]]Bellek Düzeni (Memory Layout): C-Order ve Fortran-Order
NumPy dizileri bellekte satır öncelikli (C-order) veya sütun öncelikli (Fortran-order) olarak saklanabilir. Bu, çok boyutlu bir dizinin elemanlarının bellekte fiziksel olarak nasıl sıralandığını ifade eder.
* C-Order (Row-major): Varsayılan NumPy bellek düzenidir. Son eksen (en sağdaki eksen) bellekte en hızlı değişendir. Yani, satırlar ardışık olarak depolanır.
* Fortran-Order (Column-major): İlk eksen (en soldaki eksen) bellekte en hızlı değişendir. Yani, sütunlar ardışık olarak depolanır.
Transpoze işlemi, dizinin mantıksal yapısını değiştirirken, aynı zamanda bellekteki fiziksel düzenini de etkileyebilir. Bir C-order dizinin transpozesi genellikle Fortran-order bir görünüm döndürür (ve tersi). Bu, verinin kopyalanmasını gerektirmeden verimli transpoze işlemlerine olanak tanır.
arr.flags['C_CONTIGUOUS'] ve arr.flags['F_CONTIGUOUS'] öznitelikleri ile bir dizinin bellek düzenini kontrol edebilirsiniz.
import numpy as np
matris = np.array([[1, 2, 3], [4, 5, 6]], order='C') # C-order olarak oluşturalım
print("Orijinal Matris C-contiguous:", matris.flags['C_CONTIGUOUS'])
print("Orijinal Matris F-contiguous:", matris.flags['F_CONTIGUOUS'])
transpoze_matris = matris.T
print("\nTranspoze Matris C-contiguous:", transpoze_matris.flags['C_CONTIGUOUS'])
print("Transpoze Matris F-contiguous:", transpoze_matris.flags['F_CONTIGUOUS'])Çıktı:
Orijinal Matris C-contiguous: True
Orijinal Matris F-contiguous: False
Transpoze Matris C-contiguous: False
Transpoze Matris F-contiguous: TrueGörüldüğü gibi, C-order bir matrisin transpozesi F-order bir görünüm döndürmüştür. Bellek düzeni, bazı kütüphanelerle entegrasyon veya yüksek performanslı hesaplamalar için önemli olabilir. Gerekirse, np.ascontiguousarray() veya np.asfortranarray() kullanarak diziyi belirli bir bellek düzenine dönüştürebilirsiniz.
Pratik Uygulama Alanları
Transpoze işlemi, sayısal ve bilimsel hesaplamalarda vazgeçilmez bir araçtır. İşte bazı yaygın uygulama alanları:
* Lineer Cebir:
* Matris Çarpımı: Matris çarpımı $(A \times B)$ için, $A$ matrisinin sütun sayısı ile $B$ matrisinin satır sayısı eşit olmalıdır. Bazen bu koşulu sağlamak için bir matrisin transpozesi alınır. Örneğin, $A^T \times B$ veya $A \times B^T$. NumPy’da matris çarpımı @ operatörü veya np.dot() fonksiyonu ile yapılır.
* İç Çarpım (Dot Product): Vektörlerin iç çarpımında da transpoze kullanılır.
* Veri Bilimi ve Makine Öğrenimi:
* Özellik Matrislerinin Düzenlenmesi: Makine öğrenimi algoritmaları genellikle giriş verilerini belirli bir formatta bekler. Örneğin, bazı modeller veriyi (örnek sayısı, özellik sayısı) olarak beklerken, bazıları (özellik sayısı, örnek sayısı) olarak bekleyebilir. Transpoze, bu formatlar arasında kolayca geçiş yapmayı sağlar.
* Korelasyon Matrisleri: Veri setindeki özellikler arasındaki korelasyonu hesaplarken transpozeye ihtiyaç duyulabilir.
* Görüntü İşleme:
* Görüntü Boyutlarının Yeniden Düzenlenmesi: Görüntü verileri genellikle (yükseklik, genişlik, kanal) veya (kanal, yükseklik, genişlik) şeklinde saklanır. Farklı kütüphaneler veya modeller farklı sıralamalar bekleyebilir. np.transpose() ile bu düzenlemeler kolayca yapılır.
* Döndürme ve Yansıtma: Transpoze, görüntüleri döndürme veya yansıtma gibi temel geometrik dönüşümlerin bir parçası olarak kullanılabilir.
* Zaman Serileri Analizi:
* Zaman serisi verileri genellikle (zaman adımı, özellik) veya (özellik, zaman adımı) olarak düzenlenebilir. Analiz veya modelleme için uygun formata getirmek için transpoze kullanılır.
Sık Karşılaşılan Hatalar ve En İyi Uygulamalar
* 1D Dizilerin Transpozesini Yanlış Anlama: En sık yapılan hatalardan biri, 1 boyutlu dizilerin transpozesinin onları satır veya sütun vektörüne dönüştüreceğini sanmaktır. Unutmayın, 1D dizilerin .T özniteliği sadece orijinal dizinin bir görünümünü döndürür. İstenen satır/sütun vektörü davranışını elde etmek için reshape kullanın.
* N-Boyutlu Dizilerde axes Parametresini Doğru Kullanma: np.transpose() kullanırken axes parametresini doğru anlamak ve kullanmak, N-boyutlu dizilerle çalışırken çok önemlidir. Eksenlerin orijinal indekslerini ve yeni sıralamalarını dikkatlice planlayın.
* Görünüm ve Kopya Farkını Bilmek: Transpoze işlemlerinin genellikle bir görünüm döndürdüğünü unutmayın. Eğer orijinal verinin değiştirilmesini istemiyorsanız, np.copy() kullanarak transpoze edilmiş dizinin bir kopyasını oluşturun.
* Doğru Yöntemi Seçmek:
* 2 boyutlu diziler için genellikle .T en basit ve okunaklı yöntemdir.
* N-boyutlu dizilerde belirli eksen sıralamaları gerektiğinde np.transpose() veya .transpose() metodunu axes parametresiyle kullanın.
* Sadece iki ekseni takas etmek istiyorsanız, np.swapaxes() daha açıklayıcı olabilir.
Sonuç
NumPy’daki transpoze işlemleri, çok boyutlu dizilerle çalışırken vazgeçilmez ve güçlü araçlardır. .T özniteliğinden numpy.transpose() ve numpy.swapaxes() fonksiyonlarına kadar çeşitli yöntemler, farklı senaryolar ve boyutlar için esneklik sunar. Bu yöntemlerin her birinin nasıl çalıştığını, özellikle de 1 boyutlu dizilerdeki davranış farkını ve N-boyutlu dizilerde axes parametresinin gücünü anlamak, veri manipülasyonu ve lineer cebir işlemlerinde verimli ve hatasız kod yazmak için kritik öneme sahiptir.
Transpoze, sadece matematiksel bir işlem olmanın ötesinde, veri biliminden makine öğrenimine, görüntü işlemeden mühendislik simülasyonlarına kadar geniş bir yelpazede pratik uygulamalara sahiptir. Bellek yönetimi (görünümler ve kopyalar) ve bellek düzeni (C-order ve Fortran-order) gibi temel NumPy kavramlarını anlamak, transpoze işlemlerini daha verimli kullanmanıza ve olası performans sorunlarından kaçınmanıza yardımcı olacaktır. NumPy’nin transpoze yetenekleri, Python’ı sayısal hesaplamalar için güçlü bir platform haline getiren temel özelliklerden biridir.