Как реализовать Q-learning, чтобы приблизить оптимальное управление? - PullRequest
Новая
       80

Как реализовать Q-learning, чтобы приблизить оптимальное управление?

0 голосов
/ 09 сентября 2018

Я заинтересован во внедрении Q-обучения (или некоторой формы обучения с подкреплением), чтобы найти оптимальный протокол.В настоящее время у меня есть функция, написанная на Python, где я могу использовать протокол или «действие» и «состояние» и возвращать новое состояние и «вознаграждение».Однако у меня возникают проблемы с поиском реализации Q-обучения на Python, которую я могу использовать в этой ситуации (то есть что-то, что может изучать функцию, как будто это черный ящик).Я посмотрел на тренажерный зал OpenAI, но это потребовало бы написания новой среды.Кто-нибудь знает о более простом пакете или сценарии, которые я могу принять для этого?

Мой код имеет вид: 

def myModel (state, action, param1, param2):
    ...
    return (state, reward)

То, что я ищу, будет алгоритмом формы: 

def QLearning (state, reward):
    ...
    return (action)

И какой-то способ сохранить действия, которые переходят между состояниями.Если у кого-то есть идеи, где это искать, я был бы очень взволнован!

Ответы [ 2 ]

0 голосов
/ 12 сентября 2018

Я также предлагаю вам начать со стандартного алгоритма Q-обучения. Хотя, если вы действительно хотите попробовать приблизительный алгоритм Q-обучения, вы можете взять любую игру Atari из openAI и попытаться решить проблему управления

Прежде всего, вам нужно разработать политику нейронной сети. 

import tensorflow as tf
import keras
import keras.layers as L
tf.reset_default_graph()
sess = tf.InteractiveSession()

keras.backend.set_session(sess)
network = keras.models.Sequential()
network.add(L.InputLayer(state_dim))

network.add(L.Dense(200, activation='relu'))
network.add(L.Dense(200, activation='relu'))
network.add(L.Dense(n_actions))

Это довольно простая сеть, но она будет работать. Также избегайте использования нелинейностей, таких как сигмоид и танх: наблюдения агента не нормированы, поэтому сигмоиды могут насыщаться от init.

Затем мы пробуем действие с эпсилон-жадной политикой 

def get_action(state, epsilon=0):

    if np.random.random() < epsilon:
        return int(np.random.choice(n_actions))

    return int(np.argmax(q_values))

Затем нам нужно обучить Q-функцию агента, чтобы минимизировать потери TD

enter image description here

При выполнении градиентного спуска мы не будем распространять градиенты через него, чтобы сделать обучение более стабильным 

states_ph = keras.backend.placeholder(dtype='float32', shape=(None,) + state_dim)
actions_ph = keras.backend.placeholder(dtype='int32', shape=[None])
rewards_ph = keras.backend.placeholder(dtype='float32', shape=[None])
next_states_ph = keras.backend.placeholder(dtype='float32', shape=(None,) + state_dim)
is_done_ph = keras.backend.placeholder(dtype='bool', shape=[None])

#get q-values for all actions in current states
predicted_qvalues = network(states_ph)

#select q-values for chosen actions
predicted_qvalues_for_actions = tf.reduce_sum(predicted_qvalues * tf.one_hot(actions_ph, n_actions), axis=1)

gamma = 0.99

# compute q-values for all actions in next states
predicted_next_qvalues = network(next_states_ph)

# compute V*(next_states) using predicted next q-values
next_state_values = tf.reduce_max(predicted_next_qvalues, axis=1)

# compute "target q-values" for loss - it's what's inside square parentheses in the above formula.
target_qvalues_for_actions = rewards_ph + gamma*next_state_values

# at the last state we shall use simplified formula: Q(s,a) = r(s,a) since s' doesn't exist
target_qvalues_for_actions = tf.where(is_done_ph, rewards_ph, target_qvalues_for_actions)

Наконец, реализовать среднеквадратическую ошибку, которую вы хотите минимизировать 

loss = (predicted_qvalues_for_actions - tf.stop_gradient(target_qvalues_for_actions)) ** 2
loss = tf.reduce_mean(loss)

# training function that resembles agent.update(state, action, reward, next_state) from tabular agent
train_step = tf.train.AdamOptimizer(1e-4).minimize(loss)

Оставшаяся часть заключается в создании сессий - играйте в env с примерным агентом q-learning и тренируйте его одновременно.

0 голосов
/ 10 сентября 2018

Множество комментариев, представленных здесь, требуют от вас глубоких знаний в области подкрепления. Кажется, вы только начинаете изучать с подкреплением, поэтому я бы рекомендовал начать с самого простого алгоритма обучения Q.

Лучший способ изучить RL - это написать основной алгоритм для себя. Алгоритм состоит из двух частей (модель, агент) и выглядит так: 

model(state, action):
    ...
    return s2, reward, done

где s2 - новое состояние, в которое модель вошла после выполнения действия, a. Вознаграждение основано на выполнении этого действия в этом состоянии. Done просто представляет, является ли это концом эпизода или нет. Похоже, у вас уже есть эта часть.

Следующая часть является агентом и выглядит так: 

states = [s1, s2, s3, ...]
actions = [a1, a2, a3, ...]
Q_matrix = np.zeros([state_size, action_size])
discount = 0.95
learning_rate = 0.1
action_list = []

def q_learning_action(s, Q_matrix):

    action = index_of_max(Q_matrix[s, :])
    action_list.append(action)      # Record your action as requested

    return action

def q_learning_updating(s, a, reward, s2, Q_matrix):

    Q_matrix[s, a] = (1 - learning_rate)Q_matrix[s, a] + learning_rate*(reward + gamma*maxQ_matrix[s2, a])
    s = s2

    return s, Q_matrix

С его помощью вы можете создать агент RL, чтобы изучить множество базовых вещей для оптимального управления.

По сути, Q_learning_actions дает вам действие, необходимое для выполнения в среде. Затем, используя это действие, рассчитайте следующее состояние модели и вознаграждение. Затем, используя всю информацию, обновите свою Q-матрицу новыми знаниями.

Дайте мне знать, если что-то не имеет смысла!

...