Makine Öğrenimi ve Sinir Ağları - sayfa 68

[MetaQuotes]

4.4 NumPy Broadcasting (L04: Python'da Bilimsel Hesaplama)

4.4 NumPy Broadcasting (L04: Python'da Bilimsel Hesaplama)

NumPy, "yayın" olarak bilinen, örtük boyutları tanıtan ve katı lineer cebirin sınırları içinde genellikle imkansız olan işlemleri gerçekleştirmemizi sağlayan büyüleyici bir özellik sunar. Bu yayın konsepti, dizilerle çalışırken daha fazla esneklik ve rahatlık sağlar.

NumPy, yayından yararlanarak, dizileri farklı şekillerle otomatik olarak hizalayabilir ve temel olarak bunları eşleştirmek ve öğe bazında işlemler gerçekleştirmek için genişletebilir. Bu örtük boyut oluşturma, çeşitli boyutlardaki dizilerde işlemleri sorunsuz bir şekilde yürütmemize olanak tanıyarak özlü ve verimli kod elde etmemizi sağlar.

İşlemleri matematiksel kurallara sıkı sıkıya bağlılığın yönettiği doğrusal cebir bağlamında, yayın karmaşık hesaplamaları basitleştirmek için güçlü bir araç sağlar. Farklı şekillere sahip diziler üzerinde hesaplamalar yapmamızı sağlayarak, elle yeniden şekillendirme veya öğeler arasında döngü oluşturma ihtiyacını ortadan kaldırır.

Yayınlama sayesinde, örtük boyutlara sahip diziler üzerinde zahmetsizce işlemler uygulayabiliyor, aksi takdirde kapsamlı manuel manipülasyon gerektirebilecek sonuçlara ulaşabiliyoruz. Bu yetenek, NumPy ile başarabileceklerimizin kapsamını genişleterek onu bilimsel bilgi işlem ve veri analizi için çok yönlü ve vazgeçilmez bir kitaplık haline getiriyor.

[MetaQuotes]

4.5 NumPy Gelişmiş Dizin Oluşturma -- Bellek Görünümleri ve Kopyalar (L04: Python'da Bilimsel Hesaplama)

4.5 NumPy Gelişmiş Dizin Oluşturma -- Bellek Görünümleri ve Kopyalar (L04: Python'da Bilimsel Hesaplama)

Bu beşinci videomuzda indeksleme konusuna bir kez daha değineceğiz. Ancak, temel indekslemeyi ele aldığımız ilk videonun aksine, şimdi gelişmiş indekslemeyi keşfedeceğiz. Bu bölüm, yanlışlıkla dizi değerlerinin üzerine yazmak gibi kasıtsız hatalardan kaçınmak için çok önemli uygulamalar olan bellek görünümleri ve bellek kopyaları oluşturma gibi kavramları tanıtacaktır. NumPy'de hataları ve beklenmeyen davranışları önlememize yardımcı olduğu için bunu anlamak çok önemlidir.

Şimdi başlayalım. Önceki bölümde, NumPy dizilerinin "görünümler" adı verilen bir özelliğini tartışmıştık. Görünümler, normal indeksleme veya temel dilimleme işlemlerini kullandığımızda oluşturulur. Bu görüşler, doğrusal cebirin katı matematiksel çerçevesi içinde mümkün olmayan işlemleri gerçekleştirmemizi sağlayan örtülü boyutlar olarak işlev görür. Ancak, orijinal diziyi farkında olmadan yanlışlıkla değiştirebileceğimiz için görünümlerle çalışmak riskli olabilir.

Bunu göstermek için basit bir örnek ele alalım. İki satır ve üç sütundan oluşan iki boyutlu bir dizimiz olduğunu varsayalım. Kolaylık sağlamak için, ilk satırı "birinci_satır" adlı ayrı bir değişkene atayacağım. Şimdi, işte can alıcı nokta: ilk satırı bir değişkene atamak, yeni bir nesne değil, bir görünüm oluşturur. Bu, bu değişkenin yalnızca orijinal dizinin bellekteki konumuna işaret ettiği anlamına gelir. Sonuç olarak, bu değişkendeki değerleri değiştirirsek, orijinal dizideki karşılık gelen değerleri de değiştiririz.

Bunu göstermek için "birinci_satır" değişkenindeki her öğeyi 99 artıralım. Bu işlemi gerçekleştirmek yalnızca değişkendeki değerleri değiştirmekle kalmayacak, aynı zamanda orijinal dizinin ilk satırındaki değerlerin üzerine yazacaktır. Bu davranış, bağımsız bir nesne yerine bir görünümle çalıştığımıza dair bir ipucu görevi görür. Bir görünümle çalışırken istemeden orijinal dizideki değerlerin üzerine yazmak kolay olduğundan, bunun farkında olmamak tehlikeli olabilir.

Öte yandan, gereksiz dizi kopyalarından kaçınmamıza izin verdiği için, görünümler bellek verimliliği için inanılmaz derecede yararlı olabilir. Ancak, açıkça bir dizinin bir kopyasını oluşturmak isteyebileceğimiz durumlar vardır. Bu amaçla, orijinaliyle aynı değerlere sahip yeni bir dizi oluşturan "kopyala" işlevini kullanabiliriz. Verilen örnekte, "kopyala" işlevini kullanarak dizinin ikinci satırının bir kopyasını oluşturuyorum. Bunu yaparak, "birinci_satır" değişkeninde yapılan herhangi bir değişiklik orijinal diziyi etkilemeyecektir.

Dilimleme ve tamsayı tabanlı indeksleme bellek görünümleri oluştururken, dizinin kopyalarını üreten "süslü indeksleme" adı verilen başka bir indeksleme türü olduğunu not etmek önemlidir. Süslü indeksleme, bir diziden belirli öğeleri seçmek için birden çok tamsayı indeksi kullanmayı ifade eder. Bu özellik, normal Python listelerinde desteklenmediği için "süslü" olarak adlandırılır. Ancak NumPy, oldukça güçlü olabilen bu tür indekslemeyi gerçekleştirmemize izin verir.

Örneğin, normal bir Python listesinde birinci ve üçüncü öğeleri aynı anda alamayız. Yine de, NumPy'de bunu fantezi indeksleme kullanarak başarabiliriz. Benzer şekilde, iki boyutlu bir diziden belirli sütunları seçmek için fantezi indekslemeyi kullanabiliriz. Süslü indekslemenin her zaman dizinin bir kopyasıyla sonuçlandığını, bir görünümle sonuçlanmadığını belirtmekte fayda var.

Görünümler ve kopyalar arasındaki fark, NumPy'deki verimlilik hususlarıyla ilgilidir. Dilimleme, performansı optimize ederek belirli değerleri bellekte önbelleğe almamızı sağlar. Bununla birlikte, bu önbelleğe alma mekanizmasını fantezi indeksleme ile uygulamak, bitişik bir bellek yığınını çıkaramadığımız için kolay değildir. Bunun yerine, yeni bir dizinin oluşturulmasına yol açan bireysel değerleri seçiyoruz. Bu davranış, süslü indekslemenin neden görünümler yerine kopyalar ürettiğini açıklar.

Süslü indekslemenin bir başka ilginç yönü de, bir dizideki sütunların sırasını yeniden düzenlememizi sağlamasıdır. Süslü indekslemeyi kullanarak istenen sütun indekslerini belirterek, sütunları gerektiği gibi karıştırabiliriz.

NumPy'deki Boole maskeleri, dizileri belirli koşullara göre filtrelemenin verimli ve güçlü bir yoludur. Bir Boole maskesi, orijinal diziyle aynı şekle sahip olan Boole değerlerinin (Doğru veya Yanlış) NumPy dizisidir. Boole maskesini orijinal diziye uygulayarak, verilen koşulu sağlayan öğeleri seçebilir ve gerisini atabiliriz.

Bir Boole maskesi oluşturmak için önce dizideki her öğe için bir Boole değeri döndüren bir koşul tanımlarız. Örneğin arr adında bir dizimiz olduğunu varsayalım:

import numpy as np
arr = np.array([1, 2, 3, 4, 5])

Yalnızca 3'ten büyük olan öğeleri seçmek gibi bir koşula dayalı olarak bir Boole maskesi oluşturabiliriz:

mask = arr > 3

Ortaya çıkan Boole maskesi, maske, [Yanlış, Yanlış, Yanlış, Doğru, Doğru] olacaktır. Maskedeki her öğe, orijinal dizideki aynı konuma karşılık gelir ve bu öğe için koşulun doğru mu yoksa yanlış mı olduğunu gösterir.

Boole maskesini uygulamak ve koşulu karşılayan öğeleri almak için, maskeyi dizinin bir indeksi olarak kullanabiliriz:

filtered_arr = arr[mask]

Ortaya çıkan filtered_arr, yalnızca orijinal diziden 3'ten büyük öğeleri içeren [4, 5] olacaktır.

Boole maskeleri, & (ve), | (veya) ve ~ (değil) daha karmaşık koşullar oluşturmak için. Örneğin:

mask = (arr > 2) & (arr < 5)
filtered_arr = arr[mask]

Bu koşul, 2'den büyük ve 5'ten küçük öğeleri seçerek filtered_arr öğesinin [3, 4] olmasını sağlar.

Boole maskeleri, özellikle büyük veri kümeleriyle çalışırken veya veri filtreleme ve analizi gerçekleştirirken kullanışlıdır. Açık döngülere veya durum kontrollerine ihtiyaç duymadan diziler üzerinde verimli ve özlü işlemlere izin verirler.

Dizileri filtrelemeye ek olarak, eleman ataması için Boole maskeleri de kullanılabilir. Boole maskesi aracılığıyla seçilen öğelere yeni değerler atayarak, bir koşula göre dizinin belirli kısımlarını değiştirebiliriz.

Genel olarak, Boolean maskeleri, NumPy dizilerini belirtilen koşullara göre işlemek ve filtrelemek için esnek ve verimli bir yol sağlayarak, onları veri işleme ve analizde değerli bir araç haline getirir.

[MetaQuotes]

4.6 NumPy Rastgele Sayı Üreticileri (L04: Python'da Bilimsel Hesaplama)

4.6 NumPy Rastgele Sayı Üreticileri (L04: Python'da Bilimsel Hesaplama)

Bu videoda, NumPy'deki rasgele sayı üreteçlerine kısa bir genel bakış sunacağız. NumPy'de rasgele sayı üretmeye yönelik tüm farklı yöntemleri ele almayacak olsak da, rasgele sayı üreteçlerini ve bunların pratik faydalarını anlamaya odaklanacağız.

Basit bir örnekle başlayalım. Rastgele sayı üretimi için kullanacağımız kütüphane olan NumPy'yi içe aktararak başlayacağız. NumPy, rasgele sayılar çizmek için çeşitli işlevler içeren bir rasgele modüle sahiptir. Başvuracağımız belgeler biraz eski olsa da, farklı işlevlerin ve açıklamalarının yararlı bir listesini sağlar.

Yaygın olarak kullanılan bir işlev, tek biçimli bir dağılımdan rastgele örnekler üreten random.rand işlevidir. İstenen dizinin şeklini (örneğin, 2x3) belirterek, bu işlev, düzgün bir dağılımdan rasgele sayılarla dolu iki boyutlu bir dizi üretecektir.

NumPy, yarı açık aralıkta [0, 1] rastgele değişkenler oluşturan random.random gibi başka işlevler de sunar. Random.randn işlevini kullanarak standart normal dağılım gibi farklı dağılımlardan rastgele örnekler de çizebilirsiniz.

Bazen, kodumuzun her çalıştırıldığında aynı rasgele sonuçları üretmesini sağlamak isteyebiliriz. Bu, özellikle kod paylaşırken veya farklı yöntemleri karşılaştırırken tekrarlanabilirlik açısından kullanışlıdır. Bunu başarmak için, kodumuzu veya defterimizin başına rastgele bir tohum koyabiliriz. Tohum, her seferinde aynı rasgele sayı dizisinin üretilmesini sağlayan rasgele bir sayıdır.

Rastgele bir tohum ayarlayarak, oluşturulan rasgele sayılar, birden çok kod çalışması sırasında sabit kalacaktır. Ancak, başka bir rasgele örnek alırsak sonuçların farklı olacağını unutmamak gerekir çünkü bu yine de rasgele bir süreçtir.

Tutarlı sonuçlara sahip olmak, verileri karıştırma veya uygulamaları test etme gibi makine öğrenimi uygulamalarında özellikle yararlı olabilir. Örneğin, bir veri kümesini bölerken rastgele bir çekirdek ayarlamak, bölmenin her seferinde aynı olmasını sağlar. Bu, farklı yöntemlerin doğru bir şekilde karşılaştırılmasını ve değerlendirilmesini sağlar.

Rastgeleliği daha ayrıntılı bir şekilde yönetmek için, NumPy'de bir rastgele durum nesnesi kullanabiliriz. Rastgele durum nesnesinin kendi rasgele sayı oluşturucusu vardır ve rasgeleliğin uygulandığı yer üzerinde ayrıntılı kontrol sağlar. Birden çok rasgele durum nesnesi oluşturarak, kodumuzda farklı rasgelelik kaynaklarına sahip olabiliriz. Bu, özellikle kodun belirli bölümlerinin tutarlı sonuçlar üretmesini, diğer bölümlerinin ise değişen rasgele sayılar üretmesini istediğimizde faydalıdır.

Eski random_state sınıfı hala yaygın olarak kullanılırken, NumPy topluluğu artık yeni rastgele oluşturucunun kullanılmasını önermektedir. Bu yeni üreteç, rasgele sayılar üretmek için farklı bir yöntem kullanır, ancak çoğu basit uygulama için, ikisi arasındaki seçim gözle görülür bir fark yaratmayacaktır. En önemli olan, tekrarlanabilirlik için rastgele bir tohum ayarlamaktır.

Koddaki rasgele sayı üreteçlerinin gerçekten rasgele değil, sözde rasgele olduğunu hatırlamak önemlidir. Rastgeleliği taklit eden sayı dizileri üretmek için algoritmalar kullanırlar. Bizim bağlamımızda, rasgele sayı üretimi için kullanılan özel algoritmadan ziyade tutarlılık ve yeniden üretilebilirliğe odaklanılmaktadır.

Sonuç olarak, NumPy'de rasgele sayı üreteçleriyle çalışırken üretecin kendisinin seçimi kritik değildir. Esas olan, tutarlı ve tekrarlanabilir sonuçlar sağlamak için rastgele bir tohum oluşturmaktır. Bu, kod paylaşırken, ödev gönderirken veya farklı yöntemleri karşılaştırırken özellikle değerli hale gelir.

[MetaQuotes]

4.7 NumPy Dizilerini Yeniden Şekillendirme (L04: Python'da Bilimsel Hesaplama)

4.7 NumPy Dizilerini Yeniden Şekillendirme (L04: Python'da Bilimsel Hesaplama)

Sonunda, NumPy serisinin sonuna yaklaşıyoruz. Sadece üç video ile önemli bir konuya ulaştık: NumPy dizilerini yeniden şekillendirmek. Dizileri yeniden şekillendirmek, bir matrisi bir vektöre dönüştürmek veya tam tersi gibi, verilerimizi istenen şekle dönüştürmemiz gerektiğinde çok önemlidir. MNIST'i tartıştığım giriş dersinde bu kavramdan kısaca bahsetmiştim. Bu süreci göstermek için, basitleştirilmiş bir örnek ele alalım.

Bir görüntüyü temsil eden 28'e 28 boyutlarında bir dizimiz olduğunu hayal edin. Normalde, dizideki her öğe bir piksel değerine karşılık gelir. Bununla birlikte, basitlik adına, her öğenin yalnızca tek bir rakam olduğunu varsayalım. Dolayısıyla, bir basamak görüntüsünü temsil eden 28'e 28'lik bir dizimiz var. Ancak, bu diziyi bir sınıflandırıcı için özellik vektörü olarak kullanmak istiyorsak, onu 784 elemanlı (28 * 28) tek bir uzun vektör olarak yeniden şekillendirmemiz gerekir. Her eğitim örneği bir resim olacak ve her resim 784 özelliğe sahip olacak.

Bir diziyi yeniden şekillendirmek, NumPy'deki yeniden şekillendirme işlevi kullanılarak yapılabilir. Örneğin, bir 1, 2, 3, 4, 5, 6 vektörünü 2'ye 3 matris olarak yeniden şekillendirebiliriz:

array([[1, 2, 3],
       [4, 5, 6]])

Yeniden şekillendirme sırasında belirtilen boyutların, orijinal dizideki toplam öğe sayısıyla eşleşmesi gerektiğine dikkat etmek önemlidir. Boyutlar yanlışsa, bir hata oluşur. Örneğin, 6 elemanlı bir vektörü 3'e 3 matris olarak yeniden şekillendirmeye çalışmak, yeterli eleman olmadığı için bir hata verir.

Bir diziyi yeniden şekillendirirken, yeni bir dizi yerine bir bellek görünümü oluşturulur. Bu bellek görünümü, verileri çoğaltmadan yeniden şekillendirilmiş diziyi manipüle etmemizi sağlar. Bunu doğrulamak için her zaman %100 doğru sonuç vermese de np.may_share_memory işlevini kullanabiliriz.

-1'in yeniden şekillendirmede boyut olarak kullanılması NumPy'de kullanışlı bir özelliktir. Yöntemin, toplam öğe sayısına göre uygun boyutu belirlemesine olanak tanıyan bir yer tutucu görevi görür. Örneğin, altı elemanlı bir vektörümüz varsa ve -1, 2'yi kullanarak yeniden şekillendirirsek -1, 3 ile değiştirilecektir çünkü altı eleman elde etmek için üç satırı iki sütunla düzenlemenin tek bir yolu vardır. Bu yer tutucu konsepti, rastgele sayıda boyutla çalışır.

Ek olarak, bir diziyi düzleştirmek için yeniden şekillendirme işlevini kullanabiliriz. Boyut olarak tek bir değer belirterek (örn. reshape(6)), diziyi tek boyutlu bir vektöre dönüştürebiliriz. Uygulamada, boyutu hatırlama gereğini ortadan kaldırdığı için -1 kullanmak daha uygundur. Örneğin, reshape(-1), altı elemanlı bir dizi için reshape(6) ile aynı sonuca ulaşır.

NumPy'de bir diziyi düzleştirmenin birçok yolu vardır. -1 ile yeniden şekillendirme işlevi bir bellek görünümü oluştururken, düzleştirme işlevi de bir diziyi düzleştirir ancak bir kopya oluşturur. Dizileri düzleştirmek için başka bir işlev olan ravel de kullanılır. Bu işlevler arasındaki farkları belirlemek, iyi bir öz değerlendirme sınavı olacaktır.

Son olarak, dizileri belirtilen eksenler boyunca birleştirerek NumPy'de birleştirebiliriz. Dizileri birinci eksen boyunca birleştirirken, Python listelerindeki öğelerin eklenmesine benzer. Örneğin, bir eksene sahip iki dizimiz varsa, bunları bu eksen boyunca birleştirmek, birini diğerinin altına istifleyecektir.

NumPy dizilerini yeniden şekillendirmek, verileri istenen şekle sokmak için gereklidir. Çeşitli yöntemleri, yer tutucuları ve birleştirme tekniklerini anlamak, dizilerle verimli bir şekilde çalışmamızı ve kodumuzu optimize etmemizi sağlar. Bir sonraki videoda, yeniden şekillendirme ile birleştiğinde güçlü araçlar olan NumPy karşılaştırma operatörlerini ve maskelerini ele alacağım.

[MetaQuotes]

4.8 NumPy Karşılaştırma Operatörleri ve Maskeleri (L04: Python'da Bilimsel Hesaplama)

4.8 NumPy Karşılaştırma Operatörleri ve Maskeleri (L04: Python'da Bilimsel Hesaplama)

NumPy'de karşılaştırma operatörleri ve seçim maskeleri çok fazla esneklik sunar ve birlikte çalışmak oldukça keyifli olabilir. Önceki bir videoda maskeleri ve karşılaştırma işleçlerini tanıtmıştık ama şimdi onlarla çalışırken kullanabileceğiniz bazı ek püf noktaları keşfedelim.

Basit bir örnekle başlayalım. Basitlik için bir NumPy dizimiz [1, 2, 3, 4] olduğunu varsayalım. Diziden belirli değerleri seçmek için bir maske tanımlayabiliriz. Bu maske bir Boole dizisi olacaktır, yani True veya False değerleri içerecektir. İkiden büyük değerleri seçmek gibi bir koşul belirterek maskeyi oluşturabiliriz. Ortaya çıkan maske dizisi, orijinal dizi ile aynı şekle sahip olacaktır; True değerleri, koşulun doğru olduğu konumları ve False değerleri, koşulun yanlış olduğu konumları gösterir.

Python'da, Boole değerleri ile tamsayılar arasında kullanışlı bir ilişki vardır: True, 1'e ve False, 0'a eşittir. Bu ilişki, ilginç işlemler gerçekleştirmemizi sağlar. Örneğin, bir koşulun doğru olup olmadığını kontrol etmek için sadece if koşulu: yazarak if ifadesini kullanabiliriz. Not operatörünü, bir koşulun yanlış olup olmadığını kontrol etmek için if not condition: yazarak da kullanabiliriz. Bu yaklaşımlar, koşulu True veya False ile açıkça karşılaştırmaya kıyasla daha okunabilir kod sağlar.

Bir başka yararlı özellik de, bir dizideki belirli bir koşulla eşleşen öğelerin sayısını sayabilme yeteneğidir. Toplam operatörünü bir maskeye uygulayarak, maskedeki True değerlerinin sayısını sayabiliriz. Örneğin, ikiden büyük değerleri seçen bir maskemiz varsa, bu tür değerlerin sayısını sum(mask) çağırarak sayabiliriz. Benzer şekilde, dizideki toplam öğe sayısından toplamı çıkararak False değerlerinin sayısını sayabiliriz.

Bir dizideki negatif değerlerin sayısını saymak için, maskedeki Boole değerlerini çeviren NumPy ters çevirme işlevini kullanabiliriz. Bir maskeye invert uygulayarak ve ardından toplamı çağırarak, Yanlış değerlerin sayısını sayabiliriz (bunlar şimdi negatif değerleri temsil eder).

Bir diziyi ikili hale getirmek, yani onu ikili gösterime dönüştürmek, başka bir yaygın işlemdir. Bunu, bir koşulun doğru olduğu konumlara belirli bir değer ve koşulun yanlış olduğu konumlara başka bir değer atayarak başarabiliriz. Ancak, tüm işlemi yazmak sıkıcı olabilir. Neyse ki NumPy, bu işlemi basitleştiren where işlevini sağlar. where fonksiyonu bir koşul alır ve koşulun doğru olduğu konumlar için ilk değeri, koşulun yanlış olduğu konumlar için ikinci değeri atar. Nerede kullanarak, bir diziyi yalnızca bir kod satırıyla kolayca ikili hale getirebiliriz.

Karşılaştırma işleçlerine ek olarak NumPy, and, or, xor ve not gibi mantıksal işleçler sunar. Bu operatörler, daha karmaşık koşullar oluşturmak için maskelerle birleştirilebilir. Örneğin, veya operatörünü kullanarak üçten büyük veya ikiden küçük değerleri seçebiliriz. Mantıksal operatörler kullanarak birden çok koşulu birleştirerek, ihtiyaçlarımıza uygun karmaşık seçim maskeleri oluşturabiliriz.

NumPy'deki bu Boole maskeleri, mantıksal işleçler ve karşılaştırma işleçleri, veri kümeleriyle çalışırken ve karar ağacı kurallarını uygularken inanılmaz derecede faydalıdır. Gelecek videolarda bu kavramları daha ayrıntılı inceleyeceğiz. Bir sonraki videoda, NumPy'deki temel lineer cebir kavramlarını inceleyeceğiz. Bizi izlemeye devam edin!

[MetaQuotes]

4.9 NumPy Doğrusal Cebirin Temelleri (L04: Python'da Bilimsel Hesaplama)

4.9 NumPy Doğrusal Cebirin Temelleri (L04: Python'da Bilimsel Hesaplama)

Bu videoda, özellikle NumPy bağlamında lineer cebirin bazı temel kavramlarını derinlemesine incelemek istiyorum. Bu derste lineer cebiri kapsamlı bir şekilde kullanmayacak olsak da, vektör nokta çarpımı ve matris çarpımı gibi temel işlemleri kavramak çok önemlidir. Daha önce de belirttiğim gibi, lineer cebir gösterimi kullanmak daha verimli ve özlü kod yazmamızı sağlar.

Tek boyutlu bir diziyi satır vektörü olarak ele alarak başlayalım. Alternatif olarak, birden çok elemana sahip tek bir satırdan oluşan bir vektör olarak tanımlayabiliriz. Öte yandan, satır vektörü bir sütuna ve birden çok öğeye sahip olacak şekilde yeniden şekillendirilerek bir sütun vektörü oluşturulabilir. Temel olarak, sütun vektör gösterimini temsil eder. Özellikle, bu bağlamda köşeli parantezlerin kullanılması gereksizdir.

Vektörü açıkça yeniden şekillendirmek yerine, NumPy'nin newaxis işlevini kullanarak yeni bir eksen ekleyerek aynı sonucu elde edebiliriz. İki yeni eksen ekleyerek bir 3B tensör bile oluşturabiliriz. Başka bir yaklaşım, newaxis ile aynı amaca hizmet eden None anahtar sözcüğünü kullanmaktır. Yeniden şekillendirme, yeni eksen ve Yok olarak adlandırılan bu üç yöntemin tümü, gerektiğinde ek bir eksen ekleme hedefine ulaşır.

Devam edersek, matris çarpımı için temel lineer cebir notasyonuyla karşılaşıyoruz. Doğrusal cebirde, matris çarpımı, çoklu nokta çarpımlarının hesaplanmasına eşdeğerdir. Örneğin, [1, 2, 3] ve [1, 2, 3] vektörlerine sahipsek, iç çarpımları 14 ile sonuçlanır. Benzer şekilde, [4, 5, 6] ve [1, 2, 3] sonucu 32'dir. NumPy'de matmul fonksiyonunu kullanarak matris çarpımı yapabiliriz. Alternatif olarak, kolaylık sağlamak için @ operatörü kullanılabilir. Ancak, lineer cebirde matrisleri ve vektörleri doğrudan çarpamayacağımıza dikkat etmek önemlidir. Bununla birlikte, bir sütun vektörünü bir matris, özellikle 3x1'lik bir matris olarak düşünebiliriz. Bu yaklaşım, katı lineer cebirde mümkün olmayan bir matrisi bir vektörle çarpmamızı sağlar. Böylece NumPy, geleneksel lineer cebire kıyasla daha fazla esneklik sunar.

Ayrıca NumPy, çoğu makinede etkin bir şekilde uygulanması nedeniyle yaygın olarak önerilen matris çarpımı için nokta işlevini sağlar. Bu işlev, özellikle satır vektörleriyle uğraşırken daha rahat kod yazmamızı sağlar. NumPy'de matris çarpımı için bir kısayol veya operatör aşırı yükleme işlevi görür. Nokta işlevinin, girdi şekillerine dayalı olarak nokta çarpımları veya matris çarpımı gerçekleştirerek çeşitli matris ve vektör kombinasyonlarını işleyebileceğini belirtmekte fayda var.

Performansla ilgili olarak, hem matmul hem de dot fonksiyonları benzer hıza sahiptir. Aralarındaki seçim belirli makineye bağlı olabilir. Bununla birlikte, pratikte genellikle nokta işlevi tercih edilir. Ek olarak devrik işlemi, lineer cebirdeki devrik işlemine benzer bir rol oynar ve matrisi etkili bir şekilde ters çevirir. Açıkça devrik işlevini kullanmak yerine, kısa olması için T özniteliğini kullanabiliriz.

NumPy, iki boyutlu diziler için bir matris türü içerirken, NumPy topluluğu içinde yaygın olarak kullanılmaz. Düzenli çok boyutlu diziler çoğu durumda amaca hizmet eder. Matris tipi iki boyutla sınırlıdır ve gereksiz karmaşıklık getirir. Özel olarak gerekli olmadıkça kullanmaktan kaçınılması tavsiye edilir.

Son olarak, NumPy'nin ötesinde çok çeşitli ek işlevleri kapsayan etkileyici bir kitaplık olan SciPy'ye kısaca değineceğiz. Bu kitaplık, doğrusal cebir işlemleri, Fourier dönüşümleri, enterpolasyon teknikleri, optimizasyon algoritmaları, istatistiksel işlevler ve daha fazlası gibi bilimsel hesaplama için çok sayıda özel algoritma içerir. NumPy tabanlı olsa da SciPy, çeşitli bilimsel hesaplamalar için özel araçlar sağlayan bir uzantı işlevi görür. Bu kursta, ihtiyaç duyuldukça SciPy içindeki belirli algoritmaları keşfedeceğiz. Tüm detayları ezberlemenize gerek yok; Karşılaştıkça ilgili algoritmaları tanıtacağım ve açıklayacağım.

Bununla, Python'da bilimsel hesaplama için NumPy ve SciPy hakkındaki tartışmamızı sonlandırıyoruz. Bir sonraki videoda güçlü bir plotlama kütüphanesi olan matplotlib'i keşfederek bilimsel hesaplama yolculuğumuza devam edeceğiz.

[MetaQuotes]

4.10 Matplotlib (L04: Python'da Bilimsel Hesaplama)

4.10 Matplotlib (L04: Python'da Bilimsel Hesaplama)

Nihayet oldukça uzun olan dördüncü dersin sonuna geldik. Ancak, umarım NumPy hakkında tartışılan kavramlar sizin için değerli olmuştur. Gelecekte, makine öğrenimi algoritmalarını uygulamak için ev ödevlerimizde NumPy'yi kapsamlı bir şekilde kullanacağız. Bu nedenle, bu noktada NumPy konusunda yetkin ve aşina olmanız çok önemlidir.

Dördüncü dersin son konusuna geçerek, Python için popüler bir komplo kütüphanesi olan matplotlib'i keşfedeceğiz. Günümüzde birçok çizim kütüphanesi olmasına rağmen, matplotlib en yaygın kullanılan kütüphane olmaya devam etmektedir. Şahsen benim de favori çizim kütüphanemdir ve ismi Metalab'dan esinlenmiştir. Matplotlib'in sözdizimi MATLAB'a oldukça benzer, bazı insanlar bunu takdir ederken diğerleri sevmez. Örneğin, yüksek lisans yaptığım süre boyunca MATLAB kullanmaktan hoşlanmadım, ancak matplotlib'i harika bir araç olarak görüyorum.

MATLAB hayranı olmasanız bile matplotlib'in kullanımının nispeten kolay olduğuna inanıyorum. Ayrıca, ek bir avantaj olan NumPy ile sorunsuz bir şekilde entegre olur. Öyleyse, matplotlib ile başlayalım. Kişisel olarak belirtmeliyim ki, matplotlib'de görevleri gerçekleştirmenin tüm özel yollarını ezberlemiyorum çünkü bu düşük seviyeli bir kütüphane. Bu, yüksek düzeyde özelleştirme seçenekleri sağladığı, ancak hepsinin sezgisel olmadığı anlamına gelir. Bu nedenle, sık sık kendimi bir şeyler ararken buluyorum. Spesifik bir şey yapmam gerektiğinde, çeşitli örneklerin sergilendiği matplotlib galerisini ziyaret ediyorum. Örneğin, bir gövde grafiği oluşturmak istersem, onu galeride ararım, örneği bulurum ve verilerime uyarlarım. Bu yaklaşım genellikle ihtiyaçlarım için yeterlidir. Bununla birlikte, daha ayrıntılı eğitimleri tercih ederseniz, matplotlib'in farklı yönleri hakkında açıklayıcı eğitimler sunan matplotlib.org web sitesini de keşfedebilirsiniz.

Başlangıç olarak, Jupyter Lab veya Jupyter Notebooks'ta matplotlib ile çalışırken, not defterinin içindeki çizimleri görüntülemek için satır içi işlevini kullanabilirsiniz. Bu, çizimlerin doğrudan not defterinde gösterileceği ve ayrı bir pencere ihtiyacını ortadan kaldıracağı anlamına gelir. Bunu başarmanın alternatif yolları olsa da, farklı bilgisayarlarda daha güvenilir olduğu için satır içi yaklaşımı kullanmanızı kişisel olarak tavsiye ederim. Satır içi modunu etkinleştirmek için şu sihirli komutu kullanabilirsiniz: %matplotlib inline. Alternatif olarak, olay örgüsü ifadelerinizin sonuna genellikle aynı sonucu veren bir noktalı virgül ekleyebilirsiniz. Ancak noktalı virgül hilesi bazı bilgisayarlarda iyi çalışmayabileceğinden çizimleri görüntülemek için plt.show() işlevinin kullanılması tavsiye edilir.

Şimdi matplotlib kullanarak bazı basit grafikler oluşturmaya başlayalım. Örneğin, bir sinüs eğrisi çizerek başlayabiliriz. Bunu yapmak için, sıfır ile on arasında değişen 100 değer oluşturmak için np.linspace işlevini kullanabilir ve ardından bu değerleri sinüs işlevi olan np.sin'e göre çizebiliriz. Çizim oluşturmanın en basit yolu, plt.plot işlevini kullanmaktır; burada plt, matplotlib.pyplot'un kısaltmasıdır. Sırasıyla x ekseni ve y ekseni için sınırları ayarlamak üzere plt.xlim ve plt.ylim işlevlerini kullanarak çizimin eksen aralıklarını ayarlayabiliriz. Ayrıca plt.xlabel ve plt.ylabel fonksiyonlarını kullanarak x eksenine ve y eksenine etiketler ekleyebiliriz. Son olarak, çizimi görüntülemek için plt.show() işlevini kullanabilir veya istenmeyen çıktıyı bastırmak için çizim ifadelerinin sonuna noktalı virgül ekleyebiliriz.

Tek bir çizime ek olarak, aynı şekil içinde birden fazla çizim de oluşturabiliriz. Örneğin, ayrı alt grafiklerde hem sinüs eğrisini hem de kosinüs eğrisini çizebiliriz. Bunu başarmak için, plt.subplots işlevini kullanarak iki şekil oluşturabilir ve ardından her bir alt grafikte ilgili sinüs ve kosinüs eğrilerini çizebiliriz. plt.subplots işlevi, her bir alt grafiği ayrı ayrı özelleştirmek için kullanabileceğimiz bir şekil nesnesi ve bir dizi eksen nesnesi döndürür.

Birden çok alt grafiğin oluşturulmasını gösteren örnek bir kod parçacığını burada bulabilirsiniz:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace( 0 , 10 , 100 )
y1 = np.sin(x)
y2 = np.cos(x)

fig, axs = plt.subplots( 2 , 1 )  # Create a figure with 2 subplots arranged vertically

# Plot the sine curve in the first subplot
axs[ 0 ].plot(x, y1)
axs[ 0 ].set_title( 'Sine Curve' )  # Set a title for the subplot
axs[ 0 ].set_xlabel( 'X' )
axs[ 0 ].set_ylabel( 'Y' )

# Plot the cosine curve in the second subplot
axs[ 1 ].plot(x, y2)
axs[ 1 ].set_title( 'Cosine Curve' )
axs[ 1 ].set_xlabel( 'X' )
axs[ 1 ].set_ylabel( 'Y' )

plt.tight_layout()  # Adjust the spacing between subplots for better readability
plt.show()  # Display the figure

Bu örnekte, dikey olarak düzenlenmiş 2 alt çizime (2, 1) sahip bir şekil oluşturmak için plt.subplots işlevini kullanıyoruz. İşlev, bir şekil nesnesi (şekil) ve belirtilen alt plan düzeniyle eşleşen boyutlara sahip bir eksen nesneleri ekseni dizisi döndürür. Axs dizisini indeksleyerek her bir alt plana erişebiliriz.

Alt plana özgü kod bloklarının içinde, ilgili eğrileri çizmek için çizim işlevini kullanırız ve ardından sırasıyla set_title, set_xlabel ve set_ylabel işlevlerini kullanarak her bir alt grafiğin başlığını, x ekseni etiketini ve y ekseni etiketini özelleştiririz.

Sıkı_layout işlevi, daha iyi okunabilirlik sağlamak için alt grafikler arasındaki boşluğu ayarlamak için çağrılır. Son olarak, alt grafikleri içeren şekli görüntülemek için plt.show()'u kullanırız.

Sinüs ve kosinüs eğrilerinin ayrı alt grafiklerde görüntülendiği sonucu görmek için bu kodu Jupyter Notebook veya Jupyter Lab ortamınızda çalıştırmayı deneyebilirsiniz.

Bu, alt planlar oluşturmanın yalnızca temel bir örneğidir ve çizimlerinizi daha bilgilendirici ve görsel olarak çekici hale getirmek için matplotlib'de çok daha fazla özelleştirme seçeneği mevcuttur. Daha fazla örnek ve ayrıntılı açıklama için matplotlib belgelerini ve galerisini inceleyebilirsiniz.

[MetaQuotes]

5.1 Tablo Metin Dosyasından Veri Kümesi Okuma (L05: Scikit-Learn ile Makine Öğrenimi)

5.1 Tablo Metin Dosyasından Veri Kümesi Okuma (L05: Scikit-Learn ile Makine Öğrenimi)

Herkese merhaba! Umarım hepiniz harika bir hafta geçirmişsinizdir ve tüm NumPy materyalleri üzerinde çalışma şansınız olmuştur. Bu hafta, scikit-learn ile veri işlemeye ve makine öğrenimine odaklanacağız, bu nedenle NumPy'yi iyi anlamak çok önemlidir. Kodlama pratiği yapmanın ve öğrendiğimiz kavramları gerçek hayattan örneklerde uygulamanın inanılmaz derecede yararlı olduğuna inanıyorum, bu nedenle bu derste önceden biraz kodlama yapacağız. Bu araçları yoğun bir şekilde kullandığımızda, sınıfta daha sonra bize fayda sağlayacaktır. Konu açılmışken, bu derse eklenecek başka bir şey yok, ilk büyük ev ödevini yüklediğim dışında, sizi daha önceki derslerde ele aldığımız kavramlar üzerinde, denetimli öğrenme ve NumPy kullanarak kod örnekleri de dahil olmak üzere test edecek. K-en yakın komşu algoritması ile uygulamalı deneyim kazanmak ve NumPy'yi keşfetmek ve daha fazlasını öğrenmek için harika bir fırsat.

Şimdi siz videolara dalıp, ödevleri tamamlayıp öz değerlendirme quizini çözerken ben de size biraz eğlenmenizi ve eğlenmenizi hatırlatmak istiyorum. En sevdiğim mevsim olan sonbahar burada Wisconsin'de yeni başladı ve daha soğuk havayı ve değişen yaprakların güzel renklerini seviyorum. Bu arada, gerçekten heyecanlıyım çünkü geçen hafta sonu bir balkabağı tarlasına gittim ve Cadılar Bayramı için oymak için sabırsızlandığım birkaç balkabağım oldu. Öyleyse derse başlayalım, böylece küçük balkabaklarıma geri dönebilir ve onları Cadılar Bayramı için hazırlayabilirim.

Pekala, artık hesaplama temelleri derslerinin üçüncü bölümüne ulaştık. Bu derste, geleneksel makine öğrenimi görevleri için en yaygın dosya formatı olan CSV dosyası gibi bir tablo şeklindeki metin dosyasından bir veri kümesini okumaya başlayarak birkaç konuyu ele alacağız. Ardından, makine öğrenimi algoritmaları ve eğitim prosedürleri için verilerin şekillendirilmesi de dahil olmak üzere temel veri işleme tekniklerini tartışacağız.

Ardından scikit-learn ile makine öğrenimine geçeceğiz. Ancak bunu yapmadan önce Python sınıflarını ve nesne yönelimli programlamayı kısaca özetlemek istiyorum. Daha önceki alıştırmalarda, kendinizi Python'a hazırlamanızı veya kavramlarını daha iyi anlamanızı istemiştim. Nesne yönelimli programlamayı iyi bir şekilde kavramak önemlidir çünkü scikit-learn büyük ölçüde buna dayanır. Bu nedenle, scikit-learn'ün nasıl çalıştığını anlamak için nesne yönelimli programlamayı anlamak gerekir.

İlerlerken, scikit-learn Transformatör API'sini kullanarak eğitim verilerini hazırlamayı tartışacağız. Ayrıca, veri seti hazırlama, ölçekleme, normalleştirme, boyut azaltma ve sınıflandırıcının kendisi gibi farklı işlemleri zincirlememize yardımcı olan scikit-learn ardışık düzenlerini tanımlamayı da ele alacağız. Ardışık düzenleri kullanarak, makine öğrenimi sürecinin çeşitli yönlerini birbirine bağlayan verimli eğitim iş akışları oluşturabilir ve işleri daha kolay hale getirebiliriz. Bu, scikit-learn'ün önemli güçlü yönlerinden biridir.

Bu ders için yine slayt kullanmaya karar verdim. Jupiter Lab harika bir araç olsa da, kod örneklerine bir kalem veya kurşun kalemle açıklama ekleyerek belirli kavramları açıklamayı daha kolay buluyorum. Bu yüzden, bu slaytlarda, ders sırasında açıklama yapacağım Jupiter Lab ve Jupiter Notebook'tan ekran görüntüleri yakaladım. Ancak, kod defterinin tamamını ek açıklamalar bulabileceğiniz GitHub'a da yükledim. Referansınız için bu belgeyi isteğe bağlı ders veya ders notları olarak düşünün.

Bu kursta nerede olduğumuzu hızlıca özetleyelim. Makine öğrenimine girişle başladık, temel bilgileri ele aldık ve scikit-learn'ün nasıl çalıştığını keşfettik. Ardından, NumPy ve bilimsel bilgi işlem hakkında bilgi edinerek Python'u derinlemesine inceledik. Artık scikit-learn ile veri işleme ve makine öğrenimi aşamasına geçiyoruz. Bir sonraki derste, karar ağaçları, topluluk yöntemleri ve model değerlendirme gibi temel makine öğrenimi kavramlarına geri döneceğiz. Bu hesaplama temelleri derslerinin son kısmı olmasına rağmen, bu dersin sonu olduğu anlamına gelmez. Hesaplamalı temeller derslerini tamamladıktan sonra, derin öğrenme ve sinir ağları da dahil olmak üzere makine öğreniminde daha ileri konulara geçeceğiz.

Şimdi, bu dersin ilk konusuna geçelim: tablolu bir metin dosyasından bir veri setinde okuma. Makine öğrenimi ile çalışırken, verilerin CSV (Virgülle Ayrılmış Değerler) dosyaları gibi tablo biçimlerinde saklanması yaygın bir durumdur. Bu dosyalar, her satırın bir örneği veya örneği temsil ettiği ve her sütunun bir özelliği veya niteliği temsil ettiği veri satırları ve sütunları içerir.

Python'da bir CSV dosyasında okumak için Pandas kitaplığını kullanabiliriz. Pandas, güçlü veri işleme ve analiz araçları sunarak onu Python'da tablo verileriyle çalışmak için popüler bir seçim haline getirir. Bir örneğe bakalım:

import pandas as pd

# Read the CSV file into a DataFrame
data = pd.read_csv( 'data.csv' )

# Display the first few rows of the DataFrame
print(data.head())

Bu örnekte, önce pandas kitaplığını içe aktarıyoruz ve kolaylık olması için onu pd olarak adlandırıyoruz. Ardından, data.csv CSV dosyasını Pandas tarafından sağlanan iki boyutlu bir tablo veri yapısı olan DataFrame'e okumak için read_csv() işlevini kullanırız. DataFrame, data değişkeninde saklanır.

Verileri okuduktan sonra, DataFrame'in ilk birkaç satırını görüntülemek için head() işlevini kullanabiliriz. Bu, verileri hızlı bir şekilde incelememizi ve doğru okunduğunu doğrulamamızı sağlar.

Pandas, verileri işlemek ve analiz etmek için çok çeşitli işlevler ve yöntemler sağlar. Satırları filtrelemek, sütunları seçmek, verileri birleştirmek ve çok daha fazlası gibi çeşitli işlemleri gerçekleştirebiliriz. Pandas konusunda yeniyseniz, belgelerini keşfetmenizi ve farklı işlemleri kendi başınıza denemenizi tavsiye ederim.

Artık verileri nasıl okuyacağımızı bildiğimize göre, bir sonraki konuya geçelim: temel veri işleme teknikleri. Makine öğrenimi için verilerle çalışırken, verileri uygun şekilde önceden işlemek ve hazırlamak çok önemlidir. Bu, eksik değerleri işleme, kategorik değişkenleri kodlama, sayısal özellikleri ölçeklendirme ve verileri eğitim ve test kümelerine bölme gibi görevleri içerir.

Yaygın bir ön işleme adımı, eksik değerlerin işlenmesidir. Eksik değerler genellikle verilerde NaN (Sayı Değil) veya NULL değerleri olarak temsil edilir. Bu eksik değerler, makine öğrenimi modellerini eğitirken sorunlara neden olabilir, bu nedenle bunları uygun şekilde ele almamız gerekir. Pandalar, eksik değerleri kontrol etmek için isna(), eksik değerleri belirli bir değerle doldurmak için fillna() ve eksik değerlere sahip satırları veya sütunları kaldırmak için dropna() gibi eksik değerleri işlemek için çeşitli işlevler sağlar.

Kategorik değişkenleri kodlamak bir diğer önemli adımdır. Makine öğrenimi modelleri tipik olarak sayısal verilerle çalışır, bu nedenle kategorik değişkenleri sayısal bir temsile dönüştürmemiz gerekir. Yaygın bir kodlama tekniği, her kategori için ikili sütunlar oluşturduğumuz ve bir kategorinin varlığını veya yokluğunu sırasıyla 1 veya 0 ile belirttiğimiz tek sıcak kodlamadır.

import pandas as pd

# Create a DataFrame with categorical variables
data = pd.DataFrame({ 'color' : [ 'red' , 'blue' , 'green' , 'red' , 'green' ]})

# Perform one-hot encoding
encoded_data = pd.get_dummies(data)

# Display the encoded data
print(encoded_data)

Bu örnekte, kategorik değişkenler içeren 'renk' sütunlu bir DataFrame oluşturuyoruz. Daha sonra tek seferlik kodlama gerçekleştirmek için Pandas'tan get_dummies() işlevini kullanırız. Ortaya çıkan kodlanmış veriler, orijinal 'renk' sütunundaki her benzersiz kategori için ikili sütunlar içerir.

Sayısal özellikleri ölçeklendirme, başka bir yaygın ön işleme adımıdır. Birçok makine öğrenimi algoritması, özelliklerin ölçeğine duyarlıdır. Özelliklerin farklı ölçeklere sahip olması modelin performansını etkileyebilir. Bunu ele almak için, özellikleri 0 ila 1 veya -1 ila 1 gibi standart bir aralığa ölçeklendirebiliriz. Pandas, özellik ölçeklendirmeyi gerçekleştirmek için sklearn.preprocessing modülünde MinMaxScaler ve StandardScaler sınıflarını sağlar.

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# Create a DataFrame with numerical features
data = pd.DataFrame({ 'age' : [ 25 , 30 , 35 , 40 ], 'income' : [ 50000 , 60000 , 70000 , 80000 ]})

# Perform feature scaling using MinMaxScaler
scaler = MinMaxScaler()
scaled_data = scaler.fit_transform(data)

# Convert the scaled data back to a DataFrame
scaled_df = pd.DataFrame(scaled_data, columns=data.columns)

# Display the scaled data
print(scaled_df)

Bu örnekte, iki sayısal özelliğe sahip bir DataFrame oluşturuyoruz: 'yaş' ve 'gelir'. Daha sonra özellik ölçeklendirmeyi gerçekleştirmek için sklearn.preprocessing modülündeki MinMaxScaler sınıfını kullanırız. fit_transform() yöntemi, verileri ölçeklendirir ve sonuçta ortaya çıkan ölçeklenmiş veriler, scaled_data değişkeninde bir NumPy dizisi olarak depolanır. Son olarak, ölçeklenmiş verileri tekrar bir DataFrame'e dönüştürüyoruz ve görüntülüyoruz.

Son olarak, verileri eğitim ve test kümelerine bölmek, makine öğrenimi modellerinin performansını değerlendirmek için çok önemlidir. Verileri genellikle iki kümeye ayırırız: modeli eğitmek için kullanılan bir eğitim seti ve performansını değerlendirmek için kullanılan bir test seti. Pandas, verileri eğitim ve test kümelerine bölmek için sklearn.model_selection modülünde train_test_split() işlevini sağlar.

import pandas as pd
from sklearn.model_selection import train_test_split

# Read the CSV file into a DataFrame
data = pd.read_csv( 'data.csv' )

# Split the data into features and labels
X = data.drop( 'label' , axis= 1 )
y = data[ 'label' ]

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2 , random_state= 42 )

Bu örnekte, önce 'data.csv' CSV dosyasını bir DataFrame'e okuyoruz. Ardından, verileri X özelliklerine ve y etiketlerine böleriz; burada X, "etiket" sütunu dışındaki tüm sütunları içerir ve y yalnızca "etiket" sütununu içerir.

Ardından, verileri eğitim ve test kümelerine bölmek için train_test_split() işlevini kullanırız. X özelliklerini ve y etiketlerini geçiyoruz, istenen test boyutunu belirtiyoruz (örn. %20'lik bir test seti için 0,2) ve yeniden üretilebilirlik için rastgele bir durum belirliyoruz.

Verileri böldükten sonra, eğitim setini (X_train ve y_train) makine öğrenimi modelimizi eğitmek ve test setindeki (X_test ve y_test) performansını değerlendirmek için kullanabiliriz.

Bunlar, Python'daki Pandas kitaplığı kullanılarak makine öğreniminde kullanılan bazı temel veri işleme teknikleridir. Veri ön işleme ve hazırlığının, makine öğrenimi ardışık düzeninde temel adımlar olduğunu ve projenizin özel gereksinimlerine bağlı olarak kullanılabilecek çok daha fazla teknik ve araç olduğunu unutmayın.

[MetaQuotes]

5.2 Temel veri işleme (L05: Scikit-Learn ile Makine Öğrenimi)

5.2 Temel veri işleme (L05: Scikit-Learn ile Makine Öğrenimi)

Bir önceki videoda tablo şeklindeki bir metin dosyasını veri kümesi olarak nasıl okuyacağımızı tartışmıştık. Spesifik olarak, bir CSV dosyasıyla ve daha spesifik olarak Iris veri kümesiyle çalışmaya odaklandık. Iris veri setini bir CSV dosyasından Pandas DataFrame'e aktardık.

Bu videoda, scikit-learn kullanarak verileri makine öğrenimi için uygun formatta hazırlamayı derinlemesine inceleyeceğiz. Verileri makine öğrenimi için uygun bir formata dönüştürmek için Pandas ve NumPy kullanarak temel veri işleme tekniklerini keşfedeceğiz. Ancak devam etmeden önce, bir Pandas DataFrame'de değerleri dönüştürmeyi tartışırken kullanışlı olacağından, Python işlevleri kavramını kısaca özetleyelim.

Burada "some_func" adında basit bir Python fonksiyonumuz var. Tek bir giriş bağımsız değişkeni olan "x"i alır ve onu bir dizgeye dönüştürür. Daha sonra, dönüştürülen değeri "hello world" sabit dizisiyle birleştirir. Giriş olarak 123 gibi bir tamsayı sağlarsak, bu bir dizeye ("123") dönüştürülecek ve "hello world" ile birleştirilerek son dize elde edilecektir. Bu, işlevin gövdesini gösteren iki nokta üst üste ve çıktıyı belirten bir dönüş ifadesi ile Python işlevlerinin nasıl çalıştığına dair temel bir genel bakıştır. İşlev içinde birden çok kod satırı olabilse de, dönüş ifadesi bitişi işaretler.

Bahsetmeye değer başka bir kavram da lambda fonksiyonlarıdır. Lambda işlevleri, küçük işlevleri açıkça adlandırmadan tanımlamanın kısa bir yoludur. Kod satırlarını kaydetmeye ve işlevleri hızlı bir şekilde yazmaya ihtiyaç duyulduğunda yaygın olarak kullanılırlar. Pandas sütunlarındaki veri dönüşümleri bağlamında, lambda işlevleri sıklıkla kullanılır. Lambda işlevleri daha özlü bir sözdizimi sunarken, esasen normal işlevlerle aynı işlemleri gerçekleştirirler. Bir Pandas DataFrame sütunundaki Apply yöntemiyle birleştirildiğinde özellikle yararlıdırlar.

Önceki derste, Iris veri setini CSV dosyasından bir Pandas DataFrame'e okuduk. Iris veri seti 150 satırdan oluşuyor, ancak kısa olması için yalnızca ilk beş satırı gösteriyoruz. Veri kümesi, zorunlu olmayan bir kimlik sütununu ve ardından X tasarım matrisi tarafından temsil edilen özellikleri içerir. Ayrıca, tipik olarak y olarak gösterilen sınıf etiketlerimiz de vardır. Geleneksel olarak, scikit-learn ve diğer kitaplıklar, dizi değişkenlerini sınıf etiketleri olarak işlemezdi, bu nedenle onları tamsayılara dönüştürmek yaygın bir uygulamaydı. Örneğin, "Iris setosa" 0 tamsayısına, "Iris versicolor" 1 tamsayısına ve "Iris virginica" 2 tamsayısına dönüştürülür. Birçok algoritma dize etiketleri yerine tamsayı sınıf etiketleriyle çalışacak şekilde tasarlandığından bu dönüştürme gerekliydi.

Ancak, scikit-learn artık çoğu işlevde dize sınıfı etiketlerini destekleyerek açık dönüştürme ihtiyacını ortadan kaldırıyor. Dahili olarak, dönüştürme otomatik olarak gerçekleştirilir. Bununla birlikte, bazı araçlar dize verilerini doğru işlemeyebilir, bu nedenle sınıf etiketlerini tamsayılara dönüştürmeniz önerilir. Bunu yaparak, çeşitli araçlarla uyumluluk sağlar ve hatalarla karşılaşma olasılığını azaltırsınız.

Dönüştürme sürecini göstermek için, uygulama yöntemiyle birlikte lambda işlevini kullanacağız. DataFrame'in türler sütununa bir lambda işlevi uygulayarak, string sınıfı etiketlerini tamsayı etiketlerine dönüştürebiliriz. Ancak, bir eşleme sözlüğü kullanmanın genellikle daha iyi bir yaklaşım olduğunu belirtmekte fayda var. Daha iyi okunabilirlik sağlar ve sınıf etiketi dönüşümlerinin daha kolay yorumlanmasına izin verir. Ek olarak, orijinal sınıf etiketlerini daha sonra almanız gerekirse, bir ters sözlük tanımlayabilir ve tamsayı etiketlerini orijinal dize gösterimlerine geri eşlemek için bunu kullanabilirsiniz.

Dönüşümü göstermek için veri kümesini orijinal durumuna yeniden yüklüyoruz. Daha sonra, aplikasyonu kullanmak yerine, eşleme sözlüğünü kullanarak dize etiketlerini tamsayılara dönüştürmek için harita işlevini kullanırız. Ayrıca, temel NumPy dizisine erişen değerler özniteliğinin kullanımını da gösteriyoruz. NumPy dizileriyle çalışma.

NumPy dizileriyle çalışmak birkaç nedenden dolayı faydalı olabilir. NumPy dizileri, Pandas DataFrame'lere kıyasla bellek açısından daha verimlidir ve bu da onları büyük veri kümeleri için ideal kılar. Ek olarak, scikit-learn'deki birçok makine öğrenimi algoritması, girdi verilerinin NumPy dizileri biçiminde olmasını bekler.

Pandas DataFrame'imizi NumPy dizilerine dönüştürmek için DataFrame'in değerler özniteliğine kolayca erişebiliriz. Bir örnek görelim:

import pandas as pd
import numpy as np

# Reload the Iris dataset
iris_df = pd.read_csv( 'iris.csv' )

# Convert the features (X) into a NumPy array
X = iris_df.drop([ 'species' ], axis= 1 ).values

# Convert the class labels (y) into a NumPy array
y = iris_df[ 'species' ].values

Bu örnekte, 'tür' sütununu kaldırmak ve özellikleri bir DataFrame olarak elde etmek için DataFrame'in drop yöntemini kullanıyoruz. Ardından, values özniteliğine erişerek, özellikleri bir NumPy dizisine dönüştürür ve X değişkenine atarız.

Benzer şekilde, [] indeksleme işlecini kullanarak DataFrame'in 'türler' sütununa erişir ve onu y değişkenine atayarak bir NumPy dizisine dönüştürürüz.

Şimdi, X değişkeni, bir NumPy dizisi olarak özellik matrisini içerir ve y değişkeni, bir NumPy dizisi olarak sınıf etiketlerini içerir. Bu dizileri çeşitli makine öğrenimi algoritmaları için girdi olarak kullanabiliriz.

Diyelim ki veri setimizi model değerlendirmesi için eğitim ve test setlerine ayırmak istiyoruz. Scikit-learn, bu görevi kolaylaştıran train_test_split adında bir yardımcı işlev sağlar. İşte bir örnek:

 from sklearn.model_selection import train_test_split

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.2 , random_state= 42 )

Bu örnekte, train_test_split işlevini sklearn.model_selection modülünden içe aktarıyoruz. X ve y dizilerini, test için ayrılacak veri kümesinin oranını (bu durumda, %20) belirten test_size parametresiyle birlikte işleve argüman olarak iletiyoruz. random_state parametresi, bölünmenin yeniden üretilebilirliğini sağlar.

train_test_split'i çağırdıktan sonra dört dizi elde ederiz: X_train ve y_train eğitim verilerini içerirken, X_test ve y_test test verilerini içerir.

Artık makine öğrenimi modelinizi eğitmek ve X_test ve y_test dizilerini kullanarak performansını değerlendirmek için X_train ve y_train dizilerini kullanabilirsiniz.

Özetle, Pandas DataFrame'i NumPy dizilerine dönüştürerek, NumPy'nin bellek verimliliği ve makine öğrenimi algoritmalarıyla uyumluluk gibi avantajlarından yararlanabiliriz. Ek olarak, scikit-learn, verileri eğitim ve test kümelerine bölmek için train_test_split gibi kullanışlı işlevler sağlar.

[MetaQuotes]

5.3 Nesne Yönelimli Programlama ve Python Sınıfları (L05: Scikit-Learn ile Makine Öğrenimi)

5.3 Nesne Yönelimli Programlama ve Python Sınıfları (L05: Scikit-Learn ile Makine Öğrenimi)

Bir sonraki derste scikit-learn ile makine öğrenimi konusuna girmeden önce, nesne yönelimli programlamayı, özellikle Python sınıflarını tartışalım. Scikit-learn büyük ölçüde nesne yönelimli programlama kavramlarına dayandığından, sınıfları anlamak oldukça alakalı olacaktır. Bu videonun sonuna doğru, scikit-learn'ün sınıflandırıcılar gibi tahmin edicileri uygulamak için kullandığı yaklaşım olan scikit-learn API'sini kullanarak K-en yakın komşuların uygulamasını göstereceğim.

Öyleyse, Python sınıflarını tartışarak başlayalım. Scikit-learn API'sini daha iyi anlamak için sınıfların temellerini anlamak önemlidir. Basit bir ifadeyle, bir sınıf, nesneler yaratmak için bir plan olarak düşünülebilir. Nesneler bir sınıfın örnekleridir ve kurabiye yapmak için kullanılan aynı kurabiye kalıbı şeklinin farklı varyasyonları olarak görselleştirilebilir. Çerezler, sınıftan oluşturulan nesneleri temsil ederken, sınıfın kendisi tanımlama bilgisi kesici şablonu görevi görür.

Python'da, class anahtar kelimesini ve ardından sınıf adını kullanarak bir sınıf tanımlarız. Sınıfın içinde farklı sınıf yöntemleri tanımlarız. Sınıf yöntemleri, işlevlere benzer, ancak self adında, nesnenin kendisini ifade eden zorunlu bir ilk bağımsız değişkene sahiptir. Bu öz argüman, nesnenin özniteliklerine ve yöntemlerine erişmemizi sağlar. Başka bir deyişle, nesnenin verileri ve davranışı ile etkileşime girmemizi sağlar.

Araç örneği bağlamında, basit, naif bir araç sınıfını ele alalım. Bu sınıf, arabalar, motosikletler veya kamyonlar gibi farklı araç türlerini temsil eder. Sınıfın davranışını tanımlamak için çeşitli yöntemleri vardır. İlk yöntem, yapıcı olarak da bilinen __init__ yöntemidir. Bu yöntem, sınıftan yeni bir nesne oluşturulduğunda otomatik olarak yürütülür. Self bağımsız değişkenini ve nesneyi başlatmak için gereken ek bağımsız değişkenleri kabul eder.

__init__ yönteminde, argüman olarak sağlanan değerin atandığı beygir gücü adı verilen bir öznitelik tanımlarız. Bu özellik, aracın beygir gücünü temsil eder. Yeni bir nesne oluşturulduğunda, beygir gücü değerini almak için erişilebilen bir beygir gücü özniteliğine sahip olacaktır.

__init__ yöntemine ek olarak, nesnenin özniteliklerini değiştiren başka yöntemler de tanımlayabiliriz. Örneğin, tune_motor yöntemi, bir motor ayarını simüle ederek aracın beygir gücü özelliğini iki katına çıkarır. Araç nesnesinde bu yöntemi çağırarak, beygir gücü özelliği buna göre değiştirilecektir.

Ayrıca, nesnenin niteliklerine göre değer döndüren yöntemler tanımlayabiliriz. Örnekte, beygir gücü_to_torque yöntemi, nesnenin beygir gücüne ve sağlanan RPM değerine göre tork değerini hesaplar. Bu yöntem, hesaplamaları gerçekleştirmek ve yararlı sonuçlar döndürmek için nesnenin özniteliklerinin nasıl kullanılabileceğini gösterir.

Python'da yöntemlerin görünürlüğünü belirtmek için kurallar olduğunu belirtmekte fayda var. _private_method gibi tek bir alt çizgi öneki olan yöntemler özel kabul edilir ve sınıfın kullanıcıları tarafından doğrudan kullanılması amaçlanmamıştır. Ancak, genellikle tavsiye edilmese de, kullanıcılar yine de bu yöntemlere erişebilir ve bu yöntemleri çağırabilir. __very_private_method gibi çift alt çizgi öneki olan yöntemler daha da kısıtlıdır ve bunlara erişmek için belirli bir sözdizimi gerektirir.

Ek olarak Python, sınıf kalıtımını destekler ve bir üst sınıftan özellikleri ve yöntemleri miras alan alt sınıflar oluşturmamıza izin verir. Bu kavram, üst sınıfta tanımlanan mevcut işlevsellikten yararlanırken ek özniteliklere ve davranışlara sahip özel sınıflar oluşturmamızı sağlar. Örneğin, Araç sınıfından miras alan ve özellikle arabalar için bir tekerlek_sayısı özelliği ekleyen özel bir Araba sınıfı oluşturabiliriz.

Tartışılan kavramları göstermek için, bir K-en yakın komşu sınıflandırıcı örneği verilmiştir. Bu uygulama, scikit-learn API kurallarını izler ve scikit-learn'de bir tahmin edici sınıfın kullanımını gösterir. İşte basitleştirilmiş bir uygulama:

 class KNNClassifier:

    def __init__( self , k):
         self .k = k
         self .X_train = None
         self .y_train = None
    
    def fit( self , X_train, y_train):
         self .X_train = X_train
         self .y_train = y_train
    
    def predict( self , X_test):
        predictions = []
         for x in X_test:
            distances = []
             for i, x_train in enumerate( self .X_train):
                distance = self ._calculate_distance(x, x_train)
                distances.append((distance, self .y_train[i]))
            distances.sort()
            k_nearest = distances[: self .k]
            prediction = self ._majority_vote(k_nearest)
            predictions.append(prediction)
         return predictions
    
    def _calculate_distance( self , x1, x2):
         # Calculate the distance between two data points
         # (e.g., Euclidean distance)
        pass
    
    def _majority_vote( self , neighbors):
         # Determine the majority class among the nearest neighbors
        pass

Bu örnekte KNNClassifier, K-en yakın komşu sınıflandırıcısını temsil eden bir sınıftır. Yapıcı, dikkate alınacak en yakın komşuların sayısını belirten bir k parametresi alır.

Sınıflandırıcıyı eğitmek için fit yöntemi kullanılır. İki argüman alır: X_train (eğitim verileri) ve y_train (karşılık gelen etiketler). Yöntem, eğitim verilerini ve etiketleri daha sonra kullanmak üzere nesnenin niteliklerinde saklar.

Tahmin yöntemi, yeni veriler üzerinde tahminler yapmak için kullanılır. X_test'i (test verileri) bağımsız değişken olarak alır ve test verileri için tahmin edilen etiketleri döndürür. Yöntem, X_test'teki her veri noktası için, _calculate_distance yöntemini kullanarak eğitim kümesindeki tüm veri noktalarına olan mesafeleri hesaplar. Daha sonra k en yakın komşuyu seçer ve _majority_vote yöntemini kullanarak çoğunluk sınıfını belirler. Tahmin edilen etiket, tahminler listesine eklenir.

_calculate_distance yöntemi, iki veri noktası arasındaki mesafeyi hesaplayan özel bir yöntemdir (baştaki alt çizgi ile gösterilir). Bu, Öklid uzaklığı veya soruna uygun başka herhangi bir uzaklık ölçüsü olabilir.

_majority_vote yöntemi, bir dizi komşu arasında çoğunluk sınıfını belirleyen başka bir özel yöntemdir. Bu, her bir sınıf etiketinin oluşumlarını sayarak ve en yüksek sayıya sahip etiketi seçerek yapılabilir.

Bu örnek, scikit-learn'deki bir tahminci sınıfının temel yapısını gösterir. Elbette scikit-learn, KNeighborsClassifier sınıfındaki K-en yakın komşuların daha sofistike ve optimize edilmiş bir uygulamasını sağlar, ancak bu basitleştirilmiş sürüm, temel ilkeleri gösterir.