TensorFlow 2.0'ın yeni özelliklerini göstermek için derin pekiştirmeli öğrenmenin ayrıntılı açıklaması (kod)
Xin Zhiyuan Rehberi TensorFlow yeni performansın 2.0 sürümünü resmen yayınladığından beri, birçok kişi bu konuda biraz kafa karıştırabilir. Bu nedenle, blog yazarı Roman Ring, derin pekiştirmeli öğrenme algoritmaları uygulayarak TensorFlow 2.0'ın özelliklerini özel olarak gösteren bir genel bakış makalesi yazdı.
Ne demişler uygulama Gerçek bilgi.
TensorFlow 2.0'ın özelliklerinin açıklanmasından bu yana bir süre geçti, ancak birçok kişi hala kayıpta olmalı.
Bu eğitimde yazar, özellikle gelecek TensorFlow 2.0'ın özelliklerini göstermek için derin pekiştirmeli öğrenmeyi (DRL) kullanır. Üstün aktör-eleştirmen (A2C) aracıları uygulayarak klasik CartPole-v0 ortamını çözün .
Yazarın bu makaledeki amacı TensorFlow 2.0'ı sergilemek olsa da, ilk olarak alana kısa bir genel bakış da dahil olmak üzere DRL yönlerini tanıttı.
Aslında, sürüm 2.0'ın ana odağı geliştiricilerin işini basitleştirmek, yani kullanım kolaylığı olduğundan, şimdi DRL'ye girmek için TensorFlow'u kullanmak için iyi bir zaman.
Bu makale için tam kod kaynak bağlantısı :
GitHub : Https://github.com/inoryy/tensorflow2-deep-reinforcement-learning
Google Colab : Https://colab.research.google.com/drive/12QvW7VZSzoaF-Org-u-N6aiTdBN5ohNA
Kurulum
TensorFlow 2.0 hala deneysel aşamada olduğu için ayrı (sanal) bir ortama kurulması tavsiye edilir. Anaconda'yı kullanmayı tercih ediyorum, bu yüzden burada açıklayacağım:
> conda create -n tf2 python = 3.6 > kaynak etkinleştir tf2 > pip install tf-nightly-2.0-preview # tf-nightly-gpu-2.0-önizleme GPU sürümü içinHer şeyin beklendiği gibi çalıştığını hızlıca doğrulayalım:
> > > tensorflow'u tf olarak içe aktar > > > baskı (tf .__ version__) 1.13.0-dev20190117 > > > print (tf.executing_eagerly ()) Doğru1.13.x sürümü için endişelenmeyin, bu yalnızca erken bir önizlemedir. Varsayılan olarak istekli modda olduğumuzu burada belirtmek gerekir!
> > > baskı (tf.reduce_sum ()) tf.Tensor (15, şekil = (), dtype = int32)Okuyucu istekli moda aşina değilse, o zaman basit terimlerle, esasen hesaplamanın önceden derlenmiş bir grafik yerine çalışma zamanında yapıldığı anlamına gelir. Okuyucular ayrıca TensorFlow belgelerinde bununla ilgili daha fazla bilgi edinebilir:
https://www.tensorflow.org/tutorials/eager/eager_basics
Derin takviye öğrenme
Genel olarak konuşursak, pekiştirmeli öğrenme, sıralı karar problemlerini çözmek için gelişmiş bir çerçevedir. RL ajanı, belirli gözlemlere dayalı eylemler gerçekleştirerek çevrede gezinir ve buna göre ödüllendirilir. Çoğu RL algoritmasının çalışma prensibi, aracı tarafından bir yörüngede toplanan ödüllerin toplamını maksimize etmektir.
RL tabanlı bir algoritmanın çıktısı genellikle bir stratejidir - durumları işlemlerle eşleştiren bir işlev. Etkili stratejiler, sabit kodlu işlemsiz işlemler kadar basit olabilir. Rastgele bir strateji, belirli bir durumda davranışın koşullu olasılık dağılımı olarak ifade edilir.
Oyuncu-eleştirmen yöntemi
RL algoritmaları genellikle optimize edilmiş amaç fonksiyonuna göre gruplandırılır. Değere dayalı yöntemler (DQN gibi), beklenen durum eylem değerindeki hatayı azaltarak çalışır.
Politika gradyanı (Politika Gradyan) yöntemi, genellikle gradyan inişi yoluyla parametrelerini ayarlayarak politikanın kendisini doğrudan optimize eder. Gradyanı tam olarak hesaplamak genellikle çok zordur, bu nedenle gradyanı tahmin etmek için genellikle Monte-Carlo yöntemi kullanılır.
En popüler yöntem, ikisinin bir karışımıdır: temsilci stratejisinin "politika eğimi" ile optimize edildiği ve değer temelli yöntemin beklenen değer tahmini için bir kılavuz olarak kullanıldığı, aktör açısından kritik yöntem.
Aktör için derinlemesine değerlendirme yöntemi
Pek çok temel RL teorisi, tablo halindeki durumlarda geliştirilmiş olsa da, modern RL neredeyse tamamen yapay sinir ağları gibi işlev yaklaşımlayıcılarla yapılır. Spesifik olarak, strateji ve değer işlevi derin bir sinir ağı tarafından yaklaştırılırsa, RL algoritması "derin" olarak kabul edilir.
Eşzamansız avantaj (eşzamansız avantaj) aktör açısından kritik
Yıllar içinde örnek verimliliği ve öğrenme sürecinin kararlılığı sorununu çözmek için bazı iyileştirmeler yapılmıştır.
İlk olarak, gradyan getiri ile ağırlıklandırılır: indirimli gelecek ödülleri, kredi tahsisi sorununu bir dereceye kadar hafifletir ve teorik problemi sonsuz bir zaman adımıyla çözer.
İkinci olarak, orijinal getiri yerine avantaj işlevini kullanın. Getiriler ve taban çizgileri arasındaki fark (durum eylem tahminleri gibi), belirli bir işlemin belirli bir ortalamaya kıyasla ne kadar iyi olduğunun bir ölçüsü olarak görülebilen bir avantaj oluşturur.
Üçüncüsü, aracının çeşitli stratejileri tam olarak keşfetmesini sağlamak için amaç işlevinde ek bir entropi maksimizasyonu terimi kullanın. Temelde, olasılık dağılımının rastgeleliğini ölçmek için entropi tekdüze bir dağılımla maksimize edilir.
Son olarak, örnek toplamayı hızlandırmak için paralel olarak birden çok işçi kullanılır ve eğitim sırasında birbirleriyle ilişkilerini gidermelerine yardımcı olur.
Tüm bu değişiklikleri derin sinir ağlarıyla birleştirerek, en popüler iki modern algoritmaya sahibiz: Eşzamansız avantaj aktör açısından kritik algoritma Veya kısaca A3C / A2C . İkisi arasındaki fark teorik olmaktan çok tekniktir: Adından da anlaşılacağı gibi, paralel işçinin gradyanını nasıl tahmin ettiğini ve modele yaydığını gösteriyor.
Bunlarla DRL yöntemi yolculuğumuza son vereceğim çünkü bu blog yazısının odak noktası TensorFlow 2.0 özellikleri. Konudan hala emin değilseniz endişelenmeyin, kod örnekleriyle her şey daha net ve netleşecek.
Advantage Actor-Critic'i uygulamak için TensorFlow 2.0'ı kullanın
Çeşitli modern DRL algoritmalarını uygulamanın temelinin ne olduğunu görelim: aktör-eleştirmen ajan , Önceki bölümde anlatıldığı gibi. Basitlik uğruna, çoğu kod bunu desteklese de paralel işçileri uygulamayacağız. İlgilenen okuyucular bunu bir uygulama fırsatı olarak kullanabilir.
Test platformu olarak CartPole-v0 ortamını kullanacağız. Biraz basit olmasına rağmen yine de iyi bir seçimdir.
Keras model API'si aracılığıyla elde edilen stratejiler ve değer
Öncelikle, tek bir model sınıfı altında bir strateji ve değer tahmini sinir ağı oluşturalım:
numpy'yi np olarak içe aktar tensorflow'u tf olarak içe aktar tensorflow.keras.layers'ı kl olarak içe aktar sınıf ProbabilityDistribution (tf.keras.Model): def çağrısı (self, logits): # Verilen günlüklerden rastgele bir kategorik işlemi örnekleyin return tf.squeeze (tf.random.categorical (logits, 1), axis = -1) sınıf Model (tf.keras.Model): def __init __ (self, num_actions): super () .__ init __ ('mlp_policy') # tf.get_variable () yok, sadece basit Keras API'si self.hidden1 = kl.Dense (128, etkinleştirme = 'relu') self.hidden2 = kl.Dense (128, etkinleştirme = 'relu') self.value = kl.Dense (1, ad = 'değer') # günlük, normalize edilmemiş günlük olasılıklarıdır self.logits = kl.Dense (num_actions, name = 'policy_logits') self.dist = Olasılık Dağıtımı () def çağrısı (öz, girişler): # inputs uyuşmuş bir dizidir, Tensöre dönüştür x = tf.convert_to_tensor (girdiler, dtype = tf.float32) # aynı giriş tensöründen gizli katmanları ayırın hidden_logs = self.hidden1 (x) hidden_vals = self.hidden2 (x) self.logits (hidden_logs), self.value (hidden_vals) döndür def action_value (self, obs): # başlık altında çağrıyı () yürütür günlükler, değer = self.predict (gözlem) eylem = self.dist.predict (günlükler) # daha basit bir seçenek, neden kullanmadığımız daha sonra anlaşılacaktır # action = tf.random.categorical (günlükler, 1) return np.squeeze (eylem, eksen = -1), np.squeeze (değer, eksen = -1)Ardından modelin beklendiği gibi çalıştığını doğrulayın:
ithalat spor salonu env = gym.make ('CartPole-v0') model = Model (num_actions = env.action_space.n) obs = env.reset () # feed_dict veya tf.Session () gerekmez eylem, değer = model.action_value (gözlem) print (eylem, değer) #Burada dikkat edilmesi gerekenler:
- Model katmanı ve yürütme yolu ayrı ayrı tanımlanır
- "Girdi" katmanı olmadan, model orijinal numpy dizisini kabul eder
- API fonksiyonu aracılığıyla bir modelde iki hesaplama yolu tanımlanabilir
- Model, eylem örneklemesi gibi bazı yardımcı yöntemler içerebilir
- Hevesli modda, her şey orijinal numpy dizisinden çalıştırılabilir
Rastgele Temsilci
Şimdi A2CAgent sınıfına geçelim. İlk olarak, tüm bölümü çalıştıran ve ödüllerin toplamını döndüren bir test yöntemi ekleyelim.
A2CAgent sınıfı: def __init __ (öz, model): self.model = model def test (self, env, render = True): obs, tamamlandı, ep_reward = env.reset (), False, 0 bitmemişken: eylem, _ = self.model.action_value (gözlem) gözlem, ödül, tamam, _ = ortam. adım (eylem) ep_reward + = ödül eğer render: env.render () ep_reward döndürRastgele başlatılan ağırlıklar altında modelin puanına bakalım:
aracı = A2CAgent (model) rewards_sum = agent.test (env) print ("% d / 200"% rewards_sum) # 200 üzerinden 18Hala en iyiden uzak, bir sonraki bölüm eğitim kısmı!
Kayıp / amaç işlevi
DRL'ye genel bakış bölümünde anlattığım gibi, aracı, bazı kayıp (nesnel) işlevine dayalı olarak gradyan inişiyle stratejisini geliştirir. Aktör-eleştirmen olarak, üç hedef için eğitim alıyoruz: stratejiyi iyileştirmek için avantaj ağırlıklı gradyan artı entropi maksimizasyonunu kullanın ve değer tahmin hatasını en aza indirin.
tensorflow.keras.losses'i kls olarak içe aktar tensorflow.keras.optimizers'ı ko olarak içe aktar A2CAgent sınıfı: def __init __ (öz, model): Kayıp terimleri için # hiperparametre self.params = {'değer': 0.5, 'entropi': 0.0001} self.model = model self.model.compile ( optimize edici = ko.RMSprop (lr = 0.0007), # politika günlükleri ve değer tahmini için ayrı kayıpları tanımlayın kayıp = ) def test (self, env, render = True): # önceki bölümden değişmedi ... def _value_loss (self, dönüşler, değer): # değer kaybı, tipik olarak değer tahminleri ve getiriler arasındaki MSE'dir dönüş self.params * kls.mean_squared_error (döndürür, değer) def _logits_loss (self, actions_and_advs, logits): # Aynı API aracılığıyla eylemleri ve avantajları girmek için bir numara eylemler, avantajlar = tf.split (actions_and_advs, 2, axis = -1) # Seyrek ve ağırlıklı seçenekleri destekleyen polimorfik CE kaybı işlevi # from_logits argümanı, normalleştirilmiş olasılıklara dönüşümü sağlar cross_entropy = kls.CategoricalCrossentropy (from_logits = True) # politika kaybı, avantajlarla ağırlıklandırılan politika gradyanlarıyla tanımlanır # not: Kaybı yalnızca gerçekten gerçekleştirdiğimiz eylemler üzerinden hesaplarız # böylelikle kaputun altında, CE kaybının seyrek bir versiyonu uygulanacaktır eylemler = tf.cast (eylemler, tf.int32) policy_loss = cross_entropy (eylemler, günlükler, örnek_ağırlık = avantajlar) # entropi kaybı CE üzerinden kendi başına hesaplanabilir entropy_loss = cross_entropy (günlükler, günlükler) # burada işaretler ters çevrilir çünkü optimize edici en aza indirir iade policy_loss-self.params * entropy_lossAmaç işlevini tamamladık! Kodun çok kompakt olduğuna dikkat edin: kodun kendisinden neredeyse daha fazla yorum satırı vardır.
Aracı Eğitim Döngüsü
Son olarak, bir eğitim döngüsü var. Biraz uzun ama oldukça basit: örnekler toplayın, ödülleri ve avantajları hesaplayın ve bunun üzerine bir model eğitin.
A2CAgent sınıfı: def __init __ (öz, model): Kayıp terimleri için # hiperparametre self.params = {'değer': 0.5, 'entropi': 0.0001, 'gama': 0.99} # önceki bölümden değişmedi ... def train (self, env, batch_sz = 32, güncellemeler = 1000): # tek bir veri grubu için depolama yardımcıları eylemler = np.empty ((batch_sz,), dtype = np.int32) ödüller, bağışlar, değerler = np.empty ((3, batch_sz)) gözlemler = np.empty ((batch_sz,) + env.observation_space.shape) # eğitim döngüsü: örnekleri toplayın, optimize ediciye gönderin, güncelleme zamanlarını tekrarlayın ep_rews = next_obs = env.reset () aralıktaki güncelleme için (güncellemeler): aralıktaki adım için (batch_sz): gözlemler = next_obs.copy () eylemler, değerler = self.model.action_value (sonraki_oblar) next_obs, ödüller, bağışlar, _ = ortam.adım (eylemler) ep_rews + = ödüller bağışlarsa: ep_rews.append (0.0) next_obs = env.reset () _, next_value = self.model.action_value (sonraki_ gözlemler) döndürür, avantajlar = self._returns_advantages (ödüller, bağışlar, değerler, sonraki_değer) # Aynı API aracılığıyla eylemleri ve avantajları girmek için bir numara act_and_advs = np.concatenate (, axis = -1) # toplanan grup üzerinde tam bir eğitim adımı gerçekleştirir # not: gradyanlarla uğraşmanıza gerek yok, bunu Keras API halleder kayıplar = self.model.train_on_batch (gözlemler,) ep_rews döndür def _returns_advantages (kişi, ödüller, bağışlar, değerler, sonraki_değer): # next_value, gelecekteki bir durumun önyükleme değeri tahminidir (kritik) döndürür = np.append (np.zeros_like (ödüller), sonraki_değer, eksen = -1) # iade, gelecekteki ödüllerin indirimli toplamı olarak hesaplanır ters çevrilmiş t için (aralık (rewards.shape)): döner = ödüller + self.params * döner * (1-bağış) döner = döner # avantaj geri dönüşler-referans, bizim durumumuzda değer tahminleridir avantajlar = döner-değerler iade iadeleri, avantajları def test (self, env, render = True): # önceki bölümden değişmedi ... def _value_loss (self, dönüşler, değer): # önceki bölümden değişmedi ... def _logits_loss (self, actions_and_advs, logits): # önceki bölümden değişmedi ...Eğitim sonucu
Artık bu tek çalışan A2C aracısını CartPole-v0'da eğitmeye hazırız! Eğitim süreci yalnızca birkaç dakika sürmelidir. Eğitimden sonra, 200 puanlık hedefe başarıyla ulaşan bir temsilci görmelisiniz.
rewards_history = agent.train (env) print ("Eğitim tamamlandı, test ...") print ("% d / 200"% agent.test (env)) # 200 üzerinden 200
Kaynak koduna, rewards_history'nin yanı sıra devam eden bölümün ödüllerini ve kayıplarını yazdırabilen bazı ek yardımcı programlar ekledim.
Statik hesaplama grafiği
İstekli mod o kadar iyi çalışıyor ki, statik görüntü uygulamasının da mümkün olup olmadığını merak edebilirsiniz. Tabii ki olabilir! Ayrıca, statik grafik yürütmeyi etkinleştirmek için yalnızca bir satır daha kod eklemeniz gerekir.
tf.Graph (). as_default () ile: print (tf.executing_eagerly ()) # False model = Model (num_actions = env.action_space.n) aracı = A2CAgent (model) rewards_history = agent.train (env) print ("Eğitim tamamlandı, test ...") print ("% d / 200"% agent.test (env)) # 200 üzerinden 200Unutulmaması gereken bir nokta, statik grafiğin yürütülmesi sırasında sadece Tensörleri kullanamayacağımızdır, bu yüzden model tanımlaması sırasında Kategorik Dağılım tekniğini kullanmamız gerekir.
Bir şey daha...
TensorFlow'un varsayılan olarak istekli modda çalıştığını ve hatta bunu kanıtlamak için bir kod parçacığı kullandığını söylediğimi hatırlıyor musunuz? Sana yalan söyledim.
Modelleri oluşturmak ve yönetmek için Keras API kullanırsanız, o zaman bunları alttaki statik grafiklerde derlemeye çalışır. Yani sonuçta elde ettiğiniz şey, istekli yürütme esnekliğine sahip statik bir hesaplama grafiğinin performansıdır.
Modelin durumunu model.run_eager bayrağından kontrol edebilirsiniz ve ayrıca bu bayrağı True olarak ayarlayarak istekli modun kullanımını zorlayabilirsiniz, ancak çoğu durumda bu gerekli olmayabilir - Keras istekli modu atlamanın bir yolu olmadığını tespit ederse, Otomatik olarak çıkacaktır.
Gerçekten de statik bir grafik olarak çalıştığını göstermek için, işte basit bir karşılaştırma testi:
# 100000 numune grubu oluşturun env = gym.make ('CartPole-v0') obs = np.repeat (env.reset (), 100000, axis = 0)Hevesli Benchmark
%%zaman model = Model (env.action_space.n) model.run_eagerly = Doğru print ("Hevesli Yürütme:", tf.executing_eagerly ()) print ("Hevesli Keras Modeli:", model.run_eagerly) _ = model (gözlem) ######## Sonuçlar ####### Hevesli Yürütme: Doğru Hevesli Keras Modeli: Doğru CPU süreleri: kullanıcı 639 ms, sys: 736 ms, toplam: 1.38 sStatik Kıyaslama
%%zaman tf.Graph (). as_default () ile: model = Model (env.action_space.n) print ("Hevesli Yürütme:", tf.executing_eagerly ()) print ("Hevesli Keras Modeli:", model.run_eagerly) _ = model.predict (gözlem) ######## Sonuçlar ####### Hevesli Yürütme: Yanlış Hevesli Keras Modeli: Yanlış CPU süreleri: kullanıcı 793 ms, sys: 79,7 ms, toplam: 873 msVarsayılan Karşılaştırma
%%zaman model = Model (env.action_space.n) print ("Hevesli Yürütme:", tf.executing_eagerly ()) print ("Hevesli Keras Modeli:", model.run_eagerly) _ = model.predict (gözlem) ######## Sonuçlar ####### Hevesli Yürütme: Doğru Hevesli Keras Modeli: Yanlış CPU süreleri: kullanıcı 994 ms, sys: 23.1 ms, toplam: 1.02 sGördüğünüz gibi, istekli mod statik moddan sonra yer almaktadır.Varsayılan olarak, model gerçekten statik olarak çalıştırılır.
sonuç olarak
Umarım bu makale DRL'yi ve yakında çıkacak olan TensorFlow 2.0'ı anlamak için yararlıdır. Lütfen TensorFlow 2.0'ın yalnızca bir önizleme sürümü olduğunu ve her şeyin değişebileceğini unutmayın.TensorFlow'dan özellikle hoşlanmıyorsanız (veya beğeniyorsanız :)), lütfen geliştiriciye geri bildirimde bulunun.
Her zaman sorulan soru, TensorFlow'un PyTorch'tan daha iyi olup olmadığıdır. Belki öyledir, belki değil. Her ikisi de iyi kitaplıklardır, bu nedenle hangisinin daha iyi olduğunu söylemek zor. PyTorch'a aşina iseniz, TensorFlow 2.0'ın sadece onu yakalamakla kalmayıp, aynı zamanda PyTorch API'sinin bazı kusurlarını da ortadan kaldırdığını fark edebilirsiniz.
Sonunda kim kazanırsa kazansın, geliştiriciler için bu rekabet her iki tarafa da net olumlu sonuçlar getirdi ve bu çerçevelerin gelecekte ne hale geleceğini görmek için sabırsızlanıyorum.
