{'fraction_non_alphanumeric': 0.031532655480007485, 'fraction_numerical': 0.011852036678934565, 'mean_word_length': 4.7316767965677515, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Reusability and Transferability of Macro Actions for Reinforcement Learning

Conventional reinforcement learning (RL) typically determines an appropriate primitive action at each timestep. However, by using a proper macro action, defined as a sequence of primitive actions, an agent is able to bypass intermediate states to a farther state and facilitate its learning procedure. The problem we would like to investigate is what associated beneficial properties that macro actions may possess. In this paper, we unveil the properties of reusability and transferability of macro actions. The first property, reusability, means that a macro action generated along with one RL method can be reused by another RL method for training, while the second one, transferability, means that a macro action can be utilized for training agents in similar environments with different reward settings. In our experiments, we first generate macro actions along with RL methods. We then provide a set of analyses to reveal the properties of reusability and transferability of the generated macro actions.


INTRODUCTION
Reinforcement learning (RL) [Sutton et al. 1998] has been shown to demonstrate super-human performance on a variety of environments and tasks [Mnih et al. 2016[Mnih et al. , 2013[Mnih et al. , 2015Moriarty et al. 1999;Salimans et al. 2017;Schulman et al. 2017;]. In conventional methods, agents are restricted to make decisions at each timestep. However, the policies of RL agents intrinsically favor short-term goals due to reward discounting. Such situation is further exacerbated by the greedy nature of the agents which simply follow the policy and/or value functions. Therefore, researchers in the past years have proposed a few techniques to generate macro actions [Durugkar et al. 2016;Heecheol et al. 2019;Xu et al. 2019]. A macro action (or simply "a macro") is defined as an open-loop [DiStefano et al. 2012] policy composed of a finite sequence of primitive actions. Once a macro is chosen, the actions will be taken by the agent without any further decision making process. Unfortunately, little attention has been paid to investigate the essential effects and the associated properties important for good macros in RL.
Macro actions work because of the embedding effect and the evaluation effect discussed in [Botea et al. 2005]. The former enables bypassing a series of successor states from a start state that would normally be achieved in several steps, and thus allows the search space to be changed as well as the search depth to be reduced. Since these bypassed states do not have to be evaluated, the search costs can also be reduced considerably. The latter improves the search guidance by protecting the intermediate states from the greediness of the RL agents while executing them. Such a temporal abstraction can hardly be discovered using a single reward, or achieved by a single action, e.g., risking into a dangerous zone to retrieve a valuable item. As macro actions that potentially possess these benefits are allowed to have different lengths and arbitrary compositions of primitive actions, such diversified macro actions essentially form an enormous space. We hereby define this space as the macro action space (or simply "macro space"). For a specific task in an environment, there exists good macros and bad macros in the macro space. Different macro actions have different impacts on an agent. A bad macro may lead the agent to undesirable states. On the other hand, a good macro enables an RL agent to bypass multiple intermediate states and reach a target state quicker and more easily. Such macro actions may require the agent to temporarily execute an action that may hurt the performance in the short term, while allowing it to achieve a long-term gain.
In addition, we further assume that good macros also exhibit invariance among different RL methods and similar environments. A good macro should be able to be utilized by agents trained using different RL methods. Furthermore, it should also be beneficial in similar environments with different reward settings. The first contribution of this research is a workflow that generates macros by a macro generation method. We then show that two contemporary RL methods are benefited from the derived macros due to the above two effects. The next contribution is that we evaluate the reusability property of the derived macros between different RL methods. This property allows the derived macros to be reused by different RL methods and benefit them. The third contribution is to reveal that the derived macro action possesses the property of transferability. This property allows the derived macro actions to be utilized in similar task environments with different reward settings. To the best of our knowledge, these two properties and the two effects of macros have not been properly discussed in the RL domain.
The paper is organized as follows. Section 2 briefly reviews the previous works. Sections 3 and 4 describes the preliminaries. Section 5 explains our workflow. Section 6 details our experimental setups. Section 7 examines the embedding and the evaluation effects. Section 8 discusses the reusability and transferability properties. Section 9 concludes this paper.

PREVIOUS WORKS
The concept of macro actions has been adopted in the domain of planning [Asai and Fukunaga 2015;Botea et al. 2005;Chrpa and Vallati 2019;Coles and Smith 2007;DeJong and Mooney 1986;Kaelbling 1993;Khetarpal et al. 2020;Korf 1985;Newton et al. 2007;Sacerdoti 1974], and has been shown to be able to provide advantages such as the embedding effect and evaluation effect [Botea et al. 2005]. The former enables bypassing a series of successor states from a start state, and thus allows the search space to be changed as well as the search depth to be reduced. The latter allows the evaluation of a state to be different from the methods only based on primitive actions. The two effects have been validated in the field of planning, however, have not yet been properly investigated in the domain of RL. There have been few pioneering studies dedicated to developing macro actions for RL. Previous researchers either produce macros in handcrafted manners [Xu et al. 2019], or derive them from expert demonstrations [Heecheol et al. 2019]. The authors in [Xu et al. 2019] showed that handcrafted macros can speed up their training processes in certain tasks. On the other hand, the authors in [Heecheol et al. 2019] generated their macros from expert demonstrations via a variational auto-encoder. Although these approaches have shown that macro actions are suitable for specific algorithms or applicable to grid-worlds, however, further properties such as reusability and transferability of macro actions have not been investigated and discussed.

PRELIMINARIES
In this section, we first provide the definition of macro actions. Then, we provide a model of the environment permitting macro actions, which is a special case of Semi-Markov Decision Processes (SMDP) [Sutton et al. 1999]. Next, we reformulate the essential equations in RL with macro actions, and provide the derivation procedure of them.
Macro action. A macro is defined as a finite sequence of primitive actions = ( 1 , . . . , ), for all in an action space A, and some natural number . The set of macros form a macro space = A + , where '+' stands for Kleene plus. Environment modeled. The environment we concern can be modeled as a special case of SMDP, which can be represented as a 4-tuple (S, M, ′ , ), where S is a set of states, M the finite set containing a single macro and all primitive actions contained in A provided by the environment E, ′ the transition probability from to ′ when executing , and the reward received by the agent after executing . The expressions of M, ′ , and are formulated as: Reinforcement learning. An RL agent interacts with E under a policy using provided M, where is a mapping, : S × M → [0, 1]. The expected cumulative rewards it receives from each state under can be denoted as ( ). The objective of RL is to train an agent to learn an optimal policy such that it is able to maximize its expected return. The maximal expected return from each state under the optimal policy can be denoted as * M ( ). The expressions of and * M can be represented as Eqs. (4) and (5), respectively, where the discount factor ∈ [0, 1]. As a macro action is selected atomically as one of the actions by the agent, we modify the conventional formulation such that discounting is applied between macros rather than between the primitive actions within a macro. This encourages the agent to prefer to executing the provided macro action rather than consecutively performing a series of primitive actions when rewards are positive, while discouraging it when rewards are negative.
The expected cumulative rewards that an RL agent receives from each under after taking can be denoted as ( , ). Furthermore, the maximal expected return from each state-macro pair ( , ) under the optimal policy can be denoted as * M ( , ). The expressions of and * M can be represented as Eqs. (6) and (7), respectively.

BACKGROUND MATERIALS OF DEEP REINFORCEMENT LEARNING
In this section, we introduce the background materials of Deep RL (DRL) methods adopted in this work. The goal of a DRL agent is to maximize its accumulated long-term rewards over discrete timesteps. Unlike an RL agent, the policy ( | ) of a DRL agent is a conditional probability distribution parameterized by a deep neural network (DNN) with parameters . Since training agents using off-policy based methods (e.g., Deep Q-Network (DQN) [Mnih et al. 2015]) is much slower than training agents based on on-policy methods [Stooke and Abbeel 2018], the DRL methods considered in this work include two on-policy based methods Advantage Actor-Critic (A2C) [Mnih et al. 2016] and Proximal Policy Optimization (PPO) [Schulman et al. 2017], as well as the curiositydriven exploration technique [Pathak et al. 2017]. As A2C and PPO also train their Q-functions (i.e., like DQN) to serve as the critics, it is more feasible to leverage the advantage offered by them to quickly validate the properties of macros for multiple environments. These DRL methods (i.e., A2C and PPO) have been widely adopted as the baseline approaches in the literature and are capable of completing the same training timesteps with less amount of physical time [Stooke and Abbeel 2018]. Among these methods, A2C and PPO utilize the policy gradient methods [Sutton et al. 2000;Williams 1992] to train the agents, which directly optimize in the direction of ∇ E ∼ [log ( | ) ] or ∇ E ∼ [log ( | ) ], where the latter is adopted for Actor-Critic based approaches and denotes the advantage function.

Advantage Actor-Critic (A2C)
Advantage Actor-Critic A2C is a famous on-policy method, which updates the value function based on the samples generated by the current policy. It is a synchronous variant of Asynchronous Advantage Actor-Critic (A3C) [Mnih et al. 2016], which trains agents in parallel on multiple instances of the environment. A2C offers better utilization of GPUs than A3C. For both A2C and A3C, a learning agent uses the predictions of the value function ( ) (i.e., the Critic) to update the policy function ( | ) (i.e., the Actor). During the training phase, the critic is trained to estimate the value function ( ), while the actor optimizes ( | ) by minimizing the loss term: where is a parameter for controlling the strength of the entropy ( (·| )). A2C utilizes ( (·| )) to encourage exploration, and prevent agents from converging prematurely to a sub-optimal policy.

Proximal Policy Optimization (PPO)
Proximal Policy Optimization (PPO) is another famous on-policy method, which computes an update at every timestep that minimizes the cost function while ensuring the deviation from the previous policy is relatively small. One of the two main variants of PPO is based on a clipped surrogate objective expressed as: whereˆis the advantage estimate, and a hyperparameter. The clipped probability ratio is used to prevent large changes to the policy between updates. The other variant of PPO employs a different surrogate objective during the training phase. This surrogate objective is based on an adaptive penalty derived from the KL divergence between an old policy and the current one (·| ), given by: where is an adaptive coefficient adjusted according to the observed change in the KL divergence.
In this work, we employ the former surrogate objective due to its better empirical performance.

Curiosity-driven Exploration
Curiosity-driven exploration is an exploration strategy adopted by a number of DRL researchers in recent years [Bellemare et al. 2016;Burda et al. 2018a,b;Houthooft et al. 2016;Ostrovski et al. 2017;Pathak et al. 2017] in order to explore environments more efficiently. While conventional random exploration strategies are easily trapped in local minima of state spaces for complex or sparse reward environments, curiosity-based methodologies tend to discover relatively un-visited regions, and therefore are likely to explore more effectively. In addition to the extrinsic rewards provided by the environments, most curiosity-driven exploration strategies introduce intrinsic rewards generated by the agent to encourage itself to explore novel states. The intrinsic rewards are formulated as the prediction errors of a forward dynamics network. Given an observation , a feature representation is generated by an embedding network. The forward dynamics network is then used to predict the representation of the next observation +1 by and the agent's taken action . The mean-squared error (MSE) || ( , ) − +1 )|| 2 is used as the intrinsic reward signal during the training phase, and serves as the training objective for to minimize. When the same observations are visited multiple times, their MSE errors drop, indicating that the agent are becoming familiar with them. In this work, one of our baseline Curiosity is implemented based on the concept of curiosity-driven exploration. initialize: = + + * return The best-performing macroˆin based on 35: end function

THE PROPOSED WORKFLOW
In this section, we present the proposed workflow for investigating the reusability and transferability properties for macro actions, which is the main objective of this research. Fig. 1 illustrates the workflow adopted in this paper. It contains two stages: a macro action generation stage, and a macro action utilization stage for performing various evaluations. The former stage takes into account the RL method R, A, and E, and derives a macro actionˆthat is sufficiently good enough for an RL agent to use as a means of performing temporal abstraction in E. The latter stage then encapsulates the derived macroˆand A in M, and utilizes M in our evaluation experiments. The workflow presented in Fig. 1 allows different experimental configurations to be defined.
We formulate our macro action generation stage as Algorithm 1, where the macro action construction method is based on a genetic algorithm (GA) [Mitchell 1998]. The promise of GA is that due to its simplicity, it offers an effective and easy way to construct sufficiently good macro actions. As return * = ( , 2 , . . . , | | ) 7: end function opposed to works that concentrate on evolutionary methods, our aim focuses on generating macro actions for investigating their properties, and is not proposing novel and general macro generation methods. GA offers three promising advantages for our workflow. First, it eliminates the dependency of the macro action derivation procedure from human supervision. Second, it produces diversified macros by mutation. Third, it retains good macro actions from mutation over generations.
Algorithm 1 is established atop three modules: (1) the fitness function, (2) the append operator, and (3) the alteration operator. These three modules serve as essential roles in Algorithm 1, and are additionally formulated as Algorithms 2, 3, and 4, respectively. Algorithm 2 evaluates a macro action by first appending it to A of the target E to form an augmented action space M, and then measuring the fitness score of for an agent with M in E using a given RL method R after training for a period. A single macro is evaluated rather than a set of macros, because a set of macros may cause ambiguity for determining the relative fitness of each macro in the set.
Our macro action generation stage consists of four phases: the "initialization phase", the "fitness phase", the "selection phase", and the "mutation phase". We walk through Algorithm 1 and highlight the four phases of GA as the following. Line 10 corresponds to the "initialization phase", which initializes the population of the macro actions with a number of randomly generated macro actions containing two primitive actions. Lines 17-21 correspond to the "fitness phase", which performs fitness evaluation by Algorithm 2. Lines 22-23 correspond to the "selection phase", which retains the  top performers in the population while eliminating the remaining ones from it. Lastly, lines 26-32 correspond to the "mutation phase", which randomly selects macro actions from the population, mutates them by Algorithms 3 and 4, and then form a new generation. After the macro generation stage, a macro actionˆis derived. The macro utilization stage then uses RL method R * , A, and E * to perform evaluations ofˆ. Three different configurations are considered in this research. When the embedding effect and the evaluation effect are aimed to be evaluated, R * and E * are set to be the same as R and E, respectively, such that these effects can be reflected in the evaluation experiments. When evaluating the reusability property, E * is maintained to be the same as E, while the RL method is changed to a different one. i.e., R ≠ R * and E = E * . Finally, when transferability is to be examined, E * is configured to be similar to E with a different reward setting under the same RL method, i.e., R = R * and E ≠ E * , as illustrated in Fig. 1.

EXPERIMENTAL SETUPS
In this study, we used our customized machines to perform our experiments. In total, we utilized up to 64 CPU cores and six graphics cards in our experiments. In the following subsections, we first introduce the general setups. Then, we describe the environments and RL methods for our reusability experiments. Finally, we explain the environments and RL method for our transferability experiments.

General Setup
All of the macro actions presented in this paper are derived by Algorithm 1, if not specifically mentioned. The four parameters used in Algorithm 1, , , + , and * , are set to 50, 8, 5, and 3 throughout our experiments, respectively. The former two parameters are designed to stabilize the average fitness of the population, while the latter two are selected such that GA prefers to append over alteration so as to encourage the growth of the length of our derived macro actions. The training time of "fitness phase" for Algorithm 2 is set to 5M, which is sufficient to determine whether the constructed macro action is satisfactory or not. Please note that all of the curves presented in this paper are generated based on five different random seeds, and are drawn with 95% confidence interval (displayed as the shaded areas).

Setup for the Reusability Experiments
Environments. We evaluate the derived macro actions on the following eight Atari 2600 [Bellemare et al. 2013] environments: Asteroids, Beamrider, Breakout, Kung-Fu Master, Ms. Pac-Man, Pong, Q*bert, and Seaquest. We first validate that our derived macro actions reflect the advantages of the embedding and the evaluation effects that benefit the selected RL methods in Section 7. Then we present results and analyses for our reusability experiments in Section 8.
RL methods. In our experiments, we select advantage actor-critic (A2C) [Mnih et al. 2016] and proximal policy optimization (PPO) [Schulman et al. 2017] implementations from [Hill et al. 2018] as our RL methods for training the agents. The detailed hyperparameter setups are summarized in Table 1.

Setup for the Transferability Experiments
Environments. We employ ViZDoom as our environments for examining the transferability property. ViZDoom is a research platform featuring complex three-dimensional first-person perspective environments, as shown in Fig. 2 (a). The agents in ViZDoom make decisions based on visual observations which do not contain any information about the locations of the agent and the goal. For ViZDoom, we evaluate our derived macro on the default task my_way_home (denoted as "Dense"). Then we demonstrate that the macro benefits the selected RL method in Section 7. We further use the "Sparse", "Very Sparse", and "Super Sparse" (developed by us) tasks for analyzing the transferability property of the constructed macro in Section 8. The Super Sparse task comes with extended rooms and corridors in which the distance between the spawn point of the agent and the goal is farther than the other tasks. The map layouts for these tasks are depicted in Fig. 2. When performing rotations, an agent does not make direct 90-degree turns as in grid worlds. The turning angles are less than 90 degrees and hence, it is required to perform a sequence of turning actions before making a sharp turn.  RL method. We implemented an intrinsic curiosity module (ICM) [Pathak et al. 2017] along with A2C (together denoted as "Curiosity"). The hyperparameters for "Curiosity" are summarized in Table 1.

VALIDATION OF THE PROPOSED WORKFLOW
In this section, we validate the proposed workflow presented in Section 5. We first demonstrate that the macros derived by Algorithm 1 do improve over generations. We next provide two examples to qualitatively explain the embedding effect and the evaluation effect of our derived macros in RL. Finally, we quantitatively show that the advantages of the two effects benefit two off-the-shelf RL methods. The reusability and transferability properties are examined in Section 8.
Validation 1: The macros derived over generations. Fig. 3 uses two different types of environments, Dense from ViZDoom and Enduro from Atari 2600, as example cases to demonstrate the average fitness and improvement of the each generation produced by Algorithm 1. The primary aim of the table is to offer a verification of Algorithm 1 for generating effective macro actions. The best one is then employed to investigate and examine the reusability and transferability properties of it. From the trends of these two example cases, it is observed that the mean episode rewards (i.e., the fitness) evaluated by the fitness function (i.e., Algorithm 2) improve over generations, revealing that later generations do inherit the advantageous properties from their parents. Such advantageous properties are retained over generations, pushing the population of the macro actions to evolve toward better  fitness. The improving trends therefore suggest that the fitness function presented in Algorithm 2 is effective and reliable for Algorithm 1. For the other environments and RL methods, the average fitness of the population for each generation is provided in Tables 2 and 3.
Validation 2: The embedding effect of the derived macros. In our second validation, we employ "Dense" from ViZDoom to explore and discuss the benefits of our derived macros in terms of the embedding effect by comparing the macros derived by Algorithm 1 with the action repeat macro, in which the same primitive actions are repeatedly executed. To this end, we first use the proposed macro generation stage to construct the best macroˆD for "Dense". Then, in order to construct a proper action repeat macroˆR epeat , we evaluate all possible action repeat macros with the same length equal toˆD for 10M timesteps. The macro with the highest evaluation score is then selected asˆR epeat . The final constructedˆD andˆR epeat are (MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT) and (MOVE_FORWARD, MOVE_FORWARD, MOVE_FORWARD), respectively. To visualize the impacts of them, we plot and compare the learning curve of "Curiosity+ˆD" against that of "Curiosity+ˆR epeat " in Fig. 3 (a). Fig. 3 (a) further includes a curve for the vanilla "Curiosity" for the purpose of comparison. It is observed that the curve of "Curiosity+ˆR epeat " is worse than the curves of "Curiosity" and "Curiosity+ˆD" in the early stage of the training phase. This observation provides two insights. First, although bothˆD andˆR epeat allow the RL agents to bypass intermediate states by performing consecutive actions,ˆR epeat does not lead to immediate positive impacts when compared with the vanilla "Curiosity". This suggests that not all macro generation methods are able to construct a macro action that benefits equally from the embedding effect. Second, it is observed thatˆD enables the agent to perform better than the vanilla "Curiosity", indicating that the macro action derived by our macro generation stage does provide positive impact when the agent is allowed to bypass intermediate states during the training phase of it.
Validation 3: The evaluation effect of the derived macros. In addition to the embedding effect discussed in the former example, in the third validation, we employ the "Enduro" environment from Atari 2600 to explain why the derived macro can benefit from the evaluation effect. In "Enduro", the agent controls a car to race with the other rival cars, and receives a reward signal only when it passes any one of them. We illustrate the learning curves in Fig. 3 (b), and use them to compare the A2C agent trained with and without the best macroˆA 2C constructed by our methodology for 100M timesteps. According to the results,ˆA 2C is (FIRE, FIRE), corresponding to two repeated forward moves. This macro enables the agent to learn to surpass the rival cars in the environment easier. It is observed that A2C withˆA 2C outperforms the vanilla A2C, which is hardly able to learn an effective policy throughout the training process. Cluelessly performing two consecutive forward moves poses a risk for the car to hit the rival cars, thus preventing the vanilla A2C from learning an effective policy. This observation reveals that the derived macro improves the search guidance of the RL agent due to the altered value estimation of each state. This is a direct advantage offered by the embedding effect.
Validation 4: Examination of the derived macro actions. The macro action generated using our methodology, which has the highest fitness score within the population in a generation, is defined as the best macro. In order to examine whether the best macrosˆderived by our methodology is able to benefit the selected RL methods, we first perform Algorithm 1 with A2C and PPO, and determine the best macrosˆA 2C andˆP PO for the two RL methods respectively. We then train A2C using M A2C = A ∪ {ˆA 2C } and PPO using M PPO = A ∪ {ˆP PO } for 100M timesteps. The training timesteps are chosen to be much longer than the "fitness phase" of Algorithm 1 to highlight the impact of the best macros on the agents in the long run. The results shown in Fig. 4 indicate that the RL methods benefit from the macros derived by the proposed methodology. We list the best macros for the Atari 2600 environments considered in this paper in Table 4 as a reference. These best macros are then used in Section 8 for validating the reusability and the transferability properties. Table 4. List of the macro actions generated for each Atari 2600 environment using our methodology.

Asteroids
( We reuse the macros constructed by Algorithm 1 to train an A2C agent and a PPO agent using M PPO and M A2C , respectively, for 10M timesteps.

REUSABILITY AND TRANSFERABILITY PROPERTIES
In this section, we first present a set of experiments to validate the fact that the macros derived by our workflow might exhibit the reusability property. We then discuss the existence of the transferability property for the macro presented in Section 7 in similar environments with different reward settings.
The Reusability Property. The reusability property is said to exist if a macro action constructed along with one RL method can be used by another RL method for training. To validate the existence of this property, we reuse the macros listed in Table 4 to train an A2C agent and a PPO agent using M PPO and M A2C , respectively, for 10M timesteps. We plot the results of Asteroids, Beamrider, Breakout, Kung-Fu Master, Ms. Pac-Man, Pong, Q*bert, and Seaquest in Fig. 5 Fig. 6. The learning curves of the RL method with and without the derived macro for evaluating the transferability property. We utilize the constructed macro presented in Section 7 to validate the transferability of it in the Sparse, Very Sparse, and Super Sparse ViZDoom tasks. For the Super Sparse task, 'Curiosity +ˆD' converges at around 13M timesteps, while 'Curiosity ' just begins to learn at about 25M timesteps. results show that the A2C and PPO agents are able to be benefited from the provided macros in most cases. This justifies the existence of the reusability property of the macros. The above observations also suggest that the macro actions derived by our workflow could exhibit invariance when they are employed by different RL methods during the training phase of the agents. This property further implies that once a good macro action is derived by the workflow, it can be later leveraged in the training phase of another RL method and reduce the time required by the macro generation phase. The Transferability Property. The transferability property is said to exist if the constructed macros can be leveraged in similar environments with different reward settings. In order to confirm this property, we utilize the macroˆD = (MOVE_FORWARD, MOVE_FORWARD, TURN_RIGHT) derived from the Dense reward setting presented in Section 7 to validate the transferability of it in tasks with sparse reward settings, including Sparse, Very Sparse, and Super Sparse. The results are plotted in Fig. 6. We also provide the numerical results in Table 5. Fig. 6 demonstrates that the agents withˆD learn relatively faster than the agents without it. Fig. 6 also reveals that the gap between "Curiosity+ˆD" and "Curiosity" grows as the sparsity of the reward signal increases. For the Super Sparse task, "Curiosity+ˆD" converges at around 13M timesteps, while "Curiosity" just begins to learn at about 25M timesteps. These results thus validate the transferability property of the derived macro action, and suggests that the macro derived in an environment can be utilized in a similar one with different reward settings, even if the reward signal becomes sparser than the original one. This is also due to the benefits offered by the embedding and the evaluation effects. The former reduces the search depth, while the latter provides better search guidance. These two effects together enable the RL agent to quickly reach the goal and updates its value estimates of the states more efficiently than the vanilla case.

CONCLUSIONS
In this paper, we have presented a methodology to examine the reusability and the transferability properties of the derived macros in the RL domain. We presented a workflow to generate macros, and utilized them with various evaluation configurations.We first validated the workflow, and showed that the derived macros exhibit the embedding and evaluation effects. We then examined the reusability property between RL methods and the transferability property among similar environments. Since the optimization target of the fitness phase is to find macros that can benefit the performance of the RL agents, the reusability and transferability properties found in most of the experiments can thus serve as the evidence that they are indeed possessed by the macros discovered by the proposed algorithm. The macros possessing the properties can potentially save the effort of the macro generation procedure.