Q-Öğrenmeye Giriş: Yeni Başlayanlar İçin Bir Eğitim

Pekiştirmeli öğrenme (RL), ajanın hedeflere ulaşmak için en iyi stratejiyi elde etmek üzere ortamla etkileşime girerek öğrendiği makine öğrenimi ekosisteminin bir parçasıdır. Veriyi içeri almamız ve işlememiz gereken denetimli makine öğrenimi algoritmalarından oldukça farklıdır. Pekiştirmeli öğrenmenin veriye ihtiyacı yoktur. Bunun yerine çevreden ve ödül sisteminden öğrenerek daha iyi kararlar verir.

Örneğin, Mario video oyununda bir karakter rastgele bir eylem yaparsa (ör. sola gitmek), bu eyleme bağlı olarak bir ödül alabilir. Eylemi gerçekleştirdikten sonra ajan (Mario) yeni bir durumda olur ve süreç, oyun karakteri sahnenin sonuna ulaşana veya ölünceye kadar tekrar eder. 

Bu bölüm, Mario ödülleri en üst düzeye çıkararak ortamda gezinmeyi öğrenene kadar defalarca tekrarlanır. 

Görsel: Yazar

Pekiştirmeli öğrenmeyi beş basit adımda özetleyebiliriz:

1. Ajan, bir ortamda sıfır durumundadır.
2. Belirli bir stratejiye göre bir eylemde bulunur.
3. Bu eyleme bağlı olarak bir ödül veya ceza alır.
4. Önceki hamlelerden öğrenerek stratejiyi optimize eder. 
5. En iyi strateji bulunana kadar süreç tekrarlanır. 

Daha fazlasını öğrenmek için Pekiştirmeli Öğrenmeye Giriş eğitimimizi okuyun. Pekiştirmeli öğrenmenin nasıl çalıştığını kod örnekleriyle daha ayrıntılı inceleyeceksiniz. 

Bu eğitimde Q-öğrenmeyi öğrenecek ve neden Derin Q-öğrenmeye ihtiyaç duyduğumuzu anlayacağız. Ayrıca, Numpy ve OpenAI Gym kullanarak sıfırdan Q-öğrenme algoritmaları oluşturup eğitmeyi öğreneceğiz.

Not: Makine öğreniminde yeniyseniz, Pekiştirmeli öğrenmeyi ve Q-Öğrenmeyi daha iyi anlamak için Python ile Makine Öğrenimi Bilimcisi kariyer yolumuzu takip etmenizi öneririz. 

Q-Öğrenme Nedir?

Q-öğrenme, ajanın mevcut durumuna göre en iyi eylem dizisini bulacak modelden bağımsız, değer tabanlı, off-policy bir algoritmadır. “Q” kaliteyi ifade eder. Kalite, gelecekteki ödülleri en üst düzeye çıkarmada eylemin ne kadar değerli olduğunu temsil eder.  

Model tabanlı algoritmalar, geçiş ve ödül fonksiyonlarını kullanarak en uygun politikayı tahmin eder ve modeli oluşturur. Buna karşılık, modelden bağımsız algoritmalar, geçiş ve ödül fonksiyonu olmaksızın deneyim yoluyla eylemlerinin sonuçlarını öğrenir. 

Değer tabanlı yöntem, hangi durumun daha değerli olduğunu öğrenmek ve eyleme geçmek için değer fonksiyonunu eğitir. Öte yandan, politika tabanlı yöntemler, belirli bir durumda hangi eylemin yapılacağını öğrenmek için politikayı doğrudan eğitir.

Off-policy yaklaşımda, algoritma eylemi gerçekleştirmek için kullanılan politikadan farklı bir politikayı değerlendirir ve günceller. Buna karşılık, on-policy algoritma eylemi gerçekleştirmek için kullanılan aynı politikayı değerlendirir ve iyileştirir.  

Q-öğrenmede Temel Terimler

Q-öğrenmenin nasıl çalıştığına geçmeden önce, Q-öğrenmenin temellerini anlamak için birkaç faydalı terimi öğrenmemiz gerekiyor. 

• Durumlar (s): ajanın ortam içindeki mevcut konumu. 
• Eylem (a): ajanın belirli bir durumda attığı adım. 
• Ödüller: her eylem için ajan ödül ve ceza alır. 
• Bölümler (episodes): ajanın yeni eylem alamadığı aşamanın sonu. Ajan hedefe ulaştığında veya başarısız olduğunda gerçekleşir. 
• Q(S_t+1, a): belirli bir durumda eylemi yapmanın beklenen en iyi Q-değeri. 
• Q(S_t, A_t): Q(S_t+1, a) için mevcut tahmindir.
• Q-Tablosu: ajan, durumlar ve eylemler kümelerine ilişkin Q-tablosunu tutar.
• Geçici Farklar (TD): mevcut durum ve eylem ile önceki durum ve eylemi kullanarak Q(S_t+1, a) beklenen değerini tahmin etmek için kullanılır. 

Q-Öğrenme Nasıl Çalışır?

Q-öğrenmenin nasıl çalıştığını ayrıntılı olarak donmuş göl örneğini kullanarak öğreneceğiz. Bu ortamda, ajanın başlangıçtan hedefe kadar donmuş gölü deliklere düşmeden geçmesi gerekir. En iyi strateji, en kısa yolu izleyerek hedefe ulaşmaktır. 

Gif: Yazar

Q-Tablosu

Ajan, ortamda her durum için beklenen ödüle dayanarak mümkün olan en iyi eylemi gerçekleştirmek için bir Q-tablosu kullanacaktır. Basitçe söylemek gerekirse, Q-tablosu eylem ve durum kümelerinden oluşan bir veri yapısıdır ve tablodaki değerleri güncellemek için Q-öğrenme algoritmasını kullanırız. 

Q-Fonksiyonu

Q-fonksiyonu Bellman denkleminden yararlanır ve girdi olarak durum (s) ve eylem (a) alır. Denklem, durum değerleri ile durum-eylem değeri hesaplamasını basitleştirir. 

Görsel kaynağı: freecodecamp.org

Q-öğrenme algoritması

Görsel: Yazar

Q-Tablosunu Başlatma

Önce Q-tablosunu başlatacağız. Tabloyu, sütunları eylem sayısına ve satırları durum sayısına göre oluşturacağız.

Örneğimizde karakter yukarı, aşağı, sola ve sağa hareket edebilir. Dört olası eylemimiz ve dört durumumuz var (başlangıç, boşta, yanlış yol ve son). Yanlış yolu, deliğe düşmek olarak da düşünebilirsiniz. Q-Tablosunu 0 değerleriyle başlatacağız. 

Görsel: Yazar

Bir Eylem Seçin

İkinci adım oldukça basittir. Başlangıçta, ajan rastgele bir eylem seçer (aşağı veya sağa) ve ikinci çalıştırmada eylemi seçmek için güncellenmiş Q-Tablosunu kullanır. 

Bir Eylem Gerçekleştirin

Bir eylem seçme ve eylemi gerçekleştirme, eğitim döngüsü durana kadar defalarca tekrarlanacaktır. İlk eylem ve durum Q-Tablosu kullanılarak seçilir. Bizim durumumuzda Q-Tablosundaki tüm değerler sıfırdır. 

Ardından, ajan aşağı hareket edecek ve Q-Tablosunu Bellman denklemini kullanarak güncelleyecektir. Her hamlede Q-Tablosundaki değerleri güncelleyecek ve en iyi eylem yolunu belirlemek için bu tabloyu kullanacağız. 

Başlangıçta, ajan keşif modundadır ve ortamı keşfetmek için rastgele eylemler seçer. Epsilon Greedy Stratejisi, keşif ve sömürü dengesini kurmak için basit bir yöntemdir. Epsilon, keşfetmeyi seçme olasılığını ifade eder ve keşif olasılığı azaldığında sömürüyü artırır. 

Başlangıçta epsilon oranı yüksektir; bu da ajanın keşif modunda olduğu anlamına gelir. Ortamı keşfederken epsilon azalır ve ajanlar ortamı sömürmeye başlar. Keşif sırasında, her yinelemede ajan, Q-değerlerini tahmin etmede daha kendinden emin hale gelir

Görsel: Yazar

Donmuş göl örneğinde, ajan ortamı bilmediğinden başlamak için rastgele bir eylem (aşağı hareket) yapar. Yukarıdaki görselde gördüğümüz gibi, Q-Tablosu Bellman denklemi kullanılarak güncellenir.

Ödülleri Ölçme

Eylemi gerçekleştirdikten sonra sonucu ve ödülü ölçeceğiz. 

• Hedefe ulaşmanın ödülü +1
• Yanlış yola girmenin (deliğe düşmenin) ödülü 0
• Boşta kalmanın veya donmuş göl üzerinde hareket etmenin ödülü de 0’dır. 

Q-Tablosunu Güncelleyin

Eşitliği kullanarak Q(S_t, A_t) fonksiyonunu güncelleyeceğiz. Bu fonksiyon, önceki bölümün tahmini Q-değerlerini, öğrenme oranını ve Geçici Farklar hatasını kullanır. Geçici Farklar hatası; Anlık ödül, iskonto edilmiş en yüksek beklenen gelecekteki ödül ve önceki Q-değeri tahmini kullanılarak hesaplanır. 

Süreç, Q-Tablosu güncellenip Q-değeri fonksiyonu en büyüklenene kadar defalarca tekrarlanır. 

Görsel: Yazar | Denklem görselleri: Thomas Simonini

Başlangıçta, ajan Q-tablusunu güncellemek için ortamı keşfeder. Q-Tablosu hazır olduğunda ise sömürüye geçer ve daha iyi kararlar almaya başlar. 

Görsel: Yazar

Donmuş göl örneğinde, ajan hedefe ulaşmak için en kısa yolu öğrenir ve deliklere atlamaktan kaçınır. 

Q-Öğrenme Python Eğitimi 

Bu bölümde, Gym ortamı, Pygame ve Numpy kullanarak sıfırdan Q-öğrenme modelimizi oluşturacağız. Python eğitimi, Thomas Simonini’nin Defterinin değiştirilmiş bir sürümüdür. Ortamı ve Q-Tablosunu başlatmayı, açgözlü politikayı tanımlamayı, hiperparametreleri ayarlamayı, eğitim döngüsünü ve değerlendirmeyi oluşturup çalıştırmayı ve sonuçları görselleştirmeyi içerir.   

Eğitim döngünüzü oluşturma ve çalıştırmada sorun yaşıyorsanız, çıktısıyla birlikte kod kaynağını kontrol edebilirsiniz.   

Kurulum

Sanal Ekran Kurulumu

Önce tekrar oynatma videosu (Gif) üretmek için tüm bağımlılıkları kuracağız. Ortamı işlemek ve kareleri kaydetmek için sanal bir ekrana (pyvirtualdisplay) ihtiyacımız olacak. 

Not: %%capture kullanarak Jupyter hücresinin çıktısını bastırıyoruz. 

%%capture
!pip install pyglet==1.5.1
!apt install python-opengl
!apt install ffmpeg
!apt install xvfb
!pip3 install pyvirtualdisplay

# Virtual display
from pyvirtualdisplay import Display

virtual_display = Display(visible=0, size=(1400, 900))
virtual_display.start()

Bağımlılıkları yükleyin

Şimdi, eğitim döngüsünü oluşturmamıza, çalıştırmamıza ve değerlendirmemize yardımcı olacak bağımlılıkları yükleyeceğiz. 

• gym: FrozenLake-v1 ortamını başlatmak için kullanılır.
• pygame: FrozenLake-v1 arayüzü için kullanılır.
• numPy: Q-tablosunu oluşturmak ve yönetmek için kullanılır.

%%capture
!pip install gym==0.24
!pip install pygame
!pip install numpy

!pip install imageio imageio_ffmpeg

Paketleri içe aktarın

Şimdi gerekli kütüphaneleri içe aktaracağız. 

• Imageio animasyon oluşturmak için kullanılır. 
• tqdm, ilerleme çubukları için kullanılır. 

import numpy as np
import gym
import random
import imageio
from tqdm.notebook import trange

Frozen Lake Gym Ortamı 

Frozen Lake gym kütüphanesini kullanarak kaymayan 4x4 bir ortam oluşturacağız. 

• İki ızgara sürümü vardır: “4x4” ve “8x8”.
• is_slippery=True ise donmuş gölün kaygan doğası nedeniyle ajan istenen yönde hareket etmeyebilir. 

Ortamı başlattıktan sonra bir ortam analizi yapacağız. 

env = gym.make("FrozenLake-v1",map_name="4x4",is_slippery=False)

print("Observation Space", env.observation_space)
print("Sample observation", env.observation_space.sample()) # display a random observation

Rastgele konumlarda görüntülenen ortamda 16 benzersiz alan vardır. 

Observation Space Discrete(16)
Sample observation 15

Şimdi eylem sayısını keşfedelim ve rastgele bir eylemi gösterelim. 

Eylem uzayı:

• 0: sola hareket
• 1: aşağı hareket
• 2: sağa hareket
• 3: yukarı hareket

Ödül fonksiyonu:

• Hedefe ulaşma: +1
• Deliğe düşme: 0
• Donmuş gölde kalma: 0

print("Action Space Shape", env.action_space.n)
print("Action Space Sample", env.action_space.sample())

Action Space Shape 4
Action Space Sample 1

Q-tablosunu Oluşturun ve Başlatın

Q-Tablosunda sütunlar eylemler, satırlar ise durumlardır. Eylem uzayını ve durum uzayını bulmak için OpenAI Gym kullanabiliriz. Ardından bu bilgiyi Q-Tablosu oluşturmak için kullanacağız. 

state_space = env.observation_space.n
print("There are ", state_space, " possible states")

action_space = env.action_space.n
print("There are ", action_space, " possible actions")

There are  16  possible states
There are  4  possible actions

Q-Tablosunu başlatmak için, durum uzayı ve eylem uzayından oluşan bir Numpy dizisi oluşturacağız. 16 X 4’lük bir dizi oluşturacağız. 

def initialize_q_table(state_space, action_space):
  Qtable = np.zeros((state_space, action_space))
  return Qtable

Qtable_frozenlake = initialize_q_table(state_space, action_space)

Epsilon-greedy politika

Önceki bölümde, keşif ve sömürü ödünleşimini yöneten epsilon greedy stratejisini öğrendik. 1 - ɛ olasılığıyla sömürü yaparız, ɛ olasılığıyla da keşif yaparız. 

epsilon_greedy_policy içinde şunları yapacağız:

1. 0 ile 1 arasında rastgele bir sayı üretin.
2. Rastgele sayı epsilon’dan büyükse sömürü yapacağız. Bu, ajanın, verilen bir durumda en yüksek değere sahip eylemi seçeceği anlamına gelir.
3. Aksi halde keşif yapacağız (rastgele eylem alma). 

def epsilon_greedy_policy(Qtable, state, epsilon):
  random_int = random.uniform(0,1)
  if random_int > epsilon:
    action = np.argmax(Qtable[state])
  else:
    action = env.action_space.sample()
  return action

Açgözlü politikayı tanımlayın

Artık biliyoruz ki Q-öğrenme bir off-policy algoritmadır; bu da eylem alma politikası ile fonksiyonu güncelleme politikasının farklı olduğu anlamına gelir. 

Bu örnekte, Epsilon Greedy politika eylem politikasıdır ve Açgözlü politika güncelleme politikasıdır. 

Açgözlü politika, ajan eğitildiğinde nihai politika olacaktır. Q-Tablosundan en yüksek durum ve eylem değerini seçmek için kullanılır.

def greedy_policy(Qtable, state):
  action = np.argmax(Qtable[state])
  return action

Model hiperparametreleri

Bu hiperparametreler eğitim döngüsünde kullanılır ve ince ayar yapılması size daha iyi sonuçlar verir. 

Ajanın iyi bir değer yaklaşımı öğrenmesi için yeterince durum uzayını keşfetmesi gerekir; bu nedenle epsilon’un kademeli olarak azalması gerekir. Azalma oranı yüksekse, ajan yeterli durum uzayını keşfetmediği için takılıp kalabilir.

• 10.000 eğitim ve 100 değerlendirme bölümü vardır.
• Öğrenme oranı 0,7’dir.
• Ortam olarak 99 bölüm başına azami adım ile "FrozenLake-v1" kullanıyoruz.
• Gamma (iskonto oranı) 0,95’tir.
• eval_seed: ortam için değerlendirme tohumu.
• Başlangıçtaki keşif epsilon olasılığı 1,0’dır ve minimum olasılık 0,05 olacaktır.
• Epsilon olasılığı için üstel azalma oranı 0,0005’tir.

# Training parameters
n_training_episodes = 10000
learning_rate = 0.7        

# Evaluation parameters
n_eval_episodes = 100      

# Environment parameters
env_id = "FrozenLake-v1"   
max_steps = 99             
gamma = 0.95               
eval_seed = []             

# Exploration parameters
max_epsilon = 1.0           
min_epsilon = 0.05           
decay_rate = 0.0005           

Model Eğitimi 

Eğitim döngüsünde şunları yapacağız:

1. Eğitim bölümleri için bir döngü oluşturun.
2. Önce epsilon’u azaltacağız. Her bölümle birlikte daha az keşif ve daha çok sömürüye ihtiyacımız var. 
3. Ortamı sıfırlayın.
4. Azami adımlar için iç içe bir döngü oluşturun.
5. Epsilon greedy politikayı kullanarak eylemi seçin. 
6. Eylemi (A_t) alın ve beklenen ödülü (R_t+1) ve durumu (S_t+1) gözlemleyin.
7. Eylemi (a) alın ve sonuç durumu (s') ile ödülü (r) gözlemleyin.
8. Formülü kullanarak Q-fonksiyonunu güncelleyin. 
9. done= True ise bölümü bitirin ve döngüyü kırın.
10. Son olarak mevcut durumu yeni durumla değiştirin. 
11. Tüm eğitim bölümleri tamamlandıktan sonra, fonksiyon güncellenmiş Q-Tablosunu döndürecektir. 

def train(n_training_episodes, min_epsilon, max_epsilon, decay_rate, env, max_steps, Qtable):
  for episode in trange(n_training_episodes):
 
    epsilon = min_epsilon + (max_epsilon - min_epsilon)*np.exp(-decay_rate*episode)
    # Reset the environment
    state = env.reset()
    step = 0
    done = False

    # repeat
    for step in range(max_steps):
   
      action = epsilon_greedy_policy(Qtable, state, epsilon)

   
      new_state, reward, done, info = env.step(action)

   
      Qtable[state][action] = Qtable[state][action] + learning_rate * (reward + gamma * np.max(Qtable[new_state]) - Qtable[state][action])

      # If done, finish the episode
      if done:
        break
     
      # Our state is the new state
      state = new_state
  return Qtable

10.000 eğitim bölümünü tamamlamamız 3 saniye sürdü. 

Qtable_frozenlake = train(n_training_episodes, min_epsilon, max_epsilon, decay_rate, env, max_steps, Qtable_frozenlake)

Görüldüğü gibi, eğitilmiş Q-Tablosunda değerler var ve ajan artık bu değerleri kullanarak ortamda gezinecek ve hedefe ulaşacaktır.  

Qtable_frozenlake

array([[0.73509189, 0.77378094, 0.77378094, 0.73509189],
      [0.73509189, 0.        , 0.81450625, 0.77378094],
      [0.77378094, 0.857375  , 0.77378094, 0.81450625],
      [0.81450625, 0.        , 0.77378094, 0.77378094],
      [0.77378094, 0.81450625, 0.        , 0.73509189],
      [0.        , 0.        , 0.        , 0.        ],
      [0.        , 0.9025    , 0.        , 0.81450625],
      [0.        , 0.        , 0.        , 0.        ],
      [0.81450625, 0.        , 0.857375  , 0.77378094],
      [0.81450625, 0.9025    , 0.9025    , 0.        ],
      [0.857375  , 0.95      , 0.        , 0.857375  ],
      [0.        , 0.        , 0.        , 0.        ],
      [0.        , 0.        , 0.        , 0.        ],
      [0.        , 0.9025    , 0.95      , 0.857375  ],
      [0.9025    , 0.95      , 1.        , 0.9025    ],
      [0.        , 0.        , 0.        , 0.        ]])

Değerlendirme

evaluate_agent, n_eval_episodes kadar bölüm çalıştırır ve ödülün ortalamasını ve standart sapmasını döndürür. 

1. Döngüde önce bir değerlendirme tohumu olup olmadığını kontrol edeceğiz. Yoksa ortamı tohum olmadan sıfırlayacağız. 
2. İç içe döngü azami adımlara kadar çalışacaktır.
3. Ajan, Q-Tablosunu kullanarak verilen bir durumda beklenen gelecekteki ödülü en yüksek olan eylemi alacaktır. 
4. Ödülü hesaplayın.
5. Durumu değiştirin.
6. Eğer tamamlandıysa (ajan deliğe düşerse veya hedefe ulaşılmışsa) döngüyü kırın.
7. Sonuçları ekleyin.
8. Sonunda bu sonuçları ortalama ve standart sapmayı hesaplamak için kullanacağız. 

def evaluate_agent(env, max_steps, n_eval_episodes, Q, seed):

  episode_rewards = []
  for episode in range(n_eval_episodes):
    if seed:
      state = env.reset(seed=seed[episode])
    else:
      state = env.reset()
    step = 0
    done = False
    total_rewards_ep = 0
   
    for step in range(max_steps):
      # Take the action (index) that have the maximum reward
      action = np.argmax(Q[state][:])
      new_state, reward, done, info = env.step(action)
      total_rewards_ep += reward
       
      if done:
        break
      state = new_state
    episode_rewards.append(total_rewards_ep)
  mean_reward = np.mean(episode_rewards)
  std_reward = np.std(episode_rewards)

  return mean_reward, std_reward

Gördüğünüz gibi, sıfır standart sapma ile mükemmel bir puan aldık. Bu, ajanımızın tüm 100 bölümde hedefe ulaştığı anlamına gelir. 

# Evaluate our Agent
mean_reward, std_reward = evaluate_agent(env, max_steps, n_eval_episodes, Qtable_frozenlake, eval_seed)
print(f"Mean_reward={mean_reward:.2f} +/- {std_reward:.2f}")

Mean_reward=1.00 +/- 0.00

Sonucu görselleştirme

Şimdiye kadar sayılarla oynadık ve bir demo sunmak için, ajanın başlangıçtan hedefe ulaşana kadar olan sürecinin animasyonlu bir Gif’ini oluşturmamız gerekiyor. 

1. Önce ortamı 0-500 arasında rastgele bir tamsayıyla sıfırlayarak durumu oluşturacağız. 
2. Ortama ilişkin bir görüntü dizisi oluşturmak için rdb_array kullanarak ortamı işleyin. 
3. Ardından img’i images dizisine ekleyin. 
4. Döngüde, Q-Tablosunu kullanarak adım atacak ve her adım için görüntüyü işleme alacağız. 
5. Sonunda bu dizi ve imageio’yu kullanarak saniyede bir karelik bir Gif oluşturacağız. 

def record_video(env, Qtable, out_directory, fps=1):
  images = [] 
  done = False
  state = env.reset(seed=random.randint(0,500))
  img = env.render(mode='rgb_array')
  images.append(img)
  while not done:
    # Take the action (index) that have the maximum expected future reward given that state
    action = np.argmax(Qtable[state][:])
    state, reward, done, info = env.step(action) # We directly put next_state = state for recording logic
    img = env.render(mode='rgb_array')
    images.append(img)
  imageio.mimsave(out_directory, [np.array(img) for i, img in enumerate(images)], fps=fps)

Eğer bir Jupyter defterindeyseniz, Gif’i IPython.display Image fonksiyonunu kullanarak görüntüleyebilirsiniz. 

video_path="/content/replay.gif"
video_fps=1
record_video(env, Qtable_frozenlake, video_path, video_fps)

from IPython.display import Image
Image('./replay.gif')

Artık bu sonuçları meslektaşlarınızla ve sınıf arkadaşlarınızla paylaşabilir veya sosyal medyada yayınlayabilirsiniz.