Блог

Новый вопрос Я пишу OpenAI Gym pong player с TensorFlow и до сих пор смог создать сеть на основе случайной инициализации, чтобы она случайным образом возвращалась для перемещения весла игрока вверх или вниз.

По окончании эпохи (сыграна 21 партия, в которой победил компьютер) Я собрал набор наблюдений, ходов и оценок. Итоговое наблюдение за игрой получает оценку, и каждое предыдущее наблюдение может быть оценено на основе уравнения Беллмана.

Теперь мои вопросы, которые я пока не понимаю: как мне вычислить функцию затрат, чтобы она распространялась как начальный градиент для обратного распространения? Я полностью понимаю это с обучением под наблюдением, но здесь у нас нет никаких ярлыков для повторной оценки.

С чего бы мне начать оптимизацию сети?

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

Вот где я вычисляю вознаграждения:

 def compute_observation_rewards(self, gamma, up_score_probabilities):
        """
        Applies Bellman equation and determines reward for each stored observation
        :param gamma: Learning decay
        :param up_score_probabilities: Probabilities for up score
        :returns: List of scores for each move
        """

        score_sum = 0
        discounted_rewards = []
        # go backwards through all observations
        for i, p in enumerate(reversed(self._states_score_action)):
            o = p[0]
            s = p[1]

            if s != 0:
                score_sum = 0

            score_sum = score_sum * gamma   s
            discounted_rewards.append(score_sum)

        # # normalize scores
        discounted_rewards = np.array(discounted_rewards)
        discounted_rewards -= np.mean(discounted_rewards)
        discounted_rewards /= np.std(discounted_rewards)

        return discounted_rewards
  

Ниже приведена моя сеть:

 with tf.variable_scope('NN_Model', reuse=tf.AUTO_REUSE):

        layer1 = tf.layers.conv2d(inputs,
                                3,
                                3,
                                strides=(1, 1),
                                padding='valid',
                                data_format='channels_last',
                                dilation_rate=(1, 1),
                                activation= tf.nn.relu, 
                                use_bias=True,
                                bias_initializer=tf.zeros_initializer(),
                                trainable=True,
                                name='layer1'
                            )
        # (N - F   1) x (N - F   1)
        # => layer1 should be 
        # (80 - 3   1) * (80 - 3   1) = 78 x 78

        pool1 = tf.layers.max_pooling2d(layer1,
                                        pool_size=5,
                                        strides=2,
                                        name='pool1')

        # int((N - f) / s  1) 
        # (78 - 5) / 2   1 = 73/2   1 = 37

        layer2 = tf.layers.conv2d(pool1,
                                5,
                                5,
                                strides=(2, 2),
                                padding='valid',
                                data_format='channels_last',
                                dilation_rate=(1, 1),
                                activation= tf.nn.relu, 
                                use_bias=True,
                                kernel_initializer=tf.random_normal_initializer(),
                                bias_initializer=tf.zeros_initializer(),
                                trainable=True,
                                name='layer2',
                                reuse=None
                            )

        # ((N   2xpadding - F) / stride   1) x ((N   2xpadding - F) / stride   1)
        # => layer1 should be 
        # int((37   0 - 5) / 2)   1 
        # 16   1 = 17

        pool2 = tf.layers.max_pooling2d(layer2,
                                        pool_size=3,
                                        strides=2,
                                        name='pool2')

        # int((N - f) / s  1) 
        # (17 - 3) / 2   1 = 7   1 = 8

        flat1 = tf.layers.flatten(pool2, 'flat1')

        # Kx64

        full1 = tf.contrib.layers.fully_connected(flat1,
                                            num_outputs=1,
                                            activation_fn=tf.nn.sigmoid,
                                            weights_initializer=tf.contrib.layers.xavier_initializer(),
                                            biases_initializer=tf.zeros_initializer(),
                                            trainable=True,
                                            scope=None
                                        )
  

Алгоритм, который вы ищете, называется ENFORCEMENT (УСИЛИТЬ). Я бы посоветовал прочитать главу 13 из книги Саттона и Барто RL.

Вот псевдокод из книги.

Здесь тета — это набор весов вашей нейронной сети. Если вы не знакомы с некоторыми остальными обозначениями, я бы посоветовал прочитать главу 3 вышеупомянутой книги. Она охватывает основную формулировку проблемы.