A’dan Z’ye Numpy Tutoriali (Başlangıç ve Orta Seviye)
NumPy, Python programlama dili için bir kütüphanedir; büyük, çok boyutlu diziler ve matrisler için destek ekler ve bu dizilerde çalışacak geniş bir üst düzey matematiksel işlev koleksiyonu sunar. Veri bilimi için olmazsa olmazdır.Ayrıca Numpy bilmeden Makine ve Derin öğrenme algoritmalarına geçemezsiniz. Numpy ile çok fazla işlem yapılabilmekte. Biz hemen hemen hepsine değineceğiz. Hazırsanız başlayalım.
İlk olarak ‘import’ edilmelidir.
import numpy as np Kütüphanemizi ‘np’ ismi ile ‘import’ etme işlemini yaptık. Siz böyle yapmak zorunda değilsiniz. Ama literatür de ‘np’ olarak adlandırılır. Bu en basit işlemi yaptıktan sonra Data oluşturacağız ve bu büyülü dünyaya adım atacağız.
Numpy’e İlk Adım ‘Arrayler’
Arrayler’i bir çeşit veri depolama olarak görebilirsiniz. Numpy’nin veriyi kullanabilmesi için verileri ‘Array’ haline getirmeliyiz. Array’in ne olduğundan bahsetmedik değil mi ? Arrayler aslında birer matrislerdir. Görebilmek için öncelikle bir veri yaratalım.
Data = [[1,2,3],[4,5,6],[7,8,9]]Verimizi de yarattığımıza göre ilk Array’i yaratabiliriz.
Input:
# Datayı Array formuna çevirebilmek için
Array = np.array(Data)
ArrayOutput:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
Buradan sonra bizim ne yapmak istediğimiz önemlidir. Diyelim ki ‘0.’ indekste ki veriyi merak ediyoruz. o halde şöyle yapmalıyız.
Input:
# Datayı Array formuna çevirebilmek için
Array = np.array(Data)
ArrayOutput:
array([1, 2, 3])
Matris içinde ki başka bir veriyi öğrenmek istiyoruz ve 2. indeksin 2. verisini öğrenmemiz lazım diyelim o halde şöyle yapacaktık.
Input:
Array[2,2] # 2. indexteki değerlerin arasından 2. indexi bastırOutput:
9
Bu yöntemler ile çok rahat bir şekilde istediğiniz veriyi elde edebilirsiniz. Şimdi ise Numpy’nin fonksiyonlarına geçelim.
Numpy’nin Olmazsa Olmaz Fonksiyonları
Şimdi ise hepsi birbirinden kullanışlı fonksiyonları tanıtacağım. İlki olan ‘Arange’ fonksiyonu ile başlayalım.
Arange Fonksiyonu:
Arange fonksiyonu, verdiğiniz 2 sayı arasını Array’e çevirir.
Input:
np.arange(0,100)# bu fonk 0 ila 100 değerleri arasını array olarak depolar
Output:
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])Bununla kalmıyor, verdiğiniz değer kadar atlayarak da gidebiliyor. Mesela şu örnekte 5'er 5'er atladık.
Input:
np.arange(0,100,5)# aynısı ama 5 er 5er atlayarak ilerler
Output:
array([ 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80,
85, 90, 95])Zeros, Ones ve Eye Fonksiyonları:
3 Fonksiyonu birlikte aldık çünkü birbirine oldukça yakınlar.
Zeros Fonksiyonu, belirttiğiniz miktar kadar 0'lardan oluşan bir Array yaratacaktır.
Input:
np.zeros(100)# 100 adet 0'dan olusan array bastır
Output:
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])Ones Fonksiyonu, belirttiğiniz miktar kadar 1'lerden oluşan bir Array oluşturacaktır.
Input:
np.ones(100)# 100 adet 1 den olusan array bastır
Output:
array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])Bu arrayler farkettiğiniz üzere pek de istediğimiz gibi matris değiller. Ama şeklini değiştirebiliriz bu yöntem ise şöyledir.
Input:
np.zeros((25,4)) # ones gibi fonksiyonları da bu şekilde yazabilirsiniz
Output:
array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])Ve bu bölümün sonra son fonksiyonu olan Eye fonksiyonuna gelelim. Kendisini tarif etmek biraz zor. Ama işlevi oldukça basit.
Input:
np.eye(10)
Output:
array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])Linspace Fonskiyonu:
Bu fonksiyon, genel olarak 3 değer alır. İlk 2 değer arasında olan sayıları 3. sayıya eşit olarak dağıtır. Anlamamış olabilirsiniz ama aşağıdaki kod parçasıya kolayca anlayabiliceğinizi düşünüyorum.
Input:
np.linspace(0,100,5)# 0 ve 100 arasını 5 eşit parçaya böl ve göster
Output:
array([ 0., 25., 50., 75., 100.])Random Fonksiyonları:
Bu bölümde pek çok fonksiyon göreceksiniz. Hepsinin ayrı bir işlevi var. Ve oldukça önemliler. Zira en fazla kullanılan fonksiyonlar arasında yer alıyorlar.
Input:
np.random.randint(0,100)# 0 ve 100 arasında ranstgele bir sayı üret
# ve ayrıca şu ikisi birbirine eşittir np.random.randint(0,100) = np.random.randint(100)
Output:
21Ayrıca tıpkı diğerleri gibi şu özelliğe de sahiptir.
Input:
np.random.randint(0,100,5)# 0 ve 100 arasında 5 tane rastgele sayı bastır
Output:
array([45, 30, 60, 94, 39])Şimdi ki fonskiyonumuz ise 0 ile 1 arasında ki random sayıları verecektir.
Input:
np.random.rand(5)# 0 ve 1 arasında 5 değer bastır
Output:
array([0.3339768 , 0.82951833, 0.57412653, 0.93605304, 0.9133032 ])Benzer olup ama aynı olmayan bu fonksiyon ise -1 ile 1 arası sayıları bastırır. Gauss distribution metoduyla yapılmaktadır.
Input:
np.random.randn(5)# -1 ve 1 arasında 5 değeri 'gauss distribution' ile bastır
Output:
array([-2.33988451e+00, 8.84428679e-02, 1.91807265e-03, -8.61364775e-01,-1.26429360e+00])Şimdi Array’e şekil vermeyi göreceğiz. Matris ile işlemlerimizi icra ettiğimiz için bu fonksiyon ayrı bir işlevseldir. Veriye istediğimiz şekli vermemizi sağlamaktadır.
Input:
Data1 = np.arange(225)
Output:
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,
156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,
182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,
221, 222, 223, 224])Örneğin burada ‘Arange’ fonksiyonu ile 225'e kadar değer bastırmışız. Ama şekilsiz ve istediğimiz gibi değil.
Input:
Data1.reshape(15,15)
#RESHAPE metodu datayı istediğimiz şekli vermemizi sağlar ve matrise çevirir
Output:
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14],
[ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
28, 29],
[ 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44],
[ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
58, 59],
[ 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74],
[ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
88, 89],
[ 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
103, 104],
[105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
118, 119],
[120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
133, 134],
[135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
148, 149],
[150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162,
163, 164],
[165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
178, 179],
[180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
193, 194],
[195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
208, 209],
[210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222,
223, 224]])Ama bu özel metot ile işlemlerimizi çok daha iyi halledebiliyoruz. Ama dikkat etmemiz gereken bir şey var. 225, 15'in karesidir. İlla ki kare sayılar kullanmak zorunda değilsiniz 20 değer verirsiniz ama (5,4)’lük bir matris de yaratabilirsiniz. Şimdi ise kısa öz ve gerekli işlemler yapacağız. Mesela ‘min()’ adı üstünde en küçük değeri verecektir.
Input:
Data1.cumsum()# kümülatif olarak toplar
Output:
array([ 0, 1, 3, 6, 10, 15, 21, 28, 36,
45, 55, 66, 78, 91, 105, 120, 136, 153,
171, 190, 210, 231, 253, 276, 300, 325, 351,
378, 406, 435, 465, 496, 528, 561, 595, 630,
666, 703, 741, 780, 820, 861, 903, 946, 990,
1035, 1081, 1128, 1176, 1225, 1275, 1326, 1378, 1431,
1485, 1540, 1596, 1653, 1711, 1770, 1830, 1891, 1953,
2016, 2080, 2145, 2211, 2278, 2346, 2415, 2485, 2556,
2628, 2701, 2775, 2850, 2926, 3003, 3081, 3160, 3240,
3321, 3403, 3486, 3570, 3655, 3741, 3828, 3916, 4005,
4095, 4186, 4278, 4371, 4465, 4560, 4656, 4753, 4851,
4950, 5050, 5151, 5253, 5356, 5460, 5565, 5671, 5778,
5886, 5995, 6105, 6216, 6328, 6441, 6555, 6670, 6786,
6903, 7021, 7140, 7260, 7381, 7503, 7626, 7750, 7875,
8001, 8128, 8256, 8385, 8515, 8646, 8778, 8911, 9045,
9180, 9316, 9453, 9591, 9730, 9870, 10011, 10153, 10296,
10440, 10585, 10731, 10878, 11026, 11175, 11325, 11476, 11628,
11781, 11935, 12090, 12246, 12403, 12561, 12720, 12880, 13041,
13203, 13366, 13530, 13695, 13861, 14028, 14196, 14365, 14535,
14706, 14878, 15051, 15225, 15400, 15576, 15753, 15931, 16110,
16290, 16471, 16653, 16836, 17020, 17205, 17391, 17578, 17766,
17955, 18145, 18336, 18528, 18721, 18915, 19110, 19306, 19503,
19701, 19900, 20100, 20301, 20503, 20706, 20910, 21115, 21321,
21528, 21736, 21945, 22155, 22366, 22578, 22791, 23005, 23220,
23436, 23653, 23871, 24090, 24310, 24531, 24753, 24976, 25200])
Input:
Data1.min()# en küçük değeri döndürür
Output:
0
Input:
Data1.max()# en buyuk değeri döndürür
Output:
224
Input:
Data1.sum()# tüm veriyi toplar
Output:
25200Şimdi ki fonksiyonumuz ise ‘argmax()’. Ondan kısaca bahsetmek gerekirse en büyük değere sahip değerin (bu veride 224), indexini verecektir (ne yazık ki o da 224).
Input:
Data1.argmax()# bu sizi şaşırtmasın.Bunun anlamı en büyük sayının indexini vericektir
Output:
224‘argmin()’ de aynı mantık üzerine kurulu sadece en düşük değeri verecektir.
Input:
Data1.argmin()#en küçük sayının indexini vericektir
Output:
0Şimdi ki fonksiyonumuz ise Determinant alabilmek için.
Input:
Data2 = np.array([[1,2],[3,4]])
np.linalg.det(Data2)# bu fonksiyon determinantını alır
Output:
-2.0000000000000004Input:
stddev = np.std(Data1) # Standart sapmayı bulur.
Output:
34.15650255319866
Yukarıda ki işlem standart sapmayı bulmaktadır. Standart sapma, Olasılık kuramı ve istatistik bilim dallarında, bir anakütle, bir örneklem, bir olasılık dağılımı veya bir rassal değişken, veri değerlerinin yayılımının özetlenmesi için kullanılan bir ölçüdür. Ve veri analizinde oldukça kullanılmaktadır.
Şimdi ise varyansı öğreneceğiz. Olasılık kuramı ve istatistik bilim dallarında varyans bir rassal değişken, bir olasılık dağılımı veya örneklem için istatistiksel yayılımın, mümkün bütün değerlerin beklenen değer veya ortalamadan uzaklıklarının karelerinin ortalaması şeklinde bulunan bir ölçüdür. Temel olarak standart sapmanın karesidir. Ve pek çok değişkene sahip verilerde daha doğru bir ölçütüdür.
Input:
variance = np.var(Data1)#varyansını bulur
Output:
1166.6666666666667Şimdi ise Arraylerin indexlenmesini ve birkaç küçük işlem göreceğiz.
Array Yapılarının İndexlenmesi:
Array yapıların indexlemek ile Liste indexlemek aynıdır. Biliyorsanız geçebilirsiniz. Şimdi ki göreceklerimiz en başta gördüklerimizin biraz daha işlevsel olanlarıdır. Şimdi ise yeni bir veri yaratıp başlayalım.
Input:
Data1 = np.arange(0,100)
Output:
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])Input:
Data1[:6]# 0 dan 6. indexe kadar bastır ayrıca yanda ki kod ile de eşdeğerdir. Data1[0,6]
Output:
array([0, 1, 2, 3, 4, 5])
Daha karışık olarak şunu da verebiliriz.
Input:
Data1[::3]# baştan sonra 3 atlaya atlaya ilerle
Output:
array([ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48,
51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99])Anlamış olduğunuz üzere ‘:’ işareti o index’e dair her veriyi kapsamaktadır. İlk ‘:’ ‘baştan’ anlamına gelirken, son ‘:’ ‘sona doğru anlamına’ gelmektedir.
Input:
Data1[:1] = 10 # baştan 2. indexle kadar olanları 10a eşitle
Data1 # ve datamıza baktıgımızda ilk 2 indexin 10 a eşitlendiğini görüyoruz
Output:
array([10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])Yukarıda ki işlem ise bazen gerekli olabilen bir işlemdir. Veriyi analiz ederken bazen veriler eksik olabiliyor. Bazen 0 veya 1 atamamız gerekebiliyor. O yüzden önemi büyük bir özelliktir.
Input:
Data > 40
Output:
array([False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False, False,
False, False, False, False, False, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True])Burada gördüğünüz işlemde Data1'de ki veriler eğer 40 değerinden küçük ise ‘False’ değerini, büyükse ‘True’ değerini döndürecektir.
Numpy Temel Operasyonlar:
Genel olarak temel matematiksel işlemler ve diğer alanları kapsamaktadır. İlerledikçe anlayacaksınız. Ama önce yeni bir veri yaratalım
NewArray = np.array([5,10,15,20,25])
NewArray1 = np.array([1,2,3,4,5])Input:
NewArray + NewArray1
Output:
array([ 6, 12, 18, 24, 30])
Input:
NewArray - NewArray1
Output:
array([ 4, 8, 12, 16, 20])
Input:
NewArray / NewArray1
Output:
array([5., 5., 5., 5., 5.])
Input:
NewArray * NewArray1
Output:
array([ 5, 20, 45, 80, 125])
Input:
NewArray ** NewArray1
Output:
array([ 5, 100, 3375, 160000, 9765625])
Input:
np.sqrt(NewArray)
Output:
array([2.23606798, 3.16227766, 3.87298335, 4.47213595, 5. ])
Şekilde görüldüğü gibi 2 veri arasında 4 işlem ve daha fazlası yapılabilmektedir. Hatta bu verilerle istenilen değer, 4 işlem yada daha fazlası yoluyla kazandırılabilir. Çok daha detaylı bilgiyi buradan araştırabilirsiniz.
Numpy Transpose Kullanımı:
Matrisin satırlarını sütun, sütunlarını satır yapma işlemi Numpy ile “ .T” yazmak kadar kolay. Aşağıdaki durum herşeyi açıklayabilicek seviyede.
Son söz olarak:
Evet arkadaşlar buraya kadar geldiyseniz ve gerçekten hakkını verdiyseniz kendiniz için ‘İyi seviyede Numpy biliyorum’ diyebilirsiniz. Ama bununla yetinmemeli pek çok farklı kaynağı araştırmalı ve çalışmalısınız. Zamanı geldikçe yazı güncellenecektir. Daha detaylı halini ilerleyen zamanlar da Kaggle sayfamda paylaştım buradan ulaşabilirsiniz.
Yazımı okuduğunuz ve kıymetli zamanınızı ayırdığınız için müteşekkirim. Sağlıcakla kalın ve öğrenmeyi kesmeyin.
print(‘İyi Günler !’)
