Gymnasium ile Pekiştirmeli Öğrenme: Pratik Bir Rehber

Gymnasium’un Kurulumu

Gymnasium, NumPy ve PyTorch gibi çeşitli bağımlılık programlarının belirli sürümlerine (en son sürümlerine değil) ihtiyaç duyar. Bu nedenle, Gymnasium’u kurmak, kullanmak ve RL programlarını çalıştırmak için yeni bir Conda veya venv ortamı ya da yeni bir not defteri oluşturmanızı öneririz. 

Bu öğreticiyle birlikte ilerlemek için şu DataLab çalışma kitabını kullanabilirsiniz.

Gymnasium’un kurulumu

Gymnasium’u bir sunucuya ya da yerel makineye kurmak için şunu çalıştırın: 

$ pip install gymnasium 

Google Colab veya DataCamp’in DataLab’i gibi bir Not Defteri kullanarak kurmak için şunu kullanın:

!pip install gymnasium

Yukarıdaki komut, Gymnasium’u ve doğru sürüm bağımlılıklarını kurar.

Gymnasium ortamlarını keşfetme

Kasım 2024 itibarıyla Gymnasium, 60’tan fazla yerleşik ortam içerir. Mevcut yerleşik ortamları gezmek için aşağıdaki örnekte gösterildiği gibi gym.envs.registry.all() işlevini kullanın: 

import gymnasium as gym
for i in gym.envs.registry.keys():
	print(i)

Ayrıca Gymnasium ana sayfasını ziyaret edebilirsiniz. Sol sütunda tüm ortamlara giden bağlantılar bulunur. Her ortamın web sayfası; eylemler, durumlar vb. hakkında ayrıntılar içerir. 

Ortamlar, Classic Control, Box2D ve daha fazlası gibi kategorilere ayrılmıştır. Aşağıda, her gruptaki bazı yaygın ortamları listeliyorum:

• Classic Control: Bunlar RL geliştirmede kullanılan kanonik ortamlardır; birçok ders kitabı örneğinin temelini oluştururlar. Yeni RL algoritmalarını test etmek ve kıyaslamak için ideal bir karmaşıklık ile basitlik dengesine sahiptirler. Gymnasium’daki klasik kontrol ortamları şunları içerir: 
• Acrobot
• Cart Pole
• Mountain Car Discrete
• Mountain Car Continuous
• Pendulum
• Box2D: Box2D, oyunlar için bir 2B fizik motorudur. Bu motoru temel alan ortamlar şunlar gibi basit oyunları içerir:
• Lunar Lander
• Car Racing
• ToyText: Bunlar, RL algoritmalarını hata ayıklamak için sıklıkla kullanılan küçük ve basit ortamlardır. Bu ortamların birçoğu küçük ızgara dünyası modeline ve basit kart oyunlarına dayanır. Örnekler: 
• Blackjack
• Taxi
• Frozen Lake
• MuJoCo: Çoklu Eklemlerde Temas Dinamikleri (MuJoCo), robotik, biyomekanik, ML vb. uygulamalar için ortamları simüle eden açık kaynaklı bir fizik motorudur. Gymnasium’daki MuJoCo ortamları şunları içerir:
• Ant
• Hopper
• Humanoid
• Swimmer
• Ve daha fazlası

Yerleşik ortamların yanı sıra, Gymnasium aynı API’yi kullanarak birçok harici ortam ile de kullanılabilir. 

Bu öğreticide kanonik Classic Control ortamlarından birini kullanacağız. Belirli bir ortamı içe aktarmak için .make() komutunu kullanın ve ortamın adını argüman olarak geçin. Örneğin, CartPole (sürüm 1) tabanlı yeni bir ortam oluşturmak için aşağıdaki komutu kullanın: 

import gymnasium as gym
env = gym.make("CartPole-v1")

Gymnasium’da Pekiştirmeli Öğrenme Kavramlarını Anlama

Kısaca, Pekiştirmeli Öğrenme çevresiyle etkileşime giren bir ajandan (örneğin bir robot) oluşur. Bir politika, ajanın eylemlerine karar verir. Ajanın eylemlerine bağlı olarak, ortam her zaman adımında bir ödül (veya ceza) verir. Ajan, kazandığı toplam ödülleri maksimize eden en iyi politikayı RL sayesinde bulur. 

Bir RL ortamının bileşenleri

Bir RL ortamının temel bileşenleri şunlardır: 

• Ortam: Dış sistem, dünya veya bağlam. Ajan, ortamla bir dizi zaman adımında etkileşime girer. Her zaman adımında, ajanın eylemine bağlı olarak ortam:
• Bir ödül (veya ceza) verir 
• Sonraki durumu belirler 
• Durum: Ortamın mevcut konfigürasyonunun matematiksel bir temsili. 
• Örneğin, bir sarkaç ortamının durumu, her zaman adımında sarkacın konumu ve açısal hızını içerebilir. 
• Terminal durum: Yeni/diğer durumlara yol açmayan durum. 
• Ajan: Ortamı gözlemleyen ve bu gözleme dayalı çeşitli eylemler alan algoritma. Ajanın hedefi ödüllerini maksimize etmektir. 
• Örneğin, ajan sarkaca ne kadar kuvvet ve hangi yönde itme uygulanacağına karar verir.  
• Gözlem: Örneğin sensörler kullanılarak elde edilen, ajanın çevreye dair görüşünün matematiksel temsili. 
• Eylem: Sonraki adıma geçmeden önce ajanın verdiği karar. Eylem, ortamın bir sonraki durumunu etkiler ve ajana bir ödül kazandırır. 
• Ödül: Ortamdan ajana gelen geri bildirim. Eyleme ve ortamın durumuna bağlı olarak pozitif veya negatif olabilir. 
• Getiri: Gelecekteki zaman adımları boyunca beklenen kümülatif getiri. Gelecekteki zaman adımlarından gelen ödüller bir iskonto faktörüyle iskonto edilebilir. 
• Politika: Ajanın çeşitli durumlarda hangi eylemi yapacağına dair stratejisi. Genellikle durumları eylemlere eşleyen, P olasılık matrisi olarak temsil edilir.
• Sonlu sayıda m olası durum ve n olası eylem verildiğinde, matristmn elemanı, an eylemini sm durumunda alma olasılığını gösterir.  
• Bölüm (Episode): (Rastgeleleştirilmiş) başlangıç durumundan, ajan terminal duruma ulaşana kadar geçen zaman adımları dizisi.

Gözlem uzayı ve eylem uzayı

Gözlem, ajanın ortam hakkında topladığı bilgidir. Örneğin bir robot olan bir ajan, sensörler kullanarak çevresel bilgi toplayabilir. İdeal olarak ajan, ortamın tüm yönlerini tanımlayan tam durumu gözlemleyebilmelidir. Pratikte ajan, durum için vekil olarak gözlemlerini kullanır. Bu nedenle, ajan’ın eylemlerine gözlemler karar verir. 

Bir uzay, matematiksel bir kümeye benzer. Ögelerin uzayı X, X’in tüm olası örneklerini içerir. X uzayı aynı zamanda X türündeki tüm ögelerin yapısını (sözdizimi ve biçimi) tanımlar. Her Gymnasium ortamının iki uzayı vardır: eylem uzayı, action_space ve gözlem uzayı, observation_space. Hem eylem hem gözlem uzayları, üst sınıf gymnasium.spaces.Space’ten türetilir. 

Gözlem uzayı 

Gözlem uzayı, tüm olası gözlemleri içeren uzaydır. Aynı zamanda gözlemlerin hangi formatta saklanacağını tanımlar. Gözlem uzayı genellikle veri türü Box olan bir nesne olarak temsil edilir. Bu bir ndarray’dir ve gözlemlerin parametrelerini açıklar. Kutu (box), her boyutun sınırlarını belirtir. Bir ortamın gözlem uzayını observation_space yöntemiyle görüntüleyebilirsiniz:

print("observation space: ", env.observation_space)

CartPole-v1 ortamı için çıktı aşağıdaki örneğe benzer: 

observation space:  Box([-4.8 -inf -0.41887903 -inf], [4.8 inf 0.41887903 inf], (4,), float32)

Bu örnekte, CartPole-v1 gözlem uzayı 4 boyutludur. Gözlem dizisinin 4 öğesi şunlardır:

• Arabanın konumu - -4.8 ile +4.8 arasında değişir
• Arabanın hızı - - ile + arasında değişir
• Direğin açısı - -0.4189 ile +0.4189 arasında değişir
• Direğin açısal hızı - - ile + arasında değişir

Tek bir gözlem dizisi örneği görmek için .reset() komutunu kullanın. 

observation, info = env.reset()
print("observation: ", observation)

CartPole-v1 ortamı için çıktı aşağıdaki örneğe benzer: 

[ 0.03481963 -0.0277232   0.01703267 -0.04870504]                                                                                                       

Bu dizideki dört öğe, daha önce açıklandığı gibi dört gözlenen niceliğe (araba konumu, araba hızı, direk açısı, direğin açısal hızı) karşılık gelir. 

Eylem uzayı

Eylem uzayı, ajanın alabileceği tüm olası eylemleri içerir. Eylem uzayı ayrıca eylemlerin hangi formatta temsil edildiğini tanımlar. Bir ortamın eylem uzayını action_space yöntemiyle görüntüleyebilirsiniz:

print("action space: ", env.action_space)

CartPole-v1 ortamı için çıktı aşağıdaki örneğe benzer: 

action space:  Discrete(2)

CartPole-v1 ortamında eylem uzayı kesiklidir. Ajanın alabileceği toplam iki eylem vardır:

• 0: Arabayı sola it
• 1: Arabayı sağa it

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

Önceki bölümlerde RL ve Gymnasium’un temel kavramlarını keşfettik. Bu bölümde Gymnasium’u kullanarak bir RL ajanı nasıl oluşturacağınızı göreceksiniz. 

Ortamı oluşturma ve sıfırlama

İlk adım, ortamın bir örneğini oluşturmaktır. Yeni ortamlar oluşturmak için .make() yöntemini kullanın. 

env = gym.make('CartPole-v1')

Ajanın etkileşimleri, ortamın durumunu değiştirir. .reset() yöntemi ortamı başlangıç durumuna sıfırlar. Varsayılan olarak ortam rastgele bir duruma başlatılır. Program her çalıştığında ortamı aynı duruma başlatmak için SEED parametresini .reset() yöntemiyle kullanabilirsiniz. Aşağıdaki kod bunun nasıl yapıldığını gösterir:

SEED = 1111
env.reset(seed=SEED)

Eylem örneklemesi de rastgelelik içerir. Bu rastgeleliği kontrol etmek ve tamamen çoğaltılabilir bir eğitim yolu elde etmek için NumPy ve PyTorch’un rastgele üreteçlerini tohumlayabiliriz:

np.random.seed(SEED)
torch.manual_seed(SEED)

Rastgele ve akıllı eylemler

Markov sürecinin her adımında, ajan rastgele bir eylem seçip terminal duruma ulaşana kadar ortamı keşfedebilir. Eylemleri rastgele seçerek: 

• Terminal duruma ulaşmak uzun sürebilir.
• Kümülatif ödüller, olabileceklerin çok altında kalır.

Ajanı, önceki deneyimlere (ortamla etkileşimlerine) dayalı olarak eylem seçimini optimize edecek şekilde eğitmek, uzun vadeli ödülleri maksimize etmek için daha verimlidir. 

Eğitilmemiş ajan, rastgele başlatılmış bir politikaya dayalı rastgele eylemlerle başlar. Bu politika genellikle bir sinir ağı olarak temsil edilir. Eğitim sırasında ajan, ödülleri maksimize eden optimal politikayı öğrenir. RL’de eğitim süreci politika optimizasyonu olarak da adlandırılır. 

Çeşitli politika optimizasyonu yöntemleri vardır. Bellman denklemleri, RL politikalarının değerinin nasıl hesaplanacağını ve en iyi politikanın nasıl belirleneceğini açıklar. Bu öğreticide, policy gradients adı verilen basit bir teknik kullanacağız. Proximal Policy Optimization (PPO) gibi başka yöntemler de vardır. 

Basit Bir Policy Gradient Ajanını Uygulama

Policy gradient kullanan bir RL ajanı oluşturmak için, politikayı uygulayacak bir sinir ağı kurar, adım adım ödüllerden ve eylem olasılıklarından getirileri ve kaybı hesaplayan işlevler yazar ve politikayı standart geri yayılım tekniklerini kullanarak yinelemeli olarak güncelleriz. 

Politika ağını kurma

Politikayı uygulamak için bir sinir ağı kullanırız. CartPole-v1 basit bir ortam olduğundan, şu özelliklere sahip bir sinir ağı kullanırız:

• Giriş boyutları, ortamın gözlem uzayının boyutuyla eşit.
• 64 nöronlu tek gizli katman. 
• Çıkış boyutları, ortamın eylem uzayının boyutuyla eşit.

Dolayısıyla politika ağının işlevi, gözlenen durumları eylemlere eşlemektir. Bir giriş gözlemi verildiğinde doğru eylemi tahmin eder. Aşağıdaki kod politika ağını uygular:

class PolicyNetwork(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout):
        super().__init__()
        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.layer2 = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)
    def forward(self, x):
        x = self.layer1(x)
        x = self.dropout(x)
        x = F.relu(x)
        x = self.layer2(x)
        return x

Ödül toplama ve ileri geçiş (forward pass)

Belirtildiği gibi, Markov sürecinin her adımında ortam, ajanın eylemine ve durumuna bağlı olarak bir ödül verir. RL’de hedef, toplam getiriyi maksimize etmektir. 

• Her zaman adımındaki getiri, başlangıçtan o adıma kadar elde edilen ödüllerin kümülatif toplamıdır. 
• Her bölümdeki toplam getiri, o bölümün adım adım ödüllerinin tümünün toplanmasıyla elde edilir. Dolayısıyla toplam getiri, son zaman adımındaki (ajan terminal duruma ulaştığında) getiridir. 

Pratikte ödülleri toplarken yaygın olarak şunlar yapılır: 

• Gelecekteki ödülleri bir iskonto faktörüyle ayarlama. 
• Adım adım getiriler dizisini normalize ederek eğitimin daha düzgün ve kararlı olmasını sağlama. 

Aşağıdaki kod bunun nasıl yapılacağını gösterir: 

def calculate_stepwise_returns(rewards, discount_factor):
    returns = []
    R = 0
    for r in reversed(rewards):
        R = r + R * discount_factor
        returns.insert(0, R)
    returns = torch.tensor(returns)
    normalized_returns = (returns - returns.mean()) / returns.std()
    return normalized_returns

İleri geçiş, ajanın geçerli politikaya göre terminal duruma ulaşana kadar çalıştırılmasını ve adım adım ödüllerin ve eylem olasılıklarının toplanmasını içerir. Aşağıdaki adımlar ileri geçişin nasıl uygulanacağını açıklar: 

• Ortamı başlangıç durumuna sıfırlayın. 
• Eylem olasılıklarını, ödülleri ve kümülatif getiriyi saklamak için arabellekleri başlatın
• Ajanı, ortam sonlanana kadar yinelemeli olarak çalıştırmak için .step() işlevini kullanın:
• Ortamın durumuna ilişkin gözlemi alın.
• Gözleme dayalı olarak politikanın tahmin ettiği eylemi alın.
• Tahmin edilen eylemi alma olasılığını kestirmek için Softmax işlevini kullanın.
• Tahmin edilen olasılıklara dayalı kategorik bir olasılık dağılımı simüle edin.
• Bu dağılımdan örnekleme yaparak ajanın eylemini elde edin.
• Örneklenen eylemin log olasılığını simüle edilen dağılımdan tahmin edin. 
• Eylemlerin log olasılıklarını ve her adımdaki ödülleri ilgili arabelleklerine ekleyin. 
• Ödüllere dayanarak her adım için normalize edilmiş ve iskonto edilmiş getiri değerlerini tahmin edin. 

def forward_pass(env, policy, discount_factor):
    log_prob_actions = []
    rewards = []
    done = False
    episode_return = 0
    policy.train()
    observation, info = env.reset()
    while not done:
        observation = torch.FloatTensor(observation).unsqueeze(0)
        action_pred = policy(observation)
        action_prob = F.softmax(action_pred, dim = -1)
        dist = distributions.Categorical(action_prob)
        action = dist.sample()
        log_prob_action = dist.log_prob(action)
        observation, reward, terminated, truncated, info = env.step(action.item())
        done = terminated or truncated
        log_prob_actions.append(log_prob_action)
        rewards.append(reward)
        episode_return += reward
    log_prob_actions = torch.cat(log_prob_actions)
    stepwise_returns = calculate_stepwise_returns(rewards, discount_factor)
    return episode_return, stepwise_returns, log_prob_actions

Ödüllere dayalı politikayı güncelleme

Kayıp (loss), gradyan inişinin uygulandığı niceliği temsil eder. RL’de amaç, getirileri maksimize etmektir. Bu nedenle, beklenen getiri değerini kayıp için bir vekil olarak kullanırız. Beklenen getiri değeri, adım adım beklenen getiriler ile adım adım eylemlerin log olasılıklarının çarpımı olarak hesaplanır. Aşağıdaki kod kaybı hesaplar:

def calculate_loss(stepwise_returns, log_prob_actions):
    loss = -(stepwise_returns * log_prob_actions).sum()
    return loss

Politikayı güncellemek için, kayıp fonksiyonu açısından geri yayılım çalıştırırsınız. Aşağıdaki update_policy() yöntemi calculate_loss() yöntemini çağırır. Ardından bu kayıp üzerinde geri yayılım çalıştırarak politika parametrelerini, yani politika ağının model ağırlıklarını günceller.

def update_policy(stepwise_returns, log_prob_actions, optimizer):
    stepwise_returns = stepwise_returns.detach()
    loss = calculate_loss(stepwise_returns, log_prob_actions)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    return loss.item()

Getirilerin gradyanına dayalı olarak politikayı güncellemeye policy gradient yöntemi denir. 

Politikayı eğitme

Artık politikayı eğitmek ve değerlendirmek için gereken tüm bileşenlere sahibiz. Eğitim döngüsünü aşağıdaki adımlarda açıklandığı gibi uygularız:  

Başlamadan önce hiperparametreleri tanımlar, bir politika örneği oluşturur ve bir optimize edici yaratırız:

• Hiperparametreleri Python sabitleri olarak tanımlayın:
• MAX_EPOCHS politikayı eğitmek için yürütmeyi planladığımız azami yineleme sayısıdır. 
• DISCOUNT_FACTOR gelecekteki zaman adımlarından gelen ödüllerin göreli önemini belirler. 1’lik bir iskonto faktörü tüm ödüllerin eşit derecede önemli olduğu, 0 değeri ise yalnızca mevcut zaman adımının ödülünün önemli olduğu anlamına gelir. 
• N_TRIALS ajanın performansını değerlendirmek için getirilerin ortalamasını aldığımız bölüm sayısıdır. N_TRIALS bölüm üzerindeki ortalama getiri eşik değerin üzerindeyse eğitimin başarılı olduğuna karar veririz. 
• REWARD_THRESHOLD: Politika eşik değerden daha büyük bir getiri elde edebiliyorsa başarılı kabul edilir. 
• DROPOUT rastgele sıfırlanacak ağırlıkların oranını belirler. Dropout işlevi, model ağırlıklarının bir kısmını rastgele sıfırlar. Bu, belirli nöronlara bağımlılığı azaltır ve aşırı uyumu önleyerek ağı daha sağlam hale getirir.
• LEARNING_RATE her adımda politika parametrelerinin ne kadar değişebileceğini belirler. Her yinelemede parametre güncellemesi, gradyan ile öğrenme oranının çarpımıdır. 
• Politikayı, daha önce uygulanmış olan PolicyNetwork sınıfının bir örneği olarak tanımlayın. 
• Adam algoritması ve öğrenme oranını kullanarak bir optimize edici oluşturun. 

Politikayı eğitmek için, ortalama getiri (N_TRIALS üzerinde) ödül eşiğinden büyük olana kadar eğitim adımlarını yinelemeli olarak çalıştırırız:

• Her bölüm için ileri geçişi bir kez çalıştırın. Eylemlerin log olasılıklarını, adım adım getirileri ve o bölümün toplam getirisini toplayın. Bölüm getirilerini bir dizide biriktirin. 
• Kayıpları log olasılıklar ve adım adım getiriler kullanarak hesaplayın. Kayıp üzerinde geri yayılım çalıştırın. Optimizasyon aracıyla politika parametrelerini güncelleyin. 
• N_TRIALS üzerindeki ortalama getiri ödül eşiğini aşıyor mu kontrol edin. 

Aşağıdaki kod bu adımları uygular:

def main(): 
    MAX_EPOCHS = 500
    DISCOUNT_FACTOR = 0.99
    N_TRIALS = 25
    REWARD_THRESHOLD = 475
    PRINT_INTERVAL = 10
    INPUT_DIM = env.observation_space.shape[0]
    HIDDEN_DIM = 128
    OUTPUT_DIM = env.action_space.n
    DROPOUT = 0.5
    episode_returns = []
    policy = PolicyNetwork(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM, DROPOUT)
    LEARNING_RATE = 0.01
    optimizer = optim.Adam(policy.parameters(), lr = LEARNING_RATE)
    for episode in range(1, MAX_EPOCHS+1):
        episode_return, stepwise_returns, log_prob_actions = forward_pass(env, policy, DISCOUNT_FACTOR)
        _ = update_policy(stepwise_returns, log_prob_actions, optimizer)
        episode_returns.append(episode_return)
        mean_episode_return = np.mean(episode_returns[-N_TRIALS:])
        if episode % PRINT_INTERVAL == 0:
            print(f'| Episode: {episode:3} | Mean Rewards: {mean_episode_return:5.1f} |')
        if mean_episode_return >= REWARD_THRESHOLD:
            print(f'Reached reward threshold in {episode} episodes')
            break

Son olarak, politikayı eğitmek için main() işlevini çağırın:

main()

Yukarıdaki algoritmayı doğrudan çalıştırmak ve RL ile CartPole ortamını çözmek için bu DataLab çalışma kitabını kullanın. 

Gymnasium’da İleri Teknikler

Bir RL algoritmasının nasıl uygulanacağını gösterdikten sonra, şimdi pratikte yaygın olarak kullanılan bazı ileri teknikleri tartışalım. 

Hazır mimarileri kullanma

RL algoritmalarını sıfırdan uygulamak, özellikle karmaşık ortamlar ve son teknoloji politikalar için uzun ve zorlu bir süreçtir. 

Daha pratik bir alternatif olarak Stable Baselines3 gibi yazılımlar kullanılabilir. Denenmiş ve test edilmiş RL algoritması uygulamalarıyla birlikte gelir. Önceden eğitilmiş ajanlar, eğitim betikleri, değerlendirme araçları ve grafik çizme ile video kaydetme modüllerini içerir. 

Ray RLib, RL için bir diğer popüler araçtır. RLib, ölçeklenebilir bir çözüm olarak tasarlanmıştır ve RL algoritmalarını çoklu GPU sistemlerde uygulamayı kolaylaştırır. Ayrıca, yeni olanaklar sunan çok ajanlı RL’yi de destekler. Örneğin:

• Bağımsız çok ajanlı öğrenme: Her ajan diğer ajanları ortamın bir parçası olarak ele alır.
• İşbirlikçi çok ajanlı eğitim: Bir grup ajan aynı politika ve değer fonksiyonlarını paylaşır ve birbirlerinin deneyimlerinden paralel olarak öğrenir. 
• Rekabetçi eğitim: Ajanlar (veya ajan grupları) rekabetçi, oyun benzeri ortamlarda birbirleriyle yarışır. 

Hem RLib hem de Stable Baselines3 ile OpenAI Gymnasium’dan ortamları içe aktarabilir ve kullanabilirsiniz. 

Özel ortamlar

Gymnasium ile paketlenen ortamlar, yeni RL stratejilerini test etmek ve politikaları eğitmek için doğru seçimdir. Ancak çoğu pratik uygulama için, çözmek istediğiniz problemi doğru şekilde yansıtan bir ortam oluşturmanız ve kullanmanız gerekir. Gymnasium’u özel bir ortam oluşturmak için kullanabilirsiniz. Gymnasium özel ortamlarını kullanmanın avantajı, RLib ve Stable Baselines3 gibi birçok harici aracın Gymnasium API yapısı ile çalışacak şekilde önceden yapılandırılmış olmasıdır. 

Gymnasium’da özel bir ortam oluşturmak için şunları tanımlamanız gerekir: 

• Gözlem uzayı.
• Terminal koşullar.
• Ajanın seçebileceği eylem kümesi.
• Ortamın nasıl başlatılacağı (reset() işlevi çağrıldığında). 
• Ajanın eylemleri verildiğinde ortamın bir sonraki durumu nasıl belirlediği (step() işlevi çağrıldığında). 

Daha fazlasını öğrenmek için Gymnasium’un özel ortam oluşturma rehberini takip edin. 

Gymnasium’u Kullanırken En İyi Uygulamalar

Farklı ortamlarla deneyin

Bu öğretideki kod, politika gradyanı algoritmasının CartPole ortamında nasıl uygulanacağını gösterdi. Bu, kesikli eylem uzayına sahip basit bir ortamdır. RL’i daha iyi anlamak için aynı politika gradyanı algoritmasını (ve PPO gibi diğer algoritmaları) diğer ortamlarda uygulamanızı öneririz. 

Örneğin, Pendulum ortamı sürekli bir eylem uzayına sahiptir. Herhangi bir durumda sarkaca uygulanan torkun (büyüklük ve yön) tek bir sürekli değişkenle temsil edilmesinden oluşur. Bu tork, -2 ile +2 arasında herhangi bir değer alabilir. 

Farklı ortamlarda çeşitli algoritmalarla denemeler yapmak, farklı RL çözümlerini ve bu çözümlerin zorluklarını daha iyi anlamanıza yardımcı olur. 

Eğitim ilerlemesini izleyin

RL ortamları genellikle robotlar, sarkaçlar, dağ arabaları, video oyunları vb. içerir. Ajanın ortam içindeki eylemlerini görselleştirmek, politikanın performansına dair daha sezgisel bir anlayış sağlar. 

Gymnasium’da env.render() yöntemi, ajanın ortamla etkileşimlerini görselleştirir. Ortamın mevcut durumunu—oyun ekranlarını, sarkaç veya araba direğinin konumunu vb.—grafiksel olarak gösterir. Ajanın eylemlerinin ve ortamın tepkilerinin görsel geri bildirimi, ajanın performansını ve eğitim sürecindeki ilerlemesini izlemeye yardımcı olur. 

Dört render modu vardır: “human”, “rgb_array”, “ansi” ve “rgb_array_list”. Ajanın performansını görselleştirmek için “human” render modunu kullanın. Render modu, ortam başlatılırken belirtilir. Örneğin:

env = gym.make(‘CartPole-v1’, render_mode=’human’)

Görüntülemeyi gerçekleştirmek için, ajanın her eyleminden sonra ( .step() yöntemi çağrılarak) .render() yöntemini çağırın. Aşağıdaki sözde kod bunun nasıl yapılacağını gösterir:

while not done:
    …
   step, reward, terminated, truncated, info = env.step(action.item())
   env.render()
    …

Yaygın hataları giderme

Gymnasium, karmaşık RL ortamlarıyla arayüz kurmayı kolaylaştırır. Bununla birlikte, birçok bağımlılığı olan ve sürekli güncellenen bir yazılımdır. Bu nedenle, birkaç yaygın hata türüne dikkat etmek önemlidir.

Sürüm uyuşmazlıkları

• Gymnasium sürüm uyuşmazlığı: Farama’nın Gymnasium yazılım paketi, OpenAI’nin Gym’inden 0.26.2 sürümünde çatallanmıştır. Eski Gym sürümleri ile Gymnasium’un yeni sürümleri arasında birkaç kırıcı değişiklik olmuştur. Halka açık birçok uygulama eski Gym sürümlerini temel alır ve en yeni sürümle doğrudan çalışmayabilir. Bu gibi durumlarda, ya kurulumu eski bir sürüme geri almak ya da kodu yeni sürümle çalışacak şekilde uyarlamak gerekir. 
• Ortam sürüm uyuşmazlığı: Birçok Gymnasium ortamının farklı sürümleri vardır. Örneğin iki CartPole ortamı vardır - CartPole-v1 ve CartPole-v0. Ortamın davranışı her iki sürümde de aynı olsa da bölüm uzunluğu, ödül eşiği gibi bazı parametreler farklı olabilir. Bir sürümde eğitilmiş bir politika, aynı ortamın başka bir sürümünde aynı performansı göstermeyebilir. Her ortam sürümü için eğitim parametrelerini güncellemeniz ve politikayı yeniden eğitmeniz gerekir. 
• Bağımlılık sürüm uyuşmazlığı: Gymnasium; NumPy ve PyTorch gibi bağımlılıklara bağlıdır. Aralık 2024 itibarıyla bu bağımlılıkların en son sürümleri numpy 2.1.3 ve torch 2.5.1’dir. Ancak Gymnasium, torch 1.13.0 ve numpy 1.23.3 ile en iyi çalışır. Bu bağımlılıklar önceden kurulmuş bir ortama Gymnasium’u yüklerseniz sorunlarla karşılaşabilirsiniz. Gymnasium ile yeni bir Conda ortamında kurulum ve çalışma yapmanızı öneririz. 

Yakınsama sorunları

• Hiperparametreler: Diğer makine öğrenmesi algoritmaları gibi, RL politikaları da öğrenme oranı, iskonto faktörü vb. hiperparametrelere duyarlıdır. Hiperparametreleri manuel olarak veya ızgara araması ve rastgele arama gibi otomatik tekniklerle deneyerek ayarlamanızı öneririz. 
• Keşif ve sömürü dengesi: Bazı politika sınıfları (örneğin PPO) için ajan iki yönlü bir strateji benimser: Yeni yollar keşfetmek için ortamı araştırır ve şimdiye kadar bilinen yollara dayalı olarak ödülleri maksimize etmek için açgözlü bir yaklaşım uygular. Çok fazla keşif yaparsa politika yakınsamaz. Tersine, yeterince keşfetmezse asla en iyi yolu denemez. Bu nedenle keşif ile sömürü arasında doğru dengeyi bulmak esastır. Eğitim sırasında erken bölümlerde keşfe, geç bölümlerde sömürüye öncelik vermek de yaygındır. 

Eğitimde kararsızlık

• Büyük öğrenme oranları: Öğrenme oranı çok yüksekse, politika parametreleri her adımda büyük güncellemeler geçirir. Bu, optimum değerler kümesinin kaçırılmasına yol açabilir. Yaygın bir çözüm, öğrenme oranını kademeli olarak azaltmak ve eğitim yakınsadıkça daha küçük ve daha istikrarlı güncellemeler sağlamaktır. 
• Aşırı keşif: Eylem seçiminde çok fazla rastgelelik (entropi), yakınsamayı engeller ve ardışık adımlar arasında kayıp fonksiyonunda büyük dalgalanmalara yol açar. Kararlı ve yakınsayan bir eğitim süreci için keşfi sömürü ile dengeleyin. 
• Yanlış algoritma seçimi: Policy gradient gibi basit algoritmalar, büyük eylem ve durum uzaylarına sahip karmaşık ortamlarda kararsız eğitime yol açabilir. Bu gibi durumlarda, her adımda büyük politika güncellemelerinden kaçınan ve daha kararlı olabilen PPO ve Trust Region Policy Optimization (TRPO) gibi daha sağlam algoritmaları kullanmanızı öneririz.
• Rastgelelik: RL algoritmaları, başlangıç durumlarına ve eylem seçimindeki doğuştan gelen rastgeleliğe son derece hassastır. Bir eğitim çalışması kararsız olduğunda, bazen farklı bir rastgele tohum kullanarak veya politikayı yeniden başlatarak istikrara kavuşturulabilir.

Sonuç

Bu öğreticide RL’in temel ilkelerini inceledik, çeşitli RL ortamlarıyla arayüz kurmak için temiz bir API sunan bir yazılım paketi olarak Gymnasium’u tartıştık ve basit bir RL algoritmasını uygulamak ve bunu bir Gymnasium ortamında kullanmak için nasıl bir Python programı yazacağınızı gösterdik.

Bu öğreticide temelleri anladıktan sonra, taksi rota optimizasyonu ve hisse senedi alım-satım simülasyonları gibi pratik problemleri çözmek için RL kavramlarını uygulamak üzere Gymnasium ortamlarını kullanmanızı öneririm.