Learning Control for Air Hockey Striking using Deep Reinforcement Learning
Ayal Taitler Nahum Shimkin

Unravelling the Dodecahedral Spaces
    Jonathan Spreer and Stephan Tillmann
    December 30, 2023
========================================







We consider the task of learning control policies for a robotic mechanism striking a puck in an air hockey game.
The control signal is a direct command to the robot's motors. We employ a model free deep reinforcement learning framework to learn the motoric skills of striking  the puck accurately in order to score. We propose certain improvements to the standard learning scheme which make the deep Q-learning algorithm feasible when it might otherwise fail. Our improvements include integrating prior knowledge into the learning scheme, and accounting for the changing distribution of samples in the experience replay buffer. Finally we present our simulation results for aimed striking which demonstrate the successful learning of this task, and the improvement in algorithm stability due to the proposed modifications. 







§ INTRODUCTION


The problem of learning a skill, a mapping between states and actions to reach a goal in a continuous world, lies at the heart of every interaction of an autonomous system with its environment. In this paper, we consider the problem of a robot learning how to strike effectively the puck in a game of air hockey. Air hockey is a fast competitive game where two players play against each other on a low-friction table. Players are required to develop and perfect skills as blocking and striking in order to play and win. Classical approaches for striking the puck involve a multi stage process of planning and execution. First, planning a strategy based on the goal and skill, e.g., calculating the best point of collision to achieve the goal, then planning a path and trajectory and finally executing the low level motoric control <cit.>.
Each part requires full knowledge of the mechanical and physical models, which might be complex. We propose doing the planning and the control simultaneously with learning, which offer an off model way to learn from the final result. The result will be given in a form of reward at the end of each trial, and will direct the learning to the correct policy. 


Such problems include policy gradients <cit.> where a mapping between states and actions is learned with gradient ascent optimization on the accumulated reward, with or without keeping track of the value function. Another popular approach is Learning from Demonstration  (LfD) <cit.> sometimes refereed as imitation learning <cit.> and apprenticeship learning <cit.>. In LfD a human expert (or a programmed agent) is recorded and the learning agent learns on the recorded data in a supervised fashion. Sometimes this process is used as an initialization for a second reinforcement learning stage for improvement. 
Paper <cit.> used imitation learning to learn primitive behaviors for a humanoid robot in air hockey. 


Exploration in such an environment is also an interesting issue. ϵ-greedy exploration which is the most common one, is not highly efficient in such systems, since a dynamical system functions as a low pass filter <cit.> and once in a while using a random action might have little affect on the output of the system. 
We combined several types of explorations including ϵ-greedy and local exploration, along with prior knowledge based exploration that we proposed. 


We propose an algorithm suitable for learning complex policies in dynamic physical environments.
The algorithm combined ϵ-greedy exploration with a temporally correlated noise <cit.> for local exploration, which proved to be essential for effective learning. We further propose two novel contributions. We suggest a more relaxed approach to LfD which does not have the same limitations as standard LfD and can be learned from experience as regular RL. We also manage to overcome the instability of the learning due to the non-stationarity of the observed data, by expending the target update period.  
 

We compare our results with other deep reinforcement learning algorithms and achieve significant improvements, we are able to reach near optimal results, and keep them without suffering from a drop in the score function and the policies obtained.






§ RELATED WORK


Research on learning in autonomous systems was conducted in several directions. Our work has been influenced mainly from the recent work of deep Q-networks <cit.>, and the adaptation for continuous domains of deep deterministic policy gradients <cit.>. 


Since the groundbreaking results shown by Deep Q-Learning for learning to play games on the Atari 2600 arcade environment, there has been extensive research on deep reinforcement learning. Deep Q-learning in particular seeks to approximate the Q-values <cit.>  using deep networks, such as deep convolutional neural networks. There has also been work on better target estimation <cit.>, improving the learning by prioritizing the experience replay buffer to maximize learning <cit.> and preforming better gradient updates with parallel batch approaches  <cit.>. Some work on adaptation to the continuous control domain has been done also by <cit.>. Policy gradients methods were traditionally used <cit.>, but struggled as the number of parameters increased. Adaptation to the deep neural network framework has also been done in recent years <cit.>. Several benchmarks such as <cit.> have made comparisons between continuous control algorithms. In This paper we focus on the online DQN based approach, and extend it in the domain of continuous state optimal control for striking in air hockey.









§ DEEP Q-NETWORKS
 

We consider a standard reinforcement learning setup consisting of an agent interacting with the environment in discrete time steps. At each step the agent receives an observation s_t ∈ℝ^n which represents the current physical state of the system, takes a action a_t ∈ A which it applies to the environment, receives a scalar reward r_t=r(s_t,a_t), and observes a new state s_t+1 which the environment transitions to. It is assumed that the next state is according to a stochastic transition model P(s_t+1|s_t,a_t). The action set A is assumed to be discrete. 


The goal of the agent is to maximize the sum of rewards gained from interaction with the environment. Our problem is a finite horizon problem in which the game terminates if the agent reached some predefined time T. We define the future return at time t as R_t = ∑_t'=t^Tr_t', where T is the time at which the game terminates. The goal is to learn a policy which maximizes the expected return 𝔼[R_0] from the initial state. 


The action-value function Q^*(s,a) is used in many reinforcement learning algorithms. It describes the expected return after taking an action a in state s and thereafter following an optimal policy. The optimal state-action value function Q^* obeys the equality known as the Bellman's equation. 

    Q^∗(s_t,a_t) = 𝔼_s_t+1[r_t + max_a'Q^*(s_t+1,a') | s_t,a_t ]

For learning purposes it is common to approximate the value of Q^∗(s,a) by using a function approximator, such as a neural network. We refer to the neural network function approximator with weights θ as a Q-network. A neural network representing the Q-function can be trained by considering the loss function:

    L(θ) = 𝔼_s_t,a_t,r_t,s_t+1∼ D[(y(θ) - Q(s_t,a_t ; θ) )^2 ]
 
where

    y(θ) = r(s_t,a_t)        s_t+1 terminal
       y(θ) = r(s_t,a_t) + max_a Q(s_t+1,a ; θ)        s_t+1 not terminal

During training time each transition of state, action, reward and next state <s_t,a_t,r_t,s_t+1> is stored in an experience replay buffer D from which samples are drawn uniformly in order to reduce time correlations to train the network. y(θ) is called the target and typically also a function of θ. The max{·} operator in the target makes it hard to calculation derivatives in respect to the weights, so the target is kept constant and the derivatives are calculated only according to Q(s_t,a_t;θ). This loss function has the tendency to oscillate and diverge. In order to keep the target stationary and prevent oscillations, the DQN algorithm make use of another network, called a target network with parameters θ̂^-. The target network is the same as the on-line network except that its parameters are copied every C updates from the on-line network, so that θ̂^- are kept fixed during all other updates. The training of the network in this case is according to the following sequence of loss functions

    L_i(θ_i) = 𝔼_s_t,a_t,r_t,s_t+1∼ D[(y_i(θ̂^-_i) - Q(s_t,a_t ; θ_i) )^2 ]

The target used by DQN is then 

    y_i(θ̂^-_i) = r(s_t,a_t) + max_a Q(s_t+1,a ; θ̂^-_i )

and the on-line network weights can be trained by stochastic gradient descent (SGD) and back-propagation

    θ_i+1 = θ_i + α∇_θ_i L_i(θ_i)

where α is the learning rate. An improvement on that has been proposed in the double DQN algorithm, the decoupling of the estimation of the next value and the selection of the action, and decrease the problem of value overestimation, the following target has been used

    y_i(θ̂^-_i) = r(s_t,a_t) +  Q(s_t+1 ,  a_t+1 ; θ̂_i^- ) 
       a_t+1 = _a  Q(s_t+1,a ; θ_i )

In our work unless specified otherwise all learning updates have been done according to the double DQN learning rule. 


To explore the environment the systems typically explore via the ϵ-greedy heuristic. Given a state, a deep Q-network (DQN) predicts a value for each action. The agent chooses the action with the highest value with probability 1-ϵ and a random action with probability ϵ.






§ STRIKING IN AIR HOCKEY


We next introduce the striking problem and our learning approach.


 §.§ The Striking Problem
 
The striking problem deals in general with interception of a moving puck and striking it in a controlled manner. We specialize here to the case where the puck is stationary. We wish to learn the control policy for striking the puck such that after the impact, the puck trajectory will have some desired properties. 
We focus on learning to strike the puck directly to the opponent's goal. We also considered some other different modes of striking the puck, Such as hitting the wall first. These are not presented here, but the same learning scheme fits them as well. We refer to these modes as skills, which a high level agent can choose from in full air hockey game.
The learning goal is to be able to learn these skills with the following desired properties


  * the puck's velocity should be maximal after the impact with the agent.

  * the puck's end position at the opponent's side should be the center of the goal.

  * the puck's direction should be according to the selected skill.

The agent is a planar robot with 2 degrees of freedom, X and Y (gantry like robot). We used a second order kinematics for the agent and puck.
The state vector of the problem is s_t ∈ℝ^8, which includes all the position and velocities of the agent and the puck in both axes, i.e., s_t = [m_x, m_Vx, m_y, m_Vy, p_x, p_Vx, p_y, p_Vy]^T. Here m_* stands for the agent's state variables and p_* stands for the puck's state variables. The actions are a_t ∈ℝ^2, and include the accelerations in both axes for the agent. 


The striking problem can be described as the following discrete time optimal planning problem:

    a_kminimize      ϕ(s_T, T) 
       subject to       s_k+1 = f(s_k,a_k) 
              s^(i)_k ∈[S^(i)_min, S^(i)_max],    i=1,…,8 
              a^(j)_k ∈[A^(j)_min, A^(j)_max],    j=1,2 
              s_0 = s(0)
 
Here the objective function ϕ(s_T, T) represents the value of the final state s_T (in terms of velocity and accuracy), and the final time T which we desire to be small. The function f(·) is the physical model dynamics. S^(i)_min, S^(i)_max and A^(j)_min, A^(j)_max are the constraints on the state (table boundaries and velocities) and action spaces (accelerations/torques) respectively. s_0 is the initial state.
We assume that f(·), the collision models and the table state constraints are hidden from the learning algorithm, The best known collision model is non-linear and hard to work with <cit.>. Solving analytically such a problem when these function are known is a challenging problem, when they are unknown it is practically impossible with analytic tools. In the simulations specific models were specified as explained in Section <ref>. 


In order to fit the problem as stated in <ref> to the DQN learning scheme, where the outputs are discrete Q values associated with discrete actions, we discretized the action space by sampling a 2D grid with n actions in each dimension (each dimension represents an axis in joint frame). Thus, we have n^2 actions. We make sure to include the marginal and the zero action, so our class of policies we search in will include the Bang-Zero-Bang profile which is associated with time optimal problems. Each action is associated with an output of the neural network, where each output represents the Q-values of each action under the input state supplied to the network, e.g., if state s is supplied to the network, output i is the Q-value of Q(s,a_i;θ). Thus, for every given state we have n^2 Q-values from the network, associated with the n^2 actions.



 §.§ Reward Definition


The learning is episodic and in this problem the agent receives success indication only upon reaching a terminal state and finishing an episode. The terminal states are states in which the mallet collide with one of the walls (table boundaries violation), and the states in which the mallet strikes the puck (the agent does not perform any actions beyond this point). Any other state including the states in which an episode terminates due to reaching the maximal allowed steps, are not defined as terminal states.
At the terminal state of each episode the agent receive the following reward

    R_terminal = r_c + r_v + r_d

R_terminal is consists of three components. The first is r_c, which is a fixed reward indicating a puck striking. The second component is a reward which encourages the agent to strike the puck with maximum velocity, and given by

    r_v = (V)· V^2

where V is the projection of the velocity on the direction of a desired location x_g on the goal line of the opponent. The last component is a reward for striking accuracy, which indicates how close the puck reached  x_g.

    r_d = 
    
    c     |x-x_g| ≤ w 
    
    c · e^-d · (|x-x_g|-w)    |x-x_g| > w

where x is the actual point the puck reaches on the opponent's side on the goal line, c is a scaling factor for the reward, w is the width of the window around the target point which receives the highest reward and d is a decay rate around the desired target location. Naturally, if the episode terminates without striking the puck R_terminal is zero.
In order to encourage the agent to reach a terminal state in minimum time, the agent receives a negative small reward -r_time for each time step of the simulation until termination. The accumulative reward for the entire episode then is R_total = R_terminal - n · r_time, where n is the number of time steps for that episode.



 §.§ Exploration

The problem of Exploration is a major one, especially in the continuous domain. We address the issue from two angles, completely random exploration and local exploration.


  §.§.§ Completely Random Exploration

We use ϵ-greedy exploration (see Section <ref>) in order to allow experimenting with arbitrary actions. In physical systems with inertia it is not efficient since the system acts as a low pass filter, but it does give the agent some sampling of actions it would not try under normal conditions.


  §.§.§ Local Exploration

The main type of exploration is what we refer to as local exploration. Similarly to what was done in <cit.>, we added a noise sampled from a noise process 𝒩 to our currently learned policy.Since the agent can apply only actions from a discrete set of actions 𝒜, we projected the outcome on the agent's action set:

    a_t = 𝒫_𝒜{_a Q(s_t,a ; θ) + 𝒩_t  }

We used for 𝒩 an Ornstein–Uhlenbeck process <cit.> to generate temporally correlated exploration noise for exploring efficiently. The noise parameters should be chosen in such a way that after the projection the exploration will be effective. Small noise might not change the action after the projection, but large noise might result in straying too far from the greedy policy. Thus, the parameters of the noise should be in proportion to the actions range and the aggregation.



 §.§ Prior Knowledge from Experience

In a complex environment, learning from scratch has been shown to be a hard task. Searching in a continuous high dimensional spaces with local exploration might prove futile. In many learning problems prior knowledge and understanding are present and can be used to improve the learning performance. A common way of inserting priors into the learning process uses LfD. 
For that purpose, multiple samples of expert performance should be collected, which is not always feasible or applicable. 


In many cases the prior knowledge can be translated to some reasonable actions, although usually not an optimal policy.
Examples for that can be seen in almost every planning problem. In games, the rules give us some guidance to what to do, e.g., in soccer, Kick the ball to the goal, so for an agent to spend time on learning the fact that it has to kick the ball is a waste. In skydiving, the skydivers are told to move their hands to the sides in order to rotate, they are not required to search every possible pose to learn how to rotate. Furthermore, the basic rotating procedure taught to new skydivers is not the correct way to do it, it is taught as a basic technique, an initialization for them to modify and find the correct way. 


We propose showing the agent a translation of the prior knowledge as a teacher policy. In some episodes instead of letting the agent to act according to the greedy policy, it does what the teacher policy suggests. The samples collected in those episodes are stored in the experience replay buffer as any other samples, allowing the learning algorithm to call upon that experience from the replay buffer and learn from it in within the standard framework. 


For the problem of air hockey, we used a policy encapsulating some crude knowledge we have of the problem. We just instruct the agent to move in the direction of the puck, regardless of the task at hand (aiming to the right\left\middle), since this knowledge was simple, and robust enough.
The guidance policy we constructed has the following form:

    V_next = P_puck - P_agent/ P_puck - P_agent· MaxVelocity 
       a = V_next - V_agent/Δ t/ V_next - V_agent/Δ t· MaxForce

where P_object is the x,y position vector of the object, and MaxVelocity, MaForce are physical constraints of the mechanics. The agent acts by the projection of the policy on its action space 𝒫_𝒜{·} This policy will result with an impact between the agent and puck, but by no account will be considered as a good strike since there is no reason the puck will move in the goal's direction (except in the special case when the puck lays on the line between the agent and the goal). 
The guidance policy is shown (the agent acts by it) and stored in the replay buffer with probability ϵ_p. 




 §.§ Non-Uniform Target Network Update Periods

The deep reinforcement learning problem is different from the supervised learning problem in a fundamental way, as the data which the network uses during the learning changes over time. At the beginning, the experience replay buffer is empty, the agent starts to act and fills the buffer, when the buffer reaches its maximal capacity new transitions overwrite the older ones. It is obvious that the data is changing over time, first changing in size and then changing in distribution. As the agent learns and gets better, the data in the buffer reflects that and the samples are more and more of good states which maximize the reward. 


Recall that the value the neural network tries to minimize is the loss function stated in (<ref>). In order to stabilize the oscillations a target network with fixed weights over constant update periods were introduced. That led to the stationarity of the target value. The choosing of update period length became of the parameters that had to be set. Small update period result with instability since the target network changes too fast and oscillates, large update periods may be too stationary and the bootstrap process might not work properly. Thus, a period that is somewhere in the middle is chosen so the updates are stable.


In may domains such as in the air hockey and also in some of Atari games, DQN still suffers from a fall in the score. We argue that this fall is not only due to value overestimation (it happens for Double DQN updates as well), but also for issues with the target value. Choosing a middle value for the update period may result in slow learning in the beginning and fall in the score later in the learning due to oscillations. 

  
In many domains such as in the air hockey and also in some of Atari games, DQN still suffers from a drop in the score as the learning process progresses (see, e.g., Fig. <ref>). We argue that this drop is not only due to value overestimation (it happens for Double DQN updates as well), but also for issues with the target value. Choosing a middle value for the update period may result in slow learning in the beginning and a drop in the score later in the learning due to oscillations. 


We show that by adjusting the update period over time, we manage to stabilize the learning and prevent completely the drop in the score. We start with a small update period since the replay buffer D is empty and we want to learn quickly, we then keep expanding the period as the buffer gets larger, and we need more sampling to cover it. As the agent gets better and the distribution stabilizes, we also expand the update period in order to filter oscillations and keep the agent in the vicinity of the good learned policy. The expansion of the update period is done at each target weights update according to 

    C = C· C_r,      C_r ≥ 1

where C_r is the expansion rate. When C_r=1 the updates are uniform as in the standard DQN. 


At the beginning every sample contains new information that should affect the learning. As the learning progresses and the optimal policy hasn't been obtained yet, the samples in the replay buffer are diverse allowing the agent to learn from good samples and bad samples as well. At later stages when the agent has already learned a good policy, and the distribution of samples in the replay buffer resembles that policy. The network at the point if learning continuous, might suffer from what is known as the catastrophic forgetting <cit.> of neural networks. Freezing the target network before that stage, stabilize the learning and allows the network fine tune its performances, even though the distribution in the replay buffer is undiverse. The target network contains then the knowledge gained in the past from bad examples. At that stage of the learning the update period should be large for that purpose. This is achieved by gradually increasing the update period from an initial small period at the beginning during the learning.



 §.§ Guided-DQN

Putting the above-discussed features together produces the guided-DQN algorithm we used in the air hockey problem. The algorithm is given in algorithm <ref>. 



As an input the algorithm gets the guidance policy, which encapsulated the prior knowledge we have on the problem, and the expansion rate C_r. At each
episode, with probability ϵ_p the entire episode will be executed with the guidance policy π(s), or with probability 1-ϵ_p according to the greedy policy, with the addition of time correlated exploration noise. In either case, a guided episode or a greedy episode, at each step the algorithm stores the transitions in the replay buffer, and preforms a learning step on the Q network. Samples from the replay buffer are selected randomly with uniform probability. The projection operator 𝒫_A projects the continuous actions onto the agent's discrete set, by choosing the action with the lowest euclidean distance. Every C updates the target Q network is updated with the weights of the on-line Q network, and C is expanded with a factor of C_r so the next time the target network gets updated, it will be after a longer period than the previous update. 


The learning rule is a Double DQN learning rule. Note that if the algorithm is not provided with a guidance policy (equivalent to setting ϵ_p to zero), C_r = 1, and the temporal correlated process is 𝒩≡ 0, the GDQN algorithm reduces to the standard Double DQN algorithm.








§ EXPERIMENTS



The simulation was fashioned after the robotic system in Fig. <ref>. 


In the robotic system the algorithm would learn on the real unknown physical models, but for the purpose of simulation we used simulation models for the agent dynamics and collision models. The simulation models are hidden from the learning algorithm and exist solely for the purpose of simulating the system for learning. For the agent dynamics we used a discrete time second order dynamics

    [   X_m; V_x,m;   Y_m; V_y,m ]_k+1   = 
    [ 1 T 0 0; 0 1 0 0; 0 0 1 T; 0 0 0 1 ][   X_m; V_x,m;   Y_m; V_y,m ]_k + 
    [ 0 0; T 0; 0 0; 0 T ][ a_x; a_y ]_k

under the following constraints

    |a_x,y|    < Maximum force
    
    |V{x,y},m |    < Maximum velocity
    
    |X_m,Y_m|    < Table boundaries

These constraints represent the physical constraints present in the mechanical system, where the velocity has a maximum value, the torques are bounded and we are not allowing the mallet to move outside of the table boundaries. 


We used in the simulations an ideal impact model between the mallet and puck in the sense that we neglected the friction between the bodies during the impact and we assume the impact is instantaneous with energy loss according to a restitution coefficient e. The forces, accelerations, velocities and space (the field's boundaries) are constrained to reflect the physical constraints in the robotic system. 


The list of parameters (learning rate, probabilities, etc.) used throughout the simulations is given in table <ref>.


The learning environment is a custom built simulation based on OpenAI gym <cit.>. The simulation is modeled after an air hockey robotic system with two motors and track, one for each axis. The simulation includes visually the table, the mallet and the puck. 


We simulated each attempt to strike the puck as an independent episode comprised of discrete time steps. At the beginning of each episode the puck is placed at a random position on the table at the agent's half court with zero velocity and the agent starts from a home position (a fixed position near the middle of the goal) with zero velocity. Each episode terminates upon reaching a terminal state or upon passing the maximum number of steps defined for an episode. The maximum steps number is 150 steps and the terminal states are the states where the agent collides with the puck (good states) or with one of the walls (bad states). The environment returns a reward as described in Section <ref>. No reward is given upon hitting a wall beyond the timely reward. 


The dynamic model of the puck and agent is a second order model as described in Section <ref>. T is the sampling time of the system and was set to 0.05 [sec] in the simulation. The puck's rotation was neglected, thus the collision models (puck-agent, puck-wall) are ideal with inbound and outbound angles the same. Energy loss in the collisions was modeled with restitution coefficient of e=0.99.  


The controller is a non-linear neural controller, a fully connected  Multi-Layer Perceptron with 4 layers (3 hidden layers and an output layer), the first two hidden layers are of 100 units each, the third hidden layer is of 40 units and the output layer is of 25 units. All activations are the linear rectifier f(x)=max(0,x). The controller is a map between states s_t (the inputs to the controller) and discretized Q-values. We choose 5 actions in each axis, yielding 25 output  actions\Q-values (see Section <ref>). We used the RMSProp algorithm with mini-batches of size 64. 


In all the simulation experiments we measured the score for random initial positions of the puck, it will always be shown in graph with the caption random. In addition we measured the performances for additional 3 fix representing states of the puck, fixed positions in the left side, the middle and the right side of the table. In addition we estimated the average value of all the states and present it as well.  The graphs matching these measures will be shown with appropriate captions. We present in this paper the results for the direct hit. 




 §.§ Results

First we show the performance of the standard Double DQN in Fig. <ref> for different target network update periods. We choose a fast period a intermediate period and a slow period calculated such that each state in the buffer will be visited 8 times on average before being thrown away from the buffer. 


It can be seen that the DDQN with fast updates (DDQN_200) rises the fastest but also drops quickly, the same behavior can be observed for the intermediate updates (DDQN_1000) but the rise is slower and  the drop happens less sharply. The score value the network drops to, -150, is exactly the value of the time penalty for a complete episode, i.e., the agent doesn't reach a terminal state. When investigating the policies obtained it can be seen that the agent's action oscillated between two opposite actions which affectively cause it to stand still.
For the slow updates (DDQN_5000) the case is different, the network seems mostly indifferent to the updates, and at the end it manages to rise a little.
The average value for all three runs oscillates and in general suffers from severe underestimation. 


In Fig. <ref> we compare the results of three algorithms, the DDQN algorithm with the intermediate update period (the best of the three shown before), Deep-mind's Deep Deterministic Policy Gradients (DDPG) algorithm, and our Guided-DQN algorithm. 




The DDPG algorithm manages to learn a suboptimal policy, but oscillates strongly around it. It can be seen in the fix positions graphs of the puck, although in the random graphs it looks pretty stable on the suboptimal policy. DDQN was discussed before, and our GDQN as can be seen clearly, learns the optimal policy and reaches the maximum score possible for each of them. In the random puck position the score also reaches an optimal policy in a very stable manner. Note that the score doesn't drop at all, and even the rise at the beginning is faster than the other two algorithms, it even faster than the rise of the DDQN with the fast updates shown in Fig. <ref>, due to the fast updates at the beginning and the guidance of the teacher policy.
The average values of DDQN and DDPG are oscillating and suffering from underestimation and overestimation respectively, where GDQN's average value is extremely stable and does not suffer from over or under estimation. 




The learned control polices and the trajectories are shown in Fig. <ref> for a puck stationed in the left side of the table. The profile in the X-Y plane of the table is shown in Fig. <ref>. The agent is doing a curve in order to hit the puck from the left so it will go to the middle of the goal. The motion is visually very similar to an S-curve, in the X axis the agent performs a saturated action, compatible with a Bang-Bang profile, and in the Y axis something that effectively is like a Band-Zero-Bang.











§ CONCLUSIONS


We addressed the application of striking a stationary puck with a physical mechanism. We showed that the standard DQN algorithm did not lead to satisfactory results. Therefore we proposed two novel improvements to this algorithm.


  * using prior knowledge during the learning to direct the algorithm to interesting region of the state and action spaces.

  * using non-uniform target update periods with expanding rate in order to stabilize the learning.

We also augmented the commonly used ϵ-greedy exploration mechanism with a local exploration with temporally correlated random process to better suite the physical environment. 


The modified algorithm is shown to learn near optimal performance in the motion planning and control problem of air hockey striking.
In particular, it solves completely the problem of score drop that was observed in Double DQN.


acm




