Computando a atualização do gradiente de ator no algoritmo DDPG (Deep Deterministic Policy Gradient)

Esta pergunta é referente ao documento Deepmind sobre DDPG: https://arxiv.org/pdf/1509.02971v5.pdf .

A maioria (todas?) Das implementações do algoritmo DDPG que eu vi computam a atualização do gradiente na rede do ator por $\nabla(J)=\nabla_{\mu(s|\theta)}(Q(s,\mu(s|\theta))\nabla_{\theta}(\mu(s|\theta))$, Onde $\theta$ representa os parâmetros da rede de atores, $\mu$ representa a rede de atores, $Q$ representa a rede de críticos e $s$representa a entrada do estado. Vou chamar essa equação 1.

A equação 1, como é mostrado no artigo, deriva da aplicação da regra da cadeia a $\nabla(J)=\nabla_{\theta}(Q(s,\mu(s|\theta))$. Isto dá$\nabla_{\mu(s|\theta)}(Q(s,\mu(s|\theta))\nabla_{\theta}(\mu(s|\theta))$.

Minha pergunta é, usando um pacote de software de auto-gradação (Theano / Tensorflow / Torch / etc), existe alguma razão pela qual eu não poderia apenas calcular o gradiente da saída de $Q$ wrt $\theta$diretamente? Por alguma razão, todas as implementações parecem primeiro computar o gradiente da saída de$Q$ wrt $\mu(s)$ e depois multiplique pelo gradiente de $\mu(s)$ wrt to $\theta$, de acordo com a regra da cadeia. Eu não entendo por que eles fazem isso - por que não apenas calcular diretamente o gradiente de$Q$ wrt $\theta$em vez de? Existe uma razão para você não poder fazer isso? Ou seja, por que a maioria das atualizações parece fazer isso:

Q_grad = gradients( Q(s, mu(s|theta)), mu(s|theta) )
mu_grad = gradients( mu(s|theta), theta )
J_grad = Q_grad * mu_grad

Em vez disso:

J_grad = gradients( Q(s, mu(s|theta)), theta )

Onde a primeira entrada para "gradientes" é a função que você deseja diferenciar e a segunda entrada é para o que você está diferenciando.

Para ser claro, não vejo razão para $\nabla(J)=\nabla_{\theta}(Q)$ é uma atualização diferente da equação 1, visto que a equação 1 é literalmente derivada aplicando a regra da cadeia a $\nabla_{\theta}(Q)$, mas quero ter certeza de que não estou perdendo algum tipo de sutileza.

Não há diferença no cálculo. Fiquei me perguntando a mesma coisa e verifiquei na minha própria implementação do TensorFlow DDPG, tentando as duas e afirmando que os valores numéricos são idênticos. Como esperado, eles são.

Percebi que a maioria das implementações do tipo tutorial (por exemplo, de Patrick Emami ) mostra explicitamente a multiplicação. No entanto, a implementação das linhas de base do OpenAI $does$ calcular diretamente $\nabla_{\theta^\mu} Q$. (Eles fazem isso definindo uma perda na rede de atores igual a$-\nabla_{\theta^\mu} Q$, calculada a média do lote).

Há um motivo para você querer separar $\nabla_a Q$ de $\nabla_{\theta^\mu} \mu$e multiplique-os. Isto é, se você deseja manipular diretamente um dos termos. Por exemplo, Hausknecht e Stone fazem "inversão de gradientes" em$\nabla_a Q$ coagir ações para permanecer dentro do alcance do ambiente.

Dessa forma, você pode definir duas redes independentes. Caso contrário, talvez seja necessário definir uma rede grande e distinguir qual parte pertence à política e qual parte da função de valor da ação do estado.

Não tenho certeza de entender essa multiplicação entre os dois termos de gradiente.

Quando você calcula isso usando, diga tensorflow:

J_grad = gradients( Q(s, mu(s|theta)), theta )

Aplica a regra da cadeia e, portanto, calcula os dispositivos de gravação da Qsaída da rede de políticas mu(s|theta)e, em seguida, reprograma esses "erros" através da rede de políticas para obter os gradientes amostrados theta(os parâmetros de todas as camadas da sua rede de políticas).

No entanto, quando você faz:

Q_grad = gradients( Q(s, mu(s|theta)), mu(s|theta) )
mu_grad = gradients( mu(s|theta), theta )
J_grad = Q_grad * mu_grad

Então, no meu entendimento, (1) calcula o gradiente de Qsaída da rede de políticas mu(s|theta)e (2) o gradiente de saída da rede de mu(s|theta)políticas com os parâmetros de política theta, mas desta vez SEPARADAMENTE. O que não entendo é que agora, você tem, por um lado, seu primeiro gradiente, que é um vetor de tamanho, (1, action_dim)e, por outro, seu segundo gradiente, que é um vetor de tamanho (1, theta_dim). Para aplicar sua atualização, você precisa de um gradiente wrt para theta, que seria um vetor de tamanho (1, theta_dim). Então, o que exatamente esta multiplicação está fazendo na terceira linha e como é equivalente à retropropagação do primeiro gradiente por meio da rede de políticas:

J_grad = Q_grad * mu_grad

Questão:

Ele apenas executa um produto externo criando uma matriz de forma (action_dim, theta_dim)e depois reduzido somando a dimensão para obter nosso vetor de atualização de forma (1, theta)? Em caso afirmativo, por que isso é válido (equivalente a retropropagação do primeiro gradiente por meio da rede de políticas)?