Algoritmik ticarette Python - sayfa 22
Alım-satım fırsatlarını kaçırıyorsunuz:
- Ücretsiz alım-satım uygulamaları
- İşlem kopyalama için 8.000'den fazla sinyal
- Finansal piyasaları keşfetmek için ekonomik haberler
Kayıt
Giriş yap
Gizlilik ve Veri Koruma Politikasını ve MQL5.com Kullanım Şartlarını kabul edersiniz
Hesabınız yoksa, lütfen kaydolun
matplotlib ile 1 Saatte Veri Görselleştirme
matplotlib ile 1 Saatte Veri Görselleştirme
Bu videoda eğitmen, makine öğreniminde veri görselleştirmenin önemini tanıtıyor ve bunun toplanan büyük miktarda veriyi anlamlandırmaya nasıl yardımcı olabileceğini açıklıyor. Veri görselleştirme için iki temel Python kitaplığı olan Matplotlib ve Seaborn kursta ele alınmaktadır.
Eğitmen, kursun öncelikle Python öğrenmek isteyen makine öğrenimi mühendisleri, veri mühendisleri ve veri bilimcileri için tasarlandığını belirtiyor. Matplotlib'in kullanımını göstermek için, bir eğri çizmenin basit bir örneği verilmiştir. Matplotlib'in felsefesi, makine öğrenimi modelleri oluşturmak ve verileri işlemek için standart haline gelen mevcut dil Python'dan yararlanma etrafında döner. Matplotlib'i diğer Python paketleriyle birleştirerek, kullanıcılar çeşitli görevler için mevcut olan çok sayıda paketten yararlanabilirler.
Video, bilimsel bilgi işlem için Matplotlib ile birlikte NumPy paketini kullanmanın önemini vurguluyor. Matplotlib, NumPy olmadan çalışabilirken, NumPy'yi kullanmak zamandan ve emekten önemli ölçüde tasarruf sağlayabilir. NumPy, güçlü bir çok boyutlu dizi nesnesi sağlar ve onu işlemek için işlev görür. Videoda, x ve y koordinatlarını hesaplamak için NumPy kullanılarak 100 noktalı bir eğrinin oluşturulduğu bir örnek gösterilmektedir. Bu yaklaşım, işlemi saf Python kullanarak gerçekleştirmekten çok daha hızlı olduğunu kanıtlıyor. Ek olarak video, karşılaştırma için aynı grafik üzerinde iki eğri çizmeyi, Python kodunu kullanarak verileri ayıklayıp düzenleyerek bir dosyadan verileri çizmeyi ve doğrusal bir şekilde öğeler yerine noktaları çizmeyi kapsar.
Öğretici, Matplotlib kitaplığını kullanarak farklı türde çubuk grafikler oluşturmayı ele alıyor. Her çubuk için x koordinatını ve her çubuğun yüksekliğini giriş parametreleri olarak alan, çubuk grafikler oluşturmak için özel işlev olan "çubuk" tanıtıldı. Kullanıcılar isteğe bağlı parametreleri ayarlayarak çeşitli efektler oluşturabilir ve hatta "barh" işlevini kullanarak yatay çubuklar oluşturabilir. Öğretici aynı zamanda birden çok çubuk grafiğin aynı grafik üzerinde çizilmesini ve "çubuk" işlevinde özel bir parametre kullanılarak yığılmış çubuklar oluşturulmasını da kapsar. Ayrıca video, "pasta" işlevini kullanarak pasta grafikler oluşturmaya kısaca değiniyor.
Matplotlib ile veri görselleştirmede kullanılan çeşitli fonksiyonlar öğreticide açıklanmıştır. Ele alınan ilk işlev, olasılık dağılımlarının grafiksel temsilleri olan histogramlardır. "Hist" işlevi ve parametreleri tartışılarak, kullanıcıların verileri kolayca histogram olarak çizmesine olanak sağlanır. Kapsanan ikinci işlev, değer dağılımlarının karşılaştırılmasını kolaylaştıran kutu çizimleridir. Video, bir veri kümesinin çeyrekler, medyan, ortalama ve istatistiksel miktarları dahil olmak üzere bir kutu grafiğinin bileşenlerini açıklar ve bunların "kutu grafiği" işlevini kullanarak nasıl oluşturulacağını gösterir. Son olarak, öğretici, üçüzler, dörtlüler veya HTML renk adlarını kullanarak renkleri tanımlamanın yanı sıra bir eğri grafiğinin rengini ayarlamak gibi farklı renkler ve stiller kullanarak çizimleri değiştirmeyi kapsar.
Video, "color" parametresini kullanarak dağılım grafiklerine, çubuk grafiklere ve pasta grafiklere nasıl renk ekleneceğini açıklayarak devam ediyor. Bu parametre, kullanıcıların tek tek nokta renklerini kontrol etmesini veya tüm noktalar için ortak rengi değiştirmesini sağlar. Video ayrıca kitaplıkların modüller olarak içe aktarılmasına, daha kolay kodlama için takma adların kullanılmasına ve değişkenlerin gösteriminin açıklığa kavuşturulmasına değiniyor. Matplotlib ve Python'daki hemen hemen her şeyin "pi" işlevi ve "göster" işlevi gibi işlevleri içerdiği vurgulanmaktadır.
Sonraki eğitim, kutu çizimleri, işaretçiler ve çizgi şekilleri oluştururken özel renk şemalarını ve çizgi desenlerini kapsar. Önceden tanımlanmış şekiller kullanarak özel işaretçiler oluşturmayı ve matematik metin sembollerini kullanarak özel işaretler tanımlamayı gösterir. Ek olarak, merkezi yapılandırma nesnesini kullanarak Matplotlib'in varsayılan ayarlarının nasıl kolayca değiştirilebileceğini açıklayarak, kullanıcıların siyah bir arka plana ve beyaz notlara sahip olmak gibi görsel stili farklı kullanım bağlamlarına uyarlamasını sağlar.
Sunucu, Matplotlib'deki "savefig" işlevini kullanarak bir grafiğin bir dosyaya nasıl kaydedileceğini açıklar. Ayrıca bir grafiğe bir başlık, x ve y eksenleri için etiketler, sınırlı bir kutu ve oklar dahil olmak üzere ek açıklamalar eklemeyi de kapsar. Video, grafiğin görsel netliğini ve anlaşılmasını geliştirmek için bu ek açıklamaları ekleme sürecini gösterir. Ayrıca, hassas ayarlamalar için Matplotlib'de işaret aralığının manuel olarak nasıl kontrol edileceğini gösterir. Video, grafiklere açıklama eklemek ve bunları okuyucular için daha açıklayıcı hale getirmek için Matplotlib'de bulunan çeşitli işlevleri vurgulamaktadır.
Eğitmen devam ederken, Matplotlib ile veri görselleştirmeyi tartışıyor ve Matplotlib'e üst düzey bir arayüz olan Seaborn'u tanıtıyor. Seaborn, Matplotlib'e kıyasla farklı parametreler ve işlevler sağlar. Eğitmen, Seaborn'un yerleşik veri kümesini ve renkli haritalarını kullanarak görselleştirmelerin nasıl oluşturulacağını gösterir. Video, bir faktör grafiği oluşturma ve verileri çizmek için renkli haritaları kullanma örnekleri sunarak sona eriyor. Bu örnekler aracılığıyla izleyiciler, veri görselleştirme becerilerini geliştirmek için Matplotlib ve Seaborn'daki farklı işlevleri ve araçları kullanma konusunda içgörü kazanır.
Video, Seaborn'un "set_context" işlevini kullanarak grafiklerin nasıl ölçeklendirileceğini açıklıyor. Bu işlev, kullanıcıların çizimin görüntüleneceği bağlama dayalı olarak boyut gibi çizim öğelerini kontrol etmesine olanak tanır. Ardından, Seaborn'un iki tür işlevi arasındaki farkı açıklığa kavuşturur: eksen düzeyi işlevler ve şekil düzeyi işlevler. Eksen düzeyindeki işlevler, eksen düzeyinde çalışır ve eksen nesnesini döndürürken, şekil düzeyindeki işlevler, anlamlı bir şekilde düzenlenmiş eksenleri içeren grafikler oluşturur. Son olarak, video, Matplotlib eksen alt çizimleri nesnesini kullanarak bir kutu çizimi için eksenleri ayarlama konusunda rehberlik sağlar.
Bu kapsamlı video eğitimi, Matplotlib ve Seaborn ile veri görselleştirme ile ilgili çok çeşitli konuları kapsar. Makine öğreniminde veri görselleştirmenin önemini ve Matplotlib'in güçlü bir kitaplık olarak kullanımını tanıtarak başlar. Eğrileri çizmeyi, çubuk grafikler oluşturmayı, histogramlar ve kutu çizimleri oluşturmayı ve renkleri, işaretçileri ve çizgi stillerini özelleştirmeyi gösterir. Öğretici ayrıca grafikleri kaydetmeyi, ek açıklamalar eklemeyi ve işaret aralığını değiştirmeyi de kapsar. Ek olarak, kendi özellikleri ve işlevleriyle alternatif bir görselleştirme aracı olarak Seaborn'u sunar. İzleyiciler bu öğreticiyi izleyerek veri görselleştirme becerilerini geliştirebilir ve bu güçlü Python kitaplıklarını kullanarak bulgularını etkili bir şekilde iletebilir.
Python, TensorFlow ve Keras ile Derin Öğrenme öğreticisi
Python, TensorFlow ve Keras ile Derin Öğrenme öğreticisi
Herkese selamlar ve derin öğrenme ve TensorFlow ile Python hakkında merakla beklenen bir güncellemenin yanı sıra yeni bir Kaos öğreticisine hoş geldiniz. Python'da temel derin öğrenmeyi en son ele aldığımdan bu yana iki yıldan fazla zaman geçti ve bu süre zarfında önemli ilerlemeler oldu. Derin öğrenmeye başlamak ve derin öğrenme modelleriyle çalışmak çok daha basit ve daha erişilebilir hale geldi.
Alt düzey TensorFlow kodunu ve karmaşık ayrıntıları araştırmakla ilgileniyorsanız, yine de eski videoya başvurabilirsiniz. Ancak, derin öğrenmeye başlamayı hedefliyorsanız artık bunu yapmanıza gerek yok çünkü artık Chaos gibi TensorFlow'un üzerinde oturan kullanıcı dostu üst düzey API'lere sahibiz. Bu API'ler, derin öğrenmeyi inanılmaz derecede basit hale getirerek, önceden derin öğrenme bilgisi olmayan herkesin takip etmesini sağlar.
Bu eğitimde, sinir ağlarını hızlı bir şekilde gözden geçireceğiz. Başlamak için, bir sinir ağının temel bileşenlerini anlayalım. Sinir ağları da dahil olmak üzere herhangi bir makine öğrenimi modelinin birincil amacı, girdileri çıktılara eşlemektir. Örneğin, X1, X2 ve X3 girdileri verildiğinde, çıktının bir köpeğe mi yoksa bir kediye mi karşılık geldiğini belirlemeyi amaçlıyoruz. Bu durumda çıktı katmanı, köpek ya da kedi olma olasılığını temsil eden iki nörondan oluşur.
Bu eşlemeyi elde etmek için, her girişin, X1, X2 ve X3'ün gizli katmandaki nöronlara bağlı olduğu tek bir gizli katman kullanabiliriz. Bu bağlantıların her biri, kendisiyle ilişkili benzersiz bir ağırlığa sahiptir. Ancak kendimizi tek bir gizli katmanla sınırlandırırsak, girdiler ve çıktılar arasındaki ilişkiler doğrusal olacaktır. Karmaşık problemlerde yaygın olan doğrusal olmayan ilişkileri yakalamak için iki veya daha fazla gizli katmana ihtiyacımız var. İki veya daha fazla gizli katmana sahip bir sinir ağına genellikle derin sinir ağı denir.
Bir önceki katmana tamamen bağlayarak başka bir gizli katman ekleyelim. Katmanlar arasındaki her bağlantının kendine özgü ağırlığı vardır. Sonuç olarak çıktı, çıktı katmanına olan her bağlantının benzersiz bir ağırlığa sahip olduğu son katmandan türetilir. Tek bir nöron düzeyinde, nöron, girdi katmanı değerleri (X1, X2, X3) veya diğer nöronlardan gelen girdiler olabilen girdileri alır. Bu girdiler, ilişkili ağırlıkları dikkate alınarak toplanır. Ek olarak, nöronun ateşlenip ateşlenmediğini simüle etmek için bir aktivasyon fonksiyonu uygulanır. Yaygın aktivasyon fonksiyonları, 0 ile 1 arasında değerler döndüren adım fonksiyonunu veya sigmoid fonksiyonunu içerir. Sinir ağımızda, çıktı katmanı, her sınıfa (köpek veya kedi) olasılıklar atayan bir sigmoid aktivasyon fonksiyonu kullanır. Ardından Arg max işlevi, en yüksek olasılığa dayalı olarak tahmin edilen sınıfı belirlemek için kullanılır.
Artık nöral ağlar hakkında temel bir anlayışa sahip olduğumuza göre, TensorFlow kullanarak bir tane oluşturmaya geçelim. Öncelikle, "pip install --upgrade tensorflow" komutunu çalıştırarak TensorFlow'un kurulu olduğundan emin olun. TensorFlow'u "tf" olarak içe aktarabilir ve "tf.version" kullanarak mevcut sürümü kontrol edebilirsiniz. Bu eğitim için Python 3.6 veya üstü önerilir, ancak TensorFlow'un gelecekte Python 3.7 ve sonraki sürümleri desteklemesi beklenir.
Ardından, çalışmak için bir veri kümesini içe aktaracağız. 0 ile 9 arasında değişen el yazısıyla yazılmış rakamların 28x28 görüntüsünden oluşan MNIST veri setini kullanacağız. Bu görüntüler sinir ağına beslenecek ve ağ karşılık gelen basamağı tahmin edecek. Veri setini eğitim ve test değişkenlerine ayıracağız: X_train, Y_train, X_test ve Y_test.
Daha iyi performans sağlamak için verileri normalleştireceğiz. Görüntülerin piksel değerleri şu anda 0 ile 255 arasında değişmektedir, bu nedenle TF.keras.utils.normalize işlevini kullanarak bunları 0 ile 1 arasında ölçeklendireceğiz.
Modeli oluşturmak için, TensorFlow'da sinir ağları oluşturma ve eğitme sürecini basitleştiren üst düzey API Chaos'u kullanacağız. Kaos, katmanları birbiri ardına istiflememize izin veren Sequential adlı sıralı bir model sağlar.
Kaos'u kullanarak bir sinir ağı modelini nasıl oluşturabileceğinize dair bir örnek:
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
# Create a sequential model
model = Sequential()
# Add a flatten layer to convert the input into a 1D array
model.add(Flatten(input_shape=(28, 28)))
# Add a dense layer with 128 neurons and ReLU activation
model.add(Dense(128, activation='relu'))
# Add another dense layer with 10 neurons for the output and softmax activation
model.add(Dense(10, activation='softmax'))
# Compile the model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
Yukarıdaki kodda, gerekli modülleri TensorFlow ve Chaos'tan içe aktarıyoruz. Sıralı bir model oluşturuyoruz ve add yöntemini kullanarak ona katmanlar ekliyoruz. İlk katman, 2B girişi (28x28 görüntüler) 1B dizisine dönüştüren Düzleştir katmanıdır. Daha sonra 128 nöron ve ReLU aktivasyonu ile yoğun bir katman ekliyoruz. Son olarak, 10 nöronlu (10 haneye karşılık gelen) ve softmax aktivasyonu olan bir çıktı katmanı ekliyoruz.
Modeli tanımladıktan sonra derleme yöntemini kullanarak derliyoruz. İyileştiriciyi (bu durumda 'adam'), kayıp işlevini (çok sınıflı sınıflandırma için 'sparse_categorical_crossentropy') ve eğitim sırasında değerlendirilecek metrikleri belirtiyoruz.
Artık modelimizi tanımlayıp derlediğimize göre, onu MNIST veri kümesi üzerinde eğitmeye devam edebiliriz. Modeli eğitmek için fit yöntemini kullanacağız.
# Train the model model.fit(X_train, Y_train, epochs= 10 , validation_data=(X_test, Y_test))
Yukarıdaki kodda, eğitim verilerini (X_train ve Y_train), eğitilecek çağ sayısı ile birlikte fit yöntemine iletiyoruz. Eğitim sırasında modelin görünmeyen veriler üzerindeki performansını değerlendirmek için doğrulama verilerini (X_test ve Y_test) de sağlıyoruz.
Modeli eğittikten sonra, tahmin yöntemini kullanarak tahminler yapabiliriz:
# Make predictions predictions = model.predict(X_test)
Yukarıdaki kodda, test verilerini (X_test) tahmin yöntemine iletiyoruz ve her sınıf için tahmin edilen olasılıkları döndürüyor.
Bu, TensorFlow'da Kaos kullanarak bir sinir ağı oluşturmaya ve eğitmeye kısa bir genel bakıştır. Modelinizi özelleştirmek için farklı katmanları, etkinleştirme işlevlerini, optimize edicileri ve diğer parametreleri daha fazla keşfedebilirsiniz.
sinir ağları oluşturmak ve eğitmekle ilgili ek teknikler ve kavramlar.
Düzenlileştirme Teknikleri:
Bırakma: Bırakma, fazla uydurmayı önlemek için kullanılan bir düzenlileştirme tekniğidir. Eğitim sırasında her güncellemede girdi birimlerinin bir kısmını rasgele 0'a ayarlar, bu da modelin herhangi bir özel özellik grubuna çok fazla dayanmasını önlemeye yardımcı olur.
L1 ve L2 Düzenlileştirme: L1 ve L2 düzenlileştirme, ağda büyük ağırlıkları önlemek için kayıp fonksiyonuna bir ceza eklemek için kullanılan tekniklerdir. L1 düzenlemesi ağırlıkların mutlak değerini kayıp fonksiyonuna ekleyerek seyrekliği teşvik ederken, L2 düzenlemesi ağırlıkların karesini kayıp fonksiyonuna ekleyerek küçük ağırlıkları teşvik eder.
Gelişmiş Etkinleştirme İşlevleri:
Leaky ReLU: Leaky ReLU, negatif girdiler için küçük bir eğime izin vererek "ölmekte olan ReLU" problemini çözen bir aktivasyon fonksiyonudur. Girdi negatif olduğunda, eğitim sırasında nöronların ölmesini önlemeye yardımcı olan küçük bir negatif eğim sunar.
Üstel Doğrusal Birim (ELU): ELU, negatif girişler için çıkışı yumuşatan ve aktivasyonun negatif değerler almasına izin veren bir aktivasyon fonksiyonudur. Sinir ağlarının öğrenilmesini geliştirmeye ve pozitif değerlere yönelik önyargıyı azaltmaya yardımcı olduğu gösterilmiştir.
Swish: Swish, lineer ve sigmoid fonksiyonlar arasında pürüzsüz enterpolasyon gerçekleştiren bir aktivasyon fonksiyonudur. Bazı durumlarda ReLU ve sigmoid gibi diğer aktivasyon fonksiyonlarına göre daha iyi sonuçlar verdiği gösterilmiştir.
Transfer Öğrenimi: Transfer öğrenimi, yeni görevleri çözmek veya bir modelin ilgili görevdeki performansını iyileştirmek için önceden eğitilmiş modellerden yararlanan bir tekniktir. Bir modeli sıfırdan eğitmek yerine, önceden eğitilmiş bir modeli başlangıç noktası olarak kullanabilir ve belirli görevinize veya veri kümenize göre ince ayar yapabilirsiniz. Bu, özellikle belirli göreviniz için sınırlı verileriniz olduğunda kullanışlıdır.
Hiperparametre Ayarı: Hiperparametreler, model tarafından öğrenilmeyen ancak öğrenme sürecini etkileyen, öğrenme hızı, yığın boyutu, katman sayısı vb. parametrelerdir. Bu hiperparametrelerin ayarlanması, modelin performansını önemli ölçüde etkileyebilir. Izgara arama, rastgele arama ve Bayes optimizasyonu gibi teknikler, hiperparametre uzayını sistematik olarak aramak ve en iyi kombinasyonu bulmak için kullanılabilir.
Model Değerlendirme: Bir modelin performansını değerlendirmek, etkinliğini değerlendirmek için çok önemlidir. Sınıflandırma görevleri için ortak değerlendirme ölçütleri arasında doğruluk, kesinlik, geri çağırma, F1 puanı ve alıcı çalışma karakteristik eğrisinin (ROC AUC) altındaki alan yer alır. Eldeki soruna ve verilerin doğasına göre uygun ölçümleri seçmek önemlidir.
Dengesiz Veri Kümelerini İşleme: Dengesiz veri kümeleri, sınıfların dağılımı eşit olmadığında ortaya çıkar ve bu da yanlı modellere yol açabilir. Azınlık sınıfını yüksek örnekleme, çoğunluk sınıfını alt örnekleme veya her ikisinin bir kombinasyonunu kullanma gibi teknikler bu sorunun çözülmesine yardımcı olabilir. Ek olarak, kesinlik, hatırlama ve F1 puanı gibi değerlendirme ölçütlerinin kullanılması, modelin dengesiz veri kümeleri üzerindeki performansının daha iyi anlaşılmasını sağlayabilir.
Unutmayın, sinir ağlarını oluşturmak ve eğitmek yinelemeli bir süreçtir. İstenen sonuçları elde etmek için deneme, ince ayar ve sürekli iyileştirmeyi içerir.
Kendi verilerinizi yükleme - Python, TensorFlow ve Keras ile Derin Öğrenmenin temelleri s.2
Kendi verilerinizi yükleme - Python, TensorFlow ve Keras ile Derin Öğrenmenin temelleri s.2
Karros'ta Python TensorFlow ile ilgili derin öğrenme eğitimimizin 2. bölümüne hoş geldiniz. Bu öğreticide, harici bir veri kümesi yüklemeye odaklanacağız. Özellikle, başlangıçta bir Kaggle denemesi olan Microsoft'un kediler ve köpekler veri kümesini kullanacağız. Amaç, bir görüntünün bir kedi mi yoksa bir köpek mi içerdiğini belirlemek için bir sinir ağı eğitmektir.
Başlamak için lütfen Microsoft'tan kediler ve köpekler veri kümesini indirin. Veri setini indirip çıkardıktan sonra iki dizin görmelisiniz: "cat" ve "dog". Bu dizinler sırasıyla kedi ve köpek resimlerini içerir. Her dizin, modelimizi eğitmek için bol miktarda örnek sağlayan, yaklaşık 12.500 gibi önemli sayıda örneğe sahip olmalıdır.
Şimdi kodlama kısmına geçelim. Birkaç kitaplığı içe aktarmamız gerekiyor: np olarak numpy, plt olarak matplotlib.pyplot ve cv2 olarak OpenCV. Bu kitaplıklar kurulu değilse, bunları yüklemek için pip'i kullanabilirsiniz.
Ardından, veri setimizin bulunduğu veri dizinini tanımlayacağız. Veri kümenizin yolunu buna göre belirleyebilirsiniz. Ayrıca kategorileri veri setimizdeki dizinlerle eşleşecek şekilde "köpek" ve "kedi" olarak tanımlayacağız.
İşletim sistemi kitaplığını kullanarak her bir kategoriyi ve karşılık gelen görüntüleri yineleyeceğiz. Her görüntü için cv2 kitaplığını kullanarak onu gri tonlamaya dönüştüreceğiz. Gri tonlamayı seçtik çünkü bu özel görevde kedileri ve köpekleri ayırt etmek için rengin çok önemli olmadığına inanıyoruz.
Görüntüleri görselleştirmek için matplotlib.pyplot kullanacağız. plt.imshow ve gri tonlamalı renk haritasını kullanarak örnek bir resim göstereceğiz. Bu adım, resimlerin doğru şekilde yüklendiğini doğrulamamızı sağlar.
Görüntüleri doğruladıktan sonra, onları tek tip bir şekle yeniden boyutlandırmaya devam edeceğiz. Tutarlılığı sağlamak için 50x50 piksel gibi bir hedef boyuta karar vermemiz gerekiyor. cv2.resize işlevini kullanarak görüntüleri yeniden boyutlandıracağız ve yeniden boyutlandırılan görüntü dizilerini saklayacağız.
Şimdi eğitim veri setini oluşturacağız. "training_data" adlı boş bir liste başlatıyoruz ve "create_training_data" adlı bir işlev tanımlıyoruz. Bu işlev içinde, "kategoriler" listesindeki kategorinin dizinini kullanarak görüntüleri yineliyoruz ve sayısal etiketler (köpekler için 0, kediler için 1) atayıyoruz.
Her görüntü için, onu seçilen hedef boyuta göre yeniden boyutlandırıyoruz. Yeniden boyutlandırılan görüntü dizisini ve buna karşılık gelen etiketi training_data listesine ekleriz. Veri kümesindeki bozuk görüntülerle ilgili olası istisnaları da ele alıyoruz.
Eğitim veri setini oluşturduktan sonra, verilerin dengesini kontrol etmeliyiz. Bunun gibi bir ikili sınıflandırma görevinde, her sınıf için eşit sayıda örneğe sahip olmak önemlidir (%50 köpek ve %50 kedi). Dengesiz veriler, taraflı model tahminlerine yol açabilir. Verileriniz dengesizse, bu sorunu azaltmak için eğitim sırasında sınıf ağırlıklarını kullanabilirsiniz.
Rasgeleliği sağlamak ve modelin görüntülerin sırasını öğrenmesini önlemek için, eğitim verilerini random.shuffle işlevini kullanarak karıştırırız.
Artık verilerimiz karıştırıldığına göre, onu özellikler (X) ve etiketler (Y) için değişkenler halinde paketleyebiliriz. X ve Y için boş listeleri başlatıyoruz ve özellikleri ve etiketleri ilgili listelere ekleyerek eğitim verilerini yineliyoruz. Son olarak, X'i bir NumPy dizisine dönüştürüyoruz ve np.array ve her özelliğin şeklini kullanarak yeniden şekillendiriyoruz.
Bu noktada sinir ağını eğitmek için verilerimizi hazırladık. Artık verileri eğitim ve doğrulama kümelerine bölmek, modeli oluşturmak ve TensorFlow kullanarak eğitmek gibi daha ileri adımlarla ilerlemeye hazırız.
Negatif 1, dizinin uzunluğuna ve her bir öğenin şekline göre boyutu otomatik olarak hesaplayan bir yer tutucudur. Yani bu durumda, X dizisini (-1, resim_boyutu, resim_boyutu) şeklinde olacak şekilde yeniden şekillendiriyoruz. Bu, verilerin sinir ağına beslenmek için doğru formatta olmasını sağlar.
Ardından, görüntülerin piksel değerlerini normalleştirmemiz gerekiyor. Şu anda piksel değerleri, gri tonlamanın yoğunluğunu temsil eden 0 ile 255 arasındadır. Sinir ağları genellikle giriş verileri normalleştirildiğinde daha iyi performans gösterir, yani değerler daha küçük bir aralığa ölçeklenir. Bunu piksel değerlerini 255.0'a bölerek 0 ile 1.0 arasında ölçeklendirerek başarabiliriz. Bu, aşağıdaki kod kullanılarak yapılabilir:
x = x / 255.0
Konvolüsyonel Sinir Ağları - Python, TensorFlow ve Keras ile Derin Öğrenmenin temelleri s.3
Konvolüsyonel Sinir Ağları - Python, TensorFlow ve Keras ile Derin Öğrenmenin temelleri s.3
Herkese merhaba; Python, TensorFlow ve Keras ile Derin Öğrenme eğitim serimizin üçüncü bölümüne hoş geldiniz. Bu videoda, evrişimli sinir ağlarına (CNN'ler) ve önceki videoda oluşturduğumuz veri setini kullanarak köpekleri ve kedileri sınıflandırmak için bunları nasıl uygulayacağımıza odaklanacağız.
CNN'lere dalmadan önce, nasıl çalıştıklarını ve görüntü verileri için neden yararlı olduklarını hızlıca ele alalım. CNN'ler birkaç adım içerir: evrişim, havuzlama ve ardından daha fazla evrişim ve havuzlama. Evrişimin arkasındaki ana fikir, bir görüntüden kullanışlı özellikler çıkarmaktır. Görüntüyü taramak ve pencere içindeki bilgileri tek bir değere basitleştirmek için tipik olarak bir matris (örn. 3x3) olarak temsil edilen evrişimli bir pencere kullanırız. Pencere daha sonra kayar ve bu işlemi birçok kez tekrarlar. Pencerenin ne kadar hareket edeceğini belirleyen adım da ayarlanabilir.
Keras ile pencere boyutunu belirleyebiliriz ve diğer birçok ayrıntı otomatik olarak halledilir. Derin öğrenmenin inceliklerini daha derinlemesine araştırmak istiyorsanız, özellikle ham TensorFlow kodu için iç işleyişin daha ayrıntılı olarak açıklandığı "Pratik Makine Öğrenimi" eğitim serisine göz atmanızı tavsiye ederim.
Evrişim katmanının çıktısı, görüntüden çıkarılan bir dizi özelliktir. Bu özellikler daha sonra tipik olarak bir havuzlama katmanından geçirilir ve en yaygın tür maksimum havuzlamadır. Maksimum havuzlama, bir pencere içindeki maksimum değeri seçer ve verileri etkin bir şekilde altörnekleyerek tekrar tekrar kaydırır.
CNN'lerin arkasındaki üst düzey fikir, siz ağın derinliklerine indikçe görüntüden kademeli olarak daha karmaşık özellikler çıkarmalarıdır. İlk katmanlar kenarları ve çizgileri tanımlayabilirken, daha derin katmanlar daireler veya kareler gibi daha karmaşık şekilleri tanıyabilir. Sonunda, ağ belirli nesneleri veya kalıpları tanımlamayı öğrenebilir.
Bir CNN uygulamak için gerekli kitaplıkları içe aktarmamız gerekir. TensorFlow'u ve kullanacağımız Sequential, Dense, Dropout, Activation, Conv2D ve MaxPooling2D gibi Keras modüllerini içe aktarıyoruz. Veri setimizi yüklemek için turşuyu da içe aktarıyoruz.
Verileri sinir ağına beslemeden önce, onu normalleştirmeyi düşünmeliyiz. Bizim durumumuzda, piksel değerleri 0 ile 255 arasında değiştiği için piksel verilerini 255'e bölerek ölçeklendirebiliriz. Alternatif olarak, daha karmaşık normalleştirme senaryoları için cheat.utils'deki normalize işlevini kullanabiliriz.
Ardından Sequential API kullanarak modelimizi oluşturmaya başlıyoruz. 64 birim ve 3x3 pencere boyutunda bir Conv2D katmanı ekliyoruz. input_shape, X.shape kullanılarak dinamik olarak ayarlanır. Ardından, düzeltilmiş doğrusal aktivasyon fonksiyonunu (ReLU) kullanarak bir aktivasyon katmanı ekliyoruz. Ardından, 2x2 pencere boyutunda bir maksimum havuzlama katmanı ekliyoruz.
Başka bir Conv2D katmanı ve buna karşılık gelen bir maksimum havuzlama katmanı ekleyerek bu işlemi tekrarlıyoruz. Bu noktada, 2B evrişimli bir sinir ağımız var.
Ayıklanan özellikleri tamamen bağlantılı bir katmana geçirmek için verileri düzleştirmemiz gerekir. 64 düğümlü son bir Yoğun katman eklemeden önce bir Düzleştir katmanı ekliyoruz. Son olarak, tek düğümlü bir çıktı katmanı ekliyoruz ve kategorik veya ikili olabilen aktivasyon fonksiyonunu belirtiyoruz.
Modeli, kayıp fonksiyonunu (kategorik veya ikili çapraz entropi), optimize ediciyi (örn. Adam) ve modelin performansını (örn. doğruluk) değerlendirmek için metrikleri belirterek derleriz.
Modeli eğitmek için, giriş verilerimizi X ve Y etiketlerini ileterek sığdırma yöntemini kullanırız. Parti boyutunu da belirtebiliriz (örneğin, 32).
Modeli eğitmek için aşağıdaki kodu kullanacağız:
model.fit(X, Y, batch_size= 32 , validation_split= 0.1 )
Bu kod, X giriş verilerini ve karşılık gelen Y etiketlerini kullanarak modeli eğitecektir. Parti boyutunu 32 olarak ayarladık; bu, modelin eğitim sırasında bir seferde 32 örneği işleyebileceği anlamına gelir. validation_split parametresi 0.1 olarak ayarlanmıştır, bu, modelin eğitimi sırasında verilerin %10'unun doğrulama için kullanılacağı anlamına gelir.
Model eğitildikten sonra, test verilerini kullanarak performansını değerlendirebiliriz. Modeli değerlendirmek için aşağıdaki kodu kullanabiliriz:
model.evaluate(X_test, Y_test)
Burada X_test ve Y_test, sırasıyla test verilerini ve etiketleri temsil eder. Bu kod, test verilerinde modelin kayıp değerini ve doğruluğunu döndürür.
Modeli değerlendirdikten sonra, yeni, görünmeyen veriler üzerinde tahminler yapmak için kullanabiliriz. Yeni veriler için tahmin edilen etiketleri elde etmek için tahmin () işlevini kullanabiliriz. İşte bir örnek:
predictions = model.predict(X_new)
predicted_labels = np.argmax(predictions, axis= 1 )
Bu kadar! Artık köpekleri ve kedileri sınıflandırmak için evrişimli bir sinir ağı modeli eğittiniz ve onu yeni veriler üzerinde tahminler yapmak için kullandınız. Eğitilen modeli, gerekirse ileride kullanmak üzere kaydetmeyi unutmayın.
TensorBoard ile Modelleri Analiz Etme - Python, TensorFlow ve Keras ile Derin Öğrenme s.4
TensorBoard ile Modelleri Analiz Etme - Python, TensorFlow ve Keras ile Derin Öğrenme s.4
Herkes, "Python ile Derin Öğrenme: TensorFlow ve Keras" eğitim serisinin 4. bölümüne hoş geldiniz. Bu videoda ve sonraki videoda, TensorBoard kullanarak modellerimizi nasıl analiz edeceğimizi ve optimize edeceğimizi tartışacağız. TensorBoard, modellerimizin zaman içindeki eğitimini görselleştirmemizi sağlayan güçlü bir araçtır. Ana amacı, modelimizin performansının doğruluk, doğrulama doğruluğu, kayıp ve doğrulama kaybı gibi çeşitli yönlerini anlamamıza yardımcı olmaktır. Ek olarak, TensorBoard'da gelecekteki eğitimlerde keşfedebileceğimiz daha gelişmiş özellikler var.
TensorBoard'a dalmadan önce küçük bir ayrıntıyı ele alalım. Bu eğitim için çok önemli olmasa da, küçük modellerin bile önemli miktarda GPU belleği tüketme eğiliminde olduğunu belirtmek isterim. Birden çok modeli aynı anda çalıştırmayı planlıyorsanız, her modelin kullanması gereken GPU belleğinin bir bölümünü belirleyebilirsiniz. Bunu yaparak, birden fazla model çalıştırırken veya bellek kısıtlamalarıyla karşılaşırken olası sorunlardan kaçınabilirsiniz. Örneğin, modeli genellikle GPU belleğinin üçte birini kullanacak şekilde ayarlarım. Bu yaklaşımın, nesne algılama ve kendi kendine sürüş içeren "Python Plays GTA" serisinde olduğu gibi, birden çok modeli aynı anda çalıştırırken yararlı olduğu kanıtlanmıştır. Bu sadece size biraz zaman kazandıracak ve başınızı ağrıtacak kullanışlı bir ipucu.
Şimdi asıl konuya geçelim. Ele almak istediğim ilk şey, yoğun katmandan sonra bir etkinleştirme işlevi eklemek. Başlangıçta dahil etmemek benim açımdan bir gözetimdi. Bir aktivasyon fonksiyonu eklemek önemlidir, çünkü onsuz yoğun katman lineer bir aktivasyon fonksiyonu haline gelir ki bu bizim amaçlarımız için uygun değildir. Gerilemeden kaçınmak ve modelimizin en iyi şekilde çalışmasını sağlamak istiyoruz. Öyleyse, yoğun katmanın önüne aktivasyon işlevini ekleyerek bunu hızlıca düzeltelim.
Yapılan bu düzeltme ile doğrulukta önemli bir gelişme gözlemlemeliyiz. Model eğitilirken, TensorFlow belgelerini keşfetmek ve mevcut çeşitli Keras geri aramaları hakkında bilgi edinmek için biraz zaman ayıralım. Bizim durumumuzda, TensorBoard ile arayüz oluşturmak için TensorBoard geri aramasını kullanacağız. Bununla birlikte, belirli parametrelere dayalı erken durdurma, öğrenme oranı planlaması ve model kontrol noktası belirleme gibi başka yararlı geri aramalar olduğunu belirtmekte fayda var. Model kontrol noktası, modeli en iyi kayıp veya doğrulama doğruluğu gibi belirli aralıklarla kaydetmek istediğinizde özellikle değerlidir. Şimdilik TensorBoard geri aramasına odaklanalım, ancak gelecekteki bir videoda diğer geri aramalara kısaca değinebilirim.
TensorBoard geri aramasını kullanmak için onu TensorFlow'un Keras geri arama modülünden içe aktarmamız gerekiyor. TensorBoard'u içe aktarmak için aşağıdaki kod satırını ekleyin:
from tensorflow.keras.callbacks import TensorBoard
Artık gerekli modülü import ettiğimize göre biraz temizlik yapalım. Özellikle birden çok modelle çalışırken, modelinize anlamlı bir ad vermek her zaman iyi bir uygulamadır. Bu durumda modelimize "cats_vs_dogs_CNN_64x2" gibi bir ad verebiliriz. Ek olarak, benzersizliği sağlamak için isme bir zaman damgası ekleyelim. Zaman damgasını dahil etmek, bir modeli yeniden eğitirken veya model sürümleriyle herhangi bir karışıklığı önlerken kullanışlıdır. O halde kodumuza başlarken model ismini ve zaman damgasını şu şekilde tanımlayalım:
import time model_name = f"cats_vs_dogs_CNN_64x2_ { int (time.time())} "
tensorboard_callback = TensorBoard(log_dir= f"logs/ {model_name} " )
Ayrıca, tensor board, eğitim sürecinin görselleştirilmesini sağlayarak modellerimizi analiz etmemize ve optimize etmemize olanak tanır. Öncelikle doğruluk, doğrulama doğruluğu, kayıp ve doğrulama kaybı gibi metriklere odaklanır. Bu ölçümler, modelimizin zaman içinde nasıl performans gösterdiğini anlamamıza ve iyileştirme alanlarını belirlememize yardımcı olur. Doğruluk ve kayıp yaygın olarak izlenirken, tensör kartı gelecekte keşfedebileceğimiz daha gelişmiş işlevler sunar.
Tensör kartını kullanmaya başlamak için öncelikle kodumuza küçük bir ekleme yapmamız gerekiyor. Bu eğitim için çok önemli olmasa da bahsetmeye değer. Birkaç satır kod ekleyerek, modelimiz için GPU belleğinin belirli bir bölümünü ayırabiliriz. Bu, birden fazla modeli aynı anda çalıştırırken veya VRAM ile ilgili sorunlarla karşılaştığınızda faydalıdır. GPU tahsisini kontrol etmemizi ve olası çökmeleri veya bellek taşmasını önlememizi sağlar. Bizim durumumuzda, model için GPU'nun üçte birini ayırıyoruz. Bu, sorunsuz yürütme sağlar ve diğer modellerle veya projelerle çalışırken herhangi bir çakışmayı önler.
Devam ederek, tensör kartını uygulamaya odaklanalım. Öncelikle gerekli bağımlılıkları import etmemiz gerekiyor. "tensorflow.keras.callbacks" paketinden "tensorboard" modülünü içe aktarıyoruz. Bu modül, tensör kartı için geri arama işlevselliği sağlar.
Daha sonra modelimize anlamlı bir isim vermek istiyoruz. Birden çok modelle çalışırken her modele ayrı bir ad vermek çok önemlidir. Deneyleri takip etmemize ve herhangi bir karışıklığı önlememize yardımcı olur. Bu durumda modelimize "cat's_first_dog_CNN_64x2_good_enough" adını veriyoruz. Ek olarak, mevcut zaman değerini kullanarak isme bir zaman damgası ekleriz. Bu, benzersizliği sağlar ve modellerin yanlışlıkla üzerine yazılmasını önler.
Modelimize isim verdikten sonra tensor board callback nesnesini tanımlayabiliriz. "TensorBoard" sınıfının bir örneğini oluşturup "tensorboard" değişkenine atadık. Log dizini yolunu yapıcıya iletiyoruz. Günlük dizini, tensör kartının modelimiz ile ilgili günlükleri ve verileri saklayacağı yerdir. Model adını günlük dizini yoluna dahil etmek için dize biçimlendirmesini kullanırız.
Geri çağırma nesnesini hazır hale getirdiğimizde, onu model eğitim sürecimize dahil edebiliriz. Modelimizin "fit" yönteminde ise callback nesnesini "callbacks" parametresine liste halinde geçiriyoruz. Bu durumda, tensör kartı geri araması olan tek bir geri aramamız var. Ancak, gerekirse listeye birden çok geri arama ekleyebileceğinizi belirtmekte fayda var.
Entegre geri arama ile artık modelimizi eğitebiliriz. Bu örnek için dönem sayısını 10 olarak ayarladık. Ancak, dönem sayısını gereksinimlerinize göre ayarlamaktan çekinmeyin. Model eğitilirken, tensör panosu, belirtilen metriklere dayalı olarak günlükler ve görselleştirmeler oluşturmaya başlayacaktır.
Tensör panosunu çalışırken görmek için, komut penceresini veya terminali açmamız ve günlük dosyalarını içeren dizine gitmemiz gerekir. Doğru dizine girdikten sonra, komut istemine "tensorboard --logdir logs" yazarak tensor board komutunu çalıştırıyoruz. Bu komut, tensör kartı sunucusunu başlatır ve tensör panosu arayüzüne erişebileceğimiz yerel bir URL sağlar.
Tensör kartını başlattıktan sonra, bir web tarayıcısı açabilir ve komut istemi tarafından sağlanan URL'yi girebiliriz. Bu, modelimizin eğitim ilerlemesini görselleştirebileceğimiz tensör panosu arayüzünü gösterecektir. Arayüz, numune içi doğruluk, numune içi kayıp, numune dışı doğruluk ve numune dışı kayıp gibi çeşitli grafikleri gösterir. Modelin performansını izlemek ve optimizasyonuyla ilgili bilinçli kararlar vermek için bu ölçümleri analiz ediyoruz.
Grafikleri gözlemleyerek modelin davranışındaki kalıpları ve eğilimleri belirleyebiliriz. Örneğin, doğrulama doğruluğu sabit kalırken veya azalırken doğrulama kaybı artmaya başlarsa, aşırı uydurma olduğunu gösterir. Öte yandan, hem doğrulama doğruluğu hem de kayıp zaman içinde gelişirse, modelin etkili bir şekilde öğrendiğini gösterir.
Tensör panosu, modelleri analiz etmek ve optimize etmek için güçlü bir platform sağlar. Görselleştirmeleri, eğitim sürecine ilişkin değerli bilgiler sunar ve karar vermeyi kolaylaştırır. Tensör kartından yararlanarak model geliştirme sürecini kolaylaştırabilir ve daha iyi sonuçlar elde edebiliriz.
Bu eğitim serisinin bir sonraki bölümünde, histogramlar, dağılımlar ve gömmeler dahil olmak üzere tensör kartının gelişmiş özelliklerini daha derinlemesine inceleyeceğiz. Bu özellikler daha fazla ayrıntı sağlar ve modellerimiz hakkında daha kapsamlı bir anlayış kazanmamızı sağlar. Bu heyecan verici yetenekleri keşfedeceğimiz bir sonraki video için bizi izlemeye devam edin.
Bu eğitim için bu kadar. İzlediğiniz için teşekkürler, bir sonraki videoda görüşmek üzere!
TensorBoard ile Optimizasyon - Python, TensorFlow ve Keras ile Derin Öğrenme s.5
TensorBoard ile Optimizasyon - Python, TensorFlow ve Keras ile Derin Öğrenme s.5
Herkese merhaba, Python TensorBoard ve Keras ile Derin Öğrenmenin Beşinci Bölümüne hoş geldiniz. Bu eğitimde, TensorBoard'a ve farklı model denemelerini görselleştirerek modelleri optimize etmek için nasıl kullanabileceğimize odaklanacağız. Hadi içine dalalım!
Öncelikle, modeli analiz edelim ve performansını iyileştirmek için ince ayar yapabileceğimiz yönleri belirleyelim. Mevcut modelimiz yaklaşık %79 doğruluk elde ederken, daha iyisini yapabileceğimize inanıyoruz. Optimizasyon için bazı potansiyel alanlar arasında optimize edici, öğrenme hızı, yoğun katman sayısı, katman başına birimler, etkinleştirme birimleri, çekirdek boyutu, adım, bozulma oranı ve daha fazlası yer alır. Keşfedilecek sayısız seçenekle binlerce modeli test etmek zorunda kalabiliriz. Peki nereden başlayalım?
İşleri kolaylaştırmak için en basit değişikliklerle başlayalım. Katman sayısını, katman başına düğümleri ve sonuna yoğun bir katmanın dahil edilip edilmeyeceğine odaklanacağız. Yoğun katman sayısı olarak sıfır, bir veya iki olarak ele alacağız. Katman boyutlarıyla ilgili olarak, 32, 64 ve 128 değerlerini kullanacağız. Bu değerler sadece gelenekseldir ve tercihlerinize göre farklı değerler seçebilirsiniz.
Şimdi bu değişiklikleri kodumuza uygulayalım. Yoğun katman sayısı ve katman boyutları gibi yapmak istediğimiz seçimler için bazı değişkenler tanımlayacağız. Farklı model kombinasyonları oluşturmak için bu değişkenleri yineleyeceğiz. Ek olarak, her model için yapılandırmasını yansıtan bir ad oluşturacağız.
Model konfigürasyonlarını aldıktan sonra, bunları kodumuzda uygulamaya geçebiliriz. Girdi şeklini, evrişimli katmanları, yoğun katmanları ve çıktı katmanını göz önünde bulundurarak model yapısını buna göre güncelleyeceğiz. Ayrıca katman boyutlarının uygun şekilde ayarlanmasını sağlayacağız.
Yapılan tüm değişikliklerle birlikte, kodu çalıştırmanın zamanı geldi. Ancak, çok sayıda modeli eğitmek zaman alıcı olabileceğinden, kodu zaten çalıştırdım ve sonuçları kaydettim. TensorBoard kullanarak sonuçları analiz etmeye devam edelim.
TensorBoard günlüklerini yüklüyoruz ve farklı model kombinasyonlarını gözlemliyoruz. Modeller, performanslarına, özellikle doğrulama kaybına göre düzenlenir. En iyi performans gösteren modellere odaklanır ve yapılandırmalarını not ederiz.
Sonuçlardan, üç evrişimli katmana ve sıfır yoğun katmana sahip modellerin sürekli olarak iyi performans gösterdiği ortaya çıkıyor. Katman başına belirli düğüm sayısı daha az önemli görünmektedir. Ancak, 512 veya 256 düğüm gibi daha büyük yoğun katmanların daha da iyi sonuçlar verebileceğini belirtmek gerekir. Bunu doğrulamak için farklı yoğun katman boyutlarını test edebilirsiniz.
Özetlemek gerekirse, TensorBoard kullanarak çeşitli model yapılandırmalarını keşfederek başladık. Üç evrişimli katmana sahip olan ve yoğun katman içermeyen modellerin sürekli olarak iyi performans gösterdiğini bulduk. Ayrıca katman başına düğüm sayısının daha da optimize edilebileceğini belirledik. Farklı yoğun katman boyutlarını test ederek, modelin doğruluğunu potansiyel olarak daha da geliştirebiliriz.
Bunun yalnızca bir başlangıç noktası olduğunu ve modellerinizi optimize etmek için ince ayar yapabileceğiniz birçok başka yön olduğunu unutmayın. TensorBoard, bu model varyasyonlarını görselleştirmek ve analiz etmek için değerli bir araç sağlayarak, model iyileştirme için bilinçli kararlar almanıza yardımcı olur.
Eğitimli modelinizi kullanma - Python, TensorFlow ve Keras ile Derin Öğrenmenin temelleri s.6
Eğitimli modelinizi kullanma - Python, TensorFlow ve Keras ile Derin Öğrenmenin temelleri s.6
Herkese merhaba, TensorFlow ve Keras ile Python'da Derin Öğrenme eğitim serisinin 6. Bölümüne hoş geldiniz!
Bu videoda, yeni görüntüler üzerinde tahminler yapmak için eğitilmiş modelimizi nasıl kullanacağımızı tartışacağız. Veri kümelerini başarılı bir şekilde eğittikleri ve test ettikleri, ancak modeli harici görüntüler üzerinde tahmin yapmak için nasıl kullanacaklarından emin olmadıkları için birçok kişi bunu soruyor. Öyleyse, hadi içine dalalım!
Öncelikle gerekli kütüphaneleri import etmemiz gerekiyor. Görüntü işleme için cv2'yi ve modelimizle çalışmak için TF olarak tensorflow'u içe aktaracağız. Eğitim sırasında kullandığımız "köpek" ve "kedi" sınıf etiketlerini içeren kategoriler listesine de ihtiyacımız olacak.
Ardından, bir dosya yolunu parametre olarak alan, hazırla adında bir işlev tanımlayacağız. Bu işlev, giriş görüntüsü için gereken ön işleme adımlarını işleyecektir. Görüntüyü belirli bir boyuta yeniden boyutlandıracağız ve gri tonlamaya dönüştüreceğiz. Görüntü daha sonra yeniden şekillendirilmiş bir numpy dizisi olarak döndürülür.
Bundan sonra, TF.keras.models.load_model() işlevini kullanarak eğitilmiş modelimizi yükleyeceğiz. Daha önce modelimizi "64'e 3 CNN modeli" olarak kaydettik, bu yüzden aynı adı kullanarak yükleyeceğiz.
Artık tahminlerde bulunmaya hazırız. Predict adında bir değişken tanımlayıp hazırladığımız görsel üzerinde model.predict() çağırmanın sonucunu atayacağız. Tek bir görüntü üzerinde tahmin yapıyor olsak bile, tahmin() yönteminin girdi olarak bir liste beklediğine dikkat etmek önemlidir. Bu yüzden hazırlanan görseli liste halinde geçirmemiz gerekiyor.
Tahmin sonucunu aldığımızda, onu yazdırabiliriz. Ancak, tahmin şu anda iç içe geçmiş bir liste biçimindedir. Daha okunabilir hale getirmek için, tahmin değerini bir tamsayıya dönüştürebilir ve kategori listesinden karşılık gelen sınıf etiketini almak için bir dizin olarak kullanabiliriz.
Son olarak, görüntünün köpek mi yoksa kedi olarak mı sınıflandırıldığını gösteren tahmin edilen sınıf etiketini yazdırabiliriz.
Bu öğreticide, modelimizi test etmek için iki harici görüntü kullandık: biri utanç konisi olan bir köpeğin, diğeri ise bilinmeyen bir yaratığın. Bu görüntüler, eğitim veri setimizin bir parçası değildi ve bu da görünmeyen veriler üzerinde tahminler yapmamızı sağlıyor.
Kendi köpek ve kedi resimlerinizle denemek için kodda belirtilen adımları izleyin. Doğruluğun değişebileceğini, ancak ortalama olarak %80 civarında olması gerektiğini unutmayın.
Şimdilik bu kadar! Son sponsorlarımız olan Michael, Nick, Rodrigo ve Papasan E'ye teşekkür etmek istiyorum. Desteğiniz için çok teşekkür ederiz. Gelecekteki öğreticiler için herhangi bir sorunuz, yorumunuz veya öneriniz varsa, lütfen bunları aşağıda bırakın. Yinelenen sinir ağlarını kullanma fikirlerine de açığım, bu nedenle aklınızda basit bir veri kümesi varsa bana bildirin.
Tekrarlayan sinir ağlarını keşfedeceğimiz bir sonraki eğitimde görüşmek üzere. O zamana kadar mutlu kodlamalar!
Tekrarlayan Sinir Ağları (RNN) - Python, TensorFlow ve Keras ile Derin Öğrenme s.7
Tekrarlayan Sinir Ağları (RNN) - Python, TensorFlow ve Keras ile Derin Öğrenme s.7
Herkese merhaba, Kaos eğitim serisinde Python TensorFlow ile Derin Öğrenmenin 7. Bölümüne hoş geldiniz. Bu bölümde tekrarlayan sinir ağına (RNN) odaklanacağız. Bir RNN'nin amacı, veri sırasının önemini ve önemini yakalamaktır. Bu, özellikle verilerin geçici olarak düzenlendiği zaman serisi verileriyle ve bir cümledeki sözcüklerin sırasının anlam taşıdığı doğal dil işlemeyle ilgilidir.
Konsepti açıklamak için, bir cümle örneğini ele alalım: "Bazı insanlar bir sinir ağı yaptı." Bu cümle, tipik olarak verileri tek tek sözcüklere bölerek tokenize eden derin bir sinir ağı tarafından işlendiğinde, ağ doğru anlamı yakalayamayabilir. Örneğin, "Bir sinir ağı bazı insanları yarattı" cümlesi tamamen farklı bir anlama sahiptir. Bu, bir cümlenin anlamını belirlemede kelimelerin sırasının önemini vurgular.
Şimdi, tekrarlayan bir sinir ağının işleyişini inceleyelim. Bir RNN'nin temel yapı taşı, genellikle bir uzun kısa süreli bellek (LSTM) hücresi kullanılarak uygulanan tekrarlayan hücredir. Geçitli tekrarlayan birim (GRU) gibi başka seçenekler mevcut olsa da, LSTM hücresi yaygın olarak kullanılır. Bir RNN'de, her hücre sıralı verileri girdi olarak alır ve bir sonraki katmana veya tekrarlayan katmandaki bir sonraki hücreye çıktı verir.
Bir hücreden çıktı farklı şekillerde yönlendirilebilir. Bir sonraki katmana veya bir sonraki hücreye tek yönlü veya çift yönlü olarak gidebilir. Bu öğreticide, temel bir tek yönlü RNN'ye odaklanacağız. Bunu göstermek için, yinelenen bir hücreyi temsil eden yeşil bir kutu hayal edin. Önceki hücreden gelen veriler, önceki düğümden gelen ilgisiz bilgileri unutmak, yeni girdi verilerini dahil etmek ve bir sonraki katmana veya düğüme hangi bilgilerin çıkacağına karar vermek gibi işlemleri gerçekleştiren mevcut hücreye girer.
Bu işlemi daha iyi görselleştirmek için, katmandaki belirli bir hücreyi ele alalım. Yeşil kutu, geçerli hücreyi temsil eder. Veriler önceki hücreden içeri akar, etrafı sarar ve LSTM hücresine girer. Hücre içinde önceki düğümden gelen bilgileri unutma, yeni girdi verilerini dahil etme ve bir sonraki katmana veya düğüme iletilecek çıktıyı belirleme işlemleri vardır. Bu işlemler toplu olarak LSTM hücresinin önemli bilgileri tutmasını ve sonraki katmanlara veya düğümlere iletmesini sağlar.
Bir RNN'yi uygulamak, özellikle skaler değerlerle uğraşırken karmaşık olabilir. LSTM hücrelerinin nasıl çalıştığına dair ayrıntılı bir açıklamayla ilgileniyorsanız, bunları derinlemesine açıklayan kapsamlı bir kılavuza göz atmanızı tavsiye ederim. Referans olması için öğreticinin metin sürümüne bu kılavuzun bağlantısını ekledim.
Şimdi, temel bir tekrarlayan sinir ağı oluşturmaya geçelim. Bu eğitimde, M-NIST veri setini kullanarak basit bir örnekle başlayacağız. Bir sonraki öğreticide, özellikle kripto para birimi fiyatlarına odaklanarak daha gerçekçi zaman serisi verileriyle çalışacağız.
Başlamak için gerekli kitaplıkları içe aktaralım. TensorFlow'u tf olarak, tensorflow.keras.models'den Ardışık modeli, tensorflow.keras.layers'tan Yoğun katmanı ve ayrıca Dropout ve LSTM hücrelerini içe aktaracağız. TensorFlow'un GPU sürümünü kullanıyorsanız, KU DNN LSTM hücresi adı verilen optimize edilmiş bir LSTM hücresinin de olduğunu unutmayın. Ancak, bu öğretici için normal LSTM hücresine bağlı kalacağız. TensorFlow'un CPU sürümünü kullanıyorsanız, hesaplama önemli miktarda zaman alabilir.
Ardından, veri setini yüklememiz gerekiyor. Bu örnek için M-NIST veri setini kullanacağız. Eğitim ve test verilerini döndüren tf.keras.datasets.mnist.load_data() işlevini kullanarak kolayca yükleyebiliriz. Verileri değişkenlere ayıralım: X_train, Y_train, X_test ve Y_test.
İlk olarak, her bir piksel değerini 255'e bölerek giriş verilerini normalleştirelim. Bu, piksel değerlerini 0 ile 1 arasında sinir ağı eğitimi için uygun bir aralığa ölçekleyecektir. Bunu hem eğitim hem de test verilerini 255'e bölerek elde edebiliriz.
X_train = X_train / 255.0 X_test = X_test / 255.0
Ardından, hedef etiketleri tek sıcak kodlanmış vektörlere dönüştürmemiz gerekiyor. M-NIST veri setinde, etiketler, rakamları temsil eden 0 ile 9 arasında değişen tam sayılardır. One-hot kodlama, her bir etiketi 10 uzunluğunda bir ikili vektöre dönüştürür; burada haneye karşılık gelen dizin 1'e ve diğer tüm dizinler 0'a ayarlanır. -sıcak kodlama.
Y_train = to_categorical(Y_train, num_classes=10)
Y_test = to_categorical(Y_test, num_classes=10)
Şimdi tekrarlayan sinir ağımızın mimarisini tanımlayalım. tensorflow.keras.models'den Sequential modelini kullanacağız ve ona katmanlar ekleyeceğiz.
from tensorflow.keras.layers import LSTM, Dense
model = Sequential()
model.add(LSTM(128, input_shape=(X_train.shape[1:]), activation='relu', return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
Şimdi, kayıp fonksiyonu, optimize edici ve değerlendirme metriğini belirterek modeli derleyelim.
model. compile (loss= 'categorical_crossentropy' , optimizer= 'adam' , metrics=[ 'accuracy' ])
Son olarak, eğitim verilerini kullanarak modeli eğitelim ve test verileri üzerinde değerlendirelim.
model.fit(X_train, Y_train, batch_size= 32 , epochs= 10 , validation_data=(X_test, Y_test))
Bu kadar! Artık M-NIST veri kümesi için LSTM hücrelerini kullanarak tekrarlayan bir sinir ağı oluşturdunuz. RNN'lerin yeteneklerini daha fazla keşfetmek için farklı mimariler, hiperparametreler ve veri kümeleri ile deneyler yapabilirsiniz.
Cryptocurrency-predicting RNN girişi - Python, TensorFlow ve Keras ile Derin Öğrenme s.8
Cryptocurrency-predicting RNN girişi - Python, TensorFlow ve Keras ile Derin Öğrenme s.8
Herkese merhaba, Python eğitim videosu ile başka bir derin öğrenmeye hoş geldiniz. Bu videoda ve gelecek olanlarda, tekrarlayan sinir ağının (RNN) sıralı verilerle çalışmanın daha gerçekçi bir örneğine nasıl uygulanacağını tartışacağız. Spesifik olarak, kripto para birimleri için fiyat ve hacimlerden oluşan bir zaman serisi veri seti ile çalışacağız.
Ayrıntılara girmeden önce, aynı kavramları hisse senedi fiyatları veya sensör verileri gibi diğer sıralı veri türlerine uygulayabileceğinizi açıklığa kavuşturmak istiyorum. Yani, finansla ilgilenmeseniz bile, kavramları takip edebilir ve anlayabilirsiniz.
Bu eğitimin amacı, geçmiş fiyatına ve hacmine dayalı olarak bir kripto para biriminin gelecekteki fiyatını tahmin etmek için tekrarlayan bir sinir ağı kullanmaktır. Dört ana kripto para birimine odaklanacağız: Bitcoin, Litecoin, Ethereum ve Bitcoin Cash. Fikir, bu kripto para birimlerinin her biri için son 60 dakikalık fiyat ve hacim verilerini alıp Litecoin'in fiyatını tahmin etmek için girdi olarak kullanmaktır, örneğin geleceğe üç dakika.
Bu tür tahmin problemi, zaman ve kullanım verilerine dayalı olarak sunucu arızalarını veya web sitesi trafiğini tahmin etmek gibi diğer alanlara da uygulanabilir. Nihai hedef, ya bir sınıflandırma (örneğin, fiyatın yükselip düşmeyeceğini) tahmin etmek ya da regresyon yapmaktır (örneğin, gerçek fiyatı veya yüzde değişimini tahmin etmek).
Sıralı verilerle çalışmak benzersiz zorluklar sunar. İlk olarak, verileri önceden işlememiz ve tekrarlayan sinir ağının işleyebileceği dizilere dönüştürmemiz gerekiyor. Ek olarak, farklı kripto para birimlerinin fiyatlarının ve hacimlerinin farklı ölçeklere sahip olabileceğini göz önünde bulundurarak verileri dengelememiz ve normalleştirmemiz gerekiyor. Verileri ölçeklendirmek, basitçe 255'e böldüğümüz görüntü verileri gibi diğer alanlara göre daha karmaşıktır.
Ayrıca, sıralı verilerle çalışırken örnek dışı verileri kullanarak modelin performansını değerlendirmek farklı bir zorluktur. Veri hazırlama, normalleştirme ve değerlendirme dahil ele almamız gereken birkaç husus var.
Başlamak için indirmeniz için bir veri seti sağladım. İndirme bağlantısını öğreticinin açıklamasında bulabilirsiniz. İndirilen zip dosyasını çıkardıktan sonra, her biri bir kripto para biriminin fiyat ve hacim verilerine karşılık gelen dört dosya bulacaksınız.
Veri setini okumak ve değiştirmek için Python'daki pandas kütüphanesini kullanacağız. Yüklü pandalarınız yoksa, terminalinizde veya komut isteminizde pip install pandas komutunu çalıştırarak bunu yapabilirsiniz.
Daha sonra pandaları kullanarak veri setinde okuyacağız ve verileri inceleyeceğiz. Her kripto para birimi için "kapanış" fiyat ve hacim sütunlarına odaklanacağız. Farklı dosyalardan verileri birleştirmek için, her veri çerçevesi için "zaman" sütununu dizin olarak ayarlayacağız. Ardından, veri çerçevelerini paylaşılan dizinlerine göre birleştireceğiz.
Birleştirilmiş veri çerçevesine sahip olduğumuzda, bazı parametreleri tanımlamamız gerekir. Bunlar, dizi uzunluğunu (dikkate alınacak geçmiş dönemlerin sayısı), gelecek dönemi (tahmin edilecek geleceğe yönelik dönemlerin sayısı) ve tahmin edilecek oranı (tahmin etmek istediğimiz kripto para birimi) içerir.
Bizim durumumuzda, Litecoin'in (LTC) gelecekteki fiyatını son 60 dakikalık verilere dayanarak tahmin etmeye odaklanacağız ve üç dakika sonrasını tahmin edeceğiz. Ayrıca, tahmini mevcut ve gelecekteki fiyatlara dayalı olarak bir fiyat artışı veya düşüşü olarak sınıflandırdığımız bir sınıflandırma kuralı tanımlayacağız.
Bu ilk adımlar tamamlandıktan sonra, artık verileri önceden işlemeye, diziler oluşturmaya ve tekrarlayan sinir ağını eğitmeye hazırız. Gelecek videolarda bu konuları ele alacağız, bu yüzden bizi izlemeye devam edin.
Devam etmek istiyorsanız, veri setini indirdiğinizden ve gerekli kitaplıkları kurduğunuzdan emin olun. Kodun ve talimatların tamamını eğitimin açıklamada bulunan metin tabanlı versiyonunda bulabilirsiniz.
Ele alacak çok şeyimiz var, o yüzden bunu 1 olarak sınıflandıralım, fiyat artışını belirtelim. Aksi takdirde, gelecekteki fiyat mevcut fiyattan düşükse, fiyatın düştüğünü belirten 0 olarak sınıflandırırız. Bu, sınıflandırma için kullandığımız basit bir kuraldır, ancak farklı kurallarla deneyler yapabilir ve hatta gerçek fiyat değişimini tahmin etmek için regresyon kullanabilirsiniz.
Şimdi ana DataFrame'imizde hedef sütunu oluşturalım. "LTCUSD_close" sütununun değerlerini gelecek döneme göre kaydırmak için pandaların kaydırma işlevini kullanacağız. Bu bize, sınıflandırmayı belirlemek için mevcut fiyatlarla karşılaştıracağımız gelecekteki fiyatları verecektir. Sonucu "hedef" adlı yeni bir sütuna atayacağız.
main_df[ 'target' ] = main_df[ 'LTCUSD_close' ].shift(-future_period)
main_df.dropna(inplace= True )
Ardından, giriş dizilerini oluşturalım. DataFrame'i yineleyeceğiz ve önceki Bitcoin, Litecoin, Ethereum ve Bitcoin Cash fiyatlarından ve hacimlerinden oluşan sequence_length uzunluğunda diziler oluşturacağız. Bu dizileri "diziler" adı verilen bir listede saklayacağız.
for i in range(len(main_df) - sequence_length + 1):
sequence = main_df.iloc[i:i+sequence_length, 1:-1].values.flatten()
sequences.append(sequence)
Son olarak, daha kolay manipülasyon ve eğitim için dizileri ve hedefleri uyuşuk dizilere dönüştüreceğiz.
sequences = np.array(sequences)
targets = np.array(main_df['target'])
Lütfen burada sağlanan kodun kısmi bir uygulama olduğunu ve veri ön işleme adımlarına odaklandığını unutmayın. Model mimarisini daha da geliştirmeniz, modeli eğitmeniz ve performansını değerlendirmeniz gerekecektir. Ek olarak, modelin doğruluğunu artırmak için hiperparametreleri ayarlamanız ve farklı teknikler denemeniz gerekebilir.
Modeli eğitmeden önce gerekli kitaplıkları içe aktarmayı, eksik verileri işlemeyi, özellikleri (normalleştirme, ölçeklendirme vb.) önceden işlemeyi ve verileri eğitim ve test kümelerine ayırmayı unutmayın.
Umarım bu, sıralı verilerle çalışma ve gelecekteki fiyatları tahmin etmek için tekrarlayan sinir ağlarını uygulama sürecini anlamanıza yardımcı olur. Derin öğrenme projenizde iyi şanslar!
Dizileri normalleştirme ve oluşturma Crypto RNN - Python, TensorFlow ve Keras ile Derin Öğrenme s.9
Dizileri normalleştirme ve oluşturma Crypto RNN - Python, TensorFlow ve Keras ile Derin Öğrenme s.9
Herkese merhaba; Python, TensorFlow ve Chaos ile Derin Öğrenme eğitim serisinin başka bir bölümüne tekrar hoş geldiniz. Bu videoda, bir kripto para biriminin gelecekteki fiyat hareketlerini tahmin etmek için tekrarlayan sinir ağı (RNN) uygulama mini projemiz üzerinde çalışmaya devam edeceğiz. Döviz fiyatlarının ve hacimlerinin sırasını, diğer üç kripto para birimi fiyatı ve hacmiyle birlikte kullanacağız.
Şu ana kadar verileri elde ettik, birleştirdik ve hedefleri oluşturduk. Şimdi sonraki adımlara geçelim. Verilerden diziler oluşturmamız ve dengeleme, normalleştirme, ölçekleme gibi görevleri gerçekleştirmemiz gerekiyor. Ancak, bu görevlere dalmadan önce, numune dışı test konusunu ele almak çok önemlidir.
Zamansal ve zaman serisi verileriyle uğraşırken, örneklem dışı veriler olarak bir kısmı karıştırmak ve rastgele seçmek, yanlı bir modele yol açabilir. Bizim durumumuzda, 60 dakikalık diziler ve 3 dakikalık bir tahmin penceresi ile, numune dışı verilerin rastgele seçilmesi, hem numune içi hem de numune dışı setlerde benzer örneklerin bulunmasına neden olabilir. Bu, modelin görünmeyen veriler üzerinde aşırı uyum sağlamasını ve kötü performans göstermesini kolaylaştıracaktır.
Bununla başa çıkmak için, örneklem dışı verileri dikkatli bir şekilde seçmemiz gerekiyor. Zaman serisi verileri için, örnek dışı küme olarak gelecekten bir yığın veri seçilmesi önerilir. Bizim durumumuzda, geçmiş verilerin son %5'ini örnek dışı verilerimiz olarak alacağız. Bu yaklaşım, modeli zamanın %5'i kadar önce oluşturmayı ve ileriye doğru test etmeyi simüle eder.
Şimdi, örnek dışı verilerin bu ayrımını uygulayalım. Verileri zaman damgasına göre sıralayacağız ve zamanların son %5'lik eşiğini bulacağız. Verileri bu şekilde ayırarak, örneklem dışı kümenin gelecekten veri içermesini sağlayarak veri sızıntısını ve yanlı testlerin önüne geçiyoruz. Ayrıldıktan sonra, doğrulama verilerine ve eğitim verilerine sahip olacağız.
Daha fazla ilerlemeden önce, hem doğrulama hem de eğitim verilerini önceden işlememiz gerektiğini not etmek önemlidir. Diziler oluşturacağız, verileri dengeleyeceğiz, normalleştireceğiz, ölçeklendireceğiz ve diğer gerekli görevleri gerçekleştireceğiz. Bu işlemi hızlandırmak için, bir DataFrame'i girdi olarak alan ve tüm bu ön işleme adımlarını gerçekleştiren preprocess_df adlı bir işlev oluşturalım.
Öncelikle sklearn kütüphanesinden preprocessing modülünü import ediyoruz. Eğer kurulu değilse, bunu pip install sklearn'ü çalıştırarak yapabilirsiniz. Daha sonra parametre olarak DataFrame alan preprocess_df fonksiyonunu tanımlarız.
Fonksiyon içinde gereksiz gelecek sütununu DataFrame'den bırakarak başlıyoruz. Ardından, DataFrame'in sütunlarını yineliyoruz ve yüzde değişim dönüşümünü uyguluyoruz. Bu normalleştirme adımı, kripto para birimleri genelinde farklı fiyat ve hacim büyüklüklerinin ele alınmasına yardımcı olur.
Verileri normalleştirdikten sonra, eğitim sırasında sorunlara neden olabileceğinden, NaN değerleri içeren tüm satırları çıkarıyoruz. Ardından, değerleri 0 ile 1 arasında ölçeklendirmek için preprocessing.scale işlevini kullanırız. Alternatif olarak, kendi ölçeklendirme mantığınızı uygulayabilirsiniz.
Artık verileri önceden işlediğimize göre, sıralı verileri işlemeye geçelim. Sequential_data adlı boş bir liste oluşturuyoruz ve maksimum uzunluğu 60 olan prev_days adlı bir deque nesnesini başlatıyoruz. deque nesnesi, yeni öğeleri verimli bir şekilde eklememize ve maksimum uzunluğa ulaştığında eskilerini otomatik olarak kaldırmamıza olanak tanır.
Ardından, artık normalleştirilmiş ve ölçeklenmiş verileri içeren DataFrame değerleri üzerinde yineleme yapıyoruz. Her satır için değerleri prev_days deque'ye ekleriz. Deque en az 60 uzunluğa ulaştığında, sequential_data'yı doldurmaya başlarız.
# Create a deque object with a maximum length of max_len
if len(prev_days) < max_len:
prev_days.append([n for n in i[:-1]])
else:
# Append the current values to prev_days
prev_days.append([n for n in i[:-1]])
# Add the sequence to the sequential_data list
sequential_data.append([np.array(prev_days), i[-1]])
# Remove the oldest sequence from prev_days
prev_days.popleft()
Artık dizileri oluşturduğumuza göre, verileri dengelemeye devam edebiliriz. Dengeleme, eğitim verilerimizde belirli bir sınıfa yönelik herhangi bir önyargıyı önlemek için önemlidir. Bu durumda sınıflarımız farklı fiyat hareketleridir (yukarı veya aşağı). Verileri dengelemek için, her sınıf için oluşum sayısını sayacağız ve çoğunluk sınıfının dizi sayısını azınlık sınıfıyla eşleşecek şekilde sınırlayacağız.
sells = []
for seq, target in sequential_data:
if target == 0:
sells.append([seq, target])
elif target == 1:
buys.append([seq, target])
# Determine the minimum number of sequences in buys and sells
lower = min(len(buys), len(sells))
# Balance the data by randomly selecting the required number of sequences from buys and sells
buys = buys[:lower]
sells = sells[:lower]
# Concatenate buys and sells to create balanced_data
balanced_data = buys + sells
# Shuffle the balanced_data
random.shuffle(balanced_data)
Verileri dengeledikten sonra, onu giriş özellikleri (X) ve hedef etiketleri (y) dizilerine ayırabiliriz.
y = []
for seq, target in balanced_data:
X.append(seq)
y.append(target)
# Convert X and y to numpy arrays
X = np.array(X)
y = np.array(y)
Artık giriş özellikleri olarak X'e ve hedef etiketler olarak y'ye sahip olduğumuza göre, verileri eğitim ve doğrulama kümelerine ayırmaya devam edebiliriz.
train_x, val_x, train_y, val_y = train_test_split(X, y, test_size=0.2, random_state=42)
Yukarıdaki kodda, verileri eğitim ve doğrulama kümelerine bölmek için scikit-learn'deki train_test_split işlevini kullanıyoruz. Verilerin %80'ini eğitim setine (train_x ve train_y) ve %20'sini atarız
scaler = MinMaxScaler()
train_x = scaler.fit_transform(train_x.reshape(train_x.shape[0], -1))
val_x = scaler.transform(val_x.reshape(val_x.shape[0], -1))
# Reshape the data back to its original shape
train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], -1)
val_x = val_x.reshape(val_x.shape[0], val_x.shape[1], -1)
Hazırlanan verilerle artık LSTM modelini oluşturabilir ve eğitebiliriz:
model.add(LSTM(units=128, input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128, return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(units=32, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(units=2, activation='softmax'))
# Define the optimizer and compile the model
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# Define early stopping
early_stopping = tf.keras.callbacks.EarlyStopping(patience=3)
# Train the model
history = model.fit(train_x, train_y, validation_data=(val_x, val_y), epochs=20, callbacks=[early_stopping])
Optimize ediciyi, 0.001 öğrenme oranıyla Adam olarak tanımlıyoruz ve modeli, kayıp fonksiyonu olarak seyrek kategorik çapraz entropi ve metrik olarak doğruluk kullanarak derliyoruz.
Erken durdurma, doğrulama kaybını izlemek ve 3 dönem sonra düzelmezse eğitimi durdurmak için EarlyStopping geri çağırma kullanılarak tanımlanır.
Model, eğitim verilerini (train_x ve train_y), doğrulama verilerini (val_x ve val_y) ve tanımlanmış geri aramaları geçirerek fit işlevi kullanılarak eğitilir. Eğitim 20 dönem boyunca gerçekleştirilir.
Özel gereksinimlerinize göre model mimarisini, hiperparametreleri ve eğitim yapılandırmasını ayarlayabilirsiniz.
test_x = scaler.transform(test_x.reshape(test_x.shape[0], -1))
test_x = test_x.reshape(test_x.shape[0], test_x.shape[1], -1)
loss, accuracy = model.evaluate(test_x, test_y)
print(f'Test Loss: {loss:.4f}')
print(f'Test Accuracy: {accuracy*100:.2f}%')
Ardından, test verilerindeki kaybı ve doğruluğu hesaplamak için modelin değerlendirme yöntemini kullanırız. Değerlendirme yöntemi, test girdi verilerini (test_x) ve karşılık gelen temel doğruluk etiketlerini (test_y) alır. Hesaplanan kayıp ve doğruluk konsola yazdırılır.
Komut dosyanızın başında gerekli modülleri içe aktarmayı unutmayın:
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dropout, BatchNormalization, Dense
Bu kod, alım/satım sınıflandırma göreviniz için bir LSTM modeli eğitmenize, verileri normalleştirmenize ve modelin test setindeki performansını değerlendirmenize olanak tanır. Özel gereksinimlerinize göre herhangi bir ayarlama veya değişiklik yapmaktan çekinmeyin.