ग्रेडिंग पॉलिसी को समझना

Question

मैं मूल रूप से पॉलिसी ग्रैडिएंट करपैथी ब्लॉग से पॉलिसी ग्रैडिएंट के बहुत सरल उदाहरण को फिर से बनाने की कोशिश कर रहा हूं । उस कलात्मक में, आपको कार्टपोल और पॉलिसी ग्रेडिएंट के साथ वजन और सॉफ्टमैक्स सक्रियण की सूची के साथ उदाहरण मिलेगा। यहाँ कार्टपॉल नीति ढाल का मेरा पुनर्निर्मित और बहुत सरल उदाहरण है, जो एकदम सही काम करता है ।

import gym
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
import copy

NUM_EPISODES = 4000
LEARNING_RATE = 0.000025
GAMMA = 0.99


# noinspection PyMethodMayBeStatic
class Agent:
    def __init__(self):
        self.poly = PolynomialFeatures(1)
        self.w = np.random.rand(5, 2)

    def policy(self, state):
        z = state.dot(self.w)
        exp = np.exp(z)
        return exp/np.sum(exp)

    def __softmax_grad(self, softmax):
        s = softmax.reshape(-1,1)
        return np.diagflat(s) - np.dot(s, s.T)

    def grad(self, probs, action, state):
        dsoftmax = self.__softmax_grad(probs)[action,:]
        dlog = dsoftmax / probs[0,action]
        grad = state.T.dot(dlog[None,:])
        return grad

    def update_with(self, grads, rewards):

        for i in range(len(grads)):
            # Loop through everything that happend in the episode
            # and update towards the log policy gradient times **FUTURE** reward

            total_grad_effect = 0
            for t, r in enumerate(rewards[i:]):
                total_grad_effect += r * (GAMMA ** r)
            self.w += LEARNING_RATE * grads[i] * total_grad_effect
            print("Grads update: " + str(np.sum(grads[i])))



def main(argv):
    env = gym.make('CartPole-v0')
    np.random.seed(1)

    agent = Agent()
    complete_scores = []

    for e in range(NUM_EPISODES):
        state = env.reset()[None, :]
        state = agent.poly.fit_transform(state)

        rewards = []
        grads = []
        score = 0

        while True:

            probs = agent.policy(state)
            action_space = env.action_space.n
            action = np.random.choice(action_space, p=probs[0])

            next_state, reward, done,_ = env.step(action)
            next_state = next_state[None,:]
            next_state = agent.poly.fit_transform(next_state.reshape(1, 4))
            grad = agent.grad(probs, action, state)

            grads.append(grad)
            rewards.append(reward)

            score += reward
            state = next_state

            if done:
                break

        agent.update_with(grads, rewards)
        complete_scores.append(score)

    env.close()
    plt.plot(np.arange(NUM_EPISODES),
             complete_scores)
    plt.savefig('image1.png')


if __name__ == '__main__':
    main(None)

।

।

सवाल

मैं करने की कोशिश कर रहा हूँ, लगभग एक ही उदाहरण लेकिन सिगमॉइड सक्रियण के साथ (बस सादगी के लिए)। मुझे बस इतना ही करना है। से मॉडल में सक्रियण स्विच softmaxकरें sigmoid। जो सुनिश्चित करने के लिए काम करना चाहिए (नीचे स्पष्टीकरण के आधार पर)। लेकिन मेरा नीति क्रमिक मॉडल कुछ भी नहीं सीखता है और यादृच्छिक रहता है। कोई उपाय?

import gym
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures

NUM_EPISODES = 4000
LEARNING_RATE = 0.000025
GAMMA = 0.99


# noinspection PyMethodMayBeStatic
class Agent:
    def __init__(self):
        self.poly = PolynomialFeatures(1)
        self.w = np.random.rand(5, 1) - 0.5

    # Our policy that maps state to action parameterized by w
    # noinspection PyShadowingNames
    def policy(self, state):
        z = np.sum(state.dot(self.w))
        return self.sigmoid(z)

    def sigmoid(self, x):
        s = 1 / (1 + np.exp(-x))
        return s

    def sigmoid_grad(self, sig_x):
        return sig_x * (1 - sig_x)

    def grad(self, probs, action, state):
        dsoftmax = self.sigmoid_grad(probs)
        dlog = dsoftmax / probs
        grad = state.T.dot(dlog)
        grad = grad.reshape(5, 1)
        return grad

    def update_with(self, grads, rewards):
        if len(grads) < 50:
            return
        for i in range(len(grads)):
            # Loop through everything that happened in the episode
            # and update towards the log policy gradient times **FUTURE** reward

            total_grad_effect = 0
            for t, r in enumerate(rewards[i:]):
                total_grad_effect += r * (GAMMA ** r)
            self.w += LEARNING_RATE * grads[i] * total_grad_effect


def main(argv):
    env = gym.make('CartPole-v0')
    np.random.seed(1)

    agent = Agent()
    complete_scores = []

    for e in range(NUM_EPISODES):
        state = env.reset()[None, :]
        state = agent.poly.fit_transform(state)

        rewards = []
        grads = []
        score = 0

        while True:

            probs = agent.policy(state)
            action_space = env.action_space.n
            action = np.random.choice(action_space, p=[1 - probs, probs])

            next_state, reward, done, _ = env.step(action)
            next_state = next_state[None, :]
            next_state = agent.poly.fit_transform(next_state.reshape(1, 4))

            grad = agent.grad(probs, action, state)
            grads.append(grad)
            rewards.append(reward)

            score += reward
            state = next_state

            if done:
                break

        agent.update_with(grads, rewards)
        complete_scores.append(score)

    env.close()
    plt.plot(np.arange(NUM_EPISODES),
             complete_scores)
    plt.savefig('image1.png')


if __name__ == '__main__':
    main(None)

सभी सीखने को प्लॉट करना यादृच्छिक होता है। हाइपर पैरामीटर ट्यूनिंग के साथ कुछ भी मदद नहीं करता है। नमूना छवि के नीचे।

संदर्भ :

1) डीप रिनफोर्समेंट लर्निंग: पिक्सल्स फ्रॉम पिक्सल

2) कार्टपोल और डूम के साथ पॉलिसी ग्रेजुएट्स का परिचय

3) वितरण नीति स्नातक और कार्यान्वयन लागू करना

4) मशीन लर्निंग ट्रिक ऑफ द डे (5): लॉग व्युत्पन्न चाल 12

---

अपडेट करें

नीचे दिए गए जवाब की तरह लगता है कि ग्राफिक से कुछ काम कर सकता है। लेकिन यह न तो लॉग संभावना है, और न ही पॉलिसी का ग्रेडिएंट भी। और आरएल ग्रैडिएंट पॉलिसी के पूरे उद्देश्य को बदल देता है। कृपया संदर्भ देखें। छवि के बाद हम अगले बयान।

मुझे अपनी पॉलिसी के लॉग फंक्शन का ग्रेडिएंट (जो कि केवल वज़न और sigmoidसक्रियता है) लेने की आवश्यकता है।

Comments

मेरा सुझाव है कि आप इस प्रश्न को डेटा साइंस स्टैक एक्सचेंज पर पोस्ट करें क्योंकि यह ज्यादातर एक सैद्धांतिक प्रश्न है (स्टैक ओवरफ्लो मुख्य रूप से कोडिंग प्रश्नों के लिए है)। आप उन लोगों तक भी पहुँच सकते हैं जो इस डोमेन के जानकार हैं।

— गाइल्स-फिलिप पैले

@ गिल्स-फिलिप्पेलाय मैंने कोड जोड़ा, जो समस्या का प्रतिनिधित्व करता है। मुझे क्या करने की आवश्यकता है, यह सक्रियण के साथ कुछ हिस्सों को ठीक करने के लिए है। कृपया अद्यतन उत्तर की जाँच करें।

— GensaGames

डाइविव पॉलिसी ग्रेजुएट्स के लिए, यहाँ एक ही प्रकार की व्यवस्था के उदाहरण के साथ काम करने का संदर्भ लेख है, उम्मीद है कि आप विस्तार से जानेंगे: medium.com/@thechrisyoon/… ।

— मुहम्मद उस्मान

@ मुहम्मदसमान जानकारी के लिए धन्यवाद। मैंने उस स्रोत को लाल कर दिया। अभी यह ऊपर स्पष्ट और प्रपत्र उदाहरण है, मैं से परिवर्तन सक्रियण के लिए कोशिश कर रहा हूँ softmaxकरने के लिए signmoid। यह केवल एक चीज है जो मुझे उपरोक्त उदाहरण में करने की आवश्यकता है।

— गेंसॉम्स

@JasonChia sigmoid, वास्तविक [0, 1]कार्रवाई की संभावना के रूप में व्याख्या की जा सकने वाली रेंज में वास्तविक संख्या का उत्पादन करता है (उदाहरण के लिए, कार्टपोल में दाएं मुड़ें)। फिर नकारात्मक कार्रवाई (बाएं मुड़ने) की संभावना है 1 - sigmoid। इस संभावनाओं का योग 1 है। हां, यह एक standart पोल कार्ड वातावरण है।

— पावेल त्सेव्स्की

Answer 1

समस्या gradविधि से है।

def grad(self, probs, action, state):
    dsoftmax = self.sigmoid_grad(probs)
    dlog = dsoftmax / probs
    grad = state.T.dot(dlog)
    grad = grad.reshape(5, 1)
    return grad

मूल कोड में SoftEax का उपयोग CrossEntropy loss function के साथ किया गया था। जब आप सक्रियण को सिगमॉइड पर स्विच करते हैं, तो उचित हानि फ़ंक्शन बाइनरी क्रॉसएन्ट्रॉपी बन जाता है। अब, gradविधि का उद्देश्य हानि फ़ंक्शन wrt के ग्रेडिएंट की गणना करना है। वजन। विवरण को बख्शते हुए, (probs - action) * stateआपके कार्यक्रम की शब्दावली में उचित ढाल दिया जाता है। अंतिम चीज माइनस साइन को जोड़ना है - हम नुकसान फ़ंक्शन के नकारात्मक को अधिकतम करना चाहते हैं।

gradइस प्रकार उचित विधि:

def grad(self, probs, action, state):
    grad = state.T.dot(probs - action)
    return -grad

एक और बदलाव जो आप जोड़ना चाहते हैं वह है सीखने की दर को बढ़ाना। LEARNING_RATE = 0.0001और NUM_EPISODES = 5000निम्नलिखित प्लॉट का उत्पादन करेंगे:

यदि शून्य माध्य और छोटे विचरण के साथ गौसियन वितरण का उपयोग करके वज़न को आरंभ किया जाता है, तो अभिसरण बहुत तेज़ होगा:

def __init__(self):
    self.poly = PolynomialFeatures(1)
    self.w = np.random.randn(5, 1) * 0.01

अपडेट करें

परिणामों को पुन: प्रस्तुत करने के लिए पूरा कोड जोड़ा गया:

import gym
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures

NUM_EPISODES = 5000
LEARNING_RATE = 0.0001
GAMMA = 0.99


# noinspection PyMethodMayBeStatic
class Agent:
    def __init__(self):
        self.poly = PolynomialFeatures(1)
        self.w = np.random.randn(5, 1) * 0.01

    # Our policy that maps state to action parameterized by w
    # noinspection PyShadowingNames
    def policy(self, state):
        z = np.sum(state.dot(self.w))
        return self.sigmoid(z)

    def sigmoid(self, x):
        s = 1 / (1 + np.exp(-x))
        return s

    def sigmoid_grad(self, sig_x):
        return sig_x * (1 - sig_x)

    def grad(self, probs, action, state):
        grad = state.T.dot(probs - action)
        return -grad

    def update_with(self, grads, rewards):
        if len(grads) < 50:
            return
        for i in range(len(grads)):
            # Loop through everything that happened in the episode
            # and update towards the log policy gradient times **FUTURE** reward

            total_grad_effect = 0
            for t, r in enumerate(rewards[i:]):
                total_grad_effect += r * (GAMMA ** r)
            self.w += LEARNING_RATE * grads[i] * total_grad_effect


def main(argv):
    env = gym.make('CartPole-v0')
    np.random.seed(1)

    agent = Agent()
    complete_scores = []

    for e in range(NUM_EPISODES):
        state = env.reset()[None, :]
        state = agent.poly.fit_transform(state)

        rewards = []
        grads = []
        score = 0

        while True:

            probs = agent.policy(state)
            action_space = env.action_space.n
            action = np.random.choice(action_space, p=[1 - probs, probs])

            next_state, reward, done, _ = env.step(action)
            next_state = next_state[None, :]
            next_state = agent.poly.fit_transform(next_state.reshape(1, 4))

            grad = agent.grad(probs, action, state)
            grads.append(grad)
            rewards.append(reward)

            score += reward
            state = next_state

            if done:
                break

        agent.update_with(grads, rewards)
        complete_scores.append(score)

    env.close()
    plt.plot(np.arange(NUM_EPISODES),
             complete_scores)
    plt.savefig('image1.png')


if __name__ == '__main__':
    main(None)

Comments

आपका बहुत बहुत धन्यवाद। मैं बाद में इस समाधान की कोशिश करेंगे।

— गेन्सेम्स

मुझे यकीन नहीं है, जहां आप मेरे कार्य के लिए ऐसी व्युत्पत्ति लेते हैं। जैसा कि आप ऊपर की छवि की जांच कर सकते हैं। मुझे पॉलिसी के लॉग का ग्रेडिएंट लेना होगा । जहां मेरे मामले में नीति केवल साथ वजन करती है sigmoid। लेकिन जवाब में आपके ग्रेडिएंट को मेरे ग्रेडिएंट से कोई लेना-देना नहीं होना चाहिए। सही?

— गेन्सेमेस

ध्यान दें कि आप किसी भी जानकारी को शामिल नहीं करते हैं कि क्या कार्रवाई की गई थी। पॉलिसी ग्रैडिएटर्स (स्लाइड 13) पर इस व्याख्यान के अनुसार , अपडेट दिखना चाहिए (action - probs) * sigmoid_grad(probs), लेकिन मुझे sigmoid_gradसिग्मोइड ग्रेडिएंट के साथ लुप्त होने की समस्या के कारण छोड़ दिया गया ।

— पावेल त्सेव्स्की

यहां क्रूक्स उस दिशा को इंगित करता है जिसमें हम वजन बदलना चाहते हैं। यदि action = 1, हम वजन (सकारात्मक ढाल) को बढ़ाते हुए, probsकरीब होना चाहते हैं 1। अगर action=0, हम probsकरीब होना चाहते हैं 0, इसलिए वज़न घटाना (नकारात्मक ढाल)।

— पावेल त्सेव्स्कि

किसी भी स्थिति में, ऊपर किए गए परिवर्तन बिल्कुल काम नहीं करते हैं, क्या आप पूरी फ़ाइल साझा कर सकते हैं? उसी समय, मैं स्पष्ट नमूना बनाना चाहता हूं, और इस मामले में लुप्त होने की समस्या की परवाह नहीं करता। और (action - probs)यह उसी तरह के बदलावों को बदलने का एक और तरीका है।

— गेन्सेम्स