Um dos esquemas clássicos de redes neurais para implementar o algoritmo RL é o seguinte:
Onde: insumos - insumos para a rede neural; FC - arquitetura de camada oculta (totalmente conectada) ou CNN - FC - arquitetura de camada oculta (dependendo do que é fornecido às entradas); saídas - saídas de rede. Frequentemente, as saídas de rede são uma camada softmax que fornece a probabilidade de uma das ações do conjunto de todas as ações possíveis.
A desvantagem dessa arquitetura é que é difícil implementar a escolha de várias ações executadas simultaneamente.
Para resolver esse problema, é proposta uma arquitetura com uma camada de máscara. A arquitetura proposta é a seguinte:
Essa arquitetura é totalmente consistente com a arquitetura clássica, mas também inclui uma camada de máscara de ação. Existe apenas uma maneira de sair dessa arquitetura - este é o valor do valor da ação (um grupo de ações executadas simultaneamente). A camada de máscara de ação pode ser implementada de acordo com o pseudo-código abaixo:
import numpy as np class Layer: def __init__(self, items, item_size, extra_size): assert(items > 0) assert(item_size > 0) assert(extra_size >= 0) self.items = items self.item_size = item_size self.extra_size = extra_size def build(self): self._expand_op = np.zeros((self.items, self.items*self.item_size), \ dtype=np.float32) for i in range(self.items): self._expand_op[i,i*self.item_size:(i+1)*self.item_size] = np.float32(1.0) def call(self, inputs, ops): op_mask_part = inputs[:self.items*self.item_size] if self.extra_size > 0: ext_part = inputs[self.items*self.item_size:] else: ext_part = None
E usar esse código demonstra o seguinte snippet de código:
items = 5 item_size = 10 extra_size = 20 l = Layer(items=items, item_size=item_size, extra_size=extra_size) l.build() inputs = np.random.rand(items*item_size+extra_size) ops = np.random.randint(0, 2, (items,), dtype="int") ops = ops.astype(dtype=np.float32) - np.float32(0.5) result = l.call(inputs,ops)
Pode ser visto no código da camada que, para cada ação, a rede neural aprende a formar alguma representação da ação na forma de uma série de pesos. E essas representações ou vão para a rede após a camada de máscara ou não. Dependendo da operação, esses pesos podem ocorrer com a tarefa de alguma operação em todo o grupo de pesos de ação (não apenas multiplicação por [0,1]). Assim, a tarefa das ações é formada para calcular o valor do grupo de ações realizadas pela rede. (No caso clássico, a camada softmax calculou o valor de todas as ações; na arquitetura proposta, a rede neural calcula o valor do grupo de ações selecionadas.)
(Para uma definição do valor de uma ação, consulte, por exemplo, R.S. Sutton, E.G. Barto Reinforced Learning.)
Exemplos de uso da arquitetura proposta
Jogo de Tetris
A idéia de usar essa arquitetura para tocar tetris é a seguinte. Nas entradas, enviamos a imagem do copo do jogo tetris (um pixel e um quadrado). Agrupamos ações individuais em grupos de ação. A avaliação de uma ação para uma rede neural é uma máscara da posição final de uma figura em um copo. A figura é definida por seus quadrados na máscara de ação na camada da máscara de ação na rede neural. Para selecionar um grupo de ações, selecionamos a avaliação máxima da ação (saída) na lista de todas as posições finais da figura atual.
Desenho. O campo (células azuis) e a forma de queda (células cinza claro) são mostrados. A posição final da figura é todas as posições possíveis das quais a figura não pode se mover de acordo com as regras do jogo (não mostradas).
Agente simulando o movimento de um carro
Nesse caso, cada ação de aceleração (várias acelerações de aceleração), frenagem (várias possíveis acelerações durante a frenagem) e vários graus de rotação foram modelados como ações elementares. Entende-se que ao mesmo tempo uma rotação e uma das acelerações podem estar envolvidas, ou apenas uma ação de rotação ou uma ação de aceleração. Nesse caso, a arquitetura permite especificar várias ações elementares ao mesmo tempo para formar uma ação complexa.
Desenho. Além do campo para a realização de ações pelo modelo de carro (no qual a meta de estacionamento é indicada por linhas vermelha e verde), também são exibidas as entradas da rede neural (abaixo) e os valores da avaliação de ações para todas as ações possíveis nesse estado do modelo.
Outras aplicações possíveis da arquitetura
Da mesma forma, com o uso de tetris em um jogo, a arquitetura pode ser usada para outros jogos, onde uma série de figuras e várias ações podem ser especificadas no campo ao mesmo tempo (por exemplo, movendo-se no campo de jogo).
Na robótica, essa arquitetura pode servir como uma meta-rede que coordena elementos estruturais individuais em um conjunto comum.
Além disso, essa arquitetura permite que você use o aprendizado de transferência para pré-treinar a parte CNN e vice-versa no início para treinar a parte RL da rede neural e, em seguida, treine a parte CNN na rede RL já treinada nos dados do modelo. No exemplo, ao programar o jogo Tetris, o aprendizado de transferência foi aplicado com treinamento no início da parte CNN e da parte FC na camada de máscara de ação (o que é transferido para a rede resultante). No problema do estacionamento, também pretendo aplicar o treinamento da CNN depois de aprender a parte da RL (ou seja, a primeira cereja).
→ Exemplos de código-fonte do programa podem ser encontrados
aqui