അടിത്തറയിൽ നിന്ന് പിപിഒDraft

2025, ഒക്‌ടോബർ 22

റീൻഫോഴ്സ്മെന്റ് ലേണിംഗ് (ആർഎൽ) പൊതുവേ തുറന്ന അവസാനമുള്ള പ്രശ്നങ്ങൾക്കായി ഉപയോഗിക്കുന്ന ഒരു വ്യത്യസ്ത തരം മെഷീൻ ലേണിംഗാണ്. സൂപ്പർവൈസ്ഡ് ലേണിംഗിനോട് (എസ്എൽ) ഇതിനെ താരതമ്യം ചെയ്യാം, അത് അടിസ്ഥാനപരമായി ഒരു ഉയർന്ന മാന റിഗ്രഷൻ ടാസ്കാണ്. എസ്എൽ-ൽ, ഇൻപുട്ടുകളുടെയും ഔട്ട്പുട്ടുകളുടെയും ഒരു ഡാറ്റാസെറ്റ് നൽകിയിരിക്കുന്നു, ${(x_{i}, y_{i})}$ ഞങ്ങളുടെ ചുമതല ഡാറ്റാസെറ്റിൽ ശരാശരി സ്ക്വയേർഡ് എറർ (എംഎസ്ഇ) കുറയ്ക്കുന്ന ഒരു ഫംഗ്ഷൻ $f (x)$ പഠിക്കുക എന്നതാണ്. എന്നാൽ, പല ഉപയോഗപ്രദമായ പ്രശ്നങ്ങളും ഈ ചട്ടക്കൂടിൽ പ്രകടിപ്പിക്കാൻ കഴിയില്ല. ഒരു വർച്വൽ മനുഷ്യാകൃതിയിലുള്ള ഏജന്റിനെ ഒരു ഫ്ലിപ്പ് ചെയ്യാൻ പഠിപ്പിക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചുവെന്ന് കരുതുക. ഞങ്ങളുടെ ഡാറ്റാസെറ്റ് എന്തായിരിക്കും? അത്തരമൊരു ഡാറ്റാസെറ്റ് നിങ്ങൾക്ക് എങ്ങനെ ശേഖരിക്കാനാകും? ഇത് നേരിട്ടുള്ളതല്ല. എന്താണ് നേരിട്ടുള്ളത്, എന്നാൽ, ഏജന്റ് യഥാർത്ഥത്തിൽ ഫ്ലിപ്പ് ചെയ്തിട്ടുണ്ടോ എന്ന് അറിയുക എന്നതാണ്. ഞങ്ങൾ പരിശോധിക്കുന്നു:

ഏജന്റിന്റെ കാൽ പാദങ്ങൾ നിലത്തുനിന്ന് പൊങ്ങിയോ
സമയത്തിന്റെ ഏതെങ്കിലും ഘട്ടത്തിൽ ഏജന്റിന്റെ കാൽപാദങ്ങൾ മുകളിലേക്ക് ചൂണ്ടിക്കാണിച്ചിരുന്നോ
ഏജന്റിന്റെ കാൽപാദങ്ങൾ വീണ്ടും നിലത്തേക്ക് തിരിച്ചെത്തിയോ

ഈ ടാസ്ക്കിന്, വിജയം എളുപ്പത്തിൽ നിർവചിക്കാൻ കഴിയും, എന്നാൽ വിജയത്തിന് ആവശ്യമായ കൃത്യമായ ജോയിന്റ് നിയന്ത്രണങ്ങൾക്ക് കഴിയില്ലെന്ന് നാം കാണുന്നു. അത്തരം സാഹചര്യങ്ങളിലാണ് നാം ആർഎൽ ഉപയോഗിക്കുന്നത്.

ഉയർന്ന തലത്തിൽ, ആർഎൽ ഒരു ട്രയൽ ആൻഡ് എറർ രീതിയാണ്. പിജിയിൽ, ഞങ്ങൾ ചില പോളിസികളിൽ നിന്ന് ആരംഭിക്കുന്നു, കുറച്ച് ടാക്റ്റിക്സ് പരീക്ഷിക്കുക, ഏതൊക്കെ വിജയിച്ചുവെന്ന് കാണുക, പിന്നെ പോളിസി വിജയികളെപ്പോലെ ആകാൻ നയിക്കുക. ഈ ലേഖനത്തിൽ, ഞങ്ങൾ അടിത്തറയിൽ നിന്ന് ആർഎലും പോളിസി ഗ്രേഡിയന്റ് രീതികളും പര്യവേക്ഷണം ചെയ്യാൻ പോകുന്നു, പിപിഒ ( Schulman et al., 2017 ) യിൽ അവസാനിക്കുന്നു, അത് പിജി രീതികൾക്കുള്ള അടിസ്ഥാന ബേസ്ലൈനായി തുടരുന്നു. പിപിഒയെ പ്രചോദിപ്പിച്ച മുൻ ട്രസ്റ്റ്-റീജിയൻ സമീപനങ്ങളെക്കുറിച്ചും ഞങ്ങൾ സ്പർശിക്കും.

പ്രാഥമികതയുടെ അടിസ്ഥാനങ്ങൾ

മാർക്കോവ് ഡിസിഷൻ പ്രോസസ്സുകൾ

ഏജന്റുകൾ, പരിസരങ്ങൾ, പ്രതിഫലങ്ങൾ എന്നിവയുടെ ആശയം ഗണിതശാസ്ത്രപരമായി കൈകാര്യം ചെയ്യാൻ ആദ്യം രൂപപ്പെടുത്തണം. ഏറ്റവും സാധാരണമായ രൂപപ്പെടുത്തൽ മാർക്കോവ് ഡിസിഷൻ പ്രോസസ്സുകളുടെ (എംഡിപികൾ) ആണ് ( Bellman, 1957 ; Sutton and Barto, 2018 ) .

ഒരു എംഡിപി താഴെ പറയുന്നവയാൽ നിർവചിക്കപ്പെടുന്നു:

$S$ : പരിസരത്തിന്റെ സാധ്യമായ എല്ലാ സ്ഥിതികളുടെയും സെറ്റ്
$A$ : ഏജന്റിന് ചെയ്യാൻ കഴിയുന്ന എല്ലാ പ്രവൃത്തികളുടെയും സെറ്റ്
$R$ : ഏജന്റിന് ലഭിക്കാവുന്ന എല്ലാ പ്രതിഫലങ്ങളുടെയും സെറ്റ്
$p (s^{'}, r ∣ s, a)$ : ഒരു പരിവർത്തന ഫംഗ്ഷൻ, അത് നമ്മോട് പറയുന്നു: $s$ സ്ഥിതിയിൽ $a$ പ്രവൃത്തി ചെയ്താൽ, $r$ പ്രതിഫലം കൂടാതെ അടുത്ത $s^{'}$ സ്ഥിതിയിലേക്ക് പോകാനുള്ള സാധ്യത എന്താണ്?
$0 \leq γ \leq 1$ : സമയ ഡിസ്കൗണ്ട് ഫാക്ടർ, അതായത് $t + 1$ സമയത്തെ ഒരു പ്രതിഫലം $t$ സമയത്തെതിനേക്കാൾ $γ$ മടങ്ങ് കുറവ് മൂല്യമുള്ളതാണ്.
$ρ_{0}$ : പ്രാരംഭ സ്ഥിതി വിതരണം

ഒരു എംഡിപി വഴി നിർവചിക്കപ്പെട്ട ഒരു പരിസ്ഥിതിയിൽ, നമുക്ക് ഒരു നയം $π_{θ} (a ∣ s)$ ഉണ്ടായിരിക്കാം, അത് നമ്മൾ നിലവിൽ പ്രവൃത്തികൾ സാമ്പിൾ ചെയ്യുന്ന പ്രോബബിലിറ്റി ഡിസ്ട്രിബ്യൂഷൻ നമ്മോട് പറയുന്നു. ഈ ലേഖനത്തിന്റെ ബാക്കി ഭാഗത്ത്, ഇത് $θ$ എന്ന ഭാരങ്ങളാൽ പാരാമീറ്ററൈസ് ചെയ്ത ഒരു ന്യൂറൽ നെറ്റ്വർക്ക് ആണെന്ന് ഞങ്ങൾ അനുമാനിക്കും.

നമുക്ക് ഒരു ട്രാജക്ടറി $τ = (s_{0}, a_{0}, r_{0}, s_{1}, a_{1}, r_{1}, \dots)$ സൃഷ്ടിക്കാം, അത് സമയത്തിനനുസരിച്ചുള്ള സ്ഥിതികൾ, പ്രവൃത്തികൾ, പ്രതിഫലങ്ങൾ എന്നിവയുടെ ഒരു ശ്രേണി മാത്രമാണ്

s_{0} a_{t} (r_{t}, s_{t + 1}) \sim ρ_{0}, \sim π_{θ} (\cdot ∣ s_{t}), \sim p (\cdot, \cdot ∣ s_{t}, a_{t})

ഈ വേരിയബിളുകളെല്ലാം നിങ്ങൾ ആഗിരണം ചെയ്തുകഴിഞ്ഞാൽ, നമ്മുടെ ലക്ഷ്യം വ്യക്തമാകും. $π_{θ}$ എന്നതിനുള്ള ഭാരങ്ങൾ പഠിക്കാൻ നാം ആഗ്രഹിക്കുന്നു, അങ്ങനെ പ്രതീക്ഷിക്കപ്പെടുന്ന ഭാവി ഡിസ്കൗണ്ട് ചെയ്ത പ്രതിഫലങ്ങൾ, അത് ഞങ്ങൾ $G_{0}$ എന്ന് സൂചിപ്പിക്കുന്നു, പരമാവധി ആക്കണം. ഔപചാരികമായി, നമുക്ക് പരമാവധി ആക്കണം

J (θ) = E_{τ \sim π_{θ}} [t = 0 \sum \infty γ^{t} r_{t}] = E_{τ \sim π_{θ}} [R (τ)] .

$π_{θ}$ എന്നതിൽ ബാക്പ്രോപ്പ് ഉപയോഗിച്ച് ഈ ഉദ്ദേശ്യം ഒപ്റ്റിമൈസ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നതിനാൽ, $\nabla_{θ} J (θ)$ എന്നത് $π_{θ}$ യുടെ ഗ്രേഡിയന്റിന്റെ അടിസ്ഥാനത്തിൽ പ്രകടിപ്പിക്കേണ്ടതുണ്ട്. എന്നിരുന്നാലും, $E_{a \sim π_{θ}} [\cdot]$ ഓപ്പറേഷൻ ഡിഫറൻഷ്യബിൾ അല്ല, അതായത്, $π_{θ}$ ൽ നിന്ന് സാമ്പ്ലിംഗ് ചെയ്യുന്ന പ്രവൃത്തിയിലൂടെ ഗ്രേഡിയന്റുകൾക്ക് $θ$ ലേക്ക് തിരികെ കടന്നുപോകാൻ കഴിയില്ല. $\nabla_{θ}$ പ്രതീക്ഷയുടെ അകത്ത് ആയിരിക്കണം, പുറത്തല്ല.

ഇത് സാധ്യമാണ്, കാരണം

\nabla_{θ} E_{τ \sim π_{θ}} [R (τ)] = \nabla_{θ} \int_{θ} R (τ) π_{θ} (τ) d τ = \int_{θ} R (τ) \nabla_{θ} π_{θ} (τ) d τ = \int_{θ} R (τ) π_{θ} (τ) \nabla_{θ} lo g π_{θ} (τ) d τ = E_{τ \sim π_{θ}} [\nabla_{θ} R (τ) lo g π_{θ} (τ)] .

ഇത് നമ്മെ ലളിതമായി സാമ്പിൾ ചെയ്യാൻ അനുവദിക്കുന്നു നയത്തിൽ നിന്നുള്ള ട്രാജക്ടറികൾ, ട്രാജക്ടറിയുടെ ലോഗ്-പ്രോബബിലിറ്റി അതിന്റെ ഡിസ്കൗണ്ട് ചെയ്ത ആകെ പ്രതിഫലം കൊണ്ട് ഗുണിക്കുക, തുടർന്ന് പ്രശ്നമില്ലാതെ ബാക്പ്രോപ്പ് ചെയ്യുക.

ഒരു എസ്റ്റിമേറ്റിന്റെ ഗ്രേഡിയന്റ് കണക്കാക്കാൻ നമുക്ക് കഴിയില്ല, പക്ഷേ ഒരു ഗ്രേഡിയന്റിന്റെ എസ്റ്റിമേറ്റ് കണക്കാക്കാൻ നമുക്ക് കഴിയും!

വെനില്ല പോളിസി ഗ്രേഡിയന്റ്

ശരി, സിദ്ധാന്തം മതി. ഇത് ശരിക്കും പ്രവർത്തിക്കുമോ എന്ന് നോക്കാം.

ഞങ്ങൾ gymnasium ന്റെ CartPole-v1 പരിസ്ഥിതി ഉപയോഗിക്കാൻ പോകുന്നു, ഇവിടെ ലക്ഷ്യം ഒരു കാർട്ടിൽ ഘടിപ്പിച്ചിരിക്കുന്ന കുറ്റി കഴിയുന്നതും നേരം നിവർന്ന സ്ഥാനത്ത് തുടരുക എന്നതാണ് ( Towers et al., 2024 ) .

ഓരോ സമയഘട്ടത്തിലും, പരിസ്ഥിതി അതിന്റെ അവസ്ഥ നൽകുന്നു–ഈ സാഹചര്യത്തിൽ ഇത് ഒരു 4-വെക്റ്റർ ആണ് (കുറ്റിയുടെ കോൺ, കുറ്റിയുടെ കോണീയ പ്രവേഗം, കാർട്ടിന്റെ സ്ഥാനം, കാർട്ടിന്റെ പ്രവേഗം). പിന്നെ ഞങ്ങൾ ഈ അവസ്ഥ ഒരു പോളിസി നെറ്റ്വർക്കിലൂടെ പ്രവർത്തിപ്പിക്കുന്നു, അത് രണ്ട് പ്രവർത്തനങ്ങളുടെ (ഇടത്തോട്ട് തള്ളുക അല്ലെങ്കിൽ വലത്തോട്ട് തള്ളുക) മേൽ ഒരു വിതരണം ഔട്ട്പുട്ട് ചെയ്യുന്നു. ഞങ്ങൾ ജീവിച്ചിരിക്കുന്ന ഓരോ സമയഘട്ടത്തിനും $1$ റിവാർഡ് ലഭിക്കുന്നു.

ഇതാ സ്യൂഡോകോഡ്. പൂർണ്ണമായി റൺ ചെയ്യാവുന്ന ഫയൽ ഇവിടെ ഉണ്ട്.

policy = Policy()  # a linear layer + softmax
optimizer = optim.Adam(policy.parameters(), lr=alpha)

for iteration in range(num_iterations):
    rewards, action_log_probs = [], []
    state = env.reset()  # initial state from ρ_0
    done = False
    while not done:
        log_probs = policy(state)  # (2,); has grad
        action_dist = Categorical(log_probs)
        action = action_dist.sample()
        log_prob = action_dist.log_prob(action)  # (1,); has grad
        state, r, done = env.step(action.detach())
        action_log_probs.append(log_prob)
        rewards.append(r)
    action_log_probs = torch.stack(action_log_probs)
    # compute the trajectory return ∑_{t=0}^T γ^t r_t
    R = 0.0
    for r in reversed(rewards):
        R = r + gamma * R
    # to maximize J, we minimize -J
    loss = -(action_log_probs.sum() * R)  # grad only flows through log probs
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

ഉയർന്ന തലത്തിൽ, ഇത് ഇത് ചെയ്യും:

നിലവിലെ പോളിസി ഉപയോഗിച്ച് ഒരു റോൾഔട്ട് ചെയ്യുക
ആ റോൾഔട്ടിന്റെ സാധ്യത കണക്കാക്കുക
R എന്നത് സാധ്യത കൊണ്ട് ഗുണിച്ചത് പരമാവധി ആക്കുക
- R പോസിറ്റീവ് ആണെങ്കിൽ, ട്രജക്റ്ററിയുടെ സാധ്യത വർദ്ധിപ്പിക്കുക
- R നെഗറ്റീവ് ആണെങ്കിൽ, ട്രജക്റ്ററിയുടെ സാധ്യത കുറയ്ക്കുക

ഫലങ്ങൾ

100 റണ്ണുകളിൽ ശരാശരി പ്രതിഫലം, ഓരോന്നും 1000 ആവർത്തനങ്ങൾക്ക്.

ഫലങ്ങൾ… വളരെ മോശമാണ്. നിങ്ങൾ വളരെ ശ്രദ്ധിച്ച് നോക്കിയാൽ വക്രം അൽപ്പം മുകളിലേക്ക് പോകുന്നതായി തോന്നാം—പക്ഷേ അതിനും ഇത് വളരെ മോശമാണ്. ഈ അൽഗോരിതത്തിൽ കുറച്ച് പ്രശ്നങ്ങൾ വ്യക്തമാണ്. ഒന്ന്, ഈ പരിതസ്ഥിതി പോസിറ്റീവ് പ്രതിഫലങ്ങൾ മാത്രമേ നൽകുന്നുള്ളൂ, അതിനാൽ $G_{0}$ എപ്പോഴും പോസിറ്റീവ് ആയിരിക്കും. ഇതിനർത്ഥം ഒരു ആവർത്തനത്തിലെ പാത എത്ര മോശമായാലും, അൽഗോരിതം അതിന്റെ സാധ്യത എപ്പോഴും വർദ്ധിപ്പിക്കും. പ്രതിഫലങ്ങൾ ഉണ്ടാക്കുന്ന ഒരേ വ്യത്യാസം വർദ്ധനവിന്റെ പരിമാണം മാത്രമാണ്. രണ്ട്, നമ്മുടെ ക്രെഡിറ്റ് അസൈൻമെന്റ് സീക്വൻസ്-ലെവലിലാണ്. ഒരു പാതയിലെ ഓരോ പ്രവൃത്തിയും മുഴുവൻ പാതയുടെയും വിജയത്തിന്റെ അടിസ്ഥാനത്തിൽ തുല്യമായി പ്രതിഫലിപ്പിക്കപ്പെടുന്നു, അതിനാൽ പ്രവൃത്തി തിരഞ്ഞെടുപ്പിൽ അൽഗോരിതത്തിന് സൂക്ഷ്മമായ നിയന്ത്രണം ഇല്ല.

നമുക്ക് ആദ്യം ക്രെഡിറ്റ് അസൈൻമെന്റ് പ്രശ്നത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാം.

റീൻഫോഴ്സ്

$τ$ ലെ ഓരോ പ്രവൃത്തിയും $R (τ)$ ഉപയോഗിച്ച് പ്രതിഫലിപ്പിക്കുന്നതിന് പകരം, നമുക്ക് ഓരോ പ്രവൃത്തി $a_{t}$ യ്ക്കും സമയഘട്ട തലത്തിലുള്ള പ്രതിഫലങ്ങൾ നൽകാം. നമ്മുടെ ഗ്രേഡിയന്റ് കണക്കുകൂട്ടൽ തിരിഞ്ഞുനോക്കുമ്പോൾ, അത് സമയഘട്ടങ്ങളായി വിഭജിക്കാം

\nabla_{θ} J (θ) = E_{a_{t} \sim π_{θ}} [\nabla_{θ} R (τ) lo g π_{θ} (τ)] = E_{a_{t} \sim π_{θ}} [\nabla_{θ} t = 0 \sum \infty lo g π_{θ} (a_{t} ∣ s_{t}) R (τ)] = E_{a_{t} \sim π_{θ}} [\nabla_{θ} t = 0 \sum \infty k = 0 \sum \infty lo g π_{θ} (a_{t} ∣ s_{t}) γ^{k} r_{k}] = E_{a_{t} \sim π_{θ}} [\nabla_{θ} t = 0 \sum \infty k \geq t \sum \infty lo g π_{θ} (a_{t} ∣ s_{t}) γ^{k} r_{k}] + = 0 E_{a_{t} \sim π_{θ}} [\nabla_{θ} t = 0 \sum \infty k < t \sum \infty lo g π_{θ} (a_{t} ∣ s_{t}) γ^{k} r_{k}] .

രണ്ടാമത്തെ പദം എന്തുകൊണ്ട് പൂജ്യമാണ്? അന്തർജ്ഞാനപരമായി, ഇതിന് കാരണം ഭൂതകാലത്തെ പ്രതിഫലങ്ങൾ ( $r_{k}$ for $k < t$ ) സമയം $t$ ആയപ്പോൾ ഫലപ്രദമായി സ്ഥിരാങ്കങ്ങളാണ് എന്നതാണ്. ഇത് ഘടകമാക്കി എടുത്താൽ, പ്രതീക്ഷിത മൂല്യം ശുദ്ധമായി പൂജ്യമായി കണക്കാക്കുന്നു. $τ_{t} = (s_{0}, a_{0}, r_{0}, s_{1}, a_{1}, r_{1}, \dots, s_{t})$ എന്നത് $t$ സമയം വരെയുള്ള ചരിത്രമായിരിക്കട്ടെ. രണ്ടാമത്തെ പദം തുല്യമാണ്

E_{τ_{t}} [E_{a_{t} \sim π_{θ} (\cdot ∣ s_{t})} [\nabla_{θ} lo g π_{θ} (a_{t} ∣ s_{t}) \cdot γ^{k} r_{k} ∣ τ_{t}]] = E_{τ_{t}} [γ^{k} r_{k} \cdot E_{a_{t} \sim π_{θ} (\cdot ∣ s_{t})} [\nabla_{θ} lo g π_{θ} (a_{t} ∣ s_{t}) ∣ τ_{t}]]

ആന്തരിക പ്രതീക്ഷ 0 ആയി കുറയുന്നുവെന്ന് നമ്മൾ ശ്രദ്ധിക്കുന്നു

E_{a_{t} \sim π_{θ} (\cdot ∣ s_{t})} [\nabla_{θ} lo g π_{θ} (a_{t} ∣ s_{t}) ∣ τ_{t}] = \int π_{θ} (a_{t} ∣ s_{t}) \nabla_{θ} lo g π_{θ} (a_{t} ∣ s_{t}) d a = \nabla_{θ} \int π_{θ} (a_{t} ∣ s_{t}) d a = \nabla_{θ} 1 = 0.

മുഴുവൻ പദപ്രയോഗവും അങ്ങനെ തന്നെ

E_{τ_{t}} [γ^{k} r_{k} \cdot 0] = 0.

അതിനാൽ, സമവാക്യം 4 തുല്യമാണെന്ന് നമ്മൾ കാണുന്നു

\nabla J (θ) = E_{a_{t} \sim π_{θ}} [\nabla_{θ} t = 0 \sum \infty k \geq t \sum \infty lo g π_{θ} (a_{t} ∣ s_{t}) γ^{k} r_{k}] = E_{a_{t} \sim π_{θ}} [\nabla_{θ} t = 0 \sum \infty lo g π_{θ} (a_{t} ∣ s_{t}) k \geq t \sum \infty γ^{k} r_{k}] = E_{a_{t} \sim π_{θ}} [\nabla_{θ} t = 0 \sum \infty lo g π_{θ} (a_{t} ∣ s_{t}) G_{t}] .

ശരി, ഇത് നമ്മോട് എന്താണ് പറയുന്നത്? “ഞങ്ങൾ റിവാർഡ്-ടു-ഗോ, $G_{t}$ ഉപയോഗിക്കുകയാണെങ്കിൽ, സമയഘട്ട-തല ക്രെഡിറ്റ് നിയോഗത്തിന് കീഴിൽ പോളിസി ഗ്രേഡിയന്റ് സംരക്ഷിക്കപ്പെടുന്നു”. ശരിയായതിൽ ഒരു തകർച്ചയും വരുത്താതെ, നമുക്ക് ഒരു നേർത്ത ധാന്യത്തിൽ ക്രെഡിറ്റ് നൽകാൻ ഇത് അനുവദിക്കുന്നു. ഈ അൽഗോരിതം റീൻഫോഴ്സ് എന്നറിയപ്പെടുന്നു ( Williams, 1992 ) .

നടപ്പിലാക്കൽ

വാനില പി.ജി. നടപ്പിലാക്കലിൽ നിന്ന് കുറച്ച് വരികൾ മാത്രം മാറ്റേണ്ടതുണ്ട്:

policy = Policy()
optimizer = optim.Adam(policy.parameters(), lr=alpha)

for iteration in range(num_iterations):
    rewards, action_log_probs = [], []
    state = env.reset()
    done = False
    while not done:
        log_probs = policy(state)
        action_dist = Categorical(log_probs)
        action = action_dist.sample()
        log_prob = action_dist.log_prob(action)
        state, r, done = env.step(action.detach())
        action_log_probs.append(log_prob)
        rewards.append(r)
    action_log_probs = torch.stack(action_log_probs)
    G = torch.zeros_like(action_log_probs)
    R = 0.0
    for r in reversed(rewards):
    for t, r in reversed(enumerate(rewards)):
        R = r + gamma * R
        G[t] = R
    loss = -(action_log_probs.sum() * R)
    loss = -(action_log_probs * G).sum()
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

ഫലങ്ങൾ

ഈ ഒരു മാറ്റം മാത്രമേ പ്രകടനത്തിൽ ഗണനീയമായ മെച്ചപ്പെടുത്തൽ ഉണ്ടാക്കുന്നതായി തോന്നുന്നുള്ളൂ.

100 റണുകളിൽ ശരാശരി പ്രതിഫലം, ഓരോന്നും 1000 ആവർത്തനങ്ങൾ നടത്തി.

ഇത് ക്രെഡിറ്റ് അസൈൻമെന്റ് പ്രധാനമാണ് എന്ന് കാണിക്കുന്നു! എന്നിരുന്നാലും, കാർട്ട്‌പോൾ പരിഹരിക്കുന്നതിൽ നിന്ന് ഇപ്പോഴും നാം വളരെ അകലെയാണ്, അത് 500 ടൈംസ്റ്റെപ്പുകൾക്ക് കുറ്റി നിവർന്ന് നിർത്തിയാൽ സംഭവിക്കുന്നു, അല്ലെങ്കിൽ തുല്യമായി 500 ട്രാജക്റ്ററി പ്രതിഫലങ്ങൾ ലഭിക്കുന്നു. നമുക്ക് ആവശ്യമായ അവസാന മെച്ചപ്പെടുത്തൽ ബേസ്‌ലൈനുകളാണ്.

ബേസ്‌ലൈനുകൾ

നമ്മൾ തിരിഞ്ഞു നോക്കിയാൽ, നമ്മുടെ രണ്ടാമത്തെ പ്രശ്നം ഇതായിരുന്നു: ഒരു പ്രവർത്തനം എടുക്കപ്പെടുന്ന സാധ്യത എപ്പോഴും വർദ്ധിപ്പിക്കപ്പെട്ടിരുന്നു എന്നത്. ഒരു പ്രവർത്തനം മോശമാണോ എന്ന് പറയാൻ നമ്മുടെ അൽഗോരിതത്തിന് വഴിയില്ല, അത് എത്ര നല്ലൊരു പ്രവർത്തനമാണെന്ന് മാത്രമേ വിശേഷിപ്പിക്കാൻ കഴിയൂ.

ഒരു പ്രവർത്തനം $a_{t}$ നല്ലതാണോ മോശമാണോ എന്ന് നിർണ്ണയിക്കാനുള്ള ഒരു സാധാരണ ബുദ്ധിമുട്ട്, $a_{t}$ എത്ര നന്നായി പ്രവർത്തിച്ചു എന്ന് ഒരു ബേസ്‌ലൈനുമായി താരതമ്യം ചെയ്ത് അളക്കുക എന്നതാണ്. ഇത് ചെയ്യാനുള്ള ഒരു വഴി, ഓരോ ആവർത്തനത്തിലും നിരവധി റോൾഔട്ടുകൾ പ്രവർത്തിപ്പിച്ച്, എല്ലാ റോൾഔട്ടുകളിലും $G_{t}$ യുടെ ശരാശരി എടുക്കുക എന്നതാണ് — ഇതിനെ $\overset{ˉ}{G_{t}}$ എന്ന് വിളിക്കാം — ആ അളവ് ബേസ്‌ലൈനായി ഉപയോഗിക്കുക.

അതിനാൽ, നമ്മുടെ പുതിയ പോളിസി ഗ്രേഡിയന്റ് ഇതാണ്

J (θ) = E_{a_{t} \sim π_{θ}} [\nabla_{θ} t = 0 \sum \infty lo g π_{θ} (a_{t} ∣ s_{t}) (G_{t} - \overset{ˉ}{G_{t}})]

ഒരു മുന്നറിയിപ്പ് ഉണ്ട്: $\overset{ˉ}{G_{t}}$ എന്നത് $G_{t}$ യിൽ നിന്ന് സ്വതന്ത്രമല്ലെങ്കിൽ നമ്മുടെ പിജി കണക്കാക്കലിന് (estimator) പക്ഷപാതം (bias) ഉണ്ടാകും — $J (θ)$ എന്നത് $\nabla_{θ} \frac{N - 1}{N} lo g π_{θ} (a_{t} ∣ s_{t})$ യുടെ ഒരു കണക്കാക്കലായി (estimator) മാറുമെന്ന് കാണാൻ എളുപ്പമാണ്, ഇവിടെ $N$ എന്നത് റോൾഔട്ടുകളുടെ എണ്ണമാണ്. അതിനാൽ, ബേസ്‌ലൈനായി നമുക്ക് ലീവ്-വൺ-ഔട്ട് (LOO) ശരാശരി ഉപയോഗിക്കേണ്ടതുണ്ട്. ഇതിനർത്ഥം, ട്രാജക്ടറി $τ_{i}$ യ്ക്ക്, മറ്റെല്ലാ റോൾഔട്ടുകളിലെയും ശരാശരി റിട്ടേൺ മാത്രമേ നമ്മൾ പരിഗണിക്കൂ എന്നാണ്. അതിനാൽ, നമ്മുടെ മോണ്ടെ-കാർലോ കണക്കാക്കൽ ഇതായി മാറുന്നു

J (θ) = \frac{1}{N} i = 1 \sum N \nabla_{θ} t = 0 \sum \infty lo g π_{θ} (a_{t} ∣ s_{t}) (G_{t} - \frac{1}{N - 1} j \neq = i \sum G_{j, t})

മറ്റൊരു മുന്നറിയിപ്പ്: ഓരോ റോൾഔട്ടിനും ഒരേ നീളം ആവശ്യമില്ല, കാരണം അവ വ്യത്യസ്ത സമയങ്ങളിൽ പരാജയപ്പെടുന്നു. അതിനാൽ, ഓരോ $t$ യ്ക്കും, ആ $t$ സാധുതയുള്ളതാണെങ്കിൽ, $N$ റോൾഔട്ടുകളിലുടനീളം ശരാശരി എടുക്കണം. ഇത് സമവാക്യങ്ങളിലേക്കാൾ കോഡിൽ ചിത്രീകരിക്കാൻ എളുപ്പമാണ്, അതിനാൽ ഞാൻ അത് ഇവിടെ ചേർക്കുന്നു.

env = gym.make_vec("CartPole-v1", num_envs=args.n_rollouts)
for iter in range(iterations):
    done_envs = np.zeros((N,), dtype=bool)
    rewards, log_probs_history, entropies, alive_masks_history = [], [], [], []
    done = False
    while not done:
        alive_mask = torch.as_tensor(~done_envs, dtype=torch.float32)
        state_tensor = torch.as_tensor(state, dtype=torch.float32)
        log_probs = policy.forward(state_tensor)
        dist = torch.distributions.Categorical(logits=log_probs)
        action = dist.sample()
        state, reward, terminated, truncated, info = env.step(action.numpy())
        rewards.append(torch.as_tensor(reward, dtype=torch.float32) * alive_mask)
        log_probs_history.append(dist.log_prob(action) * alive_mask)
        entropies.append(dist.entropy().detach())
        alive_masks_history.append(alive_mask)
        done_envs |= terminated | truncated
        done = np.all(done_envs)

    T = len(log_probs_history)
    action_log_probs = torch.stack(log_probs_history)  # (T, N)
    alive_masks = torch.stack(alive_masks_history)  # (T, N)
    G = torch.zeros_like(action_log_probs)
    running = torch.zeros(N, dtype=action_log_probs.dtype)
    rewards = torch.stack(rewards)  # (T, N)
    for t in reversed(range(T)):
        running = rewards[t, :] + gamma * running
        G[t, :] = running

    # Leave-one-out mean baseline for unbiased gradient estimation
    # Each rollout's baseline excludes its own return to maintain independence
    alive_count = alive_masks.sum(dim=-1, keepdim=True)  # (T, 1)
    total_G = G.sum(dim=-1, keepdim=True)  # (T, 1)
    baseline = (total_G - G) / (alive_count - 1).clamp(min=1)
    A = G - baseline
    loss = -(action_log_probs * A).sum()

മുമ്പത്തെ പതിപ്പുമായുള്ള കോഡ് വ്യത്യാസത്തിന്റെ ഭൂരിഭാഗവും വെക്റ്ററൈസ്ഡ് എൻവിറോൺമെന്റ് (vectorized env) ഉപയോഗിക്കുന്നതിൽ നിന്നാണ് വരുന്നത്, ഇത് ഒരേസമയം പ്രവർത്തിക്കുന്ന നിരവധി ട്രാജക്ടറികളുടെ done അവസ്ഥ ട്രാക്ക് ചെയ്യാൻ നമ്മെ നിർബന്ധിതരാക്കുന്നു (അല്പം ശ്രമകരമാണെങ്കിലും).

ഫലങ്ങൾ

എല്ലാ രീതികളിലും ശരാശരി മൊത്തം പ്രതിഫലം. നിഴലിച്ച പ്രദേശം IQR ആണ്.

ശരാശരി ബേസ്ലൈൻ മറ്റ് രണ്ടിനെയും തകർത്തുകളയുന്നു! ഇത് സാധാരണയായി 200-ലും കുറവ് ഘട്ടങ്ങൾക്കുള്ളിൽ ചുമതല പരിഹരിക്കുന്നു (500 പ്രതിഫലം കൈവരിക്കുന്നു). മുമ്പത്തെ പ്ലോട്ടുകൾ 1k ഘട്ടങ്ങൾ വരെ ഉൾക്കൊള്ളുമ്പോൾ, ഇത് 250-ൽ മാത്രമാണെന്നും ശ്രദ്ധിക്കുക!

പ്രദർശനം

ഈ അൽഗോരിതം ഉപയോഗിച്ച് പരിശീലിപ്പിച്ച ഒരു നയം ഇതാ, പൂർണ്ണമായും നിങ്ങളുടെ ബ്രൗസറിൽ പ്രവർത്തിക്കുന്നു. ഇതുമായി മത്സരിക്കാൻ tab അമർത്തുക.

സാമാന്യവത്കൃത അഡ്വാന്റേജ് എസ്റ്റിമേഷൻ

നമ്മുടെ പരീക്ഷണങ്ങളിൽ നിന്ന് നോക്കുമ്പോൾ, ഒരു ബേസ്ലൈൻ ചേർക്കുന്നത് പ്രകടനത്തിന് നിർണായകമാണെന്ന് കാണാം. എന്നാൽ, ബേസ്ലൈൻ കണക്കാക്കുന്നതിനുള്ള നമ്മുടെ രീതി എല്ലാ ടാസ്കുകൾക്കും പ്രവർത്തിക്കണമെന്നില്ല. ഒരു സ്റ്റേറ്റിൽ എല്ലാ ആക്ഷനുകളിലും ലഭിക്കുന്ന സാധാരണ റിട്ടേൺ എന്താണെന്ന് നിർണയിക്കാൻ, നമ്മുടെ രീതി $N$ റോൾഔട്ടുകളുടെ ഒരു കൂട്ടത്തിൽ നിന്നുള്ള അനുഭവപരമായ റിട്ടേണുകളെ ശരാശരിയാക്കുന്നു. ഉയർന്ന റാൻഡം അല്ലെങ്കിൽ വ്യത്യസ്തമായ ടാസ്കുകളിൽ ഇത് വളരെ വലിയ വേരിയൻസ് ഉള്ള ഒരു എസ്റ്റിമേറ്റ് ആയിരിക്കാം: പ്രതീക്ഷിക്കുന്ന റിട്ടേൺ സ്റ്റേറ്റ് $s_{t}$ യുടെ ഒരു ഫംഗ്ഷൻ ആയിരിക്കണമെന്നില്ല.

അത്തരം സാഹചര്യങ്ങളിൽ, ട്രെയിനിംഗ് സമയത്ത് കണ്ടുമുട്ടുന്ന യഥാർത്ഥ റിട്ടേണുകളിൽ നിന്ന് ബൂട്ട്സ്ട്രാപ്പ് ചെയ്യപ്പെടുന്ന ഒരു ന്യൂറൽ നെറ്റ്വർക്കായി ഒരു വാല്യൂ ഫംഗ്ഷൻ $V^{π} (s_{t})$ പഠിക്കുന്നത് പരിഗണിക്കാം. ഇതാണ് എസ്റ്റിമേറ്റർ

V^{π} (s_{t}) = E_{s_{t + 1 : \infty} a_{t : \infty}} [l = 0 \sum \infty r_{t + l}],

ഇത് നമ്മൾ സ്റ്റേറ്റ് $s_{t}$ യിലാണെന്നും പോളിസി $π_{θ}$ പിന്തുടരുന്നുവെന്നും കരുതുമ്പോൾ പ്രതീക്ഷിക്കുന്ന ഭാവി റിവാർഡുകൾ നമ്മോട് പറയുന്നു. എന്നിരുന്നാലും, ഈ കൃത്യമായ ഫംഗ്ഷൻ ഒരു ന്യൂറൽ നെറ്റ്വർക്കായി $V_{ϕ}$ പഠിക്കുന്നത് സാധ്യമല്ല, കാരണം $π_{θ}$ ട്രെയിനിംഗ് സമയത്ത് മാറുന്നു. അതിനാൽ എപ്പോഴും നോൺ-സീറോ എറർ ഉണ്ടായിരിക്കും

ϵ (s_{t}) = E [V^{π} (s_{t}) - V_{ϕ} (s_{t})] .

അതുകൊണ്ട്, നമ്മൾ കൂടുതൽ എസ്റ്റിമേഷൻ ബയസ് (MC സാമ്പ്ലിംഗ് ഉപേക്ഷിക്കുന്നതിനാൽ) കുറഞ്ഞ വേരിയൻസിന് വേണ്ടി കൈമാറ്റം ചെയ്യുന്നു.

ശരി, അപ്പോൾ നമ്മുടെ ബേസ്ലൈൻ $V^{π}$ ആണെങ്കിൽ, ഏത് അളവാണ് നമ്മൾ ഒപ്റ്റിമൈസ് ചെയ്യേണ്ടത്? ഒരു സാധ്യത അഡ്വാന്റേജ് $A^{π} (s_{t}, a_{t})$ ആണ്:

A^{π} (s_{t}, a_{t}) = Q^{π} (s_{t}, a_{t}) - V^{π} (s_{t})

ഇവിടെ

Q^{π} (s_{t}, a_{t}) = E_{s_{t + 1 : \infty} a_{t + 1 : \infty}} [l = 0 \sum \infty r_{t + l}],

ഇത് സ്റ്റേറ്റ് $s_{t}$ ൽ നിന്ന് ആക്ഷൻ $a_{t}$ എടുത്തുവെന്ന് നൽകിയിരിക്കുന്ന പ്രതീക്ഷിക്കുന്ന റിട്ടേണിനെ പ്രതിനിധീകരിക്കുന്നു. $A^{π}$ $π$ ൽ നിന്ന് സാമ്പിൾ ചെയ്യപ്പെടുന്ന സാധാരണ ആക്ഷനുമായി താരതമ്യം ചെയ്യുമ്പോൾ $a_{t}$ എടുക്കുന്നത് എത്രമാത്രം മികച്ചതാണെന്ന് നമ്മോട് പറയുന്നു.

മീൻ ബേസ്ലൈൻ എല്ലാ ബേസ്ലൈനുകളിലും ഏറ്റവും ലളിതമാണ്. എന്നിരുന്നാലും, അതിന് പിന്നിലുള്ള ആശയം കൂടുതൽ സാമാന്യമായി ഒരു അഡ്വാന്റേജ് $A^{π} (s_{t}, a_{t})$ ആയി പ്രതിനിധീകരിക്കപ്പെടുന്നു, ഇത് $π_{θ} (\cdot ∣ s_{t})$ ൽ നിന്ന് സാമ്പിൾ ചെയ്യപ്പെടുന്ന സാധാരണ ആക്ഷനുമായി താരതമ്യം ചെയ്യുമ്പോൾ ആക്ഷൻ $a_{t}$ എടുക്കുന്നത് എത്രമാത്രം കൂടുതൽ റിവാർഡ് പ്രതീക്ഷിക്കുന്നുവെന്ന് നമ്മോട് പറയുന്നു.

ഇത് നമുക്ക് $Q$ ഫംഗ്ഷൻ $Q^{π} (s_{t}, a_{t})$ എന്നതിന്റെ അടിസ്ഥാനത്തിൽ പ്രകടിപ്പിക്കാം

Q^{π} (s_{t}, a_{t}) = E_{s_{t + 1 : \infty}, a_{t + 1 : \infty}} [l = 0 \sum \infty r_{t + l}]

ഇത് $a_{t}$ എടുത്തതിന് ശേഷമുള്ള പ്രതീക്ഷിക്കുന്ന ഭാവി റിവാർഡുകളെ പ്രതിനിധീകരിക്കുന്നു, കൂടാതെ വാല്യൂ ഫംഗ്ഷൻ $V (s_{t})$

V^{π} (s_{t}) = E_{s_{t + 1 : \infty}, a_{t : \infty}} [l = 0 \sum \infty r_{t + l}]

—നമ്മൾ സ്റ്റേറ്റ് $s_{t}$ യിലാണെന്ന് നൽകിയിരിക്കുന്ന പ്രതീക്ഷിക്കുന്ന ഭാവി റിവാർഡുകൾ. അഡ്വാന്റേജ് നൽകുന്നത്

A^{π} (s_{t}, a_{t}) = Q^{π} (s_{t}, a_{t}) - V^{π} (s_{t}, a_{t})

ഇത് $π_{θ}$ പോളിസിയിൽ സാധാരണമായ ആക്ഷനെ അപേക്ഷിച്ച് നമ്മൾ തിരഞ്ഞെടുത്ത ആക്ഷൻ എത്രമാത്രം മികച്ചതാണെന്ന് അളക്കുന്നു.

നിലവിൽ, നമ്മുടെ സെറ്റപ്പിൽ, നമുക്ക് ഒരു നെറ്റ്വർക്ക് മാത്രമേയുള്ളൂ $π_{θ}$ . ഇത്

അവലംബങ്ങൾ

Schulman, J., Wolski, F., Dhariwal, P., Radford, A., and Klimov, O. (2017). Proximal Policy Optimization Algorithms. arXiv preprint arXiv:1707.06347. https://arxiv.org/abs/1707.06347. ↩
Bellman, R. (1957). A Markovian Decision Process. Journal of Mathematics and Mechanics. Vol. 6, No. 5, pp. 679-684. doi:10.1512/iumj.1957.6.56038. https://doi.org/10.1512/iumj.1957.6.56038. ↩
Sutton, R. S. and Barto, A. G. (2018). Reinforcement Learning: An Introduction. The MIT Press. https://mitpress.mit.edu/9780262039246/reinforcement-learning. ↩
Towers, M., Kwiatkowski, A., Terry, J., Balis, J. U., De Cola, G., Deleu, T., Goulão, M., Kallinteris, A., Krimmel, M., KG, A., Perez-Vicente, R., Pierré, A., Schulhoff, S., Tai, J. J., Tan, H., and Younis, O. G. (2024). Gymnasium: A Standard Interface for Reinforcement Learning Environments. arXiv preprint arXiv:2407.17032. doi:10.48550/arXiv.2407.17032. https://arxiv.org/abs/2407.17032. ↩
Williams, R. J. (1992). Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning. Machine Learning. Vol. 8, No. 3-4, pp. 229-256. doi:10.1007/BF00992696. https://doi.org/10.1007/BF00992696. ↩

LLM സുതാര്യത

ബ്രൗസർ കാർട്ട്-പോൾ ഇംപ്ലിമെന്റേഷനും പ്ലോട്ടിംഗ് കോഡും Codex CLI യും Claude Code ഉം എഴുതി. ബാക്കിയെല്ലാം എന്റെ സ്വന്തം.