Main Content

append

Append experiences to replay memory buffer

    Description

    example

    append(buffer,experience) appends the experiences in experience to the replay memory buffer.

    append(buffer,experience,dataSourceID) appends experiences for the specified data source to the replay memory buffer.

    Examples

    collapse all

    Define observation specifications for the environment. For this example, assume that the environment has a single observation channel with three continuous signals in specified ranges.

    obsInfo = rlNumericSpec([3 1],...
        LowerLimit=0,...
        UpperLimit=[1;5;10]);

    Define action specifications for the environment. For this example, assume that the environment has a single action channel with two continuous signals in specified ranges.

    actInfo = rlNumericSpec([2 1],...
        LowerLimit=0,...
        UpperLimit=[5;10]);

    Create an experience buffer with a maximum length of 20,000.

    buffer = rlReplayMemory(obsInfo,actInfo,20000);

    Append a single experience to the buffer using a structure. Each experience contains the following elements: current observation, action, next observation, reward, and is-done.

    For this example, create an experience with random observation, action, and reward values. Indicate that this experience is not a terminal condition by setting the IsDone value to 0.

    exp.Observation = {obsInfo.UpperLimit.*rand(3,1)};
    exp.Action = {actInfo.UpperLimit.*rand(2,1)};
    exp.NextObservation = {obsInfo.UpperLimit.*rand(3,1)};
    exp.Reward = 10*rand(1);
    exp.IsDone = 0;

    Append the experience to the buffer.

    append(buffer,exp);

    You can also append a batch of experiences to the experience buffer using a structure array. For this example, append a sequence of 100 random experiences, with the final experience representing a terminal condition.

    for i = 1:100
        expBatch(i).Observation = {obsInfo.UpperLimit.*rand(3,1)};
        expBatch(i).Action = {actInfo.UpperLimit.*rand(2,1)};
        expBatch(i).NextObservation = {obsInfo.UpperLimit.*rand(3,1)};
        expBatch(i).Reward = 10*rand(1);
        expBatch(i).IsDone = 0;
    end
    expBatch(100).IsDone = 1;
    
    append(buffer,expBatch);

    After appending experiences to the buffer, you can sample mini-batches of experiences for training of your RL agent. For example, randomly sample a batch of 50 experiences from the buffer.

    miniBatch = sample(buffer,50);

    You can sample a horizon of data from the buffer. For example, sample a horizon of 10 consecutive experiences with a discount factor of 0.95.

    horizonSample = sample(buffer,1,...
        NStepHorizon=10,...
        DiscountFactor=0.95);

    The returned sample includes the following information.

    • Observation and Action are the observation and action from the first experience in the horizon.

    • NextObservation and IsDone are the next observation and termination signal from the final experience in the horizon.

    • Reward is the cumulative reward across the horizon using the specified discount factor.

    You can also sample a sequence of consecutive experiences. In this case, the structure fields contain arrays with values for all sampled experiences.

    sequenceSample = sample(buffer,1,...
        SequenceLength=20);

    Define observation specifications for the environment. For this example, assume that the environment has two observation channels: one channel with two continuous observations and one channel with a three-valued discrete observation.

    obsContinuous = rlNumericSpec([2 1],...
        LowerLimit=0,...
        UpperLimit=[1;5]);
    obsDiscrete = rlFiniteSetSpec([1 2 3]);
    obsInfo = [obsContinuous obsDiscrete];

    Define action specifications for the environment. For this example, assume that the environment has a single action channel with one continuous action in a specified range.

    actInfo = rlNumericSpec([2 1],...
        LowerLimit=0,...
        UpperLimit=[5;10]);

    Create an experience buffer with a maximum length of 5,000.

    buffer = rlReplayMemory(obsInfo,actInfo,5000);

    Append a sequence of 50 random experiences to the buffer.

    for i = 1:50
        exp(i).Observation = ...
            {obsInfo(1).UpperLimit.*rand(2,1) randi(3)};
        exp(i).Action = {actInfo.UpperLimit.*rand(2,1)};
        exp(i).NextObservation = ...
            {obsInfo(1).UpperLimit.*rand(2,1) randi(3)};
        exp(i).Reward = 10*rand(1);
        exp(i).IsDone = 0;
    end
    
    append(buffer,exp);

    After appending experiences to the buffer, you can sample mini-batches of experiences for training of your RL agent. For example, randomly sample a batch of 10 experiences from the buffer.

    miniBatch = sample(buffer,10);

    Input Arguments

    collapse all

    Experience buffer, specified as an rlReplayMemory or rlPrioritizedReplayMemory object.

    Experience to append to the buffer, specified as a structure or structure array with the following fields.

    Observation, specified as a cell array with length equal to the number of observation specifications specified when creating the buffer. The dimensions of each element in Observation must match the dimensions in the corresponding observation specification.

    Action taken by the agent, specified as a cell array with length equal to the number of action specifications specified when creating the buffer. The dimensions of each element in Action must match the dimensions in the corresponding action specification.

    Reward value obtained by taking the specified action from the starting observation, specified as a scalar.

    Next observation reached by taking the specified action from the starting observation, specified as a cell array with the same format as Observation.

    Termination signal, specified as one of the following values.

    • 0 — This experience is not the end of an episode.

    • 1 — The episode terminated because the environment generated a termination signal.

    • 2 — The episode terminated by reaching the maximum episode length.

    Data source index, specified as a nonnegative integer or array of nonnegative integers.

    If experience is a scalar structure, specify dataSourceID as a scalar integer.

    If experience is a structure array, specify dataSourceID as an array with length equal to the length of experience. You can specify different data source indices for each element of experience. If all elements in experience come from the same data source, you can specify dataSourceID as a scalar integer.

    Version History

    Introduced in R2022a