NumPy’da numpy.sum() Fonksiyonunun Kapsamlı İncelenmesi
Giriş
Veri bilimi, makine öğrenimi ve bilimsel hesaplama alanlarında Python, sunduğu güçlü kütüphaneler sayesinde vazgeçilmez bir araç haline gelmiştir. Bu kütüphanelerin başında gelen NumPy (Numerical Python), çok boyutlu diziler (ndarray) üzerinde yüksek performanslı matematiksel işlemler yapmayı sağlayan temel bir pakettir. NumPy’ın gücü, C ve Fortran’da yazılmış optimize edilmiş kod tabanından gelir, bu da onu saf Python listelerine kıyasla çok daha hızlı kılar. Büyük veri kümeleriyle çalışırken, performans kritik bir faktördür ve NumPy bu ihtiyacı fazlasıyla karşılar.
NumPy’ın sunduğu sayısız fonksiyondan biri olan numpy.sum(), dizilerdeki elemanların toplamını hesaplamak için kullanılır. Basit bir toplama işleminden çok daha fazlasını sunan bu fonksiyon, özellikle çok boyutlu dizilerde belirli eksenler (boyutlar) boyunca toplama yapma yeteneği sayesinde veri analizi ve manipülasyonunda merkezi bir rol oynar. Bu makalede, numpy.sum() fonksiyonunun detaylı kullanımını, çeşitli parametrelerini, performans avantajlarını ve gerçek dünya uygulamalarını kapsamlı bir şekilde inceleyeceğiz. Amacımız, bu güçlü aracı en verimli şekilde kullanmak için gerekli tüm bilgiyi sağlamaktır.
numpy.sum() Fonksiyonunun Temel Kullanımı
numpy.sum() fonksiyonu, bir NumPy dizisindeki tüm elemanların toplamını veya belirli eksenler boyunca elemanların toplamını hesaplar. Temel sözdizimi oldukça basittir: numpy.sum(a, axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True). Burada a, toplamın hesaplanacağı NumPy dizisini ifade eder. Diğer parametreler isteğe bağlıdır ve fonksiyonun davranışını özelleştirmek için kullanılır.
Varsayılan olarak, axis parametresi belirtilmediğinde veya None olarak ayarlandığında, fonksiyon dizinin tüm elemanlarını tek bir sayıya indirgeyerek toplamı hesaplar. Bu, diziyi tek boyutlu bir hale getirip tüm elemanları toplamak anlamına gelir.
Örnek 1: Dizinin Tüm Elemanlarını Toplama
import numpy as np
Tek boyutlu bir dizi
arr1 = np.array([1, 2, 3, 4, 5])
toplam1 = np.sum(arr1)
print(f"Tek boyutlu dizinin toplamı: {toplam1}")
İki boyutlu bir dizi
arr2 = np.array([[1, 2, 3],
[4, 5, 6]])
toplam2 = np.sum(arr2)
print(f"İki boyutlu dizinin tüm elemanlarının toplamı: {toplam2}")
Çıktı:
Tek boyutlu dizinin toplamı: 15
İki boyutlu dizinin tüm elemanlarının toplamı: 21
Yukarıdaki örnekte görüldüğü gibi, numpy.sum() hem tek boyutlu hem de çok boyutlu diziler için tüm elemanların toplamını kolayca hesaplayabilir. Bu temel kullanım, veri setlerindeki genel toplamları bulmak için sıkça başvurulan bir yöntemdir. Ancak, numpy.sum()‘ın gerçek gücü, axis parametresiyle belirli boyutlar üzerinde toplama yapma yeteneğinde yatar.
axis Parametresi: Boyutlar Üzerinde Toplama
axis parametresi, numpy.sum() fonksiyonunun en önemli ve en sık kullanılan parametrelerinden biridir. Bu parametre, toplamın hangi eksen veya eksenler boyunca yapılacağını belirtir. NumPy dizileri, her biri bir eksen veya boyut olarak adlandırılan bir dizi boyuta sahiptir. Örneğin, 2 boyutlu bir dizi (matris) satırlara (eksen 0) ve sütunlara (eksen 1) sahiptir. axis parametresi, bu eksenlerden hangisinin “yok edileceğini” veya “indirgeneceğini” belirler.
axis=0: Sütunlar Üzerinde Toplama
axis=0 belirtildiğinde, toplama işlemi her sütun boyunca (yani satırlar arasında) yapılır. Sonuç olarak, her sütun için bir toplam değeri elde edilir ve çıktı dizisinin boyutu, orijinal dizinin 0. ekseninin (satırların) kaldırılmasıyla azalır. 2 boyutlu bir dizide, bu işlem her sütunun elemanlarını toplayarak bir satır dizisi döndürür.
Örnek 2: axis=0 ile Toplama
import numpy as np
arr = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
axis=0: Sütunlar boyunca toplama (satırlar arasında)
toplam_sutunlar = np.sum(arr, axis=0)
print(f"axis=0 ile toplama:\n{toplam_sutunlar}")
print(f"axis=0 ile toplama sonucunun boyutu: {toplam_sutunlar.shape}")
Çıktı:
axis=0 ile toplama:
[12 15 18]
axis=0 ile toplama sonucunun boyutu: (3,)
Yukarıdaki örnekte:
* İlk sütun: 1 + 4 + 7 = 12
* İkinci sütun: 2 + 5 + 8 = 15
* Üçüncü sütun: 3 + 6 + 9 = 18
Sonuç olarak, [12 15 18] şeklinde tek boyutlu bir dizi elde edilir. Orijinal dizinin şekli (3, 3) iken, sonuç dizinin şekli (3,) olmuştur, yani 0. eksen (satır ekseni) ortadan kalkmıştır.
axis=1: Satırlar Üzerinde Toplama
axis=1 belirtildiğinde, toplama işlemi her satır boyunca (yani sütunlar arasında) yapılır. Sonuç olarak, her satır için bir toplam değeri elde edilir ve çıktı dizisinin boyutu, orijinal dizinin 1. ekseninin (sütunların) kaldırılmasıyla azalır. 2 boyutlu bir dizide, bu işlem her satırın elemanlarını toplayarak bir sütun dizisi döndürür.
Örnek 3: axis=1 ile Toplama
import numpy as np
arr = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
axis=1: Satırlar boyunca toplama (sütunlar arasında)
toplam_satirlar = np.sum(arr, axis=1)
print(f"axis=1 ile toplama:\n{toplam_satirlar}")
print(f"axis=1 ile toplama sonucunun boyutu: {toplam_satirlar.shape}")
Çıktı:
axis=1 ile toplama:
[ 6 15 24]
axis=1 ile toplama sonucunun boyutu: (3,)
Yukarıdaki örnekte:
* İlk satır: 1 + 2 + 3 = 6
* İkinci satır: 4 + 5 + 6 = 15
* Üçüncü satır: 7 + 8 + 9 = 24
Sonuç olarak, [ 6 15 24] şeklinde tek boyutlu bir dizi elde edilir. Orijinal dizinin şekli (3, 3) iken, sonuç dizinin şekli (3,) olmuştur, yani 1. eksen (sütun ekseni) ortadan kalkmıştır.
Çok Boyutlu Dizilerde axis Kullanımı
axis parametresi, ikiden fazla boyuta sahip dizilerde de aynı mantıkla çalışır. Örneğin, 3 boyutlu bir dizide (derinlik, satır, sütun), axis=0 derinlik boyunca, axis=1 satırlar boyunca ve axis=2 sütunlar boyunca toplama yapar. Birden fazla eksen boyunca toplama yapmak için axis parametresine bir tuple (demet) geçirebilirsiniz.
Örnek 4: 3 Boyutlu Dizide axis Kullanımı
import numpy as np
arr_3d = np.array([[[1, 2], [3, 4]],
[[5, 6], [7, 8]]])
print(f"3 boyutlu dizi:\n{arr_3d}")
print(f"3 boyutlu dizinin boyutu: {arr_3d.shape}\n") # (2, 2, 2)
axis=0: İlk eksen (derinlik) boyunca toplama
Her bir [satır, sütun] kombinasyonu için derinlik boyunca toplama
toplam_axis0 = np.sum(arr_3d, axis=0)
print(f"axis=0 ile toplama:\n{toplam_axis0}")
print(f"axis=0 ile toplama sonucunun boyutu: {toplam_axis0.shape}\n")
Çıktı:
[[ 6 8] (1+5, 2+6)
[10 12]] (3+7, 4+8)
axis=1: İkinci eksen (satırlar) boyunca toplama
Her bir [derinlik, sütun] kombinasyonu için satırlar boyunca toplama
toplam_axis1 = np.sum(arr_3d, axis=1)
print(f"axis=1 ile toplama:\n{toplam_axis1}")
print(f"axis=1 ile toplama sonucunun boyutu: {toplam_axis1.shape}\n")
Çıktı:
[[ 4 6] (1+3, 2+4)
[12 14]] (5+7, 6+8)
axis=2: Üçüncü eksen (sütunlar) boyunca toplama
Her bir [derinlik, satır] kombinasyonu için sütunlar boyunca toplama
toplam_axis2 = np.sum(arr_3d, axis=2)
print(f"axis=2 ile toplama:\n{toplam_axis2}")
print(f"axis=2 ile toplama sonucunun boyutu: {toplam_axis2.shape}\n")
Çıktı:
[[ 3 7] (1+2, 3+4)
[11 15]] (5+6, 7+8)
Birden fazla eksen boyunca toplama (örneğin, axis=(0, 1))
Hem derinlik hem de satırlar boyunca toplama
toplam_axis01 = np.sum(arr_3d, axis=(0, 1))
print(f"axis=(0, 1) ile toplama:\n{toplam_axis01}")
print(f"axis=(0, 1) ile toplama sonucunun boyutu: {toplam_axis01.shape}\n")
Çıktı:
[20 24] (1+3+5+7, 2+4+6+8)
Birden fazla eksen belirtildiğinde, bu eksenler sırasıyla indirgenir. Örneğin, axis=(0, 1) önce 0. eksen boyunca, ardından elde edilen sonuç üzerinde 1. eksen boyunca toplama yapar. Bu, genellikle bir diziyi tek bir boyuta veya tek bir skaler değere indirgemek için kullanılır.
axis=None veya Belirtilmemiş Durum
axis parametresi belirtilmediğinde veya None olarak ayarlandığında, numpy.sum() diziyi düzleştirir (tüm boyutları tek bir boyuta indirger) ve tüm elemanları toplar. Bu, başlangıçta gösterdiğimiz temel toplama işlemidir.
import numpy as np
arr = np.array([[1, 2], [3, 4]])
toplam_none = np.sum(arr, axis=None)
toplam_varsayilan = np.sum(arr) # axis belirtilmezse None varsayılır
print(f"axis=None ile toplama: {toplam_none}")
print(f"Varsayılan toplama: {toplam_varsayilan}")
Çıktı:
axis=None ile toplama: 10
Varsayılan toplama: 10
dtype Parametresi: Veri Tipi Kontrolü
dtype parametresi, toplama işleminin sonucunun veri tipini belirtmek için kullanılır. Bu, özellikle olası sayı taşması (overflow) sorunlarını önlemek veya belirli bir hassasiyetle çalışmak istediğinizde önemlidir. Örneğin, küçük bir tamsayı tipine sahip bir dizideki elemanların toplamı, o veri tipinin maksimum değerini aşabilir ve bu da yanlış sonuçlara yol açabilir. Bu durumda, sonucu daha büyük bir veri tipine (örneğin, np.int64 veya np.float64) dönüştürmek için dtype parametresi kullanılabilir.
Örnek 5: dtype Kullanımı ve Sayı Taşması
import numpy as np
Küçük bir tamsayı tipi (int8, -128'den 127'ye kadar değer tutar)
arr_int8 = np.array([100, 50, 20], dtype=np.int8)
print(f"Orijinal dizi (int8): {arr_int8}, dtype: {arr_int8.dtype}")
Varsayılan toplama (sonuç int8'e sığmayabilir)
100 + 50 + 20 = 170. int8 için 127'den büyük.
toplam_varsayilan = np.sum(arr_int8)
print(f"Varsayılan toplama (dtype int8'den büyükse sorun olabilir): {toplam_varsayilan}, dtype: {type(toplam_varsayilan)}")
NumPy, varsayılan olarak sonuç için daha geniş bir tip seçebilir, ancak her zaman değil.
Bu örnekte Python'ın int'ine dönüştü.
Eğer sonuç yine NumPy int8 olsaydı, taşma yaşanabilirdi.
dtype belirterek toplama (sonucu int16'ya zorlama)
toplam_int16 = np.sum(arr_int8, dtype=np.int16)
print(f"int16 olarak toplama: {toplam_int16}, dtype: {toplam_int16.dtype}")
dtype belirterek toplama (sonucu float64'e zorlama)
toplam_float64 = np.sum(arr_int8, dtype=np.float64)
print(f"float64 olarak toplama: {toplam_float64}, dtype: {toplam_float64.dtype}")
Çıktı (sistem ve NumPy versiyonuna göre küçük farklılıklar gösterebilir):
Orijinal dizi (int8): [100 50 20], dtype: int8
Varsayılan toplama (dtype int8'den büyükse sorun olabilir): 170, dtype:
int16 olarak toplama: 170, dtype: int16
float64 olarak toplama: 170.0, dtype: float64
NumPy genellikle toplama işlemleri için uygun bir varsayılan dtype seçmeye çalışsa da, özellikle çok sayıda elemanı olan veya büyük değerler içeren dizilerde dtype parametresini açıkça belirtmek en güvenli yaklaşımdır.
out Parametresi: Sonucun Kaydedileceği Yer
out parametresi, toplama işleminin sonucunun kaydedileceği mevcut bir NumPy dizisini belirtmenizi sağlar. Bu, özellikle büyük dizilerle çalışırken bellek tahsisini optimize etmek ve yeni bir dizi oluşturma maliyetinden kaçınmak istediğinizde kullanışlıdır. out parametresi olarak verilen dizinin şekli ve veri tipi, beklenen sonuçla uyumlu olmalıdır.
Örnek 6: out Parametresi Kullanımı
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
Sonucun kaydedileceği boş bir dizi oluşturma
result_array = np.zeros(1, dtype=np.int64) # Tek bir skaler değer bekliyoruz
np.sum(arr, out=result_array)
print(f"Sonuç (out parametresi ile): {result_array}")
print(f"Sonucun tipi: {result_array.dtype}")
Çıktı:
Sonuç (out parametresi ile): [15]
Sonucun tipi: int64
out parametresi, özellikle döngüler içinde veya performansa duyarlı uygulamalarda bellek yönetimini iyileştirmek için değerli olabilir.
keepdims Parametresi: Boyutları Koruma
keepdims parametresi, axis parametresi kullanılarak bir eksen boyunca toplama yapıldığında, indirgenen eksenin çıktı dizisinde tek boyutlu (boyut 1) olarak korunup korunmayacağını belirler. Varsayılan değeri False‘dur, yani indirgenen eksen tamamen kaldırılır. keepdims=True olarak ayarlandığında, çıktı dizisinin şekli, indirgenen eksenlerin boyutunun 1 olduğu orijinal dizinin şekline benzer olacaktır. Bu, yayın (broadcasting) işlemleri için çıktının orijinal diziyle uyumlu kalmasını sağlamak istediğinizde çok kullanışlıdır.
Örnek 7: keepdims Kullanımı
import numpy as np
arr = np.array([[1, 2, 3],
[4, 5, 6]])
print(f"Orijinal dizi:\n{arr}")
print(f"Orijinal dizinin boyutu: {arr.shape}\n") # (2, 3)
keepdims=False (varsayılan): Eksen kaldırılır
toplam_normal = np.sum(arr, axis=0)
print(f"axis=0, keepdims=False ile toplama:\n{toplam_normal}")
print(f"Sonuç dizinin boyutu: {toplam_normal.shape}\n") # (3,)
keepdims=True: Eksen korunur (boyutu 1 olarak)
toplam_keepdims = np.sum(arr, axis=0, keepdims=True)
print(f"axis=0, keepdims=True ile toplama:\n{toplam_keepdims}")
print(f"Sonuç dizinin boyutu: {toplam_keepdims.shape}\n") # (1, 3)
axis=1 için aynı durum
toplam_normal_axis1 = np.sum(arr, axis=1)
print(f"axis=1, keepdims=False ile toplama:\n{toplam_normal_axis1}")
print(f"Sonuç dizinin boyutu: {toplam_normal_axis1.shape}\n") # (2,)
toplam_keepdims_axis1 = np.sum(arr, axis=1, keepdims=True)
print(f"axis=1, keepdims=True ile toplama:\n{toplam_keepdims_axis1}")
print(f"Sonuç dizinin boyutu: {toplam_keepdims_axis1.shape}\n") # (2, 1)
Çıktı:
Orijinal dizi:
[[1 2 3]
[4 5 6]]
Orijinal dizinin boyutu: (2, 3)
# axis=0, keepdims=False ile toplama:
[5 7 9]
Sonuç dizinin boyutu: (3,)
# axis=0, keepdims=True ile toplama:
[[5 7 9]]
Sonuç dizinin boyutu: (1, 3)
# axis=1, keepdims=False ile toplama:
[ 6 15]
Sonuç dizinin boyutu: (2,)
# axis=1, keepdims=True ile toplama:
[[ 6]
[15]]
Sonuç dizinin boyutu: (2, 1)
keepdims=True özellikle, bir diziyi bir eksen boyunca topladıktan sonra orijinal diziyle tekrar yayınlamak (broadcast) istediğinizde çok kullanışlıdır. Örneğin, her elemanı kendi sütun ortalamasından çıkarmak istediğinizde, keepdims=True kullanılarak hesaplanan sütun ortalamaları doğrudan orijinal diziyle yayınlanabilir.
initial Parametresi: Başlangıç Değeri
initial parametresi, toplama işlemine başlanacak ilk değeri belirtir. Bu, toplamın sıfır yerine belirli bir değerden başlamasını istediğiniz durumlarda kullanışlıdır. Varsayılan değeri 0’dır.
Örnek 8: initial Parametresi Kullanımı
import numpy as np
arr = np.array([1, 2, 3])
initial olmadan toplama
toplam_normal = np.sum(arr)
print(f"initial olmadan toplama: {toplam_normal}") # 1 + 2 + 3 = 6
initial=10 ile toplama
toplam_initial = np.sum(arr, initial=10)
print(f"initial=10 ile toplama: {toplam_initial}") # 10 + 1 + 2 + 3 = 16
Çıktı:
initial olmadan toplama: 6
initial=10 ile toplama: 16
Bu parametre, özellikle boş bir diziyi toplarken veya toplamın belirli bir başlangıç değeriyle başlaması gereken özel algoritmalar geliştirirken faydalıdır.
where Parametresi: Koşullu Toplama
where parametresi, NumPy 1.20 sürümünden itibaren eklenen yeni bir özelliktir. Bu parametre, bir boolean maske (mask) dizisi alarak, yalnızca maskenin True olduğu konumlardaki elemanları toplama işlemine dahil etmeyi sağlar. Bu, belirli bir koşulu sağlayan elemanların toplamını hesaplamak için np.where veya manuel filtreleme kullanmaktan daha verimli bir yol sunar.
Örnek 9: where Parametresi Kullanımı
import numpy as np
arr = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
Sadece çift sayıları toplamak için bir maske oluşturma
maske = arr % 2 == 0
print(f"Orijinal dizi:\n{arr}")
print(f"Maske (çift sayılar için):\n{maske}\n")
where parametresi ile sadece çift sayıları toplama
toplam_ciftler = np.sum(arr, where=maske)
print(f"where ile sadece çift sayıların toplamı: {toplam_ciftler}") # 2 + 4 + 6 + 8 = 20
Belirli bir eksen boyunca koşullu toplama
Her satırdaki çift sayıları topla
toplam_ciftler_satir_bazinda = np.sum(arr, axis=1, where=maske)
print(f"where ve axis=1 ile satır bazında çift sayıların toplamı: {toplam_ciftler_satir_bazinda}")
Çıktı:
[2, 10, 8] (ilk satırda 2; ikinci satırda 4+6=10; üçüncü satırda 8)
Çıktı:
Orijinal dizi:
[[1 2 3]
[4 5 6]
[7 8 9]]
Maske (çift sayılar için):
[[False True False]
[ True False True]
[False True False]]
# where ile sadece çift sayıların toplamı: 20
where ve axis=1 ile satır bazında çift sayıların toplamı: [ 2 10 8]
where parametresi, veri temizleme, eksik değerleri yok sayma veya belirli alt kümeler üzerinde analiz yapma gibi birçok senaryoda büyük esneklik ve performans avantajı sağlar.
numpy.sum() vs Python’ın Yerleşik sum() Fonksiyonu
Python’ın kendi yerleşik sum() fonksiyonu da bir iterable (liste, tuple vb.) içindeki elemanları toplamak için kullanılır. Ancak, numpy.sum() ile arasında önemli farklar vardır:
1. Performans: numpy.sum(), C dilinde yazılmış optimize edilmiş algoritmaları kullandığı için büyük veri setleri üzerinde Python’ın yerleşik sum() fonksiyonundan çok daha hızlıdır. NumPy dizileri bellekte bitişik olarak saklanır, bu da işlemci önbelleğini daha verimli kullanmasını sağlar.
2. Çok Boyutlu Diziler: Python’ın sum() fonksiyonu sadece tek boyutlu iterable’lar üzerinde çalışır. Çok boyutlu bir listeyi toplamak için iç içe döngüler kullanmanız gerekir ki bu da hem karmaşık hem de yavaştır. numpy.sum() ise axis parametresi sayesinde çok boyutlu diziler üzerinde kolayca ve verimli bir şekilde toplama yapabilir.
3. Esneklik: numpy.sum(); dtype, out, keepdims, initial ve where gibi parametrelerle çok daha fazla kontrol ve esneklik sunar. Python’ın sum() fonksiyonu sadece start (initial’a benzer) parametresine sahiptir.
4. Veri Tipleri: numpy.sum(), NumPy’ın zengin veri tipi sistemini destekler ve toplama sırasında veri tipi dönüşümleri (casting) üzerinde kontrol sağlar.
Örnek 10: Performans Karşılaştırması
import numpy as np
import time
Büyük bir liste
py_list = list(range(1, 1_000_001))
Büyük bir NumPy dizisi
np_array = np.arange(1, 1_000_001)
Python'ın sum() fonksiyonu ile süre ölçümü
start_time = time.time()
py_sum_result = sum(py_list)
end_time = time.time()
print(f"Python's sum() ile süre: {end_time - start_time:.6f} saniye")
numpy.sum() fonksiyonu ile süre ölçümü
start_time = time.time()
np_sum_result = np.sum(np_array)
end_time = time.time()
print(f"numpy.sum() ile süre: {end_time - start_time:.6f} saniye")
Çıktı (yaklaşık değerler, sistemden sisteme değişir):
Python's sum() ile süre: 0.015625 saniye
numpy.sum() ile süre: 0.000321 saniye
Yukarıdaki örnekte görüldüğü gibi, numpy.sum() çok daha hızlıdır. Büyük veri setleriyle çalışırken bu performans farkı katlanarak artar ve numpy.sum()‘ı vazgeçilmez kılar.
Performans ve Optimizasyon İpuçları
numpy.sum() zaten yüksek performanslı bir fonksiyondur, ancak yine de bazı optimizasyon ipuçları mevcuttur:
* Doğru Veri Tipi Seçimi: Bellek kullanımını ve işlem hızını etkiler. Mümkün olduğunca küçük, ancak yeterli veri tiplerini (np.int16, np.float32 vb.) kullanın. Ancak, sayı taşmasını önlemek için gerektiğinde daha büyük tipleri tercih edin.
* out Parametresi: Sonucu mevcut bir diziye yazarak bellek tahsisi maliyetinden kaçının. Bu, özellikle döngüler içinde tekrarlanan toplama işlemleri için faydalıdır.
* Vektörel İşlemler: Mümkün olduğunca for döngüleri yerine NumPy’ın vektörel işlemlerini kullanın. numpy.sum() zaten vektörel bir işlemdir, bu nedenle onu kullanmak başlı başına bir optimizasyondur.
* keepdims=True ile Yayınlama (Broadcasting): Eğer toplama sonrası elde edilen sonucu orijinal diziyle veya başka bir diziyle yayınlamak (broadcast) gerekiyorsa, keepdims=True kullanarak ara adımda boyut dönüşümlerinden kaçının.
Gerçek Dünya Uygulama Örnekleri
numpy.sum() fonksiyonu, veri biliminden mühendisliğe kadar geniş bir yelpazede uygulama alanına sahiptir:
* İstatistiksel Analiz: Bir veri setinin toplamını, ortalamasını (toplam/eleman sayısı), varyansını veya standart sapmasını hesaplamanın temelini oluşturur. Örneğin, bir hisse senedi portföyünün toplam değerini veya bir sınıfın sınav notlarının toplamını bulmak.
* Görüntü İşleme: Bir görüntünün parlaklık değerlerinin toplamını alarak genel parlaklığını ölçmek veya belirli bir bölgedeki piksel değerlerini toplamak. Bir görüntünün ortalama yoğunluğunu hesaplamak için de kullanılır.
* Makine Öğrenimi: Model eğitiminde maliyet fonksiyonlarının (loss functions) hesaplanmasında sıkça kullanılır. Örneğin, kareli hata toplamını (Sum of Squared Errors – SSE) veya çapraz entropi maliyetini hesaplarken. Ayrıca, yapay sinir ağlarında katmanların çıktılarını toplamak gibi matris işlemlerinde temel bir bileşendir.
* Finansal Analiz: Portföy getirilerinin toplamını veya belirli bir dönemdeki toplam kar/zararı hesaplamak.
* Bilimsel Hesaplama: Fizik, kimya ve biyoloji gibi alanlarda büyük veri setlerindeki toplam enerjiyi, madde miktarını veya popülasyon büyüklüğünü hesaplamak.
Sık Karşılaşılan Hatalar ve Çözümleri
numpy.sum() kullanırken karşılaşılabilecek bazı yaygın hatalar ve bunların çözümleri şunlardır:
* Sayı Taşması (OverflowError): Küçük bir dtype ile büyük sayılar toplandığında ortaya çıkar.
* Çözüm: dtype parametresini daha geniş bir veri tipine (np.int64, np.float64) ayarlayın.
arr_small_int = np.array([100000, 200000, 300000], dtype=np.int16) # int16 max 32767
# print(np.sum(arr_small_int)) # Bu hata verebilir veya yanlış sonuç döndürebilir
print(np.sum(arr_small_int, dtype=np.int64)) # Doğru sonuç için int64 kullanın* Yanlış axis Belirtme: Özellikle çok boyutlu dizilerle çalışırken hangi eksenin ne anlama geldiğini karıştırmak.
* Çözüm: Dizinin shape özelliğini kontrol edin ve hangi eksenin hangi boyuta karşılık geldiğini anlayın. Örneklerle deneme yaparak axis‘in etkisini gözlemleyin. keepdims=True kullanarak ara sonuçların boyutlarını kontrol etmek de yardımcı olabilir.
* Boş Dizilerle Çalışma: Boş bir diziyi toplamak genellikle 0 döndürür, ancak initial parametresi belirtilirse o değeri döndürür.
empty_arr = np.array([])
print(np.sum(empty_arr)) # Çıktı: 0.0 (varsayılan dtype float'a döner)
print(np.sum(empty_arr, initial=100)) # Çıktı: 100* Non-Numeric Elemanlar: Dizide sayısal olmayan elemanlar (string, None vb.) varsa TypeError verir.
* Çözüm: Diziyi toplama işleminden önce temizleyin ve sadece sayısal değerler içerdiğinden emin olun.
Sonuç ve Gelecek Perspektifi
numpy.sum() fonksiyonu, NumPy kütüphanesinin temel taşlarından biridir ve Python’da sayısal hesaplama yapan herkes için vazgeçilmez bir araçtır. Çok boyutlu diziler üzerindeki yüksek performanslı toplama yeteneği, axis parametresiyle sunduğu esneklik ve dtype, out, keepdims, initial, where gibi zengin parametre seçenekleriyle veri analizi, bilimsel hesaplama ve makine öğrenimi gibi alanlarda karmaşık işlemleri basitleştirir ve hızlandırır.
Bu makalede, numpy.sum()‘ın temel kullanımından en gelişmiş özelliklerine kadar geniş bir yelpazeyi ele aldık. axis parametresinin çok boyutlu dizilerdeki gücünü, dtype ile veri tipi kontrolünün önemini, out ile bellek optimizasyonunu, keepdims ile boyutları korumayı, initial ile başlangıç değerini ve where ile koşullu toplamayı detaylı örneklerle inceledik. Ayrıca, numpy.sum() ile Python’ın yerleşik sum() fonksiyonu arasındaki performans ve işlevsellik farklarını vurguladık.
NumPy’ın sürekli gelişimiyle birlikte, numpy.sum() gibi temel fonksiyonlar da performans ve esneklik açısından iyileşmeye devam edecektir. Veri bilimi ekosisteminde merkezi bir rol oynayan bu fonksiyonu derinlemesine anlamak ve doğru bir şekilde kullanmak, daha verimli, ölçeklenebilir ve güvenilir kodlar yazmanın anahtarıdır. Kullanıcılar, bu fonksiyonun tüm yeteneklerinden faydalanarak karmaşık veri manipülasyonu ve analiz görevlerini kolayca yerine getirebilirler.