Cree un agente para algoritmos de aprendizaje por refuerzo personalizados
Este ejemplo muestra cómo crear un agente personalizado para su propio algoritmo de aprendizaje por refuerzo personalizado. Hacerlo le permite aprovechar las siguientes funciones integradas del software Reinforcement Learning Toolbox ™.
-
Acceda a todas las funciones del agente, incluido el tren y la simulación
-
Utilice el administrador de episodios para visualizar el progreso del entrenamiento
-
Entrene al agente en el entorno Simulink®
En este ejemplo, convierte un bucle de entrenamiento REINFORCE personalizado en una clase de agente personalizada. Para obtener más información sobre el ciclo de entrenamiento personalizado REINFORCE, consulte la Política de aprendizaje de refuerzo de lluvia mediante el ciclo de entrenamiento personalizado . Para obtener más información sobre cómo escribir clases de agentes personalizados, consulte Agentes personalizados .
Reproducibilidad fija de semillas generadoras aleatorias.
rng(0)
Crea el medio ambiente
Cree y utilice el mismo entorno de formación que se utiliza en la " Política de aprendizaje de refuerzo del entrenamiento mediante el ejemplo de ciclo de formación personalizado ". Este entorno es un entorno de barra de equilibrio con un espacio de acción discreto. Utilice la función rlPredefinedEnv para crear un entorno.
env = rlPredefinedEnv('CartPole-Discrete');
Extraer observaciones y especificaciones de acción del entorno.
obsInfo = getObservationInfo(env);
actInfo = getActionInfo(env);
Obtenga el número de observaciones (numObs) y el número de acciones (numAct).
numObs = obsInfo.Dimension(1);
numAct = numel(actInfo.Elements);
Definir estrategia
En este ejemplo, la estrategia de aprendizaje por refuerzo es una estrategia estocástica de acción discreta. Está representado por una red neuronal profunda, que contiene capas totalmenteConnectedLayer, reluLayer y softmaxLayer. Dadas las observaciones actuales, la red genera la probabilidad de cada acción discreta. softmaxLayer puede garantizar que el rango de valores de probabilidad de la salida de representación sea [0 1] y que la suma de todas las probabilidades sea 1.
Crea redes neuronales profundas para los actores.
actorNetwork = [featureInputLayer(numObs,'Normalization','none','Name','state')
fullyConnectedLayer(24,'Name','fc1')
reluLayer('Name','relu1')
fullyConnectedLayer(24,'Name','fc2')
reluLayer('Name','relu2')
fullyConnectedLayer(2,'Name','output')
softmaxLayer('Name','actionProb')];
Utilice el objeto rlStochasticActorRepresentation para crear una representación de actor.
actorOpts = rlRepresentationOptions('LearnRate',1e-3,'GradientThreshold',1);
actor = rlStochasticActorRepresentation(actorNetwork,...
obsInfo,actInfo,'Observation','state',actorOpts);
Clase de agente personalizado
Para definir su agente personalizado, primero cree una clase, que es una subclase de la clase rl.agent.CustomAgent. La clase de agente personalizado para este ejemplo se define en CustomReinforceAgent.m.
La clase CustomReinforceAgent tiene la siguiente definición de clase, que indica el nombre de la clase de agente y el agente abstracto asociado.
classdef CustomReinforceAgent <rl.agent.CustomAgent
Para definir su agente, debe especificar lo siguiente:
-
Atributos del agente
-
Constructor
-
Representación del comentarista para evaluar los descuentos de recompensa a largo plazo (si es necesario para el aprendizaje)
-
Representación de actores que eligen acciones basadas en observaciones actuales (si es necesario para el aprendizaje)
-
El método de agente requerido
-
Método de agente opcional
Atributos del agente
En la sección de propiedades del archivo de clase, especifique los parámetros necesarios para crear y entrenar al agente.
La clase rl.Agent.CustomAgent ya contiene los atributos de tiempo de muestreo del agente (SampleTime) y especificaciones de operación y observación (ActionInfo y ObservationInfo, respectivamente).
El agente REINFORCE personalizado define los siguientes atributos del agente.
properties
% Actor representation
Actor
% Agent options
Options
% Experience buffer
ObservationBuffer
ActionBuffer
RewardBuffer
end
properties (Access = private)
% Training utilities
Counter
NumObservation
NumAction
end
Constructor
Para crear un agente personalizado, debe definir un constructor. El constructor realiza las siguientes operaciones.
-
Definir acciones y observar normas. Para obtener más información sobre cómo crear estas especificaciones, consulte rlNumericSpec y rlFiniteSetSpec .
-
Establecer las propiedades del agente.
-
Llame al constructor de la clase abstracta básica.
-
Defina el tiempo de muestreo (necesario para la formación en el entorno de Simulink).
Por ejemplo, el constructor CustomREINFORCEAgent define el espacio de acción y observación en función de la representación del actor de entrada.
function obj = CustomReinforceAgent(Actor,Options)
%CUSTOMREINFORCEAGENT Construct custom agent
% AGENT = CUSTOMREINFORCEAGENT(ACTOR,OPTIONS) creates custom
% REINFORCE AGENT from rlStochasticActorRepresentation ACTOR
% and structure OPTIONS. OPTIONS has fields:
% - DiscountFactor
% - MaxStepsPerEpisode
% (required) Call the abstract class constructor.
obj = obj@rl.agent.CustomAgent();
obj.ObservationInfo = Actor.ObservationInfo;
obj.ActionInfo = Actor.ActionInfo;
% (required for Simulink environment) Register sample time.
% For MATLAB environment, use -1.
obj.SampleTime = -1;
% (optional) Register actor and agent options.
Actor = setLoss(Actor,@lossFunction);
obj.Actor = Actor;
obj.Options = Options;
% (optional) Cache the number of observations and actions.
obj.NumObservation = prod(obj.ObservationInfo.Dimension);
obj.NumAction = prod(obj.ActionInfo.Dimension);
% (optional) Initialize buffer and counter.
reset(obj);
end
El constructor usa el identificador de función para establecer la función de pérdida representada por el actor en lossFunction, que se implementa como una función local en CustomREINFORCEAgent.m.
function loss = lossFunction(policy,lossData)
% Create the action indication matrix.
batchSize = lossData.batchSize;
Z = repmat(lossData.actInfo.Elements',1,batchSize);
actionIndicationMatrix = lossData.actionBatch(:,:) == Z;
% Resize the discounted return to the size of policy.
G = actionIndicationMatrix .* lossData.discountedReturn;
G = reshape(G,size(policy));
% Round any policy values less than eps to eps.
policy(policy < eps) = eps;
% Compute the loss.
loss = -sum(G .* log(policy),'all');
end
funciones relacionadas
Para crear un agente de aprendizaje por refuerzo personalizado, debe definir las siguientes funciones de implementación.
-
getActionImpl: evalúa la estrategia del agente y selecciona un agente durante la simulación.
-
getActionWithExplorationImpl: evalúe la estrategia y seleccione acciones exploratorias durante la capacitación.
-
learningImpl: cómo aprende el agente de la experiencia actual
Para llamar a estas funciones en su propio código, use el método contenedor en la clase base abstracta. Por ejemplo, para llamar a getActionImpl, use getAction. El método contenedor tiene los mismos parámetros de entrada y salida que el método de implementación.
Función getActionImpl
La función getActionImpl se usa para evaluar la estrategia del agente y seleccionar una operación cuando la función sim se usa para simular al agente. Esta función debe tener la siguiente firma, donde obj es el objeto del agente, observación es el valor de observación actual y Acción es la acción seleccionada.
function Action = getActionImpl(obj,Observation)
Para un agente REINFORCE personalizado, puede seleccionar una acción llamando a la función getAction de la representación del actor . La rlStochasticActorRepresentation discreta genera una distribución discreta basada en observaciones y muestra una acción de la distribución.
function Action = getActionImpl(obj,Observation)
% Compute an action using the policy given the current
% observation.
Action = getAction(obj.Actor,Observation);
end
Función getActionWithExplorationImpl
Cuando se usa la función de entrenamiento para entrenar al agente, la función getActionWithExplorationImpl usa el modelo de exploración del agente para seleccionar acciones. Con esta función, puede implementar técnicas de exploración como la exploración ávida de épsilon o la adición de ruido gaussiano. Esta función debe tener la siguiente firma, donde obj es el objeto del agente, observación es el valor de observación actual y Acción es la acción seleccionada.
function Action = getActionWithExplorationImpl(obj,Observation)
Para los agentes REINFORCE personalizados, la función getActionWithExplorationImpl es la misma que getActionImpl. De forma predeterminada, los actores aleatorios siempre exploran, es decir, siempre eligen una acción en función de una distribución de probabilidad.
function Action = getActionWithExplorationImpl(obj,Observation)
% Compute an action using the exploration policy given the
% current observation.
% REINFORCE: Stochastic actors always explore by default
% (sample from a probability distribution)
Action = getAction(obj.Actor,Observation);
end
función learnImpl
La función learningImpl define cómo aprende el agente de la experiencia actual. Esta función implementa el algoritmo de aprendizaje personalizado del agente actualizando los parámetros de la estrategia y eligiendo la acción para explorar el siguiente estado. La función debe tener la siguiente firma, donde obj es el objeto del agente, Experiencia es la experiencia del agente actual y Acción es la operación seleccionada.
function Action = learnImpl(obj,Experience)
La experiencia del agente es la matriz de celdas Experiencia = {estado, acción, recompensa, próximo estado, está terminado}. Aquí:
-
El estado es la observación actual.
-
La acción es la acción actual. Esto es diferente del parámetro de salida Acción, que es la siguiente acción de estado.
-
La recompensa es la recompensa actual.
-
nextState es el siguiente valor de observación.
-
isDone es una bandera lógica que indica que se ha completado el episodio de entrenamiento.
Para el agente REINFORCE personalizado, repita los pasos 2 a 7 del ciclo de capacitación personalizado en " Fortalecimiento de la estrategia de capacitación mediante el ciclo de capacitación personalizado ". Omitirá los pasos 1, 8 y 9, porque utilizará la función de capacitación incorporada para capacitar a su agente.
function Action = learnImpl(obj,Experience)
% Define how the agent learns from an Experience, which is a
% cell array with the following format.
% Experience = {
observation,action,reward,nextObservation,isDone}
% Reset buffer at the beginning of the episode.
if obj.Counter < 2
resetBuffer(obj);
end
% Extract data from experience.
Obs = Experience{
1};
Action = Experience{
2};
Reward = Experience{
3};
NextObs = Experience{
4};
IsDone = Experience{
5};
% Save data to buffer.
obj.ObservationBuffer(:,:,obj.Counter) = Obs{
1};
obj.ActionBuffer(:,:,obj.Counter) = Action{
1};
obj.RewardBuffer(:,obj.Counter) = Reward;
if ~IsDone
% Choose an action for the next state.
Action = getActionWithExplorationImpl(obj, NextObs);
obj.Counter = obj.Counter + 1;
else
% Learn from episodic data.
% Collect data from the buffer.
BatchSize = min(obj.Counter,obj.Options.MaxStepsPerEpisode);
ObservationBatch = obj.ObservationBuffer(:,:,1:BatchSize);
ActionBatch = obj.ActionBuffer(:,:,1:BatchSize);
RewardBatch = obj.RewardBuffer(:,1:BatchSize);
% Compute the discounted future reward.
DiscountedReturn = zeros(1,BatchSize);
for t = 1:BatchSize
G = 0;
for k = t:BatchSize
G = G + obj.Options.DiscountFactor ^ (k-t) * RewardBatch(k);
end
DiscountedReturn(t) = G;
end
% Organize data to pass to the loss function.
LossData.batchSize = BatchSize;
LossData.actInfo = obj.ActionInfo;
LossData.actionBatch = ActionBatch;
LossData.discountedReturn = DiscountedReturn;
% Compute the gradient of the loss with respect to the
% actor parameters.
ActorGradient = gradient(obj.Actor,'loss-parameters',...
{
ObservationBatch},LossData);
% Update the actor parameters using the computed gradients.
obj.Actor = optimize(obj.Actor,ActorGradient);
% Reset the counter.
obj.Counter = 1;
end
end
Función opcional
(Opcional) Puede definir cómo restablecer el agente al comienzo del entrenamiento especificando la función resetImpl con la siguiente firma de función, donde obj es el objeto del agente.
function resetImpl(obj)
Con esta función, puede configurar el agente en condiciones conocidas o aleatorias antes del entrenamiento.
function resetImpl(obj)
% (Optional) Define how the agent is reset before training/
resetBuffer(obj);
obj.Counter = 1;
end
Además, puede definir cualquier otra función auxiliar en la clase de agente personalizado según sea necesario. Por ejemplo, el agente REINFORCE personalizado define la función resetBuffer para reinicializar el búfer de experiencia al comienzo de cada episodio de entrenamiento.
function resetBuffer(obj)
% Reinitialize all experience buffers.
obj.ObservationBuffer = zeros(obj.NumObservation,1,obj.Options.MaxStepsPerEpisode);
obj.ActionBuffer = zeros(obj.NumAction,1,obj.Options.MaxStepsPerEpisode);
obj.RewardBuffer = zeros(1,obj.Options.MaxStepsPerEpisode);
end
Crea un agente personalizado
Después de definir la clase de agente personalizado, cree una instancia de ella en el espacio de trabajo de MATLAB. Para crear un agente REFUERZO personalizado, primero especifique las opciones del agente.
options.MaxStepsPerEpisode = 250;
options.DiscountFactor = 0.995;
Luego, usando las opciones y la representación del actor previamente definida, llame al constructor del agente personalizado.
agent = CustomReinforceAgent(actor,options);
Capacitar a un agente personalizado
Configure el entrenamiento para usar las siguientes opciones.
-
Configure el entrenamiento para que dure hasta 5000 episodios, y cada episodio dura hasta 250 pasos.
-
El entrenamiento finaliza cuando se alcanza el número máximo de episodios o la recompensa promedio en 100 episodios alcanza un valor de 240.
numEpisodes = 5000;
aveWindowSize = 100;
trainingTerminationValue = 240;
trainOpts = rlTrainingOptions(...
'MaxEpisodes',numEpisodes,...
'MaxStepsPerEpisode',options.MaxStepsPerEpisode,...
'ScoreAveragingWindowLength',aveWindowSize,...
'StopTrainingValue',trainingTerminationValue);
Utilice la función de entrenamiento para entrenar al agente. La formación de este agente es un proceso computacionalmente intensivo que tarda varios minutos en completarse. Para ahorrar tiempo al ejecutar este ejemplo, cargue el agente previamente entrenado configurando doTraining en falso. Para capacitar al agente usted mismo, configure doTraining en verdadero .
doTraining = false;
if doTraining
% Train the agent.
trainStats = train(agent,env,trainOpts);
else
% Load pretrained agent for the example.
load('CustomReinforce.mat','agent');
end
Simulación de agente personalizado
Habilite la visualización del entorno, que se actualiza cada vez que se llama a la función de paso del entorno.
plot(env)
Para verificar el desempeño del agente capacitado, simule en un entorno de péndulo invertido. Para obtener más información sobre la simulación de agentes, consulte rlSimulationOptions y sim.
simOpts = rlSimulationOptions('MaxSteps',options.MaxStepsPerEpisode);
experience = sim(env,agent,simOpts);
