SAC minitaur com a API Actor-Learner

Copyright 2021 Os autores do TF-Agents.

Ver no TensorFlow.org Executar no Google Colab Ver fonte no GitHub Baixar caderno

Introdução

Este exemplo mostra como treinar um agente Soft Actor Critic no ambiente do Minitaur .

Se você já trabalhou com o DQN Colab, isso deve parecer muito familiar. Mudanças notáveis ​​incluem:

  • Mudando o agente de DQN para SAC.
  • Treinamento em Minitaur, que é um ambiente muito mais complexo do que CartPole. O ambiente do Minitaur visa treinar um robô quadrúpede para avançar.
  • Usando a API Actor-Learner do TF-Agents para aprendizado por reforço distribuído.

A API oferece suporte à coleta de dados distribuídos usando um buffer de reprodução de experiência e um contêiner variável (servidor de parâmetros) e treinamento distribuído em vários dispositivos. A API foi projetada para ser muito simples e modular. Utilizamos o Reverb para o buffer de reprodução e o contêiner variável e a API TF DistributionStrategy para treinamento distribuído em GPUs e TPUs.

Se você não instalou as seguintes dependências, execute:

sudo apt-get update
sudo apt-get install -y xvfb ffmpeg
pip install -q 'imageio==2.4.0'
pip install -q matplotlib
pip install -q tf-agents[reverb]
pip install -q pybullet

Configurar

Primeiro, importaremos as diferentes ferramentas de que precisamos.

import base64
import imageio
import IPython
import matplotlib.pyplot as plt
import os
import reverb
import tempfile
import PIL.Image

import tensorflow as tf

from tf_agents.agents.ddpg import critic_network
from tf_agents.agents.sac import sac_agent
from tf_agents.agents.sac import tanh_normal_projection_network
from tf_agents.environments import suite_pybullet
from tf_agents.metrics import py_metrics
from tf_agents.networks import actor_distribution_network
from tf_agents.policies import greedy_policy
from tf_agents.policies import py_tf_eager_policy
from tf_agents.policies import random_py_policy
from tf_agents.replay_buffers import reverb_replay_buffer
from tf_agents.replay_buffers import reverb_utils
from tf_agents.train import actor
from tf_agents.train import learner
from tf_agents.train import triggers
from tf_agents.train.utils import spec_utils
from tf_agents.train.utils import strategy_utils
from tf_agents.train.utils import train_utils

tempdir = tempfile.gettempdir()

Hiperparâmetros

env_name = "MinitaurBulletEnv-v0" # @param {type:"string"}

# Use "num_iterations = 1e6" for better results (2 hrs)
# 1e5 is just so this doesn't take too long (1 hr)
num_iterations = 100000 # @param {type:"integer"}

initial_collect_steps = 10000 # @param {type:"integer"}
collect_steps_per_iteration = 1 # @param {type:"integer"}
replay_buffer_capacity = 10000 # @param {type:"integer"}

batch_size = 256 # @param {type:"integer"}

critic_learning_rate = 3e-4 # @param {type:"number"}
actor_learning_rate = 3e-4 # @param {type:"number"}
alpha_learning_rate = 3e-4 # @param {type:"number"}
target_update_tau = 0.005 # @param {type:"number"}
target_update_period = 1 # @param {type:"number"}
gamma = 0.99 # @param {type:"number"}
reward_scale_factor = 1.0 # @param {type:"number"}

actor_fc_layer_params = (256, 256)
critic_joint_fc_layer_params = (256, 256)

log_interval = 5000 # @param {type:"integer"}

num_eval_episodes = 20 # @param {type:"integer"}
eval_interval = 10000 # @param {type:"integer"}

policy_save_interval = 5000 # @param {type:"integer"}

Meio Ambiente

Os ambientes em RL representam a tarefa ou problema que estamos tentando resolver. Ambientes padrão podem ser facilmente criados em TF-Agents usando suites . Temos diferentes suites para carregar ambientes de fontes como OpenAI Gym, Atari, DM Control, etc., dado um nome de ambiente de string.

Agora vamos carregar o ambiente Minituar do pacote Pybullet.

env = suite_pybullet.load(env_name)
env.reset()
PIL.Image.fromarray(env.render())
current_dir=/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pybullet_envs/bullet
urdf_root=/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pybullet_data
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/gym/logger.py:30: UserWarning: WARN: Box bound precision lowered by casting to float32
  warnings.warn(colorize('%s: %s'%('WARN', msg % args), 'yellow'))

png

Nesse ambiente, o objetivo é que o agente treine uma política que irá controlar o robô Minitaur e fazê-lo avançar o mais rápido possível. Os episódios duram 1000 etapas e o retorno será a soma das recompensas ao longo do episódio.

Vejamos as informações que o ambiente fornece como uma observation que a política usará para gerar actions .

print('Observation Spec:')
print(env.time_step_spec().observation)
print('Action Spec:')
print(env.action_spec())
Observation Spec:
BoundedArraySpec(shape=(28,), dtype=dtype('float32'), name='observation', minimum=[  -3.1515927   -3.1515927   -3.1515927   -3.1515927   -3.1515927
   -3.1515927   -3.1515927   -3.1515927 -167.72488   -167.72488
 -167.72488   -167.72488   -167.72488   -167.72488   -167.72488
 -167.72488     -5.71        -5.71        -5.71        -5.71
   -5.71        -5.71        -5.71        -5.71        -1.01
   -1.01        -1.01        -1.01     ], maximum=[  3.1515927   3.1515927   3.1515927   3.1515927   3.1515927   3.1515927
   3.1515927   3.1515927 167.72488   167.72488   167.72488   167.72488
 167.72488   167.72488   167.72488   167.72488     5.71        5.71
   5.71        5.71        5.71        5.71        5.71        5.71
   1.01        1.01        1.01        1.01     ])
Action Spec:
BoundedArraySpec(shape=(8,), dtype=dtype('float32'), name='action', minimum=-1.0, maximum=1.0)

Como podemos ver, a observação é bastante complexa. Recebemos 28 valores que representam os ângulos, velocidades e torques para todos os motores. Em troca, o ambiente espera 8 valores para as ações entre [-1, 1] . Estes são os ângulos de motor desejados.

Normalmente criamos dois ambientes: um para coleta de dados durante o treinamento e outro para avaliação. Os ambientes são escritos em python puro e usam matrizes numpy, que a API Actor Learner consome diretamente.

collect_env = suite_pybullet.load(env_name)
eval_env = suite_pybullet.load(env_name)
urdf_root=/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pybullet_data
urdf_root=/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pybullet_data

Estratégia de distribuição

Usamos a API DistributionStrategy para permitir a execução da computação das etapas do trem em vários dispositivos, como várias GPUs ou TPUs, usando paralelismo de dados. A etapa do trem:

  • Recebe um lote de dados de treinamento
  • Divide entre os dispositivos
  • Calcula o passo à frente
  • Agrega e calcula o MEAN da perda
  • Calcula o retrocesso e realiza uma atualização da variável gradiente

Com a API TF-Agents Learner e a API DistributionStrategy, é muito fácil alternar entre a execução da etapa do trem em GPUs (usando MirroredStrategy) e TPUs (usando TPUStrategy) sem alterar nenhuma das lógicas de treinamento abaixo.

Habilitando a GPU

Se quiser tentar rodar em uma GPU, primeiro você precisará habilitar as GPUs para o notebook:

  • Navegue até Editar → Configurações do Notebook
  • Selecione GPU no menu suspenso do Hardware Accelerator

Escolha uma estratégia

Use strategy_utils para gerar uma estratégia. Sob o capô, passando o parâmetro:

use_gpu = True

strategy = strategy_utils.get_strategy(tpu=False, use_gpu=use_gpu)
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

Todas as variáveis ​​e Agentes precisam ser criados em strategy.scope() , como você verá a seguir.

Agente

Para criar um Agente SAC, primeiro precisamos criar as redes que ele treinará. O SAC é um agente ator-crítico, então precisaremos de duas redes.

O crítico nos dará estimativas de valor para Q(s,a) . Ou seja, ele receberá como entrada uma observação e uma ação, e nos dará uma estimativa de quão boa essa ação foi para o estado dado.

observation_spec, action_spec, time_step_spec = (
      spec_utils.get_tensor_specs(collect_env))

with strategy.scope():
  critic_net = critic_network.CriticNetwork(
        (observation_spec, action_spec),
        observation_fc_layer_params=None,
        action_fc_layer_params=None,
        joint_fc_layer_params=critic_joint_fc_layer_params,
        kernel_initializer='glorot_uniform',
        last_kernel_initializer='glorot_uniform')

Utilizaremos esta crítica para formar uma rede de actor que nos permitirá gerar ações a partir de uma observação.

O ActorNetwork irá prever parâmetros para uma distribuição MultivariateNormalDiag ActorNetwork . Esta distribuição será então amostrada, condicionada à observação atual, sempre que precisarmos gerar ações.

with strategy.scope():
  actor_net = actor_distribution_network.ActorDistributionNetwork(
      observation_spec,
      action_spec,
      fc_layer_params=actor_fc_layer_params,
      continuous_projection_net=(
          tanh_normal_projection_network.TanhNormalProjectionNetwork))

Com essas redes em mãos, agora podemos instanciar o agente.

with strategy.scope():
  train_step = train_utils.create_train_step()

  tf_agent = sac_agent.SacAgent(
        time_step_spec,
        action_spec,
        actor_network=actor_net,
        critic_network=critic_net,
        actor_optimizer=tf.compat.v1.train.AdamOptimizer(
            learning_rate=actor_learning_rate),
        critic_optimizer=tf.compat.v1.train.AdamOptimizer(
            learning_rate=critic_learning_rate),
        alpha_optimizer=tf.compat.v1.train.AdamOptimizer(
            learning_rate=alpha_learning_rate),
        target_update_tau=target_update_tau,
        target_update_period=target_update_period,
        td_errors_loss_fn=tf.math.squared_difference,
        gamma=gamma,
        reward_scale_factor=reward_scale_factor,
        train_step_counter=train_step)

  tf_agent.initialize()

Replay Buffer

Para acompanhar os dados coletados do ambiente, usaremos o Reverb , um sistema de replay eficiente, extensível e fácil de usar da Deepmind. Ele armazena dados de experiência coletados pelos Atores e consumidos pelo Aluno durante o treinamento.

Neste tutorial, isso é menos importante do que max_size - mas em uma configuração distribuída com coleta e treinamento assíncronos, você provavelmente desejará experimentar rate_limiters.SampleToInsertRatio , usando um samples_per_insert em algum lugar entre 2 e 1000. Por exemplo:

rate_limiter=reverb.rate_limiters.SampleToInsertRatio(samples_per_insert=3.0, min_size_to_sample=3, error_buffer=3.0))
table_name = 'uniform_table'
table = reverb.Table(
    table_name,
    max_size=replay_buffer_capacity,
    sampler=reverb.selectors.Uniform(),
    remover=reverb.selectors.Fifo(),
    rate_limiter=reverb.rate_limiters.MinSize(1))

reverb_server = reverb.Server([table])

O buffer de reprodução é construído usando especificações que descrevem os tensores que devem ser armazenados, que podem ser obtidos do agente usando tf_agent.collect_data_spec .

Como o Agente SAC precisa da observação atual e da próxima para calcular a perda, definimos sequence_length=2 .

reverb_replay = reverb_replay_buffer.ReverbReplayBuffer(
    tf_agent.collect_data_spec,
    sequence_length=2,
    table_name=table_name,
    local_server=reverb_server)

Agora geramos um conjunto de dados TensorFlow do buffer de reprodução do Reverb. Vamos passar isso para o aluno para que ele experimente experiências para treinamento.

dataset = reverb_replay.as_dataset(
      sample_batch_size=batch_size, num_steps=2).prefetch(50)
experience_dataset_fn = lambda: dataset

Políticas

Em TF-Agents, as políticas representam a noção padrão de políticas em RL: dado um time_step produz uma ação ou uma distribuição sobre as ações. O método principal é policy_step = policy.step(time_step) onde policy_step é uma tupla nomeada PolicyStep(action, state, info) . O policy_step.action é a action a ser aplicada ao ambiente, o state representa o estado das políticas com estado (RNN) e as info podem conter informações auxiliares, como as probabilidades de log das ações.

Os agentes contêm duas políticas:

  • agent.policy - A política principal usada para avaliação e implantação.
  • agent.collect_policy - uma segunda política que é usada para coleta de dados.
tf_eval_policy = tf_agent.policy
eval_policy = py_tf_eager_policy.PyTFEagerPolicy(
  tf_eval_policy, use_tf_function=True)
tf_collect_policy = tf_agent.collect_policy
collect_policy = py_tf_eager_policy.PyTFEagerPolicy(
  tf_collect_policy, use_tf_function=True)

As políticas podem ser criadas independentemente dos agentes. Por exemplo, use tf_agents.policies.random_py_policy para criar uma política que selecionará aleatoriamente uma ação para cada time_step.

random_policy = random_py_policy.RandomPyPolicy(
  collect_env.time_step_spec(), collect_env.action_spec())

Atores

O ator gerencia as interações entre uma política e um ambiente.

  • Os componentes do Actor contêm uma instância do ambiente (como py_environment ) e uma cópia das variáveis ​​de política.
  • Cada trabalhador Ator executa uma sequência de etapas de coleta de dados, dados os valores locais das variáveis ​​de política.
  • As atualizações de variáveis ​​são feitas explicitamente usando a instância do cliente do contêiner de variáveis ​​no script de treinamento antes de chamar actor.run() .
  • A experiência observada é gravada no buffer de reprodução em cada etapa de coleta de dados.

Conforme os Atores executam as etapas de coleta de dados, eles passam trajetórias de (estado, ação, recompensa) para o observador, que os armazena em cache e os grava no sistema de replay do Reverb.

Estamos armazenando trajetórias para os quadros [(t0, t1) (t1, t2) (t2, t3), ...] porque stride_length=1 .

rb_observer = reverb_utils.ReverbAddTrajectoryObserver(
  reverb_replay.py_client,
  table_name,
  sequence_length=2,
  stride_length=1)

Criamos um ator com a política aleatória e coletamos experiências para alimentar o buffer de reprodução.

initial_collect_actor = actor.Actor(
  collect_env,
  random_policy,
  train_step,
  steps_per_run=initial_collect_steps,
  observers=[rb_observer])
initial_collect_actor.run()

Instancie um ator com a política de coleta para reunir mais experiências durante o treinamento.

env_step_metric = py_metrics.EnvironmentSteps()
collect_actor = actor.Actor(
  collect_env,
  collect_policy,
  train_step,
  steps_per_run=1,
  metrics=actor.collect_metrics(10),
  summary_dir=os.path.join(tempdir, learner.TRAIN_DIR),
  observers=[rb_observer, env_step_metric])

Crie um ator que será usado para avaliar a política durante o treinamento. Passamos actor.eval_metrics(num_eval_episodes) para registrar as métricas mais tarde.

eval_actor = actor.Actor(
  eval_env,
  eval_policy,
  train_step,
  episodes_per_run=num_eval_episodes,
  metrics=actor.eval_metrics(num_eval_episodes),
  summary_dir=os.path.join(tempdir, 'eval'),
)

Aprendizes

O componente Learner contém o agente e executa atualizações de gradiente nas variáveis ​​de política usando dados de experiência do buffer de reprodução. Após uma ou mais etapas de treinamento, o aluno pode enviar um novo conjunto de valores de variáveis ​​para o contêiner de variáveis.

saved_model_dir = os.path.join(tempdir, learner.POLICY_SAVED_MODEL_DIR)

# Triggers to save the agent's policy checkpoints.
learning_triggers = [
    triggers.PolicySavedModelTrigger(
        saved_model_dir,
        tf_agent,
        train_step,
        interval=policy_save_interval),
    triggers.StepPerSecondLogTrigger(train_step, interval=1000),
]

agent_learner = learner.Learner(
  tempdir,
  train_step,
  tf_agent,
  experience_dataset_fn,
  triggers=learning_triggers)
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7fa28994fe50>". Calling saved_model.distribution() will raise the following assertion error: Unable to make a CompositeTensor for "<tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag object at 0x7fa28985a6d0>" of type `<class 'tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag'>`. Email `tfprobability@tensorflow.org` or file an issue on github if you would benefit from this working. (Unable to serialize: No encoder for object [Tensor("ActorDistributionNetwork/TanhNormalProjectionNetwork/Exp:0", shape=(None, 8), dtype=float32)] of type [<class 'tensorflow.python.framework.ops.Tensor'>].)
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7fa28994fe50>". Calling saved_model.distribution() will raise the following assertion error: Unable to make a CompositeTensor for "<tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag object at 0x7fa27c71c250>" of type `<class 'tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag'>`. Email `tfprobability@tensorflow.org` or file an issue on github if you would benefit from this working. (Unable to serialize: No encoder for object [Tensor("ActorDistributionNetwork/TanhNormalProjectionNetwork/Exp:0", shape=(None, 8), dtype=float32)] of type [<class 'tensorflow.python.framework.ops.Tensor'>].)
WARNING:absl:Function `function_with_signature` contains input name(s) 0/step_type, 0/reward, 0/discount, 0/observation with unsupported characters which will be renamed to step_type, reward, discount, observation in the SavedModel.
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7fa28994fe50>". Calling saved_model.distribution() will raise the following assertion error: Unable to make a CompositeTensor for "<tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag object at 0x7fa27c4cbd50>" of type `<class 'tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag'>`. Email `tfprobability@tensorflow.org` or file an issue on github if you would benefit from this working. (Unable to serialize: No encoder for object [Tensor("ActorDistributionNetwork/TanhNormalProjectionNetwork/Exp:0", shape=(None, 8), dtype=float32)] of type [<class 'tensorflow.python.framework.ops.Tensor'>].)
WARNING:absl:Found untraced functions such as ActorDistributionNetwork_layer_call_fn, ActorDistributionNetwork_layer_call_and_return_conditional_losses, EncodingNetwork_layer_call_fn, EncodingNetwork_layer_call_and_return_conditional_losses, TanhNormalProjectionNetwork_layer_call_fn while saving (showing 5 of 35). These functions will not be directly callable after loading.
WARNING:tensorflow:FOR KERAS USERS: The object that you are saving contains one or more Keras models or layers. If you are loading the SavedModel with `tf.keras.models.load_model`, continue reading (otherwise, you may ignore the following instructions). Please change your code to save with `tf.keras.models.save_model` or `model.save`, and confirm that the file "keras.metadata" exists in the export directory. In the future, Keras will only load the SavedModels that have this file. In other words, `tf.saved_model.save` will no longer write SavedModels that can be recovered as Keras models (this will apply in TF 2.5).

FOR DEVS: If you are overwriting _tracking_metadata in your class, this property has been used to save metadata in the SavedModel. The metadta field will be deprecated soon, so please move the metadata to a different file.
WARNING:tensorflow:FOR KERAS USERS: The object that you are saving contains one or more Keras models or layers. If you are loading the SavedModel with `tf.keras.models.load_model`, continue reading (otherwise, you may ignore the following instructions). Please change your code to save with `tf.keras.models.save_model` or `model.save`, and confirm that the file "keras.metadata" exists in the export directory. In the future, Keras will only load the SavedModels that have this file. In other words, `tf.saved_model.save` will no longer write SavedModels that can be recovered as Keras models (this will apply in TF 2.5).

FOR DEVS: If you are overwriting _tracking_metadata in your class, this property has been used to save metadata in the SavedModel. The metadta field will be deprecated soon, so please move the metadata to a different file.
INFO:tensorflow:Assets written to: /tmp/policies/policy/assets
INFO:tensorflow:Assets written to: /tmp/policies/policy/assets
WARNING:absl:Function `function_with_signature` contains input name(s) 0/step_type, 0/reward, 0/discount, 0/observation with unsupported characters which will be renamed to step_type, reward, discount, observation in the SavedModel.
WARNING:absl:WARNING: Could not serialize policy.distribution() for policy "<tf_agents.policies.actor_policy.ActorPolicy object at 0x7fa28994fe50>". Calling saved_model.distribution() will raise the following assertion error: Unable to make a CompositeTensor for "<tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag object at 0x7fa2898ab350>" of type `<class 'tensorflow.python.ops.linalg.linear_operator_diag.LinearOperatorDiag'>`. Email `tfprobability@tensorflow.org` or file an issue on github if you would benefit from this working. (Unable to serialize: No encoder for object [Tensor("ActorDistributionNetwork/TanhNormalProjectionNetwork/Exp:0", shape=(None, 8), dtype=float32)] of type [<class 'tensorflow.python.framework.ops.Tensor'>].)
WARNING:absl:Found untraced functions such as ActorDistributionNetwork_layer_call_fn, ActorDistributionNetwork_layer_call_and_return_conditional_losses, EncodingNetwork_layer_call_fn, EncodingNetwork_layer_call_and_return_conditional_losses, TanhNormalProjectionNetwork_layer_call_fn while saving (showing 5 of 35). These functions will not be directly callable after loading.
WARNING:tensorflow:FOR KERAS USERS: The object that you are saving contains one or more Keras models or layers. If you are loading the SavedModel with `tf.keras.models.load_model`, continue reading (otherwise, you may ignore the following instructions). Please change your code to save with `tf.keras.models.save_model` or `model.save`, and confirm that the file "keras.metadata" exists in the export directory. In the future, Keras will only load the SavedModels that have this file. In other words, `tf.saved_model.save` will no longer write SavedModels that can be recovered as Keras models (this will apply in TF 2.5).

FOR DEVS: If you are overwriting _tracking_metadata in your class, this property has been used to save metadata in the SavedModel. The metadta field will be deprecated soon, so please move the metadata to a different file.
WARNING:tensorflow:FOR KERAS USERS: The object that you are saving contains one or more Keras models or layers. If you are loading the SavedModel with `tf.keras.models.load_model`, continue reading (otherwise, you may ignore the following instructions). Please change your code to save with `tf.keras.models.save_model` or `model.save`, and confirm that the file "keras.metadata" exists in the export directory. In the future, Keras will only load the SavedModels that have this file. In other words, `tf.saved_model.save` will no longer write SavedModels that can be recovered as Keras models (this will apply in TF 2.5).

FOR DEVS: If you are overwriting _tracking_metadata in your class, this property has been used to save metadata in the SavedModel. The metadta field will be deprecated soon, so please move the metadata to a different file.
INFO:tensorflow:Assets written to: /tmp/policies/collect_policy/assets
INFO:tensorflow:Assets written to: /tmp/policies/collect_policy/assets
WARNING:absl:Function `function_with_signature` contains input name(s) 0/step_type, 0/reward, 0/discount, 0/observation with unsupported characters which will be renamed to step_type, reward, discount, observation in the SavedModel.
WARNING:absl:Found untraced functions such as ActorDistributionNetwork_layer_call_fn, ActorDistributionNetwork_layer_call_and_return_conditional_losses, EncodingNetwork_layer_call_fn, EncodingNetwork_layer_call_and_return_conditional_losses, TanhNormalProjectionNetwork_layer_call_fn while saving (showing 5 of 35). These functions will not be directly callable after loading.
WARNING:tensorflow:FOR KERAS USERS: The object that you are saving contains one or more Keras models or layers. If you are loading the SavedModel with `tf.keras.models.load_model`, continue reading (otherwise, you may ignore the following instructions). Please change your code to save with `tf.keras.models.save_model` or `model.save`, and confirm that the file "keras.metadata" exists in the export directory. In the future, Keras will only load the SavedModels that have this file. In other words, `tf.saved_model.save` will no longer write SavedModels that can be recovered as Keras models (this will apply in TF 2.5).

FOR DEVS: If you are overwriting _tracking_metadata in your class, this property has been used to save metadata in the SavedModel. The metadta field will be deprecated soon, so please move the metadata to a different file.
WARNING:tensorflow:FOR KERAS USERS: The object that you are saving contains one or more Keras models or layers. If you are loading the SavedModel with `tf.keras.models.load_model`, continue reading (otherwise, you may ignore the following instructions). Please change your code to save with `tf.keras.models.save_model` or `model.save`, and confirm that the file "keras.metadata" exists in the export directory. In the future, Keras will only load the SavedModels that have this file. In other words, `tf.saved_model.save` will no longer write SavedModels that can be recovered as Keras models (this will apply in TF 2.5).

FOR DEVS: If you are overwriting _tracking_metadata in your class, this property has been used to save metadata in the SavedModel. The metadta field will be deprecated soon, so please move the metadata to a different file.
INFO:tensorflow:Assets written to: /tmp/policies/greedy_policy/assets
INFO:tensorflow:Assets written to: /tmp/policies/greedy_policy/assets
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tf_agents/train/learner.py:146: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version.
Instructions for updating:
rename to distribute_datasets_from_function
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tf_agents/train/learner.py:146: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version.
Instructions for updating:
rename to distribute_datasets_from_function

Métricas e Avaliação

actor.eval_metrics o eval Actor com actor.eval_metrics acima, que cria as métricas mais comumente usadas durante a avaliação da política:

  • Retorno médio. O retorno é a soma das recompensas obtidas durante a execução de uma política em um ambiente para um episódio, e normalmente fazemos a média disso em alguns episódios.
  • Duração média do episódio.

Executamos o Ator para gerar essas métricas.

def get_eval_metrics():
  eval_actor.run()
  results = {}
  for metric in eval_actor.metrics:
    results[metric.name] = metric.result()
  return results

metrics = get_eval_metrics()
def log_eval_metrics(step, metrics):
  eval_results = (', ').join(
      '{} = {:.6f}'.format(name, result) for name, result in metrics.items())
  print('step = {0}: {1}'.format(step, eval_results))

log_eval_metrics(0, metrics)
step = 0: AverageReturn = -0.256803, AverageEpisodeLength = 55.599998

Confira o módulo de métricas para outras implementações padrão de métricas diferentes.

Treinando o agente

O loop de treinamento envolve a coleta de dados do ambiente e a otimização das redes do agente. Ao longo do caminho, iremos ocasionalmente avaliar a política do agente para ver como estamos nos saindo.

try:
  %%time
except:
  pass

# Reset the train step
tf_agent.train_step_counter.assign(0)

# Evaluate the agent's policy once before training.
avg_return = get_eval_metrics()["AverageReturn"]
returns = [avg_return]

for _ in range(num_iterations):
  # Training.
  collect_actor.run()
  loss_info = agent_learner.run(iterations=1)

  # Evaluating.
  step = agent_learner.train_step_numpy

  if eval_interval and step % eval_interval == 0:
    metrics = get_eval_metrics()
    log_eval_metrics(step, metrics)
    returns.append(metrics["AverageReturn"])

  if log_interval and step % log_interval == 0:
    print('step = {0}: loss = {1}'.format(step, loss_info.loss.numpy()))

rb_observer.close()
reverb_server.stop()
step = 5000: loss = -48.70292282104492
step = 10000: AverageReturn = -0.241995, AverageEpisodeLength = 122.949997
step = 10000: loss = -59.98332214355469
step = 15000: loss = -35.55713653564453
step = 20000: AverageReturn = -0.607229, AverageEpisodeLength = 221.500000
step = 20000: loss = -22.29997444152832
step = 25000: loss = -12.32511043548584
step = 30000: AverageReturn = -1.270276, AverageEpisodeLength = 410.549988
step = 30000: loss = -6.429823398590088
step = 35000: loss = -1.2349894046783447
step = 40000: AverageReturn = -0.467371, AverageEpisodeLength = 492.149994
step = 40000: loss = -4.74995231628418
step = 45000: loss = -2.0106310844421387
step = 50000: AverageReturn = -0.827860, AverageEpisodeLength = 548.849976
step = 50000: loss = -2.952303886413574
step = 55000: loss = 0.84348464012146
step = 60000: AverageReturn = -0.172424, AverageEpisodeLength = 572.549988
step = 60000: loss = -3.286008596420288
step = 65000: loss = -0.6228725910186768
step = 70000: AverageReturn = -0.090871, AverageEpisodeLength = 450.049988
step = 70000: loss = -0.7660086154937744
step = 75000: loss = 0.5882142782211304
step = 80000: AverageReturn = 0.392658, AverageEpisodeLength = 457.850006
step = 80000: loss = 0.8202561736106873
step = 85000: loss = 0.8028820157051086
step = 90000: AverageReturn = 0.564336, AverageEpisodeLength = 317.450012
step = 90000: loss = 0.3934253454208374
step = 95000: loss = 2.7876131534576416
step = 100000: AverageReturn = 1.998965, AverageEpisodeLength = 646.400024
step = 100000: loss = 4.307077884674072

Visualização

Enredos

Podemos traçar o retorno médio vs etapas globais para ver o desempenho de nosso agente. No Minitaur , a função de recompensa é baseada na distância que o minitaur percorre em 1000 passos e penaliza o gasto de energia.

steps = range(0, num_iterations + 1, eval_interval)
plt.plot(steps, returns)
plt.ylabel('Average Return')
plt.xlabel('Step')
plt.ylim()
(-1.43373801112175, 2.162427324056625)

png

Vídeos

É útil visualizar o desempenho de um agente, renderizando o ambiente em cada etapa. Antes de fazermos isso, vamos primeiro criar uma função para incorporar vídeos neste colab.

def embed_mp4(filename):
  """Embeds an mp4 file in the notebook."""
  video = open(filename,'rb').read()
  b64 = base64.b64encode(video)
  tag = '''
  <video width="640" height="480" controls>
    <source src="data:video/mp4;base64,{0}" type="video/mp4">
  Your browser does not support the video tag.
  </video>'''.format(b64.decode())

  return IPython.display.HTML(tag)

O código a seguir visualiza a política do agente para alguns episódios:

num_episodes = 3
video_filename = 'sac_minitaur.mp4'
with imageio.get_writer(video_filename, fps=60) as video:
  for _ in range(num_episodes):
    time_step = eval_env.reset()
    video.append_data(eval_env.render())
    while not time_step.is_last():
      action_step = eval_actor.policy.action(time_step)
      time_step = eval_env.step(action_step.action)
      video.append_data(eval_env.render())

embed_mp4(video_filename)