PyTorch ve Gymnasium ile Proximal Policy Optimization

1. Ortamın Hazırlanması 

PPO’yu uygulamadan önce, gerekli yazılım kütüphanelerini yüklememiz ve politikayı uygulayacağımız uygun bir ortam seçmemiz gerekir. 

PyTorch ve gerekli kütüphanelerin kurulumu 

Aşağıdaki yazılımları kurmamız gerekir: 

• PyTorch ve numpy (matematiksel ve istatistiksel fonksiyonlar için) ile matplotlib (grafik çizimi için) gibi diğer yazılım kütüphaneleri.
• OpenAI’dan açık kaynaklı Gym yazılım paketi; pekiştirmeli öğrenme ile çözülebilecek farklı ortam ve oyunları simüle eden bir Python kütüphanesi. Algoritmanızın ortamla etkileşim kurmasını sağlamak için Gym API’sini kullanabilirsiniz. Yükseltme sürecinde gym’in işlevselliği bazen değiştiğinden, bu örnekte sürümünü 0.25.2’ye sabitliyoruz.

Bir sunucuya veya yerel makineye kurmak için şunu çalıştırın: 

$ pip install torch numpy matplotlib gym==0.25.2

Google Colab gibi bir Notebook ya da DataLab kullanarak kurmak için: 

!pip install torch numpy matplotlib gym==0.25.2

CartPole ortam(lar)ını oluşturma

OpenAI Gym kullanarak CartPole ortamının iki örneğini (biri eğitim, diğeri test için) oluşturun:

env_train = gym.make('CartPole-v1')
env_test = gym.make('CartPole-v1')

2. PyTorch’ta PPO’nun Uygulanması

Şimdi, PPO’yu PyTorch kullanarak uygulayalım.

Politika ağının tanımlanması

Daha önce açıklandığı gibi, PPO bir aktör-eleştirmen modeli olarak uygulanır. Aktör politikayı uygular ve eleştirmen onun tahmini değerini öngörür. Hem aktör hem eleştirmen sinir ağları aynı girdiyi—her zaman adımındaki durumu—alır. Bu nedenle aktör ve eleştirmen modelleri, omurga (backbone) mimarisi olarak adlandırılan ortak bir sinir ağını paylaşabilir. Aktör ve eleştirmen, omurga mimarisini ek katmanlarla genişletebilir. 

Omurga ağını tanımlayın

Aşağıdaki adımlar omurga ağını açıklar:

• 3 katmanlı bir ağ uygulayın - bir giriş, bir gizli ve bir çıkış katmanı. 
• Giriş ve gizli katmanlardan sonra bir aktivasyon fonksiyonu kullanıyoruz. Bu eğitimde hesaplama açısından verimli olduğu için ReLU’yu seçiyoruz. 
• Ayrıca sağlam bir ağ elde etmek için giriş ve gizli katmanlardan sonra bir dropout işlevi uyguluyoruz. Dropout işlevi bazı nöronları rastgele sıfırlar. Bu, belirli nöronlara bağımlılığı azaltır ve aşırı uyumu önler, böylece ağı daha sağlam hale getirir. 

Aşağıdaki kod omurgayı uygular:

class BackboneNetwork(nn.Module):
    def __init__(self, in_features, hidden_dimensions, out_features, dropout):
        super().__init__()
        self.layer1 = nn.Linear(in_features, hidden_dimensions)
        self.layer2 = nn.Linear(hidden_dimensions, hidden_dimensions)
        self.layer3 = nn.Linear(hidden_dimensions, out_features)
        self.dropout = nn.Dropout(dropout)
    def forward(self, x):
        x = self.layer1(x)
        x = f.relu(x)
        x = self.dropout(x)
        x = self.layer2(x)
        x = f.relu(x)
        x = self.dropout(x)
        x = self.layer3(x)
        return x

Aktör-eleştirmen ağını tanımlayın

Şimdi bu ağı kullanarak ActorCritic adlı aktör-eleştirmen sınıfını tanımlayabiliriz. Aktör politikayı modeller ve eylemi tahmin eder. Eleştirmen değer fonksiyonunu modeller ve değeri tahmin eder. İkisi de girdide durumu alır. 

class ActorCritic(nn.Module):
    def __init__(self, actor, critic):
        super().__init__()
        self.actor = actor
        self.critic = critic
    def forward(self, state):
        action_pred = self.actor(state)
        value_pred = self.critic(state)
        return action_pred, value_pred

Aktör ve eleştirmen ağlarını örnekleyin

Yukarıda tanımlanan ağları kullanarak bir aktör ve bir eleştirmen oluşturacağız. Ardından aktör ve eleştirmeni içeren bir ajan yaratacağız. 

Ajanı oluşturmadan önce ağın parametrelerini başlatın:

• Yapılandırılabilir bir parametre olan gizli katmanın boyutları, H. Gizli katmanların boyutu ve sayısı problemin karmaşıklığına bağlıdır. 64 X 64 boyutlarında bir gizli katman kullanacağız. 
• Girdi özellikleri, N; burada N, durum dizisinin boyutudur. Giriş katmanı N X H boyutlarındadır. CartPole ortamında durum, 4 elemanlı bir dizidir. Yani N = 4. 
• Aktör ağının çıktı özellikleri, O; burada O, ortamdaki eylem sayısıdır. Aktörün çıkış katmanı H x O boyutlarındadır. CartPole ortamında 2 eylem vardır. 
• Eleştirmen ağının çıktı özellikleri. Eleştirmen ağı yalnızca beklenen değeri (bir girdi durumu verildiğinde) tahmin ettiğinden, çıktı özelliği sayısı 1’dir. 
• Dropout oranı (kesir olarak).

Aşağıdaki kod, omurga ağına dayalı olarak aktör ve eleştirmen ağlarının nasıl tanımlanacağını gösterir:

def create_agent(hidden_dimensions, dropout):
    INPUT_FEATURES = env_train.observation_space.shape[0]
    HIDDEN_DIMENSIONS = hidden_dimensions
    ACTOR_OUTPUT_FEATURES = env_train.action_space.n
    CRITIC_OUTPUT_FEATURES = 1
    DROPOUT = dropout
    actor = BackboneNetwork(
            INPUT_FEATURES, HIDDEN_DIMENSIONS, ACTOR_OUTPUT_FEATURES, DROPOUT)
    critic = BackboneNetwork(
            INPUT_FEATURES, HIDDEN_DIMENSIONS, CRITIC_OUTPUT_FEATURES, DROPOUT)
    agent = ActorCritic(actor, critic)
    return agent

Getirilerin hesaplanması

Ajanın eylemine bağlı olarak ortam, her adımdan bir sonrakine giderken bir ödül verir. Ödül, R, şu şekilde ifade edilir:

Getiri, beklenen gelecekteki ödüllerin birikimli değeri olarak tanımlanır. Gelecekte daha uzakta olan zaman adımlarının ödülleri, anlık ödüllerden daha az değerlidir. Bu nedenle getiri, yaygın olarak indirgenmiş getiri, G, olarak hesaplanır ve şu şekilde tanımlanır:

Bu eğitimde (ve birçok diğer kaynakta) getiri, indirgenmiş getiri anlamına gelir. 

Getiriyi hesaplamak için:

• Tüm gelecekteki durumlardan beklenen ödüllerle başlayın.
• Her gelecekteki ödülü iskonto faktörünün bir üssü ile çarpın. Örneğin, (şimdiden) 2 zaman adımı sonraki beklenen ödül, 2 ile çarpılır. 
• Tüm indirgenmiş gelecekteki ödülleri toplayarak getiriyi hesaplayın. 
• Getirinin değerini normalize edin. 

calculate_returns() işlevi bu hesaplamaları aşağıda gösterildiği gibi yapar:

def calculate_returns(rewards, discount_factor):
    returns = []
    cumulative_reward = 0
    for r in reversed(rewards):
        cumulative_reward = r + cumulative_reward * discount_factor
        returns.insert(0, cumulative_reward)
    returns = torch.tensor(returns)
    # normalize the return
    returns = (returns - returns.mean()) / returns.std()
    return returns

Avantaj fonksiyonunun uygulanması

Avantaj, eleştirmenin tahmin ettiği değer ile aktörün politikaya göre seçtiği eylemlerden beklenen getiri arasındaki fark olarak hesaplanır. Belirli bir eylem için avantaj, bu spesifik eylemi, rastgele (ortalama) bir eyleme kıyasla seçmenin faydasını ifade eder. 

Orijinal PPO makalesinde (denklem 10), T zaman adımına kadar ileri bakıldığında avantaj şu şekilde ifade edilir:

Algoritmayı kodlarken, belirli sayıda zaman adımına kadar ileri bakma kısıtı, yığın boyutu aracılığıyla uygulanır. Dolayısıyla yukarıdaki denklem, değer ile beklenen getiriler arasındaki fark olarak basitleştirilebilir. Beklenen getiriler, durum-eylem değer fonksiyonu Q ile nicelenir. 

Dolayısıyla, aşağıdaki basitleştirilmiş formül, seçmenin avantajını ifade eder: 

• belirli bir eylem 
• belirli bir durumda 
• belirli bir politika altında 
• belirli bir zaman adımında 

Şu şekilde ifade edilir: 

OpenAI de RL uygulamak için bu formülü kullanır. Aşağıda gösterilen calculate_advantages() işlevi avantajı hesaplar:

def calculate_advantages(returns, values):
    advantages = returns - values
    # Normalize the advantage
    advantages = (advantages - advantages.mean()) / advantages.std()
    return advantages

Vekil kaybı ve kırpma mekanizması

Politika kaybı, PPO gibi özel teknikler olmadan standart politika gradyanı kaybı olurdu. Standart politika gradyanı kaybı şu çarpım olarak hesaplanır:

• Politikanın eylem olasılıkları 
• Avantaj fonksiyonu; bu da şu ikisi arasındaki fark olarak hesaplanır:
• Politikanın getirisi 
• Beklenen değer

Standart politika gradyanı kaybı, ani politika değişiklikleri için düzeltme yapamaz. Vekil kaybı, politikanın her yinelemede ne kadar değişebileceğini kısıtlamak için standart kaybı değiştirir. İki büyüklüğün minimumudur:

• Şunların çarpımı:
• Politika oranı. Bu oran, eski ve yeni eylem olasılıkları arasındaki farkı ifade eder.  
• Avantaj fonksiyonu 
• Şunların çarpımı:
• Politika oranının sıkıştırılmış (clamped) değeri. Bu oran, güncellenen politikanın eski politikanın belirli bir yüzdesi içinde kalacak şekilde kırpılır. 
• Avantaj fonksiyonu 

Optimizasyon süreci için vekil kayıp, gerçek kaybın bir temsili (proxy’si) olarak kullanılır. 

Kırpma mekanizması

Politika oranı, R, yeni ve eski politikalar arasındaki farktır ve yeni ve eski parametreler altındaki politikanın log olasılıklarının oranı olarak verilir:

Kırpılmış politika oranı, R', şu şekilde kısıtlanır: 

Önceki bölümde gösterilen avantaj At ve yukarıda gösterilen politika oranı verildiğinde, vekil kayıp şu şekilde hesaplanır:

Aşağıdaki kod, kırpma mekanizması ve vekil kaybın nasıl uygulanacağını gösterir. 

def calculate_surrogate_loss(
        actions_log_probability_old,
        actions_log_probability_new,
        epsilon,
        advantages):
    advantages = advantages.detach()
    policy_ratio = (
            actions_log_probability_new - actions_log_probability_old
            ).exp()
    surrogate_loss_1 = policy_ratio * advantages
    surrogate_loss_2 = torch.clamp(
            policy_ratio, min=1.0-epsilon, max=1.0+epsilon
            ) * advantages
    surrogate_loss = torch.min(surrogate_loss_1, surrogate_loss_2)
    return surrogate_loss

3. Ajanın Eğitilmesi

Şimdi ajanı eğitelim.

Politika ve değer kaybının hesaplanması 

Artık politika ve değer kayıplarını hesaplamaya hazırız: 

• Politika kaybı, vekil kayıp ile entropi bonusunun toplamıdır. 
• Değer kaybı, eleştirmenin tahmin ettiği değer ile politikanın ürettiği getiriler (kümülatif ödül) arasındaki farka dayanır. Değer kaybının hesaplanması Smooth L1 Kayıp fonksiyonunu kullanır. Bu, kayıp fonksiyonunu yumuşatmaya yardımcı olur ve aykırı değerlere daha az duyarlı hale getirir. 

Yukarıda hesaplanan her iki kayıp da tensördür. Gradyan inişi skaler değerlere dayanır. Kaybı temsil eden tek bir skaler değer elde etmek için .sum() işlevini kullanarak tensör elemanlarını toplayın. Aşağıdaki işlev bunun nasıl yapılacağını gösterir: 

def calculate_losses(
        surrogate_loss, entropy, entropy_coefficient, returns, value_pred):
    entropy_bonus = entropy_coefficient * entropy
    policy_loss = -(surrogate_loss + entropy_bonus).sum()
    value_loss = f.smooth_l1_loss(returns, value_pred).sum()
    return policy_loss, value_loss

Eğitim döngüsünün tanımlanması

Eğitim sürecine başlamadan önce, tamponları boş diziler olarak oluşturun. Eğitim algoritması, her zaman adımında ajanın eylemleri, ortamın durumları ve ödüllerine ilişkin bilgileri depolamak için bu tamponları kullanacaktır. Aşağıdaki işlev bu tamponları başlatır: 

def init_training():
    states = []
    actions = []
    actions_log_probability = []
    values = []
    rewards = []
    done = False
    episode_reward = 0
    return states, actions, actions_log_probability, values, rewards, done, episode_reward

Her eğitim yinelemesi, o yinelemenin politika parametreleriyle ajanı çalıştırır. Ajan, bir sonlandırma koşuluna ulaşana kadar bir döngü içinde zaman adımlarında ortamla etkileşime girer. 

Her zaman adımından sonra, ajanın eylemi, ödül ve değeri ilgili tamponlara eklenir. Bölüm sona erdiğinde, bölüme ait sonuçları özetleyen güncellenmiş tampon kümesi döndürülür. 

Eğitim döngüsünü çalıştırmadan önce:

• Modeli eğitim moduna agent.train() ile ayarlayın. 
• Ortamı env.reset() kullanarak rastgele bir duruma sıfırlayın. Bu, bu eğitim yinelemesinin başlangıç durumudur. 

Aşağıdaki adımlar, eğitim döngüsündeki her zaman adımında neler olduğunu açıklar: 

• Durumu ajanına iletin. 
• Ajan şunları döndürür:
• Politikaya (aktöre) göre, durum verildiğinde tahmin edilen eylem. Bu tahmin edilen eylem tensörünü softmax işlevinden geçirerek eylem olasılıkları kümesini elde edin.  
• Eleştirmene göre durumun tahmin edilen değeri.
• Ajanın alacağı eylemi seçin:
• Eylem olasılıklarını kullanarak olasılık dağılımını tahmin edin. 
• Bu dağılımdan bir örnek seçerek rastgele bir eylem seçin. dist.sample() işlevi bunu yapar. 
• env.step() işlevini kullanarak bu eylemi ortama iletin ve bu zaman adımı için ortamın tepkisini simüle edin. Ajanın eylemine bağlı olarak ortam şunları üretir:
• Yeni durum
• Ödül
• Boole dönüş değeri done (ortamın son durumuna ulaşıp ulaşmadığını gösterir)
• Ajanın eyleminin, ödüllerin, tahmin edilen değerlerin ve yeni durumun değerlerini ilgili tamponlara ekleyin. 

Eğitim bölümü, env.step() işlevi done’ın boole dönüş değeri için true döndürdüğünde sona erer. 

Bölüm sona erdikten sonra, bu bölümden kümülatif getirileri, her zaman adımındaki ödülleri toplayarak hesaplamak için her zaman adımından biriken değerleri kullanın. Bunu yapmak için daha önce açıklanan calculate_returns() işlevini kullanıyoruz. Bu işlevin girdileri, iskonto faktörü ve her zaman adımındaki ödülleri içeren tampondur. Bu getirileri ve her zaman adımından biriken değerleri kullanarak calculate_advantages() işleviyle avantajları hesaplıyoruz. 

Aşağıdaki Python işlevi bu adımların nasıl uygulanacağını gösterir:

def forward_pass(env, agent, optimizer, discount_factor):
    states, actions, actions_log_probability, values, rewards, done, episode_reward = init_training()
    state = env.reset()
    agent.train()
    while not done:
        state = torch.FloatTensor(state).unsqueeze(0)
        states.append(state)
        action_pred, value_pred = agent(state)
        action_prob = f.softmax(action_pred, dim=-1)
        dist = distributions.Categorical(action_prob)
        action = dist.sample()
        log_prob_action = dist.log_prob(action)
        state, reward, done, _ = env.step(action.item())
        actions.append(action)
        actions_log_probability.append(log_prob_action)
        values.append(value_pred)
        rewards.append(reward)
        episode_reward += reward
    states = torch.cat(states)
    actions = torch.cat(actions)
    actions_log_probability = torch.cat(actions_log_probability)
    values = torch.cat(values).squeeze(-1)
    returns = calculate_returns(rewards, discount_factor)
    advantages = calculate_advantages(returns, values)
    return episode_reward, states, actions, actions_log_probability, advantages, returns

Model parametrelerinin güncellenmesi

Her eğitim yinelemesi, bir sonlandırma koşuluna ulaşana kadar birçok zaman adımından oluşan tam bir bölüm boyunca modeli çalıştırır. Her zaman adımında, politika parametrelerini, ajanın eylemini, getirileri ve avantajları depolarız. Her yinelemeden sonra, model, o yinelemedeki tüm zaman adımlarındaki politikanın performansına göre güncellenir. 

CartPole ortamındaki en fazla zaman adımı sayısı 500’dür. Daha karmaşık ortamlarda zaman adımı daha fazladır, hatta milyonlarca olabilir. Bu gibi durumlarda, eğitim sonuçları veri kümesi yığınlara bölünmelidir. Her yığındaki zaman adımı sayısına optimizasyon yığın boyutu denir. 

Dolayısıyla model parametrelerini güncelleme adımları şunlardır:

• Eğitim sonuçları veri kümesini yığınlara bölün. 
• Her yığın için:
• Her durum için ajanın eylemini ve tahmin edilen değeri alın.
• Bu tahmin edilen eylemleri kullanarak yeni eylem olasılık dağılımını tahmin edin. 
• Bu dağılımı kullanarak entropiyi hesaplayın. 
• Bu dağılımı kullanarak eğitim sonuçları veri kümesindeki eylemlerin log olasılığını elde edin. Bu, eğitim sonuçları veri kümesindeki eylemlerin yeni log olasılıklarıdır. Bu eylemlerin eski log olasılıkları, önceki bölümde açıklanan eğitim döngüsünde hesaplanmıştı. 
• Eylemlerin eski ve yeni olasılık dağılımlarını kullanarak vekil kaybı hesaplayın. 
• Vekil kaybı, entropi ve avantajları kullanarak politika ve değer kaybını hesaplayın. 
• .backward()’ı politika ve değer kayıpları üzerinde ayrı ayrı çalıştırın. Bu, kayıp fonksiyonlarındaki gradyanları günceller. 
• Politika parametrelerini güncellemek için optimize edicide .step() çalıştırın. Bu durumda hız ve sağlamlık dengesini kurmak için Adam optimize edicisini kullanıyoruz. 
• Politika ve değer kayıplarını biriktirin. 
• Geriye doğru geçişi (yukarıdaki işlemleri), PPO_STEPS parametresinin değerine bağlı olarak her yığının üzerinde birkaç kez tekrarlayın. Her yığın üzerinde geriye doğru geçişi tekrarlamak, ek ileri geçişler çalıştırmadan eğitim veri kümesinin boyutunu etkin biçimde artırdığı için hesaplama açısından verimlidir. Örnekleme ve optimizasyon arasındaki her değişimdeki ortam adımı sayısına yineleme yığın boyutu denir. 
• Ortalama politika ve değer kaybını döndürün.

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

def update_policy(
        agent,
        states,
        actions,
        actions_log_probability_old,
        advantages,
        returns,
        optimizer,
        ppo_steps,
        epsilon,
        entropy_coefficient):
    BATCH_SIZE = 128
    total_policy_loss = 0
    total_value_loss = 0
    actions_log_probability_old = actions_log_probability_old.detach()
    actions = actions.detach()
    training_results_dataset = TensorDataset(
            states,
            actions,
            actions_log_probability_old,
            advantages,
            returns)
    batch_dataset = DataLoader(
            training_results_dataset,
            batch_size=BATCH_SIZE,
            shuffle=False)
    for _ in range(ppo_steps):
        for batch_idx, (states, actions, actions_log_probability_old, advantages, returns) in enumerate(batch_dataset):
            # get new log prob of actions for all input states
            action_pred, value_pred = agent(states)
            value_pred = value_pred.squeeze(-1)
            action_prob = f.softmax(action_pred, dim=-1)
            probability_distribution_new = distributions.Categorical(
                    action_prob)
            entropy = probability_distribution_new.entropy()
            # estimate new log probabilities using old actions
            actions_log_probability_new = probability_distribution_new.log_prob(actions)
            surrogate_loss = calculate_surrogate_loss(
                    actions_log_probability_old,
                    actions_log_probability_new,
                    epsilon,
                    advantages)
            policy_loss, value_loss = calculate_losses(
                    surrogate_loss,
                    entropy,
                    entropy_coefficient,
                    returns,
                    value_pred)
            optimizer.zero_grad()
            policy_loss.backward()
            value_loss.backward()
            optimizer.step()
            total_policy_loss += policy_loss.item()
            total_value_loss += value_loss.item()
    return total_policy_loss / ppo_steps, total_value_loss / ppo_steps

4. PPO Ajanını Çalıştırma 

Artık PPO ajanını çalıştıralım.

Performansın değerlendirilmesi 

Ajanın performansını değerlendirmek için yeni bir ortam oluşturun ve ajanın bu yeni ortamda çalıştırılmasından elde edilen kümülatif ödülleri hesaplayın. Ajanı .eval() işlevini kullanarak değerlendirme moduna almanız gerekir. Adımlar, eğitim döngüsüyle aynıdır. Aşağıdaki kod parçacığı değerlendirme işlevini uygular: 

def evaluate(env, agent):
    agent.eval()
    rewards = []
    done = False
    episode_reward = 0
    state = env.reset()
    while not done:
        state = torch.FloatTensor(state).unsqueeze(0)
        with torch.no_grad():
            action_pred, _ = agent(state)
            action_prob = f.softmax(action_pred, dim=-1)
        action = torch.argmax(action_prob, dim=-1)
        state, reward, done, _ = env.step(action.item())
        episode_reward += reward
    return episode_reward

Eğitim sonuçlarının görselleştirilmesi

Matplotlib kütüphanesini eğitim sürecinin ilerlemesini görselleştirmek için kullanacağız. Aşağıdaki işlev, hem eğitim hem test döngülerinden elde edilen ödüllerin nasıl çizileceğini gösterir:

def plot_train_rewards(train_rewards, reward_threshold):
    plt.figure(figsize=(12, 8))
    plt.plot(train_rewards, label='Training Reward')
    plt.xlabel('Episode', fontsize=20)
    plt.ylabel('Training Reward', fontsize=20)
    plt.hlines(reward_threshold, 0, len(train_rewards), color='y')
    plt.legend(loc='lower right')
    plt.grid()
    plt.show()

def plot_test_rewards(test_rewards, reward_threshold):
    plt.figure(figsize=(12, 8))
    plt.plot(test_rewards, label='Testing Reward')
    plt.xlabel('Episode', fontsize=20)
    plt.ylabel('Testing Reward', fontsize=20)
    plt.hlines(reward_threshold, 0, len(test_rewards), color='y')
    plt.legend(loc='lower right')
    plt.grid()
    plt.show()

Aşağıdaki örnek grafiklerde, sırasıyla eğitim ve test ortamlarında politikayı uygulayarak elde edilen eğitim ve test ödüllerini gösteriyoruz. Kod her çalıştırıldığında bu grafiklerin şeklinin farklı görüneceğini unutmayın. Bunun nedeni eğitim sürecinin doğasında bulunan rastgeleliktir. 

Eğitim ödülleri (eğitim ortamında politika uygulanarak elde edilmiştir). Görsel: Yazar.

Test ödülleri (test ortamında politika uygulanarak elde edilmiştir). Görsel: Yazar. 

Yukarıdaki çıktı grafiklerinde eğitim sürecinin ilerlemesini gözlemleyin:

• Ödül düşük değerlerle başlar. Eğitim ilerledikçe ödüller artar. 
• Ödüller artarken rastgele dalgalanır. Bu, ajanın politika uzayını keşfetmesinden kaynaklanır. 
• Eğitim sona erer ve test ödülleri birçok yineleme boyunca eşik (475) etrafında dengelenir. 
• Ödüller 500 ile sınırlandırılmıştır. Bunlar, ortamın (Gym CartPole v1) dayattığı kısıtlardır. 

Benzer şekilde, yinelemeler boyunca değer ve politika kayıplarını da çizebilirsiniz:

def plot_losses(policy_losses, value_losses):
    plt.figure(figsize=(12, 8))
    plt.plot(value_losses, label='Value Losses')
    plt.plot(policy_losses, label='Policy Losses')
    plt.xlabel('Episode', fontsize=20)
    plt.ylabel('Loss', fontsize=20)
    plt.legend(loc='lower right')
    plt.grid()
    plt.show()

Aşağıdaki örnek grafik, eğitim bölümleri boyunca izlenen kayıpları gösterir:

Eğitim süreci boyunca değer ve politika kayıpları. Görsel: Yazar

Grafiği gözlemleyin ve şunları fark edin:

• Kayıplar rastgele dağılmış gibi görünür ve bir desen izlemez. 
• Bu, amacın kaybı en aza indirmek değil, ödülleri en üst düzeye çıkarmak olduğu RL eğitimine tipiktir. 

PPO algoritmasını çalıştırın

Artık ajanı PPO kullanarak eğitmek için tüm bileşenlere sahipsiniz. Tümünü bir araya getirmek için şunları yapmanız gerekir:

• İskonto faktörü, yığın boyutu, öğrenme oranı vb. hiperparametreleri tanımlayın. 
• Her yinelemeden gelen ödül ve kayıpları depolamak için tamponları boş diziler olarak başlatın. 
• create_agent() işlevini kullanarak bir ajan örneği oluşturun.
• forward_pass() ve update_policy() işlevlerini kullanarak ileri ve geri geçişleri yinelemeli olarak çalıştırın. 
• evaluate() işlevini kullanarak politikanın performansını test edin. 
• Politika ve değer kayıplarını ve eğitim ile değerlendirme işlevlerinden gelen ödülleri ilgili tamponlara ekleyin. 
• Son birkaç zaman adımı üzerindeki ödül ve kayıpların ortalamasını hesaplayın. Aşağıdaki örnek, son 40 zaman adımı üzerindeki ödül ve kayıpları ortalamaktadır. 
• Sonuçları her birkaç adımda bir yazdırın. Aşağıdaki örnek, her 10 adımda bir yazdırır. 
• Ortalama ödül belirli bir eşiği aştığında süreci sonlandırın. 

Aşağıdaki kod, bunu Python’da yapan bir işlevin nasıl ilan edileceğini gösterir:

def run_ppo():
    MAX_EPISODES = 500
    DISCOUNT_FACTOR = 0.99
    REWARD_THRESHOLD = 475
    PRINT_INTERVAL = 10
    PPO_STEPS = 8
    N_TRIALS = 100
    EPSILON = 0.2
    ENTROPY_COEFFICIENT = 0.01
    HIDDEN_DIMENSIONS = 64
    DROPOUT = 0.2
    LEARNING_RATE = 0.001
    train_rewards = []
    test_rewards = []
    policy_losses = []
    value_losses = []
    agent = create_agent(HIDDEN_DIMENSIONS, DROPOUT)
    optimizer = optim.Adam(agent.parameters(), lr=LEARNING_RATE)
    for episode in range(1, MAX_EPISODES+1):
        train_reward, states, actions, actions_log_probability, advantages, returns = forward_pass(
                env_train,
                agent,
                optimizer,
                DISCOUNT_FACTOR)
        policy_loss, value_loss = update_policy(
                agent,
                states,
                actions,
                actions_log_probability,
                advantages,
                returns,
                optimizer,
                PPO_STEPS,
                EPSILON,
                ENTROPY_COEFFICIENT)
        test_reward = evaluate(env_test, agent)
        policy_losses.append(policy_loss)
        value_losses.append(value_loss)
        train_rewards.append(train_reward)
        test_rewards.append(test_reward)
        mean_train_rewards = np.mean(train_rewards[-N_TRIALS:])
        mean_test_rewards = np.mean(test_rewards[-N_TRIALS:])
        mean_abs_policy_loss = np.mean(np.abs(policy_losses[-N_TRIALS:]))
        mean_abs_value_loss = np.mean(np.abs(value_losses[-N_TRIALS:]))
        if episode % PRINT_INTERVAL == 0:
            print(f'Episode: {episode:3} | \
                  Mean Train Rewards: {mean_train_rewards:3.1f} \
                  | Mean Test Rewards: {mean_test_rewards:3.1f} \
                  | Mean Abs Policy Loss: {mean_abs_policy_loss:2.2f} \
                  | Mean Abs Value Loss: {mean_abs_value_loss:2.2f}')
        if mean_test_rewards >= REWARD_THRESHOLD:
            print(f'Reached reward threshold in {episode} episodes')
            break
    plot_train_rewards(train_rewards, REWARD_THRESHOLD)
    plot_test_rewards(test_rewards, REWARD_THRESHOLD)
    plot_losses(policy_losses, value_losses)

Programı çalıştırın: 

run_ppo()

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

Episode:  10 | Mean Train Rewards: 22.3 | Mean Test Rewards: 30.4 | Mean Abs Policy Loss: 0.37 | Mean Abs Value Loss: 0.39 
Episode:  20 | Mean Train Rewards: 38.6 | Mean Test Rewards: 69.8 | Mean Abs Policy Loss: 0.46 | Mean Abs Value Loss: 0.37 
.
.
.
Episode: 100 | Mean Train Rewards: 289.5 | Mean Test Rewards: 427.3 | Mean Abs Policy Loss: 1.73 | Mean Abs Value Loss: 0.21 
Episode: 110 | Mean Train Rewards: 357.7 | Mean Test Rewards: 461.4 | Mean Abs Policy Loss: 1.86 | Mean Abs Value Loss: 0.22 
Reached reward threshold in 116 episodes

Çalışan programı şu DataLab not defterinde görüntüleyip çalıştırabilirsiniz!

5. Hiperparametre Ayarlama ve Optimizasyon

Makine öğreniminde hiperparametreler eğitim sürecini kontrol eder. Aşağıda, PPO’da kullanılan önemli hiperparametrelerden bazılarını açıklıyorum: 

• Öğrenme oranı: Öğrenme oranı, politika parametrelerinin her yinelemede ne kadar değişebileceğini belirler. Stokastik gradyan inişinde, politika parametrelerinin her yinelemede ne kadar güncelleneceği, öğrenme oranı ve gradyanın çarpımıyla belirlenir. 
• Kırpma parametresi: Epsilon, ε olarak da anılır. Politika oranının ne ölçüde kırpılacağını belirler. Yeni ve eski politikaların oranının,  [1-ε, 1+ε] aralığında değişmesine izin verilir. Bu aralığın ötesine geçtiğinde, aralık içinde kalacak şekilde yapay olarak kırpılır. 
• Yığın boyutu: Bu, her gradyan güncellemesi için dikkate alınacak adım sayısını ifade eder. PPO’da yığın boyutu, politikayı uygulamak ve politika parametrelerini güncellemek için vekil kaybı hesaplamak üzere gereken zaman adımı sayısıdır. Bu makalede 64 yığın boyutu kullandık. 
• Yineleme adımları: Her yığının, geriye doğru geçişi çalıştırmak için tekrar kullanılma sayısıdır. Bu makaledeki kodda PPO_STEPS olarak anılır. Karmaşık ortamlarda ileri geçişi birçok kez çalıştırmak hesaplama açısından maliyetlidir. Daha verimli bir alternatif, her yığını birkaç kez yeniden çalıştırmaktır. Genellikle 5 ile 10 arasında bir değer önerilir. 
• İskonto faktörü: Gamma, γ olarak da adlandırılır. Anlık ödüllerin gelecekteki ödüllere kıyasla ne ölçüde daha değerli olduğunu ifade eder. Bu, paranın zaman değeri hesaplamalarındaki faiz oranı kavramına benzer. 0’a yakın olduğunda, gelecekteki ödüller daha az değerlidir ve ajan anlık ödülleri önceliklendirmelidir. 1’e yakın olduğunda, gelecekteki ödüller önemlidir. 
• Entropi katsayısı: Entropi katsayısı, entropi bonusunu belirler; bu, entropi katsayısı ile dağılımın entropisinin çarpımı olarak hesaplanır. Entropi bonusunun rolü, politikaya daha fazla rastgelelik katmaktır. Bu, ajanın politika uzayını keşfetmesini teşvik eder. Ancak rastgelelik çok yüksek olduğunda eğitim, en iyi politikaya yakınsamaz. 
• Eğitimin başarı kriterleri: Eğitimin ne zaman başarılı sayılacağına yönelik kriterleri belirlemeniz gerekir. Yaygın bir yol, son N denemedeki (bölümdeki) ortalama ödüllerin belirli bir eşiğin üzerinde olmasıdır. Yukarıdaki örnek kodda bu, N_TRIALS değişkeni ile ifade edilmiştir. Bu daha yüksek bir değere ayarlandığında eğitim daha uzun sürer, çünkü politikanın eşik ödülünü daha fazla bölümde elde etmesi gerekir. Ayrıca daha sağlam bir politika ile sonuçlanır, fakat hesaplama açısından daha maliyetlidir. PPO’nun stokastik bir politika olduğunu ve ajanın eşiği aşamadığı bölümler olacağını unutmayın. Bu nedenle N_TRIALS değeri çok yüksekse eğitiminiz sonlanmayabilir.

PPO performansını optimize etme stratejileri

PPO algoritmalarının eğitim performansını optimize etmek deneme-yanılmayı ve farklı hiperparametre değerleriyle denemeler yapmayı içerir. Ancak bazı genel yönergeler vardır: 

• İskonto faktörü: Uzun vadeli ödüllerin önemli olduğu durumlarda—örneğin, çubuğun zaman içinde dengede kalması gereken CartPole ortamında—0,99 gibi orta düzey bir gamma değeriyle başlayın. 
• Entropi bonusu: Karmaşık ortamlarda ajan, en iyi politikayı bulmak için eylem uzayını keşfetmelidir. Entropi bonusu keşfi teşvik eder. Entropi bonusu, vekil kayba eklenir. Entropi katsayısına karar vermeden önce vekil kaybın ve dağılımın entropisinin büyüklüğünü kontrol edin. Bu makalede 0,01 entropi katsayısı kullandık.
• Kırpma parametresi: Kırpma parametresi, güncellenen politikanın mevcut politikadan ne kadar farklı olabileceğini belirler. Kırpma parametresinin büyük bir değeri, ortamın daha iyi keşfedilmesini teşvik eder, ancak eğitimin dengesizleşmesi riskini taşır. Dengesizleştirici güncellemeleri önlerken kademeli keşfe izin veren bir kırpma parametresi istersiniz. Bu makalede 0,2 kırpma parametresi kullandık.
• Öğrenme oranı: Öğrenme oranı çok yüksek olduğunda politika büyük adımlarla güncellenir ve her yineleme ile eğitim süreci dengesizleşebilir. Çok düşük olduğunda ise eğitim çok uzun sürer.  Bu eğitim, ortama uygun olarak 0,001 öğrenme oranı kullandı. Birçok durumda 1e-5 öğrenme oranı önerilir. 

PPO’da Zorluklar ve En İyi Uygulamalar

PPO’nun kavramlarını ve uygulama ayrıntılarını açıkladıktan sonra, zorluklar ve en iyi uygulamaları tartışalım. 

PPO eğitiminde yaygın zorluklar

PPO yaygın olarak kullanılıyor olsa da, bu tekniği gerçek dünya problemlerini başarıyla çözmek için uygularken potansiyel zorlukların farkında olmanız gerekir. Bu zorluklardan bazıları şunlardır:

• Yavaş yakınsama: Karmaşık ortamlarda PPO, örnek-verimsiz olabilir ve en iyi politikaya yakınsamak için ortamla çok sayıda etkileşime ihtiyaç duyabilir. Bu da eğitimi yavaş ve maliyetli kılar. 
• Hiperparametrelere duyarlılık: PPO, politika uzayının verimli şekilde keşfine dayanır. Eğitim sürecinin kararlılığı ve yakınsama hızı, hiperparametrelerin değerlerine duyarlıdır. Bu hiperparametrelerin en iyi değerleri çoğunlukla yalnızca deneme-yanılma ile belirlenebilir. 
• Aşırı uyum:  RL ortamları genellikle rastgele parametrelerle başlatılır. PPO eğitimi, ajanın ortamına dayalı en iyi politikayı bulmaya dayanır. Bazen eğitim süreci, belirli bir ortam için en iyi parametreler kümesine yakınsar, ancak rastgeleleştirilmiş herhangi bir ortam için yakınsamaz. Bu genellikle, her biri farklı şekilde rastgeleleştirilmiş eğitim ortamına sahip çok sayıda yineleme yapılarak ele alınır. 
• Dinamik ortamlar: CartPole gibi basit RL ortamları statiktir—kurallar zaman içinde aynıdır. Dengesiz hareketli bir yüzeyde yürümeyi öğrenen bir robot gibi diğer birçok ortam ise dinamiktir—ortamın kuralları zamanla değişir. Bu tür ortamlarda iyi performans göstermek için PPO genellikle ek ince ayar gerektirir. 
• Keşif ve sömürü dengesi: PPO’nun kırpma mekanizması, politika güncellemelerinin güvenilir bir bölge içinde olmasını sağlar. Ancak bu, ajanın eylem uzayını keşfetmesini de engeller. Bu durum, özellikle karmaşık ortamlarda yerel optimumlara yakınsamaya yol açabilir. Öte yandan, ajanın çok fazla keşfetmesine izin vermek, herhangi bir en iyi politikaya yakınsamayı engelleyebilir. 

PPO modellerini eğitmek için en iyi uygulamalar

PPO ile iyi sonuçlar elde etmek için bazı en iyi uygulamaları öneriyorum:

• Girdi özelliklerini normalize edin: Getiri ve avantaj değerlerinin normalize edilmesi, verideki değişkenliği azaltır ve daha istikrarlı gradyan güncellemelerine yol açar. Veriyi normalize etmek, tüm değerleri tutarlı bir sayısal aralığa getirir. Aykırı değerlerin ve uç değerlerin etkisini azaltmaya yardımcı olur; aksi halde gradyan güncellemelerini bozabilir ve yakınsamayı yavaşlatabilirler. 
• Uygun büyüklükte yığın boyutları kullanın: Küçük yığınlar daha hızlı güncellemeler ve eğitim sağlar, ancak yerel optimumlara yakınsamaya ve eğitim sürecinde dengesizliğe yol açabilir. Daha büyük yığın boyutları, ajanın sağlam politikalar öğrenmesine izin verir ve istikrarlı bir eğitim süreci sağlar. Ancak çok büyük yığın boyutları da optimal değildir. Hesaplama maliyetlerini artırmanın yanı sıra, gradyan güncellemeleri büyük yığınlar üzerinden tahmin edilen ortalamalara dayandığı için politika güncellemelerini değer fonksiyonuna daha az duyarlı hale getirir. Ayrıca, güncellemelerin o belirli yığına aşırı uyum sağlamasına (overfitting) yol açabilir. 
• Yineleme adımları: Genellikle her yığını 5-10 yineleme için yeniden kullanmak tavsiye edilir. Bu, eğitim sürecini daha verimli hale getirir. Aynı yığını çok fazla kez yeniden kullanmak aşırı uyuma yol açar. Kod, bu hiperparametreyi PPO_STEPS olarak adlandırır. 
• Düzenli değerlendirme yapın: Aşırı uyumu tespit etmek için politikanın etkinliğini periyodik olarak izlemek esastır. Politika belirli senaryolarda etkisiz çıkarsa, daha fazla eğitim veya ince ayar gerekebilir. 
• Hiperparametreleri ayarlayın: Daha önce açıklandığı gibi, PPO eğitimi hiperparametrelerin değerlerine duyarlıdır. Spesifik probleminiz için doğru değerler kümesini belirlemek üzere çeşitli hiperparametre değerleriyle deneyler yapın. 
• Paylaşılan omurga ağı: Bu makalede gösterildiği gibi paylaşılan bir omurga kullanmak, aktör ve eleştirmen ağları arasındaki dengesizlikleri önler. Aktör ve eleştirmen arasında bir omurga ağının paylaşılması, paylaşılan özellik çıkarımı ve ortamın ortak bir anlayışına yardımcı olur. Bu, öğrenme sürecini daha verimli ve istikrarlı hale getirir. Ayrıca algoritmanın hesaplama alanı ve zaman karmaşıklığını azaltmaya yardımcı olur. 
• Gizli katmanların sayısı ve boyutu: Daha karmaşık ortamlar için gizli katmanların sayısını ve boyutlarını artırın. CartPole gibi daha basit problemler tek bir gizli katmanla çözülebilir. Bu makalede kullanılan gizli katman 64 boyutludur. Ağı, gerekenden çok daha büyük yapmak hesaplama açısından israf olur ve ağı dengesizleştirebilir. 
• Erken durdurma: Değerlendirme metrikleri karşılandığında eğitimin durdurulması, aşırı eğitimi önlemeye ve kaynak israfını engellemeye yardımcı olur. Yaygın bir değerlendirme metriği, ajanın son N olayda eşik ödülleri aşmasıdır. 

Sonuç

Bu makalede RL problemlerini çözmenin bir yolu olarak PPO’yu tartıştık. Ardından PyTorch kullanarak PPO’nun nasıl uygulanacağına ilişkin adımları ayrıntılandırdık. Son olarak, PPO için bazı performans ipuçları ve en iyi uygulamaları sunduk. 

Öğrenmenin en iyi yolu, kodu kendiniz uygulamaktır. Kodu Gym’deki diğer klasik kontrol ortamlarıyla çalışacak şekilde de değiştirebilirsiniz. Python ve OpenAI’nin Gymnasium’u kullanarak RL ajanlarının nasıl uygulanacağını öğrenmek için Reinforcement Learning with Gymnasium in Python kursunu takip edin!