Derin Pekiştirmeli Öğrenme için TorchRL’e Başlangıç

TorchRL’i Kurma

Bu bölümde TorchRL’i nasıl kuracağınızı ve kullanmaya nasıl başlayacağınızı göstereceğim. 

Önkoşullar

TorchRL’i kurmadan ve kullanmadan önce birkaç bağımlılık yazılım paketine ihtiyacınız var:

• PyTorch: TorchRL, PyTorch üzerine kurulu olduğundan önkoşuldur. 
• Gymnasium: RL ortamlarını içe aktarmak için Gymnasium paketine ihtiyaç duyarsınız. Ocak 2025 itibarıyla, Gymnasium’un en son sürümü TorchRL ile uyumlu değildir; bu durum şu Git Discussions sayfasında açıklanmıştır. Bu nedenle eski sürüm olan 0.29.1 sürümünü kurun. 
• PyGame: Video oyunları için bir Python paketidir.  TorchRL, CartPole gibi oyun benzeri RL ortamlarını simüle etmek için buna ihtiyaç duyar. 
• TensorDict: Sinir ağlarının girdi ve çıktılarının sözlük benzeri bir veri yapısında tutulması, TorchRL’de tensörlerle çalışmayı kolaylaştırır. TensorDict, tensörleri anahtar-değer çiftleri olarak saklayan bir tensör konteyneri sağlar. 

Önkoşul paketlerini kurun:

!pip install torch tensordict  gymnasium==0.29.1 pygame

TorchRL’in kurulumu

TorchRL’i pip kullanarak kurun. Kişisel bir bilgisayar veya sunucuda çalışıyorsanız bu paketleri bir Conda ortamına kurmanızı şiddetle tavsiye ederim. 

!pip install torchrl

Kurulumu doğrulama

Kurulumdan sonra, TorchRL’in başarıyla yüklendiğini test edin. Bir Python kabuğunda (veya not defterinde) torchrl içe aktarmayı deneyin. Standart bir ortamın (ör. CartPole) torchrl özellikleriyle eşleştiğini kontrol etmek için check_env_specs() yöntemini kullanın:

import torchrl 
from torchrl.envs import GymEnv 
from torchrl.envs.utils import check_env_specs

check_env_specs(GymEnv("CartPole-v1"))

Çıktı, ortamın başarıyla oluşturulduğunu ve TorchRL ile çalıştığını belirtmelidir. 

[torchrl][INFO] check_env_specs succeeded!

TorchRL’in Temel Bileşenleri

İlk RL ajanınızı oluşturmadan önce TorchRL’in temel yapı taşlarına bakalım.

Ortamlar

TorchRL, farklı ortamlarla arayüz oluşturmak için tek tip bir API sağlar. Bunu, ortama özgü işlevsellikleri standart bir sarmalayıcı sınıflar ve fonksiyonlar kümesine sararak yapar. Uygun parametreleri sarmalayıcıya verirsiniz; o da komutunuzu ilgili ortama karşılık gelen fonksiyon çağrısına dahili olarak eşler. Özellikle:

• TorchRL, ortam durumlarını (gözlemler), eylemleri ve ödülleri PyTorch tensör nesnelerine dönüştürür; bunlar doğrudan RL algoritmalarını uygulayan modüller tarafından kullanılabilir.
• Ön işleme ve son işleme adımlarını uygulamayı mümkün kılar; örneğin, girdi tensörlerini normalize etmek ve ölçeklemek ya da çıktı tensörlerini belirli bir formatta sunmak.

Örneğin Gymnasium’dan bir ortam oluşturmak için GymEnv modülünü kullanın:

env = GymEnv("CartPole-v1")

Dönüşümler

Hazır ortamı, normalde kendinizin uygulaması gerekecek eklenti özellikler ve dönüşümlerle genişletmek yaygındır. Örneğin, sayacı kendiniz kodlamak yerine ortama bir adım sayacı modülü ekleyebilirsiniz. Adım sayacı her bölümdeki adım sayısını takip eder. transformedEnv modülü bu konuda yardımcı olur:

from torchrl.envs import GymEnv, StepCounter, TransformedEnv
env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())

Benzer şekilde, tensörleri üzerinde işlem yapmadan önce normalleştirmek yaygın bir ön işleme adımıdır. ObservationNorm modülü ile yapılan bir normalizasyon dönüşümü tensörleri normalleştirir. TransformedEnv fonksiyonunun dokümantasyonu çeşitli dönüşüm türlerini açıklar. 

Ayrıca compose() parametresiyle birden fazla dönüşümü birleştirebilirsiniz:

base_env = GymEnv('CartPole-v1', device=device) 

env = TransformedEnv( 
    base_env, 
    Compose(
        ObservationNorm(in_keys=["observation"]), 
        StepCounter()
    )
)

Ajanlar ve politikalar

RL’de ajan, ortamın gözlemlenen durumuna ve politikaya dayanarak eylemlerine karar verir. Ajanın amacı, ortamdan aldığı kümülatif ödülleri en üst düzeye çıkarmaktır. Doğru eylemi seçtiğinde (ör. kırmızı ışıkta durmak) ödül alır. 

Örneğin bir otonom araçta, aracı süren ajandır. Kararları (ör. aracı belirli bir yöne çevirmek), ortamın durumu (ör. trafik, aracın konumu vb.) ve politikası (ör. yayalardan ve diğer engellerden kaçınmak, kırmızı ışıkta durmak vb.) temel alınarak verilir. 

En basit politika, rastgele bir eylem seçmektir. Aktör, olası eylemler uzayından rastgele birini seçer. Rastgele politika, bazen modeli eğitmeye başlamadan önce ilk etkileşim veri kümesini üretmek için kullanılır. 

RandomPolicy modülünü kullanarak rastgele bir politika oluşturun. Bu rastgele politika, eylem uzayını belirten bir action_spec parametresi alır. Aşağıdaki örnekte eylem uzayı -1 ile +1 arasındaki (sürekli) sayılardan oluşur. Dolayısıyla, rastgele politika -1 ile +1 arasında rastgele bir sayıyla temsil edilen bir eylem seçer. 

import torchrl 
import torch
from tensordict import TensorDict
from torchrl.data.tensor_specs import Bounded

action_spec = Bounded(-torch.ones(1), torch.ones(1))
actor = torchrl.envs.utils.RandomPolicy(action_spec=action_spec) 
td = actor(TensorDict({}, batch_size=[])) 
print(td.get("action"))

Çıktı, aşağıda gösterildiği gibi bir tensör olmalıdır:

tensor([0.9258])

Aktörü tekrar çalıştırarak politikanın gerçekten rastgele olduğunu kontrol edin:

td = actor(TensorDict({}, batch_size=[])) 
print(td.get("action"))

Farklı bir rastgele tensör çıktısı vermelidir.

RL kavramlarına hızlı bir girişe ihtiyacınız varsa, DataCamp’teki Python ile Pekiştirmeli Öğrenme beceri yoluna göz atın!

TorchRL ile İlk RL Ajanınızı Oluşturma

Bu bölümde, TorchRL kullanarak basit bir Pekiştirmeli Öğrenme ajanını nasıl uygulayacağınızı göstereceğim. 

Başlamadan önce, Python’da gerekli yazılım paketlerini içe aktarın:

• time: ajanın eğitilmesi için geçen süreyi ölçmek.
• GymEnv, StepCounter ve TransformedEnv: Gymnasium ortamlarıyla çalışmak.
• MLP: basit bir MLP (çok katmanlı algılayıcı) sinir ağı oluşturmak. 
• EGreedyModule: ortamı keşfetme ve en iyi bilinen politikadan faydalanma dengesini kurmak.
• QValueModule ve DQNLoss : Derin Q-Öğrenme algoritmasını uygulamak.
• SoftUpdate: sinir ağını güncellemek.
• SyncDataCollector: ajanın etkileşimlerinden veri toplamak. 
• ReplayBuffer: ajanın etkileşimlerinden gelen veriyi depolamak.
• Adam: geri yayılım için.
• matplotlib: eğitim ilerlemesini görselleştirmek. 
• torchrl_logger: eğitim oturumunu kaydetmek.

import time
import matplotlib.pyplot as plt
from torchrl.envs import GymEnv, StepCounter, TransformedEnv
from tensordict.nn import TensorDictModule as TensorDict, TensorDictSequential as Seq
from torchrl.modules import EGreedyModule, MLP, QValueModule
from torchrl.objectives import DQNLoss, SoftUpdate
from torchrl.collectors import SyncDataCollector
from torchrl.data import LazyTensorStorage, ReplayBuffer
from torch.optim import Adam
from torchrl._utils import logger as torchrl_logger

Adım 1: Ortamı tanımlayın

Bu örnekte CartPole ortamını çözüyoruz. Eğitim adımlarının sayısını takip etmek için bir adım sayacıyla birlikte bu ortamı Gymnasium’dan içe aktarın:

env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())

Eğitim oturumları arasında benzer sonuçlar çoğaltmak için Python ve RL ortamlarını tohumlayın. 

torch.manual_seed(0)
env = TransformedEnv(GymEnv("CartPole-v1"), StepCounter())
env.set_seed(0)

Eğitim için parametreleri ve hiperparametreleri tanımlayın: 

• INIT_RAND_STEPS: Ajanın, politikayı kullanmaya başlamadan önce rastgele davrandığı adım sayısı. Bu ilk adımlar, politikayı eğitmeye başlamak için başlangıç verisini toplamakta kullanılır.
• FRAMES_PER_BATCH: Bir eğitim yığınındaki veri noktası sayısı (her etkileşim veya zaman adımı için bir tane). 
• OPTIM_STEPS: Geri yayılımın tek bir geçişini çalıştırmadan önce kayıpların biriktirileceği adım sayısı. 
• EPS_0: Keşif katsayısı epsilon’un başlangıç değeri. 
• BUFFER_LEN: Tekrar oynatma tamponunun boyutu.
• ALPHA: Öğrenme oranı.
• TARGET_UPDATE_EPS: yumuşak güncelleme modülü kullanılarak hedef ağın güncellenmesi için bozunma faktörü.
• REPLAY_BUFFER_SAMPLE: Her eğitim yinelemesinde tekrar oynatma tamponundan seçilecek rastgele örneğin boyutu. Tekrar oynatma tamponu, her zaman adımında ajanın ortamla etkileşimlerinin sonuçlarını saklar. 
• LOG_EVERY: Eğitim ilerlemesinin yazdırılacağı adım sayısı.
• MLP_SIZE: Sinir ağının boyutu.

INIT_RAND_STEPS = 5000 
FRAMES_PER_BATCH = 100
OPTIM_STEPS = 10
EPS_0 = 0.5
BUFFER_LEN = 100_000
ALPHA = 0.05
TARGET_UPDATE_EPS = 0.95
REPLAY_BUFFER_SAMPLE = 128
LOG_EVERY = 1000
MLP_SIZE = 64

Adım 2: Politikayı oluşturun

Politikayı uygulamak için basit bir sinir ağı tanımlayın: 

• MLP’yi (sinir ağı) tanımlayın. Bir gözlem verildiğinde, MLP eylem değerini çıktılar; fiilen Q-fonksiyonunun işini yapar. 
• TensorDict modülünü kullanarak yukarıdaki MLP üzerinde bir tensör sözlüğü tanımlayın. Bu sözlük, ortamın durum gözlemlerini (sözlük anahtarları) o duruma karşılık gelen eylem olasılık değerlerine (sözlük değerleri) eşler. 
• Q-fonksiyonunu uygulamak için QValueModule'ü kullanın. Eylem değerleri içeren bir tensör verildiğinde, en yüksek eylem değerine karşılık gelen eylemi döndürür. Açgözlü (sömürü) stratejisini uygular. 
• Politikayı tanımlamak için MLP’nin tensör sözlüğü ile QValueModule'ü TensorDictSequential modülüyle birleştirin. 

value_mlp = MLP(out_features=env.action_spec.shape[-1], num_cells=[MLP_SIZE, MLP_SIZE])
value_net = TensorDict(value_mlp, in_keys=["observation"], out_keys=["action_value"])
policy = Seq(value_net, QValueModule(spec=env.action_spec))

• EGreedyModule kullanarak keşif fonksiyonunu tanımlayın – girdi olarak ortamın eylem uzayını, tekrar oynatma tamponunun uzunluğunu ve keşif katsayısı epsilon’u alır. Nihai politikayı elde etmek için bu keşif fonksiyonunu, yukarıda tanımlanan politikayla TensorDictSequential modülü aracılığıyla birbirine zincirleyin:

exploration_module = EGreedyModule(
    env.action_spec, annealing_num_steps=BUFFER_LEN, eps_init=EPS_0
)
policy_explore = Seq(policy, exploration_module)

Adım 3: Ajana eğitim verin

Ajanı eğitmenin ilk adımı, ajanın ortamla etkileşimlerinden gelen verileri toplamaktır. SyncDataCollector kullanarak, politikayı çalıştıran ve ajanın etkileşim sonuçlarını toplayan bir toplayıcı oluşturun: 

collector = SyncDataCollector(
    env,
    policy_explore,
    frames_per_batch=FRAMES_PER_BATCH,
    total_frames=-1,
    init_random_frames=INIT_RAND_STEPS,
)

Etkileşim sonuçlarını depolamak için bir tekrar oynatma tamponu oluşturun:

rb = ReplayBuffer(storage=LazyTensorStorage(BUFFER_LEN))

Ayrıca, kayıp fonksiyonu (DQN tabanlı kayıp hesaplaması için), eniyileyici (klasik Adam algoritması) ve güncelleyiciler (sinir ağını güncellemek için) gibi eğitime özgü modülleri de tanımlamanız gerekir. Bunların tümü önceden tanımlanmış TorchRL modüllerine dayanır:

loss = DQNLoss(value_network=policy, action_space=env.action_spec, delay_value=True)
optim = Adam(loss.parameters(), lr=ALPHA)
updater = SoftUpdate(loss, eps=TARGET_UPDATE_EPS)

Toplam adım ve bölüm sayısını, bölüm başına başarılı adımları ve yürütme süresini takip etmek için sayaçları başlatın:

total_count = 0
total_episodes = 0
t0 = time.time()
success_steps = []

Eğitim fonksiyonu 2 for döngüsünden oluşur: 

• En dıştaki döngü politikayı yürütür ve ajanın etkileşim sonuçlarını tekrar oynatma tamponuna ekler.
• İç döngü eğitim örneklerini yığınlara böler. Her yığını şu şekilde işler: 
• Tekrar oynatma tamponundan rastgele bir örnek seçin.
• Kayıpları kayıp fonksiyonu kullanarak hesaplayın.
• Eniyileyiciyi ve güncelleyiciyi çalıştırın.
• Sayaçları güncelleyin.

Her adım, sıfırdan hiçbir şey kodlamadan hazır TorchRL modüllerini çağırmayı içerir. Aşağıdaki kod, bu adımların nasıl uygulanacağını gösterir:

for i, data in enumerate(collector):
    rb.extend(data)
    max_length = rb[:]["next", "step_count"].max()
    if len(rb) > INIT_RAND_STEPS:
        for _ in range(OPTIM_STEPS):
            sample = rb.sample(REPLAY_BUFFER_SAMPLE)
            loss_vals = loss(sample)
            loss_vals["loss"].backward()
            optim.step()

            optim.zero_grad()
            # Update exploration factor
            exploration_module.step(data.numel())

            # Update target params
            updater.step()
            total_count += data.numel()
            total_episodes += data["next", "done"].sum()
    success_steps.append(max_length)

Adım 4: Ajanı değerlendirin

Önceki bölümdeki döngü politikayı sürekli olarak eğitir. Performansı değerlendirmek için ölçütleri belirlememiz ve eğitimin ne zaman başarılı sayılacağına karar vermemiz gerekir. Ayrıca eğitimin ilerlemesini çıktıda görmek isteriz. 

TorchRL günlüğünü kullanarak belirli aralıklarla eğitim ilerlemesini yazdırıyoruz:

if total_count > 0 and total_count % LOG_EVERY == 0:
    torchrl_logger.info(f"Successful steps in the last episode: {max_length}, rb length {len(rb)}, Number of episodes: {total_episodes}")

Eğitimin başarılı olup olmadığını belirlemek için, ajanın son bölümde ulaştığı maksimum adım sayısını kullanıyoruz. CartPole-v1 ortamı, bölüm başına maksimum adım sayısını ve toplam ödülü 500 ile sınırlar. Bir politikanın 475 adımın üzerinde başarı elde etmesi geleneksel olarak başarılı kabul edilir:

if max_length > 475:
    print("TRAINING COMPLETE")
    break

Yukarıdaki iki kod parçacığı, (daha önce gösterilen) eğitim döngüsünün sonuna eklenmelidir. Aşağıdaki parçacık, ajanın değerlendirilmesi için kod eklenmiş eğitim döngüsünü gösterir: 

for i, data in enumerate(collector):
    # Write data in replay buffer
    rb.extend(data)
    max_length = rb[:]["next", "step_count"].max()
    if len(rb) > INIT_RAND_STEPS:
        for _ in range(OPTIM_STEPS):
            sample = rb.sample(REPLAY_BUFFER_SAMPLE)
            loss_vals = loss(sample)
            loss_vals["loss"].backward()
            optim.step()

            optim.zero_grad()
            # Update exploration factor
            exploration_module.step(data.numel())

            # Update target params
            updater.step()
            total_count += data.numel()
            total_episodes += data["next", "done"].sum()
    success_steps.append(max_length)

    if total_count > 0 and total_count % LOG_EVERY == 0:
        torchrl_logger.info(f"Successful steps in the last episode: {max_length}, rb length {len(rb)}, Number of episodes: {total_episodes}")

    if max_length > 475:
        print("TRAINING COMPLETE")
        break

Son olarak, eğitim ve değerlendirme sonrası toplam eğitim süresini yazdırın ve eğitim ilerlemesini görselleştirin:

t1 = time.time()

torchrl_logger.info(
    f"solved after {total_count} steps, {total_episodes} episodes and in {t1-t0}s."
)

def plot_steps():
    plt.plot(success_steps)
    plt.title('Successful steps over training episodes')
    plt.xlabel('Training episodes')
    plt.ylabel('Steps')
    plt.show()

plot_steps()

Bu DataLab çalışma defterinde TorchRL kullanarak DQN uygulamak için tam kodu bulup çalıştırabilirsiniz. 

Bu bölümde basit DQN algoritmasını kullanarak bir RL ajanı oluşturup eğittik. Sonraki bölümde, TorchRL’in hazır modüllerini kullanarak PPO gibi daha karmaşık bir algoritmanın nasıl uygulanacağını inceleyeceğiz. 

TorchRL’de Hazır Algoritmaları Keşfetme

Önceki bölümlerde belirtildiği gibi TorchRL, birkaç hazır algoritmayla birlikte gelir. Onlara ve nasıl çalıştıklarına göz atalım.

Desteklenen algoritmalar

TorchRL, birçok yaygın Derin Pekiştirmeli Öğrenme algoritması için hazır modüller içerir. Örneğin: 

• Derin Q ağları (DQN)
• Derin belirleyici politika gradyanı (DDPG)
• Yumuşak aktör-eleştirmen (SAC)
• Rastgele topluluklu çift Q-öğrenme (REDQ)
• CrossQ
• Örtük Q-öğrenme (IQL)
• Sürekli Q-öğrenme (CQL)
• Üretici çekişmeli taklit öğrenme (GAIL)
• Karar dönüştürücü (DT)
• İkiz gecikmeli DDPG (TD3) 
• Aktör-avantaj eleştirmen (A2C)
• Yakınsak politika optimizasyonu (PPO)
• REINFORCE
• ve daha fazlası 

Bu, farklı türde algoritmalarla denemeler yapmayı ve belirli bir problemi çözmek için her birinin performansını incelemeyi verimli kılar. 

Örnek: TorchRL’de PPO

Yakınsak Politika Optimizasyonu, keşif ve sömürü dengesini kuran, kesilmiş vekil amaç fonksiyonunu kullanarak düzgün bir eğitim süreci sağlar. 

Bu bölümde TorchRL’deki hazır PPO modülünün nasıl kullanılacağını göstereceğim. Önceki uygulamaya benzer şekilde, önkoşul modülleri içe aktarın. Önceki uygulamada gereken modüllere (ör. ReplayBuffer, SyncDataCollector vb.) ek olarak, PPO için birkaç pakete daha ihtiyaç vardır:

• ProbabilisticActor: eylemi stokastik olarak seçmek için. Eylemi stokastik seçmek (politikayı her zaman izleyip ödülü maksimize etmek yerine), ortamın keşfini ve eğitim sırasında daha iyi yolların bulunmasını kolaylaştırır.
• OneHotCategorical: eylemlerin log olasılıklarını ifade eden tensörün tek-sıcak kodlamasını üretmek için. 
• ValueOperator: değer fonksiyonunu uygulayan sinir ağına dayalı bir TorchRL modülü oluşturmak için.
• GAE: genelleştirilmiş avantaj tahminini uygulamak için. PPO, değer fonksiyonu için bir vekil olarak avantaj fonksiyonunu kullanır. Yukarıdaki değer modülü, GAE’nin girdisidir. 
• ClipPPOLoss: PPO’yu uygulamak için kesme tabanlı amaç fonksiyonunu oluşturmak üzere. 

import torch
from torch import nn

from torchrl.envs import Compose, ObservationNorm, DoubleToFloat, StepCounter, TransformedEnv
from torchrl.envs.libs.gym import GymEnv
from torchrl.envs.utils import check_env_specs
from torchrl.modules import ProbabilisticActor, OneHotCategorical, ValueOperator
from torchrl.collectors import SyncDataCollector
from torchrl.data.replay_buffers import ReplayBuffer
from torchrl.data.replay_buffers.storages import LazyTensorStorage
from torchrl.data.replay_buffers.samplers import SamplerWithoutReplacement
from torchrl.objectives.value import GAE
from torchrl.objectives import ClipPPOLoss
from tensordict.nn import TensorDictModule

Eğitim için parametreleri ve hiperparametreleri tanımlayın:

• FRAMES_PER_BATCH: Ajanın ortamla etkileşimlerinden oluşan her bir veri yığınındaki kare (zaman adımı) sayısı. 
• SUB_BATCH_SIZE: Her alt yığındaki zaman adımı sayısı. PPO eğitiminde her yığın alt yığınlara bölünür. 
• TOTAL_FRAMES: Eğitimin yürütüleceği toplam zaman adımı sayısı. 
• GAMMA: Gelecekteki zaman adımlarından gelen ödülün değerini iskonto etmek için iskonto faktörü.
• CLIP_EPSILON: Politikanın, ardışık eğitim yinelemelerinde değişebileceği güven bölgesini tanımlar. Yeni ve eski olasılıklar arasındaki oranın belirli bir sınır içinde kalması için güncellenmiş politika kırpılarak uygulanır. 
• ALPHA: Öğrenme oranı.
• ENTROPY_EPS: Bu hiperparametre, keşif ve sömürü oranını kontrol eder. 
• OPTIM_STEPS: Eniyileyicinin her alt yığın üzerinde çalıştırılacağı tekrar sayısı. 
• LOG_EVERY: Politikanın değerlendirileceği ve ödüllerin yazdırılacağı adım aralığı. 

FRAMES_PER_BATCH = 1024
TOTAL_FRAMES = 1048576
GAMMA = 0.99
LAMBDA = 0.95
CLIP_EPSILON = 0.2
ALPHA = 1e-4
ENTROPY_EPS = 5e-4 
SUB_BATCH_SIZE = 64
OPTIM_STEPS = 8
LOG_EVERY = 16

Gymnasium’dan temel CartPole ortamını içe aktarın:

device="cpu"
base_env = GymEnv('CartPole-v1', device=device) 

Temel ortamı içe aktararak ve gözlem tensörlerini normalleştirme ile adım sayımı modüllerini ekleyerek TorchRL ortamını tanımlayın:

env = TransformedEnv( 
    base_env, 
    Compose(
        ObservationNorm(in_keys=["observation"]), 
        DoubleToFloat(), 
        StepCounter()
    )
)

Ortamı başlatın ve rastgele sayı üreteçlerini tohumlayın:

env.transform[0].init_stats(1024) 
torch.manual_seed(0)
env.set_seed(0)
check_env_specs(env) 

Aktörü, 1 gizli katmanda 16 ağırlıklı bir sinir ağı olarak tanımlayın. Girdi olarak ortamdan gelen gözlemi alır ve eylem uzayındaki her eylemin olasılığını çıktılar. 

actor_net = nn.Sequential(
    nn.Linear(env.observation_spec["observation"].shape[-1], 32, device=device),
    nn.ReLU(),
    nn.Linear(32, 32, device=device),
    nn.ReLU(),
    nn.Linear(32, env.action_spec.shape[-1], device=device),
    nn.ReLU()
)

Durumları eylem olasılıklarına eşleyen anahtarlar ve değerlerle (yukarıdaki sinir ağına dayalı) bir tensör sözlüğü oluşturun. 

actor_module = TensorDictModule(actor_net, in_keys=["observation"], out_keys=["logits"])

PPO (ve daha birçok RL algoritması) eğitiminde, her zaman bir sonraki adımda en yüksek ödüle götüren eylemi seçmezsiniz. Eylem seçiminde bir miktar rastgelelik olması, ajanın ortamı keşfetmesine ve daha yüksek uzun vadeli getiriler sağlayabilecek daha iyi yolları keşfetmesine olanak tanır. Bunu yapmak için olasılıksal bir aktör oluşturun:

actor = ProbabilisticActor(
    module = actor_module,
    spec = env.action_spec,
    in_keys = ["logits"],
    distribution_class = OneHotCategorical, 
    return_log_prob = True
)

Değer fonksiyonunu uygulayacak ağı oluşturun. Bu ağ 16 ağırlığa sahiptir. Girdi olarak ortamın durumunu (gözlem) alır ve o durumun beklenen değerini çıktılar. 

value_net = nn.Sequential(
    nn.Linear(env.observation_spec["observation"].shape[-1], 16, device=device),
    nn.ReLU(),
    nn.Linear(16, 1, device=device),
    nn.ReLU()
)

ValueOperator() kullanarak (yukarıda uygulanan) değer fonksiyonunu saran bir TorchRL modülü oluşturun. Bu modül, diğer TorchRL bileşenleriyle arayüz oluşturur. 

value_module = ValueOperator(
    module = value_net,
    in_keys = ["observation"]
)

Ajanın ortamla etkileşimlerinin sonuçlarını depolamak için tekrar oynatma tamponunu oluşturun: 

replay_buffer = ReplayBuffer(
    storage = LazyTensorStorage(max_size=FRAMES_PER_BATCH),
    sampler = SamplerWithoutReplacement()
)

Politikayı ortam üzerinde çalıştırmak ve her zaman adımında (karede) ajanın etkileşim sonuçlarını toplamak için bir veri toplayıcı oluşturun:

collector = SyncDataCollector(
    env,
    actor,
    frames_per_batch = FRAMES_PER_BATCH,
    total_frames = TOTAL_FRAMES,
    split_trajs = True,
    reset_at_each_iter = True,
    device=device
)

GAE modülünü, PPO için avantaj fonksiyonunu uygulamak üzere kullanın. Avantaj fonksiyonu, değer fonksiyonuna dayanır. 

advantage_module = GAE(
    gamma = GAMMA, 
    lmbda = GAMMA, 
    value_network = value_module,
    average_gae = True
) 

PPO algoritmasına göre kayıp fonksiyonunu uygulamak için yerleşik ClipPPOLoss modülünü kullanın:

loss_module = ClipPPOLoss(
    actor_network = actor,
    critic_network = value_module,
    clip_epsilon = CLIP_EPSILON,
    entropy_bonus = bool(ENTROPY_EPS),
    entropy_coef = ENTROPY_EPS
)

Adam eniyileyicisini tanımlayın: 

optim = torch.optim.Adam(loss_module.parameters(), lr=ALPHA)

Eğitim ilerledikçe öğrenme oranını kademeli olarak azaltacak bir zamanlayıcı oluşturun: 

scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optim, TOTAL_FRAMES // FRAMES_PER_BATCH)

Yukarıda oluşturulan bileşenleri kullanarak eğitim döngüsünü kurun. Eğitim fonksiyonu üç for döngüsünden oluşur:

• En dış döngü, ajanın ortamla etkileşimlerinden toplanan veriler boyunca çalışır. TOTAL_FRAMES parametresi, ajanın kaç zaman adımı çalıştırılacağını belirler. 
• Orta döngü şunları yapar: 
• En iç döngüyü sabit sayıda yineleme (genellikle 5 ile 10 arasında), OPTIM_STEPS hiperparametresi tarafından tanımlandığı şekilde çalıştırır. 
• Her eğitim yinelemesinden sonra öğrenme oranını günceller. 
• Her zaman adımı için avantaj fonksiyonunun değerini de hesaplar. 
• Politikayı periyodik olarak değerlendirir ve ödülleri yazdırır. 
• En iç döngü eğitim döngüsünü çalıştırır:
• Tekrar oynatma tamponundan bir eğitim yığını örnekleyin.
• Kayıp modülünü kullanarak kaybı hesaplayın. 
• Kayıp üzerinde geri yayılım çalıştırın.
• Gradyan inişi için eniyileyiciyi kullanın. 

Aşağıdaki kod eğitim döngüsünü uygular:

for i, tensordict_data in enumerate(collector): 
    for _ in range(OPTIM_STEPS): 
        advantage_module(tensordict_data)
        replay_buffer.extend(tensordict_data.reshape(-1).cpu())
        for _ in range(FRAMES_PER_BATCH // SUB_BATCH_SIZE): 
            data = replay_buffer.sample(SUB_BATCH_SIZE)
            loss = loss_module(data.to(device))
            loss_value = loss["loss_objective"] + loss["loss_critic"] + loss["loss_entropy"]
            loss_value.backward()
            optim.step()
            optim.zero_grad()
    scheduler.step()

    if i % LOG_EVERY == 0:
        with torch.no_grad():
            rollout = env.rollout(FRAMES_PER_BATCH, actor)
            reward_eval = rollout["next","reward"].sum()
            #print(rollout["next","reward"].sum())
            print(reward_eval)
            rewards.append(reward_eval)
            del rollout

TorchRL’in PPO algoritmasını kullanarak bir RL ajanını eğitmek için yukarıda gösterilen kodu içeren bu DataLab çalışma defteri mevcuttur. Parametreleri ince ayarlamak ve ajanın performansını iyileştirmek için başlangıç noktası olarak kullanın. 

Algoritmaları özelleştirme

TorchRL, RL çözümlerini özelleştirmeyi mümkün kılan modüler bir tasarıma sahiptir. Çerçeve, farklı bileşenler arasındaki arayüzle ilgilenir. Performanslarını test etmek ve karşılaştırmak için ortamları, farklı politikaları, tekrar oynatma tamponlarını ve RL algoritmalarını tak-çalıştır biçiminde kullanabilirsiniz. Bu modülerlik sayesinde:

• Farklı bileşenleri, programın büyük bölümlerini yeniden yazmak zorunda kalmadan değiştirebilirsiniz. 
• Bireysel bileşenler de bağımsız olarak değiştirilerek özel çözümler oluşturulabilir. 

• Farklı modüllerle denemeler yapabilir ve optimize edilmiş bir çözüm oluşturabilirsiniz. 

TorchRL’de özelleştirmeye örnekler:

• Eğitim döngüleri, öğrenme oranı zamanlayıcıları, günlükleyiciler ve özel metriklerle özelleştirilebilir. 
• Eğitim süresini ayarlamak için farklı uzunluklarda tekrar oynatma tamponları kullanılabilir.
• Ortam, ölçekleme ve normalleştirme fonksiyonları, adım sayaçları vb. içerecek şekilde özelleştirilebilir. 

RL Eğitimini Görselleştirme ve Hata Ayıklama

Önceki bölümlerde TorchRL modüllerini kullanarak RL ajanlarını nasıl eğiteceğinizi gördük. Bu bölümde, eğitimin ilerlemesini izleme ve görselleştirme yöntemlerini tartışıyoruz. 

Eğitim ilerlemesini izleme

Eğitimin ilerlemesini izlemek için süreç boyunca çeşitli metriklerin kaydını tutmak faydalıdır. TensorBoard gibi paketler, sonuçları eğitim süreci sırasında doğrudan kaydetmeyi kolaylaştırır. Örneğin, TensorBoard’un SummaryWriter sınıfı, metrikleri kaydetmek için eğitim döngüsü içinde çağrılabilir. Aşağıdaki sözde kod nasıl yapılacağını gösterir:

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter(log_dir="training_logs")

for _ in training_data (): # training loop
    loss = … 
    loss.backprop() 
    writer.add_scalar(“Loss - “, loss.item(), step)
   … 

writer.close() 

Eğitim ve kaydı bitirdikten sonra sonuçları çizebilir ve görselleştirebilirsiniz. Örneğin, eğitim ilerlemesini görselleştirmek için tensorboard komutunu kullanın. 

tensorboard --logdir=”training_logs”

TorchRL ile hata ayıklama

Hata ayıklama, ajanın ortamla etkileşimini doğrulamak için esastır. İlk adım olarak, eylem uzayı ve gözlem uzayını kontrol etmek istersiniz. Ortamın dokümantasyonu, ortamın özelliklerini içermelidir. Örneğin CartPole’un dokümantasyonu şunları gösterir: 

• Eylem uzayı iki ayrık değerden oluşur – 0 (arabayı sola itmek) ve 1 (arabayı sağa itmek) 
• Gözlem uzayı 4 değere sahiptir: 
• Araba konumu; değer aralığı 
• -4.8 ile +4.8. 
• Araba hızı; herhangi bir gerçek sayı
• Direk açısı; -24 ° ile  +24 ° arasında bir değer
• Direğin açısal hızı; herhangi bir gerçek sayı

Beklenen değerlere karşılık geldiklerini kontrol etmek için gözlem ve eylem uzaylarını inceleyin. Örneğin:

print("Observation space: ", env.observation_spec)
print("Action space: ", env.action_spec)

Ayrıca gözlem ve eylem uzaylarından rastgele örnekler çekip değerlerini kontrol edebilirsiniz: 

print("Sample Observation:", base_env.observation_spec.sample().get("observation"))
print("Sample Action:", base_env.action_spec.sample())

Çıktı aşağıdaki örneğe benzer olacaktır:

Sample Observation: tensor([-4.5960e+00,  3.4028e+38,  2.2261e-02,  3.4028e+38])
Sample Action: tensor([1, 0])

Dört durum değerinin daha önce belirtilen aralıklar içinde olduğunu fark edin. Yukarıdaki komutları birkaç kez tekrarlayın ve farklı (rastgele örneklenmiş) çıktı değerlerinin belirtilen aralıklarda kaldığını gözlemleyin. 

Yukarıdaki iki komut, doğrudan Gymnasium’dan içe aktarılan temel ortama dayanmaktadır. Pratikte, orijinal tensör değerleri üzerinde normalizasyon gibi dönüşümler uygulayan dönüştürülmüş ortamı kullanırız. Bu nedenle, dönüştürülmüş TorchRL ortamını kullanarak bir gözlem örneği aldığınızda, değerleri artık orijinal Gymnasium ortamındakiyle aynı aralıkta olmayabilir. 

Örneğin, dönüştürülmüş ortamdan bir örnek çekin:  

print("Sample Observation:", env.observation_spec.sample().get("observation"))

Çıktı şu şekilde olabilir: 

Sample Observation: tensor([-57.5869,      nan,   4.5276,      nan])

Araba konumu ve direk açısı değerlerinin aralıkların dışında olduğuna dikkat edin. Bunun nedeni tensör değerlerinin normalleştirilmiş olmasıdır. Ayrıca, araba hızı ve direğin açısal hızı nan değerleridir; çünkü ajan henüz ortamla etkileşime başlamamıştır. 

Ajan performansını görselleştirme

Eğitimin ilerlemesini çizmenin yanı sıra, ortamı işleyip ajanın etkileşimlerini görsel olarak gözlemlemek yararlı olabilir. Bu, ajanın nasıl performans gösterdiğine dair içgörüler sağlayabilir. 

Ortamı görselleştirmenin en pratik yolu bir video oluşturmaktır. Birkaç ek pakete ihtiyacınız var: 

• torchvision: multimedya dosyalarıyla çalışmak için
• av: ffmpeg paketini sarmalayarak PyTorch ile arayüz oluşturmak için. 

pip install torchvision
pip install av==12.0.0

Eğitim tamamlandıktan sonra, videoyu işlemek için şu hazırlık adımlarını izleyin:

• Videonun saklanacağı (bağıl) yolu tanımlayın.
• Ajanın etkileşim sonuçlarını CSV formatında saklamak için günlüğü başlatın.
• CSV günlüklerini kullanarak video üretmek için video kaydediciyi başlatın.
• Video kaydediciyi içerecek şekilde TorchRL ortamını dönüştürün.

…
# training loop
# for _ in …
…
…

from torchrl.record import CSVLogger, VideoRecorder 

path = "./training_loop"
logger = CSVLogger(exp_name="dqn", log_dir=path, video_format="mp4")
video_recorder = VideoRecorder(logger, tag="video")
record_env = TransformedEnv(
    GymEnv("CartPole-v1", from_pixels=True, pixels_only=False), video_recorder
)

(Eğitilmiş) politikayı ortam üzerinde çalıştırın ve oluşturulan görüntüleri video dosyasına yazdırın:

record_env.rollout(max_steps=1000, policy=policy)
video_recorder.dump()

Programı çalıştırdıktan sonra, videoyu daha önce belirlediğiniz dizin yolunda (./training_loop yukarıdaki parçacıkta) bulacaksınız. TorchRL kullanarak DQN uygulaması için DataLab çalışma defterinin çevrimiçi bir not defteriyle video dosyaları dışa aktarmak zor olduğundan video oluşturma kodunu içermediğini unutmayın. Videoları kaydetmek için programı yerel bir bilgisayarda veya sunucuda çalıştırın (ve yukarıdaki adımları ekleyin).

TorchRL Kullanımı için En İyi Uygulamalar

Son olarak bazı en iyi uygulamalara değinelim. İşte önerilerim.

Basit ortamlardan başlayın

TorchRL geliştirmeyi kolaylaştırsa da, karmaşık ortamlarda iyi performans gösteren RL ajanlarını eğitmek hâlâ zorludur. Bu nedenle, zor problemleri denemeden önce CartPole gibi basit ortamları çözmek önemlidir. 

TorchRL’in modülerliği, farklı algoritmalar ve parametrelerle denemeler yapmaya olanak tanır. Pratikte alternatif algoritmaları ve özelleştirme seçeneklerini kullanmadan önce, işleyişlerine dair içgörüler edinmek gerekir. Bu, bireysel değişikliklerin etkilerinin görsel olarak kolayca gözlemlenebildiği basit bir ortamda en iyi şekilde yapılır. 

Hiperparametrelerle deney yapın

RL modellerinin eğitim performansı, öğrenme oranı, keşif oranı, iskonto oranı ve PPO için kırpma oranı gibi algoritmaya özgü hiperparametreler de dâhil olmak üzere çeşitli hiperparametrelere duyarlıdır. Örneğin, çok yüksek bir öğrenme oranı eğitimi dengesiz hale getirirken, çok düşük bir öğrenme oranı yakınsamayı çok uzun sürdürür. 

Benzer şekilde, çok yüksek bir keşif oranı eğitimin yakınsamasını engellerken, çok düşük bir keşif oranı ajanın en iyi yolu keşfetmesini engelleyebilir. 

Doğru hiperparametre değerlerini belirlemek için bir formül yoktur. Standart ortamlar için yönergeler ve önerilen değerler bulunsa da, bunlar tüm problemlere uygulanmayabilir. Bu nedenle, hiperparametreler için en iyi değerleri belirlemek üzere ızgara araması veya rastgele arama gibi çeşitli yöntemlerle denemeler yapmak gerekir. 

Ayrıca, farklı hiperparametre kombinasyonlarında eğitim performansını test etmek için Weights & Biases Sweeps veya Optuna gibi otomatik kütüphaneler de kullanılabilir. 

Hazır algoritmalardan yararlanın

Önceki örneklerde gördüğünüz gibi, TorchRL’in hazır modüllerini kullanmak önemli ölçüde geliştirme çabası tasarrufu sağlar. Alternatifi, tüm işlevselliği sıfırdan inşa etmektir ki bu da çok daha fazla zaman ve geliştirme/test maliyeti gerektirir. 

TorchRL modüllerini birçok geliştirici kullandığından, çeşitli senaryolarda test edilmiş olmanın avantajına da sahiptirler. Bu nedenle, özel olarak geliştirilmiş bir modüle kıyasla daha az hatalı olmalarını bekleyebilirsiniz. Bu yüzden, çoğu standart kullanım durumu için hazır modülleri kullanmak kuvvetle tavsiye edilir. 

Sonuç

Bu yazıda, RL algoritmalarını uygulamak için PyTorch tabanlı bir çerçeve olan TorchRL’in temel kavramlarını ele aldık. Ayrıca TorchRL kullanarak Derin Q-Öğrenme gibi daha basit çözümler ve PPO gibi daha karmaşık algoritmaları uygulamaya yönelik pratik örnekler gördük. 

Bir sonraki adım olarak, bu programları diğer ortamlar ve algoritmalarla denemeler yapmak için temel olarak kullanabilirsiniz. 

RL temellerini ve pratik uygulamalarını daha da derinleştirmek istiyorsanız, Gymnasium tabanlı ortamlarda daha fazla uygulama yapmak için Python ile Gymnasium’da Pekiştirmeli Öğrenme kursuna göz atın.