Main Content

getModel

Get computational model from policy or value function representation

    Description

    example

    model = getModel(rep) returns the computational model used by the policy or value function representation rep.

    Examples

    collapse all

    Create an environment with a continuous action space and obtain its observation and action specifications. For this example, load the environment used in the example Train DDPG Agent to Control Double Integrator System.

    Load the predefined environment.

    env = rlPredefinedEnv("DoubleIntegrator-Continuous")
    env = 
      DoubleIntegratorContinuousAction with properties:
    
                 Gain: 1
                   Ts: 0.1000
          MaxDistance: 5
        GoalThreshold: 0.0100
                    Q: [2x2 double]
                    R: 0.0100
             MaxForce: Inf
                State: [2x1 double]
    
    

    Obtain observation and action specifications.

    obsInfo = getObservationInfo(env);
    actInfo = getActionInfo(env);

    Create a PPO agent from the environment observation and action specifications.

    agent = rlPPOAgent(obsInfo,actInfo);

    To modify the deep neural networks within a reinforcement learning agent, you must first extract the actor and critic representations.

    actor = getActor(agent);
    critic = getCritic(agent);

    Extract the deep neural networks from both the actor and critic representations.

    actorNet = getModel(actor);
    criticNet = getModel(critic);

    To view a network, use the plot function. For example, view the actor network.

    plot(actorNet)

    You can modify the actor and critic networks and save them back to the agent. To modify the networks, you can use the Deep Network Designer app. To open the app for each networks, use the following commands.

    deepNetworkDesigner(criticNet)
    deepNetworkDesigner(actorNet)
    

    In Deep Network Designer, modify the networks. For example, you can add additional layers to your network. When you modify the networks, do not change the input and output layers of the networks returned by getModel. For more information on building networks, see Build Networks with Deep Network Designer.

    To export the modified network structures to the MATLAB® workspace, generate code for creating the new networks and run this code from the command line. Do not use the exporting option in Deep Network Designer. For an example that shows how to generate and run code, see Create Agent Using Deep Network Designer and Train Using Image Observations.

    For this example, the code for creating the modified actor and critic networks is in createModifiedNetworks.m.

    createModifiedNetworks

    Each of the modified networks includes an additional fullyConnectedLayer and reluLayer in their output path. View the modified actor network.

    plot(modifiedActorNet)

    After exporting the networks, insert the networks into the actor and critic representations.

    actor = setModel(actor,modifiedActorNet);
    critic = setModel(critic,modifiedCriticNet);

    Finally, insert the modified actor and critic representations in the actor and critic objects.

    agent = setActor(agent,actor);
    agent = setCritic(agent,critic);

    Input Arguments

    collapse all

    Policy or value function representation, specified as one of the following:

    To create a policy or value function representation, use one of the following methods:

    • Create a representation using the corresponding representation object.

    • Obtain the existing value function representation from an agent using getCritic.

    • Obtain the existing policy representation from an agent using getActor.

    Note

    For agents with more than one critic, such as TD3 and SAC agents, you must call getModel for each critic representation individually, rather than calling getModel for the array of returned by getCritic.

    critics = getCritic(myTD3Agent);
    criticNet1 = getModel(critics(1));
    criticNet2 = getModel(critics(2));

    Output Arguments

    collapse all

    Computational model, returned as one of the following:

    • Deep neural network defined as a DAGNetwork object

    • rlTable object

    • 1-by-2 cell array that contains the function handle for a custom basis function and the basis function parameters

    Introduced in R2020b