I Introduction
Reinforcement learning (RL) with neural network function approximators, known as “Deep RL,” has achieved tremendous results in recent years
[1]. Deep RL uses multilayered neural networks to represent policies that are trained to maximize an agent’s expected future reward. However, these neuralnetworkbased approaches are largely uninterpretable due to the millions of parameters involved.In safetycritical domains, such as healthcare, aviation, and military operations, interpretability is of utmost importance. Human operators must be able to interpret and follow stepbystep procedures and checklists [10, 11, 5]. Of the class of machine learning methods that can generate such a set of procedures, decision tree algorithms are perhaps the most highly developed [26]. While interpretable machine learning methods offer the promise of revolutionizing safetycritical domains [14], they are generally unable to match the singular performance seen in Deep RL [21, 8]. Decision trees have often been viewed as the de facto technique for interpretable machine learning [18, 14] as they can learn compact representations of underlying relationships within data [3]. In prior work, decision trees have been applied to RL problems where they served as function approximators: compactly representing information about which action to take in which state [7, 8, 20, 17].
The challenge with applying decision trees as function approximators in RL lies in the online nature of the learning problem. As such, the decision tree model (or any model) must be able to adapt to handle the nonstationary distribution of the observed data. The two primary techniques for RL function approximation are Qlearning [25] and policy gradient(PG) [24]. Underlying these learning mechanisms are variants of stochastic gradient descent (SGD); at each timestep, the RL agent takes an action based on the prediction of the approximated policy, receives a reward from the environment, and computes how to update the setting of each of the policy’s parameters [2, 9]
. Decision trees are not typically amenable to gradient descent due to their Boolean nature; they are a collection of nested ifthen rules. Therefore, researchers have used heuristic, nongradientdescentbased methods for training decision trees
[7, 8, 17]. A common approach when applying decision trees to RL is to perform online state aggregation using heuristics to update or expand a decision tree’s terminal (i.e., leaf) nodes rather than seeking to update the entire model with respect to a global loss function
[17]. Researchers have also attempted to use decision trees for RL by training them in batch mode, completely relearning the tree from scratch to account for the nonstationarity introduced by an improving policy [7]. While effective, this approach is inefficient when seeking algorithms that scale to realistic situations. Despite these attempts, success comparable to that of modern deep learning approaches has been elusive
[8].Seeking to develop a decision tree formulation amenable to gradient descent, Suárez and Lutsko formulated a continuous and fully differentiable decision tree (DDT), in which they adopted a sigmoidal representation of each decision node’s splitting criterion [22]. Suárez and Lutsko applied their approach to offline, supervised learning but not to RL. Researchers have continued to explore continuous decision tree formulations [15, 12], while there has been limited success in applying such fuzzy trees to RL (e.g., [20]).
In this paper, we develop and demonstrate an endtoend framework for RL with function approximation via DDTs. We provide three key contributions: first, we examine the theoretical properties for gradient descent over DDTs, motivating the need for PG based learning. To the best of our knowledge, this is the first investigation of the optimization surfaces of Qlearning and PGs for DDTs. Second, we introduce a regularization formulation to ensure interpretability via sparsity in the tree structure. Third, we demonstrate the novel ability to seamlessly update an entire decision tree via PG in canonical RL domains to produce an interpretable, sharp policy.
Ii Preliminaries
In this section, we highlight the traditional decision tree and describe how Suárez and Lutsko augmented this model to be fully differentiable for gradient descent. We also review RL, QLearning, and PG.
Iia Decision Trees
A decision tree is a directed, acyclic graph, with nodes and edges, that takes as input an example, , performs a forward recursion, and returns a label as shown in Equations 13. There are two types of nodes: decision nodes and leaf nodes. Decision and leaf nodes have an outdegree of two and zero, respectively. All nodes, , have an indegree of one except for the root node, , which has an indegree of zero. Each decision node is represented as a Boolean expression, (Equation 3), where and are the selected feature and splitting threshold, respectively, for decision node . For each decision node, the left outgoing edge is labeled “true” and the right outgoing edge is labeled “false.” If is evaluated true (or false) for an example, then the left child node, , (or right child node, ) is considered next. If the child node is a decision node, the process is repeated until a leaf node is reached. Once a leaf node is reached, the tree returns the label represented by that leaf node. The problem of finding the optimal decision tree is to determine, , the best feature and splitting criterion, for each decision node the label, , for each leaf node; and the structure of the tree (i.e., whether, for each node , there exists a corresponding child node).
(1)  
(2)  
(3) 
There are many heuristic techniques for learning decision trees with a batch data set that reason about the entropy, rsquared error, or other loss function [3]. A limitation of these Boolean decision trees is that one cannot readily apply standard gradient descent update rules since a tree is fixed after generation. Some researchers have tried heuristic approaches to iteratively grow trees in an RL context [17]; however, these approaches do not allow for a natural update of the entire structure of the tree in online learning environments.
IiB DDTs
Suárez and Lutsko provide one of the first DDT models. In their approach, they employ a sigmoid formulation for Equation 3, with a linear combination of features, , weighted by , and a steepness parameter . Suárez and Lutsko demonstrate that one can then compute the gradient of the tree with respect to the tree’s parameters, , , and , for all nodes, to approximately solve classification and regression problems [22].
(4) 
While there are limitations to this approach (i.e., whether a weighted, linear combination of many features is interpretable), we believe this model is at least a strong building block towards developing interpretable, machine learning models amenable to gradient descent.
IiC Reinforcement Learning
RL is an approach within machine learning where an agent is tasked with learning the optimal sequence of actions that will lead to the maximal expected future reward [23]
. The actions and observations of the agent are traditionally abstracted as a Markov Decision Process (MDP). Formally, an MDP is a fivetuple
defined as follows: is the set of states; is the set of actions;is the transition matrix describing the probability that taking action
in state will result in state ; is the discount factor which states how important it is to receive a reward in the current state versus a future state; and is the function dictating the reward an agent receives by taking action in state . In RL, the goal is to learn a policy, , that prescribes which action to take in each state in order to maximize the agent’s future expected reward, as defined in Equation 5:(5) 
Here, is the optimal policy and is the value of policy when starting in state . There are two widely practiced approaches to learn such a policy: Qlearning and PG.
IiC1 Qlearning
In Qlearning, one seeks to learn a Qfunction, , which returns the expected future reward when taking a given action in a given state when following policy . Since enumerating the state space is intractable for problems of a realistic nature, the Qfunction is typically approximated by some parameterization (e.g., a linear combination of features describing the states weighted by ), as denoted by . To learn these parameters and in turn, an approximation for the Qfunction one seeks to minimize the Bellman residual by applying the update rule in Equation 6, where indicates the change in with timestep under Qlearning, is the state the agent arrives in after applying action in state , and is the step size.
(6) 
IiC2 Policy Gradient
In PG, the objective is to directly learn a policy, , parameterized by as opposed to Qlearning. The update rule seeks to maximize the expected reward of a policy, as shown in Equation 7, where indicates the change in with timestep under PG, and are the state and action chosen at time , is the reward received at time , and
is the PG coefficient. This update considers an entire episode to compute an estimate of the expected value of the policy for each time step.
(7) 
Iii Assessing Online Methods for DDTs: QLearning and Policy Gradient
Iiia Problem Set Up
For our investigation into using a DDT for RL, we consider an MDP with four states and two actions as depicted in Figure 1. The rewards are for each state, respectively. The transition matrix, defined in Equation 8, indicates that the agent moves to a state with a higher index (i.e., ) when taking action and a state with a lower index (i.e., ) when taking action . Actions are taken successfully with probability . We note that and are terminal states.
We optimistically assume ; despite this hopeful assumption, we show unfavorable results for Qlearning and PG based agents using DDTs as function approximators. Further, we note that the Qlearning and PG updates do not explicitly consider transition probabilities (i.e., Equations 6 and 7). We assume the agent operating on this MDP learns episodically, meaning that the agent takes a sequence of actions until either time expires or a terminal node is reached. The agent begins in state when the time, , is (i.e., ) and takes at most four actions (i.e., , where is the final time step).
Given these assumptions, one can see by inspection^{1}^{1}1Derivation withheld due to space constraints. that the optimal policy, , is to apply action in state and action in state .
(8) 
Remark 1 (Analogy to Cart Pole).
We note that this MDP determines that when the agent is in one portion of the state space, one action should be applied; when the agent is in a different portion of the state space, a different action should be applied. This behavior is analogous to many canonical RL problems, such as Cart Pole (Figure 2). In the Cart Pole problem, there is a point mass located at the end of a pole, connected to a cart through an unactuated joint. Gravity causes the pole to fall to the left when the pole is leaning left and right when leaning right. The RL agent must provide a counteracting force to balance the pole.
IiiB Decision Trees as Function Approximators
We aim to learn a decision tree that can serve as a function approximator for Qlearning or PG. For simplicity, we consider a decision tree with one decision node and two leaf nodes, as shown in Figure 3 and defined in Equation 9. This decision tree bifurcates the state space into two: states with an index less than or equal to and those greater than .
(9) 
Under Qlearning, the leaf nodes return an estimate of the expected future reward (i.e., the Qvalue) for applying each action when in the portion of the state space dictated by the decision node’s criteria. For example, if and the agent is in (i.e, parameter in is ), the Qvalues for taking actions and are and
, respectively. Under PG, the leaves represent an estimate of the optimal probability distribution over actions the RL agent should take to maximize its future expected reward. Therefore, the values at these leaves represent the probability of selecting the corresponding action. We note here that one would impose the constraint
.For our investigation, we assume that the decision tree’s parameters are initialized to the optimal setting. As noted previously —and regardless of using Qlearning or PG— the optimal policy, , is to apply action in state and action in state , assuming . As such, for Qlearning, we set and , which correspond to the Qvalues of taking action and in states and when otherwise following the optimal policy starting in a nonterminal node. When generating results in Section V for PG, we set and . These settings correspond to a decision tree that focuses on exploiting the current (optimal if ) policy. While varying the setting of leaf node values using PG is outside of the scope of this paper due to space considerations, we note that the results generalize to other settings of these parameters
IiiC Decision Tree Function Approximator Policies
There can be five qualitatively unique policies using a Boolean tree (i.e., Equation 3). These policies correspond to . For each policy, we can generate the sequence of states and the associated rewards the agent would receive, shown in Table I, assuming the agent starts in . Based on this information, we compute in Table II the value function (Equation 5) for each setting . For simplicity, we assume .
Remark 2 (Boolean vs. Continuous Decision Trees).
A key difference between a Boolean and differentiable decision tree is that the output of the differentiable tree is a weighted, nonlinear combination of the leaves (Equation 9). Using PG, one samples actions probabilistically from . The probability of applying the “wrong” action (i.e., one resulting in a negative reward) is in state and in state . Assuming it equally likely to be in states and , the overall probability is . These probabilities are depicted in Figure 4, which shows how the optimal setting, , for should be using PG.
IiiD Computing Critical Points
To apply Qlearning and PG updates, we must compute the gradient of the DDT formulation from Equations 2 and 4. As we focus primarily on the splitting criterion, , we need only consider as shown in Equation 10.
(10) 
The full Qlearning and PG updates, and , respectively, are then given by Equations 11 and 12, where the indicates the updates are dependent on a specific time step with an associated stateaction pair.
Recall the agent experiences episodes with four time steps (). Each step generates its own update, which are combined to give the overall update in Equation 13.
(13) 
Pseudocritical points exist, then, whenever = 0. A gradient descent algorithm would treat these as extrema because the gradient update would push towards these points. As such, we consider them critical points in our analyses.
The critical points given by are shown in Figures 4(a) and 4(b) for Qlearning and PG, respectively. For each curve, there are five critical points. We note that the curve is piecewise curvilinear, with breaks at , and . The only true critical point exists at for Qlearning and, suboptimally, at for PG.
IiiE Inferring the Optimality Curve
By integrating (Equation 14) with respect to from to , we infer the “optimality curve,” which should equal the value of the policy, , implied by Qlearning and PG. We numerically integrate using Riemann’s method as shown in Figure 6, normalized to be in .
(14) 
IiiF Evaluation of GradientBased Methods
Figures 4(a) and 4(b) depict the Qlearning and PG updates, respectively. We can see that the Qlearning update introduces multiple critical points as a function of the splitting criterion, , whereas the PG update includes only a single critical point for finite values of the splitting criterion, .
Figure 5(a) depicts the value of the DDT policy when trained using Qlearning and PG. This Figure shows the expected behavior with a maximum at for both training methods. However, Figure 5(b), derived using Equation 13 from the curves in Figure 5, stands in contradiction.
One would expect that the respective curves for the policy value and integrated gradient updates (i.e., Equation 13) would be identical; however, this does not hold for Qlearning. As we saw in Figure 4(a), Qlearning with DDTs introduces undesired extrema (critical points in 4(a)), depicted by the blue curve in Figure 5(b). PG, on the other hand, maintains a single maximum, coinciding with the expected .
The conclusion of this finding is that PG is not always superior to Qlearning as a training method for DDTs. However, this analysis does provide evidence that, even for toy problems, Qlearning exhibits weaknesses. As such, we conclude that PG serves as a more promising approach for training DDTs. Based on this evidence, the results reported below are for DDTs trained with PG.
Iv Interpretability in Fullgradient Learning
Given a training algorithm (i.e., PG as per Section III’s conclusion), we now seek to address the two key drawbacks of the original DDT formulation in [22] in making the tree interpretable. First, the operation at each node produces a linear combination of the features (rather than a single feature) and there is a smooth transition on the feature space between the and states of a node (rather than a step function transition occurring at the splitting criterion). To overcome these limitations, we propose a regularizing to generate decisions on a single feature and tune to encourage steepness (i.e., “crispness”) of the tree.
Iva Modification and Regularization for Interpretability
To achieve our goal of interpretability while maintaining competitive performance, we applied three modifications to the original [22]: 1) sparsityinducing regularization, 2) unbiased (i.e., uniform) tree initialization, and 3) discretization of the tree (i.e., to obtain the interpretable, classical version of a decision tree) at each time step to assess model performance.
IvA1 Sparsityinducing Regularization
During online RL via stochastic gradient descent, we added a regularization term to the loss that encouraged sparse feature representation in . Although regularization is often applied at the beginning of a training episode and increased according to some schedule, we found that allowing the model to converge in performance and then beginning the regularization procedure improved results in our tests.
(15) 
Although equation 15 improves sparsity, if used alone, it likely multiplies the chosen feature by some amount other than the unit (i.e., for a single feature and otherwise). To mitigate this problem, we applied a Softmax operator, , to the learned beta parameter, , such that the resulting decision node was governed by Equation 16 and 17. This modeling choice encouraged emphasis on a single feature.
(16)  
(17) 
IvA2 Tree Initialization
By employing a sparsityinducing regularization term, we sought to improve the tree’s interpretability; however, this regularization can result in undesired underfitting of the model by overpowering the reward signal. Through experimentation, we found that a random tree initialization introduced bias into the training process from which the tree could not recover even when allowed to converge before regularizing. To avoid this, we uniformly initialized at each node such that .
IvA3 Decision Sharpening
Due to the nature of the sigmoid function, even a sparse
was not sufficient to guarantee a discrete decision at each node. Thus, to obtain a truly discrete tree, we converted the fuzzy tree into a discrete tree at each iteration by employing an to obtain the index of the feature of that the node will use as in Equation 18.(18) 
V Results
Va Supervised Learning
Next, as a proof of concept, we evaluated our algorithm using the TicTacToe Endgame, the Breast Cancer Wisconsin (Diagnostic) and the Caesarian Section Classification data sets from the UCI repository [6]. For comparison we used a decision tree trained with C4.5 using the gini coefficient as the splitting criterion. For evaluation, we computed the Precision Recall Curve’s AUC over threefold crossvalidation using of the data for validation on each fold. The goal of this validation was not to achieve onpar performance with traditional decisiontreelearning mechanisms, which have the advantage of offline learning; rather, the goal of this intermediate investigation was to confirm that the model could learn competent mappings from input to outputs. Given such confirmation, we confidently move to demonstrate on our target task: RL.
For this intermediate supervisedlearning task, we initialized the DDT to be a full binary tree of depth equal to the maximum depth of the tree generated by C4.5. Namely, for TicTacToe a depth of 13, for Cancer a depth of 8, and for Cesarean a depth of 11.
Dataset  Cesarean  TickTackToe  Cancer 

Tree AUC  0.5032  0.8513  0.9263 
Sharp DDT AUC  0.6141  0.6577  0.7948 
DDT AUC  0.6077  0.7693  0.9910 
VB Reinforcement Learning
Our ultimate goal is in showing DDTs can learn competent, interpretable policies online for RL tasks. To show this, we evaluated our DDT algorithm using the CartPole, LunarLander and Acrobot OpenAI Gym environments [4] using PPO [19] [13] as our chosen optimization algorithm. Since our interest is interpretability, the policies are trained on the observed environment states. For comparison, we used an MLP with one hidden layer of
hidden units. We compared the performance of full binary trees of depth 4 and depth 6. To show the variance of the policy being trained, we ran 5 seeds for each policyenvironment combination. Finally, to assess the performance of each sharp tree, we computed an average reward over 10 episodes initialized to different seeds. In Figure
7, it is evident there was comparable performance to MLP in terms of sample complexity.After training, we retained the best performing seeds for the MLP and the crisp DDTs as measured on the evaluation dataset. The performance achieved by these policies for each environment is reported in Figure 8.
VB1 Resulting Trees
For our most challenging domain for learning (Acrobot), we were still able to find a good, crisp policy as depicted in Figure 9. Due to space limitations, we were unable to report the crisp version of each DDT we learned.
VC Implementation
These results were gathered on decision trees implemented with PyTorch
[16]. Our code is opensource and available here: https://github.com/ivandariojr/ddt.Vi Discussion
In this paper, we provide a theoretical argument in favor of PG as a training method for DDTs over Qlearning in the RL setting based on analysis of a simple, singlecriterion, stochastic gradient descent update on the Cart Pole domain. We also provide results for fuzzy and discrete DDTs for several reinforcement learning and classification settings.
Given the flexibility of MLPs and their large number of parameters,we anticipated an advantage in raw performance. After all, our DDT’s have a much smaller number of parameters, were regularized to encourage sparsity, and were constrained even further through discretization. We provide promising results that— even after converting the trained DDT into a discretized (i.e., interpretable) tree— the training process would yield tree policies that outperformed even the best MLP. Before triggering regularization, DDTs would even manage to improve on MLP’s sample efficiency as is the case with the CartPole and the LunarLander. Similarly, in supervised learning, we found that discretized DDTs sometimes outperformed traditional decision trees.
Choosing montecarlo sampling of seeds to explore better trees was a potential limitation, although ubiquitous in the field of RL. By effect of sampling policies every certain number of epochs, one policy could have happened to perform well on the evaluation environments, a possibility considering the high variance DDTs exhibited across seeds during training. Although possible for a very expressive policy class such as MLPs, it is exceedingly unlikely in the case of DDTs as they are designed to underfit in achieving interpretability. Further, we evaluated each discretized tree across
random episodes.A hypothesis for future work, we suspect DDTs perform better in the Acrobot and CartPole scenarios because, in part, we believe Bang Bang Controllers would likely also perform well in those scenarios. Although MLPs are more expressive in a continuous domain of policies, they may be poor approximators for discrete decision boundaries. In the future, we would also like to explore ways of pruning DDTs. As seen in Figure 9, there are redundant nodes in the policy that could be removed. Finally, we aim to further analyze the convergence and performance of DDT policies.
Vii Conclusion
Ultimately, we show how differentiable decision trees can be used in the context of reinforcement learning to generate interpretable policies. We provide a motivating example for why PG should be used to train this particular policy class and demonstrate results in both classification and reinforcement learning settings.
References
 Arulkumaran et al. [2017] K Arulkumaran, MP Deisenroth, M Brundage, and AA Bharath. A brief survey of deep reinforcement learning. IEEE Signal Processing Magazine, 34(6):26–38, 2017.
 Bottou [2010] L Bottou. Largescale machine learning with stochastic gradient descent. In Proceedings of COMPSTAT’2010, pages 177–186. Springer, 2010.
 Breiman et al. [1984] L Breiman, J Friedman, CJ Stone, and RA Olshen. Classification and regression trees. CRC press, 1984.
 Brockman et al. [2016] Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.
 ClayWilliams and Colligan [2015] R ClayWilliams and L Colligan. Back to basics: checklists in aviation and healthcare. BMJ Qual Saf, 24(7):428–431, 2015.
 Dheeru and Karra Taniskidou [2017] Dua Dheeru and Efi Karra Taniskidou. UCI machine learning repository, 2017.
 Ernst et al. [2005] D Ernst, P Geurts, and L Wehenkel. Treebased batch mode reinforcement learning. Journal of Machine Learning Research, 6(Apr):503–556, 2005.

Finney et al. [2002]
S Finney, NH Gardiol, LP Kaelbling, and T Oates.
The thing that we tried didn’t work very well: deictic representation
in reinforcement learning.
In
Proceedings of the Conference on Uncertainty in Artificial Intelligence
, pages 154–161. Morgan Kaufmann Publishers Inc., 2002.  Fletcher and Powell [1963] R Fletcher and MJD Powell. A rapidly convergent descent method for minimization. The computer journal, 6(2):163–168, 1963.
 Gawande [2010] A Gawande. Checklist Manifesto, The (HB). Penguin Books India, 2010.
 Haynes et al. [2009] AB Haynes, TG Weiser, WR Berry, SR Lipsitz, AHS Breizat, EP Dellinger, T Herbosa, S Joseph, PL Kibatala, MCM Lapitan, et al. A surgical safety checklist to reduce morbidity and mortality in a global population. New England Journal of Medicine, 360(5):491–499, 2009.

Kontschieder et al. [2015]
P Kontschieder, M Fiterau, A Criminisi, and S RotaBulo.
Deep neural decision forests.
In
Proceedings of the IEEE International Conference on Computer Vision
, pages 1467–1475, 2015.  Kostrikov [2018] Ilya Kostrikov. Pytorch implementations of reinforcement learning algorithms. https://github.com/ikostrikov/pytorcha2cppoacktr, 2018.

Letham et al. [2015]
B Letham, C Rudin, TH McCormick, D Madigan, et al.
Interpretable classifiers using rules and bayesian analysis: Building a better stroke prediction model.
The Annals of Applied Statistics, 9(3):1350–1371, 2015.  Olaru and Wehenkel [2003] C Olaru and L Wehenkel. A complete fuzzy decision tree technique. Fuzzy sets and systems, 138(2):221–254, 2003.
 Paszke et al. [2017] Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.

Pyeatt et al. [2001]
LD Pyeatt, AE Howe, et al.
Decision tree function approximation in reinforcement learning.
In
Proceedings of the third international symposium on adaptive systems: evolutionary computation and probabilistic graphical models
, volume 2, pages 70–77. Cuba, 2001.  Rudin [2014] C Rudin. Algorithms for interpretable machine learning. In Proceedings of the ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pages 1519–1519. ACM, 2014.
 Schulman et al. [2017] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms, 2017.
 Shah and Gopal [2010] H Shah and M Gopal. Fuzzy decision tree function approximation in reinforcement learning. International Journal of Artificial Intelligence and Soft Computing, 2(12):26–45, 2010.
 Silver et al. [2016] D Silver, A Huang, CJ Maddison, A Guez, L Sifre, G Van Den Driessche, J Schrittwieser, I Antonoglou, V Panneershelvam, M Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
 Suárez and Lutsko [1999] A Suárez and JF Lutsko. Globally optimal fuzzy decision trees for classification and regression. IEEE Transactions on Pattern Analysis and Machine Intelligence, 21(12):1297–1311, 1999.
 Sutton and Barto [1998] RS Sutton and AG Barto. Reinforcement learning: An introduction. MIT Press, 1998.
 Sutton et al. [2000] RS Sutton, DA McAllester, SP Singh, and Y Mansour. Policy gradient methods for reinforcement learning with function approximation. In NIPS, pages 1057–1063, 2000.
 Watkins [1989] CJCH Watkins. Learning from delayed rewards. PhD thesis, King’s College, Cambridge, 1989.
 Weiss and Indurkhya [1995] SM Weiss and N Indurkhya. Rulebased machine learning methods for functional prediction. Journal of Artificial Intelligence Research, 3:383–403, 1995.
Appendix A: Derivation of the Optimal Policy
In this section, we provide a derivation of the optimal policy for the MDP in Figure 1. For this derivation, we use the definition of the Qfunction described in Equation 19, where is the state resulting from applying action in state . In keeping with the investigation in this paper, we assume deterministic transitions between states (i.e., from Equation 8). As such, we can ignore and simply apply Equation 20.
(19)  
(20) 
Theorem 1.
Proof.
We begin by asserting in Equation 21 that the Qvalues for are given and for any action . This result is due to the definition that states and are terminal states and the reward for those states is regardless of the action applied.
(21) 
Next, we must compute the Qvalues for the remaining stateaction pairs, as shown in Equations 2225.
(22)  
(23)  
(24)  
(25) 
By the definition of the MDP in Figure 1, we substitute in for as shown in Equations 2629.
(30)  
(31) 
For the Qvalue of stateaction pair, , we must determine whether is less than or equal to . If the agent were to apply action in state , we can see from Equation 31 that the agent would receive at a minimum , because , must be the maximum from Equation 30. We can make a symmetric argument for in Equation 31. Given this relation, we arrive at Equations 32 and 33.
(32)  
(33) 
Equations 32 and 33 represent a recursive, infinite geometric series, as depicted in Equation 35.
(34)  
(35) 
In the case that , Equation 35 represents an infinite geometric series, the solution to which is . In our case however, (i.e., fourtime steps). As such, , as shown in Equation 36.
(36) 
Recall that given our definition of the MDP in Figure 1. Therefore, . If the RL agent is nonmyopic, i.e., , then we have the strict inequality . For these nontrivial settings of , we can see that the optimal policy for the RL agent is to apply action in state and action in state . Lastly, because and are terminal states, the choice of action is irrelevant, as seen in Equation 21. ∎
The optimal policy is then given by Equation 37.
(37) 
Appendix B: Qlearning Leaf Values
For the decision tree in Figure 3, there are four leaf values: , , , and . Table IV contains the settings of those parameters. In Table IV, the first column depicts the leaf parameters; the second column depicts the Qfunction stateaction pair; the third column contains the equation reference to Appendix A, where the Qvalue is calculated; and the fourth column contains the corresponding Qvalue. These Qvalues assume that the agent begins in a nonterminal state (i.e., or ) and follows the optimal policy represented by Equation 37.
Comments
There are no comments yet.