Paper deep dive
Self-Supervised Bio-Inspired Robotic Trajectory Planning with Obstacle Avoidance
Miroslav Krupa, Miroslav Cibula, Kristína Malinovská
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 7/24/2026, 2:10:58 AM
Summary
This paper presents a neuro-inspired self-supervised learning framework for robotic trajectory planning that utilizes forward and inverse models as internal supervisory mechanisms to generate collision-free trajectories in obstacle-rich environments. The study evaluates a neural trajectory planner on a 7-DOF KUKA LBR iiwa arm, identifying a tendency for the planner to exploit learning signals by generating oscillatory paths in safe regions, and proposes mitigation strategies including geometric priors and additional training regimes.
Entities (7)
Relation Signals (6)
KUKA LBR iiwa → isevaluatedon → Neuro-inspired self-supervised learning framework
confidence 95% · We present an evaluation of an industrial 7-degree-of-freedom robotic arm... The robotic manipulator was a KUKA LBR iiwa
Neuro-inspired self-supervised learning framework → uses → Forward Model (FM)
confidence 95% · This follow-up work tests our neuro-inspired self-supervised learning framework for trajectory planning that leverages forward and inverse models as the internal supervisory mechanism
Neuro-inspired self-supervised learning framework → uses → Inverse Model (IM)
confidence 95% · This follow-up work tests our neuro-inspired self-supervised learning framework for trajectory planning that leverages forward and inverse models as the internal supervisory mechanism
Trajectory Model (TM) → istrainedby → Forward Model (FM)
confidence 90% · The rectified trajectory is used in the training of the TM, allowing the FM and IM to provide a supervisory feedback signal.
Trajectory Model (TM) → istrainedby → Inverse Model (IM)
confidence 90% · The rectified trajectory is used in the training of the TM, allowing the FM and IM to provide a supervisory feedback signal.
Trajectory Model (TM) → exhibits → Oscillatory Behavior
confidence 85% · Experimental results demonstrate... a tendency of our planner to exploit the learning signal... The model produced paths oscillating in these regions
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Trajectory planning is a fundamental problem in robotics, requiring the generation of collision-free and efficient trajectories in a potentially complex environment. While sampling-based planners remain the dominant approach, they are often computationally expensive, particularly in high-dimensional spaces and obstacle-rich environments. Methods based on model learning offer a promising alternative, enabling efficient planning through a bounded number of forward passes through a neural trajectory planner, but commonly suffer from low sample efficiency or limited generalisation due to their reliance on exploration or expert demonstrations. This follow-up work tests our neuro-inspired self-supervised learning framework for trajectory planning that leverages forward and inverse models as the internal supervisory mechanism in an environment that contains an obstacle. Experimental results demonstrate the feasibility of the approach while revealing a tendency of our planner to exploit the learning signal provided by the forward and inverse models. To address this issue, additional training regimes and mitigation strategies are proposed and evaluated.
Tags
Links
- Source: https://arxiv.org/abs/2607.20743v1
- Canonical: https://arxiv.org/abs/2607.20743v1
Trouble viewing inline? Open PDF directly →
Full Text
38,479 characters extracted from source content.
Expand or collapse full text
11institutetext: Faculty of Mathematics, Physics and Informatics, Comenius University Bratislava, Bratislava, Slovakia 11email: krupa39@uniba.sk, cibula25@uniba.sk, kristina.malinovska@fmph.uniba.sk Self-Supervised Bio-Inspired Robotic Trajectory Planning with Obstacle Avoidance Miroslav Krupa Miroslav Cibula Kristína Malinovská(✉) Abstract Trajectory planning is a fundamental problem in robotics, requiring the generation of collision-free and efficient trajectories in a potentially complex environment. While sampling-based planners remain the dominant approach, they are often computationally expensive, particularly in high-dimensional spaces and obstacle-rich environments. Methods based on model learning offer a promising alternative, enabling efficient planning through a bounded number of forward passes through a neural trajectory planner, but commonly suffer from low sample efficiency or limited generalisation due to their reliance on exploration or expert demonstrations. This follow-up work tests our neuro-inspired self-supervised learning framework for trajectory planning that leverages forward and inverse models as the internal supervisory mechanism in an environment that contains an obstacle. Experimental results demonstrate the feasibility of the approach while revealing a tendency of our planner to exploit the learning signal provided by the forward and inverse models. To address this issue, additional training regimes and mitigation strategies are proposed and evaluated. 1 Introduction Motion planning, i.e., finding the optimal path between two poses of a robot or its manipulator, remains one of the fundamental and relevant challenges in robotics [3]. A trajectory planner is an algorithm that computes a collision-free sequence of states and actions to safely transition from the robot’s initial position to the specified goal position, particularly in obstacle-rich environments. Sampling-based planning methods represent the current state of the art in robotic motion planning [9]. These methods iteratively construct a graph by connecting a sample produced by a sampling strategy from the specified planning space (e.g., a Cartesian space of end-effector positions or a space of the robot’s joint-angle configurations) to the existing graph via a local planner. A feasible trajectory is then obtained by finding a path from the start to the goal node. However, the methodology frequently requires post-processing, such as smoothing, to produce natural motion, and its performance deteriorates in high-dimensional planning spaces and obstacle-rich environments. For complex humanoids, this can lead to unpredictable run times and difficulty finding a near-optimal solution. Alternative methods for trajectory planning include learning-based approaches [7], which learn motion strategies from experience or demonstration, such as reinforcement learning and imitation learning. While the former allows discovering viable behaviour through interaction with the environment, it often suffers from sample inefficiency and typically requires extensive exploration, which may be hazardous or costly, posing challenges when deploying in physical robotic systems. In contrast, imitation learning avoids the need for exploration by leveraging expert demonstrations, but its performance is strictly tied to the quality of the training dataset, which may limit generalisation and prevent the discovery of optimal behaviour. To address these limitations we proposed a novel neuro-inspired self-supervised learning framework that incorporates separately trained forward (FM) and inverse models (IM) into the training of a trajectory planner [2]. The FM and IM, analogous to cognitive internal sensorimotor models, learn the possible motions constrained by the robot’s kinematics. This internalised knowledge is then utilised to train a trajectory planner that can produce trajectories within a fixed runtime, making it highly efficient when many trajectories need to be planned in the same environment. In the present article, we extend our neural trajectory planner [2] to respond to obstacles in the environment and plan the trajectories while avoiding the collision with them. To this end, the FM and IM are retrained to account for the presence of an obstacle in the environment. The models are subsequently used in the trajectory planner’s training to correct its predicted trajectories. The empirical error between the predicted and corrected trajectory serves as self-supervised learning feedback, guiding the trajectory model (TM) to generate feasible trajectories. We present an evaluation of an industrial 7-degree-of-freedom robotic arm in a simulated environment with a single obstacle, and interpret our results as another step towards constant-runtime neural trajectory planners. 2 Related Work Sampling-based planning begins by constructing a graph or tree from samples of the robot’s collision-free configuration space, with nodes connected via local steering to approximate paths in the high-dimensional spaces. Many classical algorithms [9], such as probabilistic roadmaps and rapidly-exploring random trees, are probabilistically complete if a feasible path exists. However, these approaches are not asymptotically optimal, meaning there is no guarantee of path quality, which contradicts the aim of planning smooth, efficient trajectories, and while probabilistic completeness ensures convergence in probability, the process can be computationally intensive and overly demanding on memory. A recent comparative review [9] shows that modern implementations of these sampling-based algorithms balance success rate, runtime, and path quality, and that performance varies across scenarios such as passage widths and the number of robot degrees of freedom. Although this category of planners contains some disadvantages, it is evident that they remain the workhorse of complex motion planning. In reinforcement learning, the trajectory is viewed as a sequence of the environment’s states and actions performed by the robot under a policy learned through interaction with the environment, with the aim of maximising cumulative reward by completing the motion task [13]. Such models have shown promise for obstacle-avoiding path planning and tracking that respect the robot’s environmental constraints [4]. However, because reinforcement learning methods generally entail substantial data requirements and exploration costs, offline forms of this paradigm [6], as well as combinations with supervised approaches, have been explored to leverage the advantages of demonstration learning [5]. Issues such as reward design and sample efficiency have motivated alternative formulations of reinforcement learning problems, including supervised sequence modelling approaches, in which task solving is reformulated as generating temporally ordered states, actions, and rewards, constituting trajectories [8]. Such approaches mitigate the above-mentioned disadvantages of reinforcement learning while capitalising on the strengths of sequence modelling, such as improved scalability and adaptable representations provided by recurrent neural networks or transformer-based architectures. Nevertheless, these implementations tend to suffer from common supervised-learning limitations, a higher failure rate outside the training distribution, and low explainability and verifiability due to their end-to-end system design [7]. Our previous work [2] presents a novel bio-inspired self-supervised approach to trajectory planning, utilizing paired forward and inverse models and a recurrent predictor. Rather than relying on an explicit training distribution, the FM and IM enrich the training process by providing more informative learning targets. Our model overcomes some of the abovementioned problems and generally aims at improving the generalisation ability and the feasibility of the generated trajectories. 3 Methods This work aims to implement, train, and evaluate a neural trajectory planner that receives vector representations of the initial and the goal state of the environment and generates a sequence of intermediate states facilitating transitions between them. The generated trajectory enables the robot to perform a motion task by reaching the desired goal state from the initial state. Depending on the features of the representation used, the trajectory may consist of either joint configurations directly followed by the robot or end-effector positions, from which joint configurations are computed through an inverse kinematics solver. The planner follows a self-supervised learning paradigm in which a trajectory model is trained with the aid of separately trained forward and inverse models. In this section, we describe the architectures of the individual components and their corresponding training procedures. The overall design and training approach are adapted from our trajectory model [2]. To assess the robustness of the architecture, two datasets are generated using context-specific representations of the state of the environment at time t, vector ts_t, and of the action taken or control input followed by a robot at time t, vector ta_t. First, we generate a transition dataset for imitation learning of the FM and the IM, where each data point is represented by a triplet (t,t,t+1) (s_t,a_t,s_t+1 ), denoting an event of performing ta_t in ts_t, resulting in t+1s_t+1. Secondly, a trajectory dataset is generated for training the TM. Each trajectory is defined as τ=(0,0,1,1,2,…,T−1,T−1,T)τ= (s_0,a_0,s_1,a_1,s_2,…,s_T-1,a_T-1,s_T ), where 0s_0 denotes the initial state, Ts_T the final (goal) state, and T the trajectory length. The data generation procedures used to obtain these datasets implement the approach proposed in [10, Sec. 4.1]. The FM is learned by a multi-layer perceptron FM FM that approximates the system dynamics denoted by fm, such that FM(t,t)≡^t+1≈t+1≡(t,t),FM\! (s_t,a_t )≡ s_t+1 _t+1 \! (s_t,a_t ), (1) where ^t+1 s_t+1 is the predicted next state, which is an approximation of the ground-truth next state t+1s_t+1. The output is structured into multiple heads, one for each subvector of the state vector. This design allows individual state components, such as the robot’s joint-angle configuration and the obstacle’s position and rotation, which differ in scale and semantic meaning, to be optimised more effectively. During the FM training, the loss function ℒFM≡ℒ(^t+1,t+1)≜1k∑t+1(i)⊆t+1,^t+1(i)⊆^t+1ℒ(i)(^t+1(i),t+1(i))L_FM _s\! ( s_t+1,s_t+1 ) 1k _y^(i)_t+1 _t+1,\ y^(i)_t+1 s_t+1L_y^(i)\! ( y^(i)_t+1,y^(i)_t+1 ) (2) is minimised. The constant k represents the number of output heads, t+1(i)y^(i)_t+1, t+1(i)⊆t+1y^(i)_t+1 _t+1 the i-th subvector of the vector t+1s_t+1, and ℒ(i)L_y^(i) the loss function used for the subvector t+1(i)y^(i)_t+1. The loss is then formulated as a weighted sum of the prediction errors of each head of the network. Analogously, the IM is learned by a multi-layer perceptron IM IM that approximates the inverse dynamics im, such that IM(t,t+1′)≡^t≈t≡(t,t+1′),IM\! (s_t,s _t+1 )≡ a_t _t \! (s_t,s _t+1 ), (3) where ^t a_t is the predicted action causing the transition between state ts_t and the reduced representation t+1′s _t+1 of the next state t+1s_t+1, where components directly resulting from the action taken are excluded. During the IM training, the following loss function is minimised ℒIM≜ℒ(^t,t)L_IM _a( a_t,a_t) (4) Figure 1: Architecture of the trajectory model. At each time step , the same GRU stack is recursively executed, and the time-distributed output heads produce the trajectory τ τ_s. Dimensions of layers are denoted as dxd_x, where x is the respective model part. ngrun_gru is the number of GRUs. Finally, the trajectory model TM TM is a neural network with recurrent layers implemented as gated recurrent units (GRU) [1], defined as TM(0,T)≡τ^≡(^1,…,^T−1),TM\! (s_0,s_T )≡ τ_s≡ ( s_1,…, s_T-1 ), (5) where τ τ_s is the predicted trajectory represented as a sequence of state vectors. During inference, the model receives an input consisting of the initial state 0s_0 and the desired goal state Ts_T, which the generated trajectory τ τ_s connects. Similarly to the FM, the time-distributed output of the recurrent network is divided into multiple output heads, where each head corresponds to a separate component of the state vector (see Fig. 1). The model’s output τ τ_s is used together with the initial state 0s_0 and the final state Ts_T of the ground-truth trajectory for the rectification process. Given the predicted trajectory, the algorithm produces a rectified trajectory τ~=(~0,~1,…,~T−1,~T), τ_s= ( s_0, s_1,…, s_T-1, s_T ), (6) consisting of rectified state vectors. The first and final states are fixed to the ground-truth states, meaning ~0=0 s_0=s_0 and ~T=T s_T=s_T. For each intermediate time step t, the IM predicts an action a^t−1 a_t-1 from the previous rectified state ~t−1 s_t-1 and the reduced predicted state ^t′ s _t, obtained from ^t s_t by removing components directly determined by the action vector. The FM then predicts the next rectified state ~t s_t using the previous rectified state and the predicted action. The rectified trajectory τ~ τ_s is used in the training of the TM, allowing the FM and IM to provide a supervisory feedback signal. The result of such training is presumed to be a planner generating internally consistent and feasible trajectories that respect the system’s dynamics and environmental constraints (under the assumption that the models responsible for trajectory corrections approximate the dynamics sufficiently well). The TM is trained by minimising the loss function ℒTM(τ^s,τ~s,0,T)≜1|τ^|∑t=1T−1ℒ(^t,~t)+ℒinit(^1,0)+ℒgoal(^T−1,T),L_TM( τ_s, τ_s,s_0,s_T) 1| τ_s| _t=1^T-1L_s\! ( s_t, s_t )+L_ init\! ( s_1,s_0 )+L_ goal\! ( s_T-1,s_T ), (7) where the first term represents the weighted rectification error, encouraging the predicted trajectory to remain feasible and consistent regarding the learned FM and IM. The remaining terms guide the model towards intermediate states that form a valid connection between the initial and goal states. 4 Experiments and Results In this work, we define the state vector t≜(t,t,,t,R,t,,t,R,t,,t,R,t),s_t ( θ_t, mgt_t,ef_xyz,t,ef_R,t,g_xyz,t,g_R,t,o_xyz,t,o_R,t ), (8) where t∈ℝ7 θ_t ^7 is the joint-angle configuration of the robot, t∈0,1 mgt_t∈\0,1\ is the binary state of the magnet, ,t∈ℝ3ef_xyz,t ^3 and R,t∈ℍef_R,t are the position and the orientation of the robot’s end-effector, ,t∈ℝ3g_xyz,t ^3 and R,t∈ℍg_R,t are the position and the orientation of the goal object, and ,t∈ℝ3o_xyz,t ^3 and R,t∈ℍo_R,t are the position and the orientation of the obstacle object at time t. The action vector ta_t leading from ts_t to t+1s_t+1 is given as t≜(Δt,Δt),a_t ( θ_t, mgt_t ), (9) where Δt≜t+1−t θ_t θ_t+1- θ_t, and Δt≜t+1−t mgt_t mgt_t+1- mgt_t. The dataset generation process was accomplished in a simulated environment using a MyGym toolkit [12]. The robotic manipulator was a KUKA LBR iiwa with 7 degrees of freedom and equipped with a magnet attached to the last link instead of a gripper. The environment contained a single static obstacle object, a primitive oriented box. A special pose of the obstacle, ∅≜[(−2)×7]o_ [(-2)_× 7], was selected arbitrarily to represent no obstacle present in the environment, as such a position lies outside the valid workspace and thus does not correspond to any physically realisable obstacle pose. The simulation was used to generate three training datasets. Datasets 1D_1 and 2D_2 consisted of 500 000 transitions, both with the ratio of transitions in the obstacle vs. obstacle-free setups at 9:1, while the ratio of colliding to non-colliding transitions was 4:1. These ratios were chosen to increase the density of samples in regions where the dynamics are more complex and critical for learning. 1D_1 contained multiple transitions per setup, contrasting 2D_2 with only a single transition per setup. The simulation was also used to generate training trajectories. Similarly, the generation was done in both obstacle-containing and obstacle-free environments. A ratio similar to that for transitions was enforced. This produced a set 3D_3 of 12 000 trajectories with a maximum allowed length of 52 states. The FM and IM were obtained by the same training process as described in [10, Sec. 5.2]. The former was trained on the dataset 1D_1, while the latter was trained using 2D_2. The evaluations of the FM and IM are presented in Tab. 1. The models were evaluated on multiple metrics, all measured as mean absolute errors except the rotational subvectors, which were computed as mean geodesic error (i.e., the angular distance between two rotations on the unit quaternion sphere) to better reflect the quaternion representation. Table 1: FM and IM test performance across transition categories. Mean absolute error was measured for the corresponding subvector of the state/action vector. Test set contained 30 000 transitions, evenly divided into 3 categories: no obstacle present, non-colliding in the presence of an obstacle, and resulting in a collision. Forward model Inverse model θ [rad] ef_ xyz [m] Ref_R [rad] g_ xyz [m] Rg_R [rad] o_ xyz [m] Ro_R [rad] Δ θ [rad] Δ mgt No obstacle 0.015 0.010 0.070 4.4e-4 9.8e-4 1.9e-4 1.0e-3 0.0143 2.6e-5 Colliding 0.057 0.020 0.134 1.6e-4 9.8e-4 1.6e-4 1.1e-3 0.0313 9.0e-6 Non-colliding 0.016 0.010 0.072 3.5e-4 9.8e-4 3.3e-4 1.4e-3 0.0139 2.4e-5 With the supervisory models trained, the TM architecture and training were examined. The loss function ℒTML_ TM from Eq. 7 was minimised with all terms using the same loss functions as for the FM architecture: ℒL_ θ (joint configuration error) and ℒL_ xyz (total error of positional outputs ef_ xyz, g_ xyz, o_ xyz) use mean squared error of the corresponding subvectors, while ℒL_ mgt uses binary cross-entropy with logits. Lastly, we define the loss function ℒRL_R for the rotational heads as ℒR=ℒchordal(^R,R)=1−|^R⊤R|.L_R=L_chordal\! ( y_R,y_R )=1- | y_R y_R |. (10) The initial and final states from the trajectory training dataset served as input during the experiments, and their corresponding loss functions were computed as ℒinit(^1,0) _init\! ( s_1,s_0 ) =ℒ(^1,0)+ℒ(^1,0) =L_ θ\! ( θ_1, θ_0 )+L_ xyz\! ( ef_1,ef_0 ) (11) ℒgoal(^T−1,T) _goal\! ( s_T-1,s_T ) =ℒ(^T−1,T)+ℒ(^T−1,T) =L_ θ\! ( θ_T-1, θ_T )+L_ xyz\! ( ef_T-1,ef_T ) (12) The initial attempts at hyperparameter tuning with weaker internal models exposed a weakness of this framework [10, Sec. 6.2], where a model with large enough capacity learned to exploit the rectification learning signal, creating trajectories, while consistent with the FM and IM, that performed unnatural and unnecessary movement in safe areas, where action and its resulting state were easily predictable. The model produced paths oscillating in these regions as long as possible to lower the rectification loss, after which heaping movements towards the goal followed to minimise the penalty for distance away from the goal position (see Fig. 2). Figure 2: Generated trajectories’ waypoints in a space with (left) and without an obstacle for a model exploiting the rectification learning feedback. Green and red points mark the initial and the final ground-truth state, respectively. The planned trajectory starts in the blue crossmark and terminates in the orange one. Oscillation pattern in safe regions is learned and repeated for every trajectory. Various prevention mechanisms were tested to mitigate the exploitation, including supervised pretraining based on ground-truth trajectories from the training dataset and better tuning of the rectifying models. The next approach introduced additional end-effector-based geometric priors through a separate geometric loss term encouraging smoother spacing between waypoints and more geometrically consistent trajectories by preventing large steps, sharp angles, unnecessarily long trajectories, and oscillations. These modifications significantly improved trajectory quality and reduced oscillatory behaviour during training. We constructed 5 different models that were further used for experimentation. Each model was trained using the AdamW optimiser [11] with the initial learning rate η=1×10−4η=1× 10^-4. To prevent gradient explosion for long-horizon recurrent model predictors, a horizon of ntimesteps=50n_ timesteps=50 was chosen, and gradient clipping was implemented with a clip norm of 2.02.0 to stabilise the learning curves. Figure 3: Generated trajectories’ waypoints in a space with (left) and without an obstacle for models after exploitation prevention. Green and red points mark the initial and the final ground-truth state, respectively. The planned trajectories start in the blue crossmarks and terminate in the orange ones. The trajectory models were evaluated in two phases. The first phase focused on the geometric properties of the generated trajectories, assessed based on the distance to the initial position, distance to the goal position, transition sizes, average angle between consecutive trajectory segments, and tail-related metrics, i.e., the real effective length of the predicted trajectory and what fraction of available steps goes unused. The distances to the boundary positions indicate whether the models can correctly position trajectories in the workspace, with the goal-position distance specifically showing a model’s ability to correctly perform trajectory planning. Both step sizes and angles between the points determine the smoothness and geometric consistency of the trajectories. Large variations between individual step sizes or sharp turns lead to unnatural and inefficient motions. All metrics are calculated based on generated trajectories’ end-effector positions τ τ_ ef. An additional test set of 4 000 trajectories was generated, with 2 000 containing no obstacle in the environment. Their initial and goal states were used for querying the model. During training, each architecture was evaluated every 10 epochs. Although the models learn how to generate trajectories with higher geometric consistency, successful execution in the simulated environment additionally depends on correct timing and physically feasible positioning. We evaluated the models’ ability to generate practically executable trajectories by executing the predictions directly in the simulator. As an additional metric, we measured the ground-truth distance to the goal position and the differences between predicted and executed trajectories to assess whether the generated waypoints were correctly followed. Furthermore, the ratio of successful trajectories and collisions was recorded. Execution was evaluated in two modes: following the generated configurations directly and following configurations obtained via inverse kinematics using the generated end-effector positions. A summary of this experiment is presented in Table 2. Table 2: Simulator evaluation metrics of the trajectory models measured on the generated test trajectory set. The table reports collision rate c%c\%, raw magnet success rate m%m_ raw\%, collision-free magnet success rate m%m\%, waypoint following rate w%w\%, average number of repeated control steps per waypoint r, final distance to goal d_ goal, mean executed step size s¯ s, mean executed trajectory angle α¯ α, and average deviation between predicted and executed trajectories d_ exec. Lower values are better for c%c\%, r, d_ goal, s¯ s, and d_ exec, while higher values are better for m%m_ raw\%, m%m\%, and w%w\%. Each model, mode, and environmental setup was tested with 200 episodes. Entries marked with “–” indicate that the metric could not be computed due to an inverse kinematics failure. c%c\% [%] m%m_ raw\% [%] m%m\% [%] w%w\% [%] Model Mode No obs. / Obs. No obs. / Obs. No obs. / Obs. No obs. / Obs. TM1TM_1 Cfg. 0.0 / 14.5 100.0 / 86.0 100.0 / 85.5 99.0 / 98.2 E+IK – / 43.0 – / 78.0 – / 57.0 – / 0.0 TM2TM_2 Cfg. 0.0 / 44.5 100.0 / 84.5 100.0 / 55.5 88.8 / 79.4 E+IK 0.0 / 44.0 58.0 / 80.0 58.0 / 56.0 0.0 / 0.0 TM3TM_3 Cfg. 0.0 / 16.5 100.0 / 84.5 100.0 / 82.0 63.7 / 64.9 E+IK 0.0 / 46.5 100.0 / 81.0 100.0 / 53.0 0.0 / 0.0 TM4TM_4 Cfg. 0.0 / 20.0 100.0 / 89.5 100.0 / 80.0 63.0 / 61.7 E+IK 0.0 / 61.5 99.5 / 61.0 99.5 / 37.0 0.1 / 0.0 TM5TM_5 Cfg. 0.0 / 7.5 100.0 / 95.5 100.0 / 92.5 99.8 / 96.7 E+IK 0.0 / 47.0 97.0 / 79.0 97.0 / 51.0 0.0 / 0.0 r d_ goal [m] s¯ s [m] α¯ α [∘] d_ exec [m] Model Mode No obs. / Obs. No obs. / Obs. No obs. / Obs. No obs. / Obs. No obs. / Obs. TM1TM_1 Cfg. 2.02 / 2.09 0.131 / 0.177 0.096 / 0.082 148.92 / 159.75 0.725 / 0.677 E+IK – / 20.0 – / 0.185 – / 0.025 – / 172.78 – / 0.151 TM2TM_2 Cfg. 11.27 / 12.54 0.134 / 0.178 0.508 / 0.430 30.47 / 18.91 0.719 / 0.807 E+IK 11.6 / 20.0 0.175 / 0.185 0.037 / 0.029 168.71 / 172.49 0.131 / 0.158 TM3TM_3 Cfg. 11.39 / 10.95 0.146 / 0.189 0.389 / 0.391 12.87 / 12.29 0.796 / 0.808 E+IK 20.0 / 19.9 0.132 / 0.180 0.029 / 0.029 173.89 / 171.95 0.129 / 0.181 TM4TM_4 Cfg. 11.87 / 11.70 0.128 / 0.163 0.433 / 0.427 12.25 / 11.28 0.827 / 0.869 E+IK 19.9 / 19.7 0.148 / 0.225 0.039 / 0.033 171.98 / 167.44 0.130 / 0.297 TM5TM_5 Cfg. 1.05 / 1.63 0.128 / 0.140 0.016 / 0.017 166.61 / 165.20 0.144 / 0.149 E+IK 19.4 / 19.6 0.150 / 0.183 0.015 / 0.016 175.41 / 167.63 0.131 / 0.171 5 Discussion and Future Work Our results demonstrate that self-supervised recurrent trajectory planning can generate feasible and geometrically meaningful robotic motion in static environments. At the same time, the experiments revealed limitations of the framework and highlighted directions for future improvement. We observed the TM’s tendency to exploit the rectification mechanism. TMs with larger capacity gradually learned to minimise the rectification loss without generating meaningful trajectories. Instead of naturally spacing the intermediate states between the initial and goal positions, they often generated oscillatory or near-stationary trajectories that locally minimised the rectification error produced by the FM and IM. This points towards the TM effectively overfitting to imperfections of the self-supervised feedback mechanism. Since the rectification process depends completely on the learned FM and IM, inaccuracies of these models create regions in the state-action space where unrealistic transitions can still achieve low rectification loss. As the TM capacity increased, the model became capable of finding and exploiting such regions. Both geometric priors and supervised pretraining had similar effects on performance. In both cases, the model first learned geometrically meaningful trajectories before the rectification process became the main learning objective. This suggests that such training strategies may provide a more robust mitigation mechanism against exploitation of the self-supervised feedback process. However, the experiments suggest that exploiting learned supervisory models remains one of the main limitations of the proposed self-supervised framework, highlighting the importance of the FM and IM optimisation. We hypothesise that geometric consistency is not sufficient for the successful execution of trajectories. Several models achieved relatively good geometric metrics and low rectification errors, but still planned trajectories that were difficult to execute. This was especially visible during the initial experiments without action repetition, where the self-supervised models struggled to correctly follow the generated waypoints. This suggests that even small local prediction errors can accumulate during execution and cause divergence from the originally planned trajectory. The difference between generated and executed trajectories also indicates that the TMs learned an approximation of the dynamics represented by the internal models instead of the true simulator dynamics. Since the FM and IM themselves contain prediction errors, the TM optimises for consistency with these approximations. As a result, a low rectification error does not necessarily guarantee physically feasible execution inside the simulator. The comparison between TM2TM_2, TM3TM_3, and TM4TM_4 showed that both geometric priors and supervised pretraining significantly improved the behaviour of the larger trajectory models in the no-obstacle environment. TM2TM_2, trained solely through the self-supervised rectification, frequently generated trajectories that did not lead to the successful completion of the task. This suggests that a more guided optimisation approach helps the model learn in an obstacle-free setup. Most promising is the smaller TM1TM_1 architecture. Despite its smaller capacity, TM1TM_1 consistently achieved better execution quality in obstacle environments in both execution modes. Compared to the larger self-supervised networks, TM1TM_1 achieved significantly better collision rate, success rate, waypoint reach rate, and required fewer repeated actions during execution. The model also generated smoother trajectories and fewer unrealistic transitions. In several obstacle-related metrics, TM1TM_1 achieved better performance than the fully supervised TM5TM_5 model. This behaviour suggests that with a smaller representation space, the model was forced to economise, choosing the simplest solution to the problem, which led to implicit learning of what a good-quality trajectory respecting the environmental constraints looks like. As a result, the smaller recurrent architecture generalised better and was less capable of exploiting the weakness of the self-supervised rectification mechanism. Therefore, smaller models may be more favourable for obstacle-aware planning, as they have lower spatial and temporal complexity in both training and inference. However, even the TM1TM_1 architecture did not produce executable trajectories in all environments and conditions. Ultimately, all self-supervised trajectory models’ executed trajectories diverged from the originally planned motion. This further emphasises the importance of accurate FM and IM, as the TM optimises consistency with approximated dynamics instead of true simulator dynamics. We will direct our future work toward improving the quality of the internal models to improve executability and long-horizon trajectory consistency. The obtained results indicate that self-supervised recurrent trajectory planning represents a promising direction for robotic motion planning. The current limitations, hypothesised to be related to learned dynamics approximation quality and exploitation, will be addressed through improved internal models, richer datasets, stronger geometric constraints, and more advanced architectures. 5.0.1 Acknowledgements. The authors thank Matthias Kerzel (Department of Informatics, University of Hamburg) for his advice and rigorous feedback. This research was supported by the Slovak Research and Development Agency, project APVV-21-0105. Research results were in part obtained using the computational resources of the supercomputer PERUN at the Supercomputing Center at TU Košice, with support from the EU, funds of the Recovery and Resilience Plan of the Slovak Republic, project 17I03-04-P03-00001. We also thank the Slovak Society for Cognitive Science (SSKV)111https://cogsci.fmph.uniba.sk/sskv/ for their support. References [1] K. Cho, B. van Merrienboer, C. Gulcehre, D. Bahdanau, F. Bougares, H. Schwenk, and Y. Bengio (2014) Learning phrase representations using RNN encoder–decoder for statistical machine translation. In 2014 Conf. on Empirical Methods in NLP (EMNLP), p. 1724–1734. External Links: Document Cited by: §3. [2] M. Cibula, K. Malinovská, and M. Kerzel (2025) Towards bio-inspired robotic trajectory planning via self-supervised RNN. In Int. Conf. on Artif. Neural Networks, p. 149–160. External Links: Document, ISBN 978-3-032-04552-2, ISSN 1611-3349 Cited by: §1, §1, §2, §3. [3] M. Dobiš, M. Dekan, P. Beňo, F. Duchoň, and A. Babinec (2022) Evaluation criteria for trajectories of robotic arms. Robotics 11 (1). External Links: ISSN 2218-6581, Document Cited by: §1. [4] Í. Elguea-Aguinaco, I. Inziarte-Hidalgo, S. Bøgh, and N. Arana-Arexolaleiba (2024) A review on reinforcement learning for motion planning of robotic manipulators. Int. Journal of Intel. Systems 2024 (1). External Links: ISSN 1098-111X, Document Cited by: §2. [5] S. Emmons, B. Eysenbach, I. Kostrikov, and S. Levine (2022) RvS: What is essential for offline RL via supervised learning?. In Int. Conf. on Learning Representations, External Links: Link Cited by: §2. [6] R. Figueiredo Prudencio, M. R. Maximo, and E. L. Colombini (2024) A survey on offline reinforcement learning: Taxonomy, review, and open problems. IEEE Trans. on Neural Networks and Learning Systems 35 (8), p. 10237–10257. External Links: ISSN 2162-2388, Document Cited by: §2. [7] J. Hu, Y. Chang, and H. Wang (2026) A review of learning-based motion planning: Toward a data-driven optimal control approach. Transportation Research Part C: Emerging Technologies 190, p. 105767. External Links: ISSN 0968-090X, Document Cited by: §1, §2. [8] M. Janner, Q. Li, and S. Levine (2021) Offline reinforcement learning as one big sequence modeling problem. In Advances in NeurIPS, Vol. 34, p. 1273–1286. Cited by: §2. [9] S. Karaman and E. Frazzoli (2011) Sampling-based algorithms for optimal motion planning. The Int. Jour. of Robotics Research 30 (7), p. 846–894. External Links: ISSN 1741-3176, Document Cited by: §1, §2. [10] M. Krupa (2026) Self-supervised robotic trajectory planning with obstacle avoidance. Bachelor’s thesis, Comenius University Bratislava. Cited by: §3, §4, §4. [11] I. Loshchilov and F. Hutter (2019) Decoupled weight decay regularization. In Int. Conf. on Learning Representations, External Links: Link Cited by: §4. [12] M. Vavrečka, N. Sokovnin, M. Mejdrechová, and G. Šejnová (2021) MyGym: Modular toolkit for visuomotor robotic tasks. In 33rd Int. Conf. on Tools with AI (ICTAI), p. 279–283. External Links: Document Cited by: §4. [13] J. Xie, Z. Shao, Y. Li, Y. Guan, and J. Tan (2019) Deep reinforcement learning with optimized reward functions for robotic trajectory planning. IEEE Access 7, p. 105669–105679. External Links: ISSN 2169-3536, Document Cited by: §2.