Safe and efficient motion planning for autonomous systems using hamilton-jacobi reachability
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- CONTINENTAL AUTONOMOUS MOBILITY GERMANY GMBH
- Filing Date
- 2026-02-05
- Publication Date
- 2026-08-07
Smart Images
Figure CN122525885A_ABST
Abstract
Description
[0001] This invention relates to the field of autonomous systems, and more specifically, to a method for safe motion planning in dynamic and partially observable environments using Hamilton-Jacobi (HJ) reachability analysis enhanced by machine learning techniques.
[0002] Safe motion planning is a critical requirement for autonomous vehicles and robotic systems operating in real-world environments. A promising approach to ensuring safety is based on Hamiltonian-Jacobi (HJ) reachability analysis, which provides a formal framework for calculating the set of states under all permissible perturbations that allow the system to avoid unsafe conditions. Recent methods propose using neural networks to approximate the HJ value function, enabling it to be integrated as a constraint into optimization-based planners such as model predictive control (MPC) or safety filters.
[0003] One notable previous approach involved partitioning the neural network architecture into a supernetwork and a main network. The supernetwork processed local observations—typically in the form of a signed distance field (SDF) derived from an occupied grid map (OGM)—and generated parameters for the main network, which then approximated the residual of the HJ value function. This residual was constrained to be non-positive using a ReLU activation function, ensuring that the resulting value function was at least as conservative as the SDF. While this approach provides theoretical safety guarantees, it suffers from several practical limitations, including being overly conservative in occluded environments, infeasibility in critical scenes, and redundant computation in static scenes.
[0004] Besides HJ-based methods, other safe motion planning approaches include sampling-based algorithms such as Rapidly Explored Random Trees (RRT) and Probabilistic Roadmaps (PRM). These methods can be extended with safety constraints or risk-aware cost functions, but they often suffer from real-time performance difficulties and lack formal guarantees in dynamic or partially observable environments. Furthermore, their reliance on random sampling can lead to inconsistent behavior and makes them difficult to handle strict constraints or high-dimensional state spaces.
[0005] Another class of methods relies on control barrier functions (CBFs), which enforce safety by ensuring that the system's state remains within a predefined safety set. While CBFs are computationally efficient and can be integrated with arbitrary controllers, they typically require an explicit and differentiable representation of the safety set, which can be difficult to obtain in complex or uncertain environments. Furthermore, CBFs are often sensitive to modeling errors and sensor noise, which, if not properly considered, can lead to overly conservative or unsafe behavior.
[0006] Learning-based methods, such as reinforcement learning (RL) and imitation learning, have also been explored for motion planning under uncertainty. These methods can learn complex behaviors from data, but they often lack interpretability and formalized safety guarantees. Furthermore, RL-based planners require extensive training and may not generalize to novel or rare scenarios, especially in safety-critical applications. Hybrid approaches that combine learning with model-based planning attempt to address these issues, but challenges remain in integrating safety constraints in a principled and verifiable manner.
[0007] Finally, some recent studies have proposed using occupancy prediction or semantic scene understanding to improve planning in dynamic environments. While these methods can enhance situational awareness, they typically rely on deep learning models, which are difficult to verify and may produce unreliable outputs in extreme cases. Furthermore, they generally do not provide a direct mechanism for enforcing safety constraints during planning, making them unsuitable as standalone solutions for safety-critical systems.
[0008] This invention addresses these limitations by introducing a novel motion planning framework that enhances the safety of HJ-based reachability constraints through three key innovations: (1) a state-dependent relaxation function that allows controlled constraint relaxation in unknown or critical regions, enabling exploration and graceful degradation; (2) the use of time differences between consecutive SDFs to capture environmental dynamics and reduce redundant computation; and (3) a neural network architecture optimized for real-time execution on embedded systems, robust to sensor noise and incomplete data. These improvements collectively enable safer, more efficient, and more predictable motion planning in complex and dynamic environments.
[0009] According to one aspect of the present invention, a method for safe motion planning of an autonomous system is provided, the method comprising: obtaining an environment representation by a hypernetwork, the environment representation including one or more differences between consecutive signed range fields (SDFs) obtained at multiple time steps within a motion planning time range; generating parameters by the hypernetwork based on the environment representation; obtaining residuals of a Hamiltonian-Jacobi (HJ) value function by a main network based on the obtained parameters; applying an activation function to the residuals to obtain a corrected residual; determining an intermediate HJ value function by subtracting the corrected residual from a selected SDF corresponding to a current or future time step within the motion planning range; determining a final HJ value function by adding the intermediate HJ value function to a state-dependent relaxation function, wherein the relaxation function enables the autonomous system to explore environmental regions marked as unsafe due to unknown space, thereby reducing conservatism and improving navigation efficiency; and performing safe motion planning of the autonomous system using the determined final HJ value function.
[0010] The method disclosed herein uses a hypernetwork that receives an environment representation, the environment representation comprising one or more differences between consecutive signed distance fields (SDFs). The signed distance field (SDF) is a spatial representation of obstacle proximity derived from sensor data, such as an occupancy grid map. These differences are computed over multiple time steps within the motion planning scope, capturing temporal variations in the environment. The supernetwork, which can be a neural network, generates parameters for another network (the main network) based on this environmental representation. The main network then uses these parameters to compute the residuals of the Hamilton-Jacobi (HJ) value function, which represent a correction to the baseline safety estimate. An activation function—such as ReLU or leaky ReLU—is applied to the residuals to ensure they adhere to safety constraints, resulting in a corrected residual. This corrected residual is subtracted from a selected SDF (from the current or future time step) to obtain an intermediate HJ value function. A state-dependent relaxation function is then added to this intermediate value function to produce the final HJ value function; this relaxation function allows controlled relaxation of safety constraints in uncertain or occluded regions. Finally, the resulting HJ value function is used as a constraint in the motion planning process to ensure safe and efficient trajectory generation.
[0011] Each step of the method contributes to a cumulative technical effect that enhances the safety, efficiency, and real-time feasibility of autonomous motion planning. The use of SDF allows the system to focus on dynamic changes in the environment, thereby reducing redundant computation and improving responsiveness. The hypernetwork implements adaptive parameter generation tailored to the current environmental context, enabling generalization across various scenarios. By computing the residuals of the HJ value function, the main network refines the safety estimate, exceeding the capabilities of a static SDF. The activation function ensures that the residuals do not overestimate safety, maintaining conservative guarantees. Subtracting the residuals from the SDF yields a safety function that is both data-driven and based on reachability theory. Adding a relaxation function introduces flexibility, allowing the system to explore unknown regions or handle infeasibility in a predictable manner without sudden or unsafe behavior. Finally, the value function is used in the motion planner to ensure that all generated trajectories adhere to learned safety boundaries, enabling real-time, constraint-aware navigation in complex and partially observable environments.
[0012] In an embodiment, the one or more signed distance fields (SDFs) may be derived from an occupancy grid map (OGM) generated by onboard sensors, such as lidar, radar, or stereo cameras. The OGM provides binary or probabilistic representations of occupancy and free space, which are converted into continuous SDFs using a distance transform or a learned mapping. This allows the system to utilize standard sensing outputs while producing a smooth, differentiable spatial representation suitable for neural network processing and security analysis.
[0013] In an embodiment, the two consecutive SDFs used to calculate the difference can be obtained for the current time step and the previous time step, or for the current time step and the next time step. This flexibility allows the system to operate in both reactive and predictive modes, enabling it to respond to recent changes or anticipate future environmental dynamics, depending on planning strategies and available sensor or predictive data.
[0014] In an embodiment, the environment representation may include a sequence of differences between consecutive SDFs at multiple time steps, and the hypernetwork may be configured to process this sequence to ensure the temporal consistency of the learned parameters or the resulting HJ value function. This allows the system to capture trends and motion patterns of the environment, thereby improving the stability and consistency of safety constraints applied throughout the planning scope.
[0015] In this embodiment, temporal consistency within the planning scope is enforced by training a supernetwork to minimize a temporal smoothing loss that penalizes sudden changes in predicted parameters or value functions between time steps. This regularization causes the network to produce stable outputs over time, reducing jitter in safety constraints and improving the reliability of the resulting motion plan.
[0016] In this embodiment, the final HJ value function (determined using one or more SDFs from the motion planning time range) can be used as a terminal constraint in the model predictive control (MPC) framework. The terminal constraint ensures that the final state of the planned trajectory lies within the safe region defined by the value function, thereby enforcing long-term safety guarantees during optimization-based control.
[0017] In this embodiment, the terminal state of the MPC optimization problem can be constrained to lie within a safe set defined by the final HJ value function, where the safe set includes all states where the value function is non-negative. This constraint ensures that the system is in a sustainably safe state at the end of each planning cycle, thereby supporting recursive feasibility and robust control.
[0018] In this embodiment, the final HJ value function can be used as a control barrier function (CBF) in a safety filter that operates in conjunction with a performance controller. The CBF ensures that the system state remains within a safe set by modifying the control input only when necessary, thereby enabling safety to be enforced without significantly impacting performance.
[0019] In an embodiment, the safety filter can modify the control inputs proposed by the performance controller to ensure they remain within the safety set defined by the HJ value function. This modification is likely minimal and computed using optimization techniques, allowing the system to maintain safety while preserving the intent of the original control strategy.
[0020] In an embodiment, a safety filter can project potentially unsafe control inputs onto a safe action space, defined as the control inputs that ensure the system's state remains within a safe set. This projection can be computed using convex optimization or learned mappings, ensuring that the system adheres to safety constraints even in the presence of aggressive or suboptimal control schemes.
[0021] In embodiments, state-dependent relaxation functions can be determined using at least one of the following methods: analyzing sensor data to assess environmental uncertainty; utilizing a machine learning model trained on historical navigation data; calculating the potential kinetic energy of a collision and assigning higher relaxation values to states with lower damage; integrating relaxation variables into an MPC framework to dynamically relax constraints; and applying heuristics based on proximity to obstacles and incentivizing exploration. These methods allow the relaxation function to adaptively relax safety constraints in uncertain or low-risk areas, thereby improving flexibility and efficiency.
[0022] In embodiments, relaxation functions can be used to achieve predictable behavior in infeasible scenarios by selecting states that minimize potential damage. When no completely safe trajectory exists, relaxation functions allow the system to prioritize unsafe options and select the least harmful one, thereby supporting graceful degradation and enhancing the system's ability to handle emergencies.
[0023] In this embodiment, the autonomous system can skip computations for states with zero SDF increments and reuse previously computed values of the HJ value function for those states. This optimization reduces redundant computations, saves processing resources, and improves real-time performance, especially in static or slowly changing environments.
[0024] In this embodiment, the supernetwork and main network can be configured to execute in real time on embedded or edge hardware of an autonomous system, and the supernetwork architecture can reduce computational overhead by reusing shared features between time steps. This design supports deployment on resource-constrained platforms while maintaining responsiveness and adaptability.
[0025] In embodiments, one or more SDFs or OGMs may include noisy or incomplete observation data, and the supernetwork or main network is trained to be robust to such noise using at least one of the following methods: data augmentation using corrupted or missing sensor data; uncertainty-aware loss functions; Dropout or Bayesian inference; and filtering or smoothing of the input map. These techniques improve the reliability of the system under real-world conditions where sensor defects are common.
[0026] In embodiments, the supernetwork and / or main network can be trained using supervised, unsupervised, or reinforcement learning techniques based on simulated or real-world navigation data, and deployment can include exporting the trained model parameters to an embedded runtime optimized for real-time motion planning. This training and deployment pipeline enables the system to learn from diverse experiences and operate efficiently in production environments.
[0027] In this embodiment, the activation function applied to the residual can be a leaky rectified linear unit (Leaky ReLU), thereby reducing the conservatism of the resulting HJ value function. Unlike standard ReLU, leaky ReLU allows small negative values to pass through, achieving smoother corrections and finer safety boundaries, especially in low-risk or uncertain regions.
[0028] According to another aspect of this disclosure, a computer program is provided that includes instructions that, when executed by a computer, cause the computer to perform any of the methods disclosed herein.
[0029] According to another aspect of this disclosure, a computer-readable data carrier is provided having the computer program disclosed herein stored thereon.
[0030] According to another aspect of this disclosure, an apparatus is provided, the apparatus comprising: one or more interfaces for communication; a memory; and data processing circuitry configured to implement any of the methods disclosed herein.
[0031] The example will now be described further with reference to the accompanying drawings, in which: Figure 1 The diagram shown is a flowchart illustrating a computer implementation method 100 for safe motion planning of an autonomous system; Figure 2 The diagram shown is an embodiment of a system for implementing the methods disclosed herein; and Figure 3 A block diagram schematically illustrates an embodiment of an apparatus for performing the methods described herein. Detailed Implementation
[0032] This invention provides a method and system for safe and efficient motion planning of autonomous systems (such as self-driving vehicles or mobile robots) operating in dynamic, uncertain, and partially observable environments. The invention is based on the theoretical foundation of Hamiltonian-Jacobi (HJ) reachability analysis, which is widely recognized for its ability to characterize the set of states that a system can avoid unsafe conditions under worst-case perturbations. However, unlike traditional computationally intensive HJ methods that are difficult to scale to real-time applications, this invention utilizes machine learning techniques to approximate the HJ value function in a way that is both computationally tractable and adaptable to real-world conditions.
[0033] The system architecture comprises two main neural network components: a supernetwork and a main network. The supernetwork is designed to process environmental observation data and generate parameters that define the structure or weights of the main network. In turn, the main network is responsible for approximating the residuals of the HJ value function, which are used to define the safety constraints for motion planning. This modular architecture allows the system to dynamically adapt to changes in the environment while maintaining a consistent safety framework.
[0034] Environmental observation data is represented in the form of signed distance fields (SDFs), which are derived from occupied grid maps (OGMs) or other sensor-based representations of the local environment. These SDFs are computed over multiple time steps within a predefined motion planning range. To capture temporal dynamics and reduce redundant computations, the system computes the differences between consecutive SDFs, referred to as... SDF. These differences highlight changes in the environment over time and serve as input to the hypernetwork. In scenarios where the environment remains static or changes slowly, many The SDF value is zero, which allows the system to bypass unnecessary calculations by reusing previously cached outputs.
[0035] Received Following the SDF sequence, the supernetwork processes the data and outputs a set of parameters for configuring the main network. The main network then computes a residual function, denoted as R(x), which estimates the deviation between the SDF and the true HJ value function. To ensure the resulting value function remains conservative and does not overestimate safety, the residual is passed through a non-positive activation function, such as a rectified linear unit (ReLU) or a leaky ReLU. This produces a corrected residual, which, when subtracted from the selected SDF—typically corresponding to the current or future time step within the planning range—results in an intermediate HJ value function.
[0036] Furthermore, to address the inherent conservatism of traditional HJ-based methods, especially in the presence of occlusion or unknown regions, this invention introduces a novel state-dependent relaxation function, denoted as s(x). This relaxation function is added to the intermediate HJ value function to produce the final value function for planning. The relaxation amount is constrained to be non-negative and does not exceed a predefined maximum value. It is selectively activated in regions estimated to be unsafe due to lack of information or in critical scenarios where no completely safe trajectory exists. The relaxation value can be determined using various strategies, including analyzing sensor uncertainties, predictions from machine learning models trained on historical navigation data, or heuristics based on the potential collision severity (such as kinetic energy estimation).
[0037] The final HJ value function, incorporating both the corrected residuals and the relaxation term, is then used as a safety constraint in the optimization-based motion planner. This constraint can be applied in several ways. In one embodiment, the value function serves as a terminal constraint within a model predictive control (MPC) framework, ensuring that the terminal state of the planned trajectory lies within a safety set defined by the value function. In another embodiment, the value function serves as a control barrier function (CBF) within a safety filter that modifies the control input proposed by the performance controller to ensure the system remains within the safety set. In both cases, the system allows controlled relaxation in uncertain or critical situations while maintaining safety.
[0038] This invention is also designed to execute in real time on embedded or edge computing platforms commonly used in autonomous systems. SDF enables event-triggered computation, which significantly reduces processing overhead in static or slowly changing environments. Furthermore, training the neural network using data augmentation, uncertainty-aware loss functions, Dropout, and filtering techniques makes it robust to noise and incomplete data. This ensures reliable performance even in the presence of sensor defects or environmental changes.
[0039] In summary, this invention provides a robust, efficient, and adaptable framework for safe motion planning in autonomous systems. By combining HJ reachability theory with neural network approximation, temporal scene understanding, and constraint relaxation based on relaxation quantities, this invention overcomes key limitations of existing technologies and enables practical deployment in complex real-world environments.
[0040] Figure 1 The diagram shows a flowchart illustrating a computer implementation method 100 for safe motion planning of an autonomous system. Figure 2 The diagram shown is a schematic representation of an embodiment of a system for implementing method 100.
[0041] Step 110 of method 100 includes obtaining an environment representation from a supernetwork, the environment representation comprising one or more differences between consecutive signed distance fields SDF obtained at multiple time steps within the motion planning time range.
[0042] In this step, the system acquires an environmental representation that encodes the temporal variations of the autonomous system's local environment. This representation is derived by calculating the difference between signed distance fields (SDFs) generated at different time steps. The SDF itself is a spatial representation that encodes the distance from each point in the environment to the nearest obstacle, where the sign indicates whether the point is inside (negative) or outside (positive) the obstacle.
[0043] The difference between consecutive SDFs -- is called SDF – Captures how the environment evolves over time. These differences are used as input to a hypernetwork, a neural network architecture configured to generate parameters for another neural network (the main network) based on contextual inputs. The use of SDF allows the system to pay attention to dynamic changes in the environment, thereby improving computational efficiency and responsiveness.
[0044] In embodiments, the term "hypernetwork" can refer to any neural network or parametric model that generates weights, parameters, or configuration data for another model (e.g., the main network). In alternative embodiments, the hypernetwork can be implemented as a recurrent neural network (RNN), a Transformer, or other context-aware architecture.
[0045] The term "environment representation" can encompass any data structure, tensor, or feature map derived from sensor data, including but not limited to differences between SDFs. In some embodiments, the environment representation may also include the raw SDF, occupancy grid map (OGM), semantic map, or uncertainty map.
[0046] The phrase "one or more differences between consecutive SDFs" is intended to cover a single SDF (e.g., between time step t and t-1) and calculated within a certain time range SDF sequences (e.g., ΔSDF(t), ΔSDF(t-1), ...) both. This allows for both instantaneous and time-stretched representations.
[0047] The term "motion planning time range" refers to a finite sequence of future time steps in which an autonomous system plans its trajectory. In some embodiments, this may correspond to a fixed number of steps (e.g., 5-10) or a variable length range determined by system constraints or environmental complexity.
[0048] The term “acquire” can include computation, retrieval from memory, reception from sensors or external modules, or generation via a preprocessing pipeline.
[0049] As a non-limiting example, consider an autonomous vehicle driving in an urban environment. At time step t-1, the vehicle's sensors generate a Special Data Form (SDF) representing the local environment, which includes static obstacles such as parked cars and buildings. At time step t, a pedestrian enters the scene, and a new SDF is generated. The system calculates the difference between the two SDFs to produce a result highlighting the pedestrian's presence. SDF. Then, the The SDF is passed to the supernetwork, which uses it to generate parameters for the main network, which then calculates the safety constraints for motion planning.
[0050] Step 120 of method 100 includes generating parameters from the hypernetwork based on the environment representation. In this step, the hypernetwork processes the environment representation obtained in step 110—typically including one or more... SDF—and generates a set of parameters. These parameters are used to configure or tune the main network, which then computes the residuals of the HJ value function. The supernetwork essentially acts as a context-aware model, adjusting the behavior of the main network based on current environmental conditions.
[0051] The term "parameter" can refer to weights, biases, feature embeddings, or any other numerical value that defines the behavior of the main network. In some embodiments, the parameters may be used to initialize the main network, while in other embodiments, they may be used to modulate intermediate layers or the output.
[0052] The phrase "generate parameters" can include direct computation, transformation, or inference using learned functions. In an alternative embodiment, the hypernetwork can output a latent representation, which is decoded into parameters by a separate module.
[0053] The term "context-based representation" can include direct dependencies (e.g., via feedforward computation) and / or indirect dependencies (e.g., via attention mechanisms or memory modules).
[0054] For example, a supernetwork can receive a sequence of SDF tensors representing changes in the environment over the past five time steps. It processes this sequence using a convolutional or recurrent architecture and outputs a set of weight matrices that define the layers of the main network. These weights are customized based on the current environmental context, such as the presence of moving obstacles or occluded regions.
[0055] Step 130 of method 100 includes obtaining the residual of the Hamilton-Jacobi HJ value function by the main network based on the obtained parameters. In this step, the main network uses parameters generated by the supernetwork to compute the residual function, which approximates the difference between the baseline safety metric (e.g., SDF) and the true HJ value function. The residual captures the correction needed to align the baseline with a more accurate, theoretically sound HJ value.
[0056] The term "residual" refers to a learned correction term, which, when subtracted from the SDF, yields an approximation of the HJ value function. In some embodiments, the residual can be interpreted as a risk or cost adjustment. The phrase "obtaining the residual" can include directly computing the residual via forward propagation through the main network, or retrieving the residual from a pre-computed cache if the environment remains unchanged. The term "based on the obtained parameters" includes static initialization and dynamic modulation of the main network using the output of the supernetwork.
[0057] As an example, the main network can be a fully connected neural network, whose weights are generated by the supernetwork in step 120. It receives a state vector x as input and outputs a scalar residual R(x), which represents the deviation between the SDF and the HJ value function in that state. The residual is then used to refine the security constraints.
[0058] Step 140 of method 100 involves applying an activation function to the residuals to obtain corrected residuals. This step ensures that the residuals output by the main network meet safety constraints. Specifically, the activation function forces the residuals to be non-positive, thereby ensuring that the resulting HJ value function does not overestimate safety. This helps maintain conservative safety guarantees.
[0059] The term "activation function" can include a rectified linear unit (ReLU), a leaky ReLU, or any other function that enforces a non-negative or bounded output. In some embodiments, a softplus or sigmoid function may be used to allow for a smoother transition. The phrase "corrected residual" refers to the output of the activation function applied to the original residual. This ensures that the residual cannot increase the safety level of the estimate beyond what the SDF allows. The term "application" can include element-wise application, batch processing, or integration into a larger computation graph.
[0060] For example, if the main network output residual R(x) = 0.3, applying the ReLU activation function will result in ReLU(R(x)) = 0.3, which will be subtracted from the SDF. If ReLU with leakage is used, the negative value will be preserved with a small slope, allowing for finer correction (i.e., advantageously relaxing conservatism) while still maintaining safety.
[0061] Step 150 of method 100 includes determining an intermediate HJ value function by subtracting the corrected residual from a selected SDF corresponding to a current or future time step within the motion planning scope. In this step, the system calculates an intermediate approximation of the HJ value function by subtracting the corrected residual—obtained in step 140—from the selected SDF. Depending on the planning strategy and prediction model, the selected SDF may correspond to a current or future time step within the motion planning scope. This subtraction operation uses the learned correction (i.e., residual) to adjust the baseline safety estimate (i.e., SDF), resulting in a more accurate and context-aware safety function.
[0062] This intermediate value function represents a preserve-of-the-reach safety set, taking into account both the known environmental geometry and the learned safety margin. It serves as the basis for further refinement in step 160.
[0063] The term "intermediate HJ value function" refers to the initial safety function that has not yet been incorporated into the relaxation based on the slack quantity. It can be used for diagnostic, visualization, or rollback purposes. The phrase "selected SDF" is intended to include any SDF selected from a set of available SDFs within the planning scope. In some embodiments, the SDF may be selected based on its temporal proximity, predictive relevance, or confidence level. Subtraction operations can be implemented as element-wise tensor operations, scalar subtraction for individual states, or symbolic operations within the optimization framework.
[0064] For example, suppose the system selects an SDF corresponding to time step t+1, where the SDF represents the prediction environment for the next step. The intermediate HJ value function V is obtained by subtracting the corrected residual ReLU(R(x)) or the leaky ReLU(R(x)) from this SDF. intermediate (x) = SDF t+1 (x) - Leaky ReLU(R(x)). Then use this function to evaluate whether a given state x is within a conservative safe set.
[0065] Step 160 of method 100 includes determining the final HJ value function by adding an intermediate HJ value function to a state-dependent relaxation function, wherein the relaxation function enables the autonomous system to explore environmental regions marked as unsafe due to unknown space, thereby reducing conservatism and improving navigation efficiency.
[0066] This step introduces the integration of a state-dependent relaxation function into the HJ value function. The relaxation function s(x) is added to the intermediate value function to produce the final HJ value function V(x). This addition allows the system to relax safety constraints in a controlled and interpretable manner, especially in regions where the environment is unknown or partially observed.
[0067] The relaxation function is designed to be non-negative and bounded such that 0 ≤ s(x) ≤ smax. It is selectively activated in states estimated to be unsafe due to lack of information (e.g., occlusion, sensor blind spots) or in critical scenarios where no perfectly safe trajectory exists. The relaxation function can be computed using sensor uncertainty metrics, machine learning models trained on historical data, or heuristics based on proximity to obstacles or the severity of potential collisions.
[0068] The term "state-dependent relaxation function" refers to a function that assigns relaxation values to each state x in the planning space. In some embodiments, the relaxation function can be learned, pre-computed, or dynamically adjusted during planning. The phrase "supporting exploration" is intended to include both physical exploration (e.g., entering unknown regions) and computational exploration (e.g., considering otherwise infeasible trajectories). Relaxation functions can be integrated into the optimization problem as soft constraints, penalty terms, or auxiliary variables.
[0069] As an illustrative example, consider a vehicle following a large truck that is obstructing the oncoming lane. An intermediate HJ value function might classify the obstructed area as unsafe. However, a relaxation function assigns small positive values to the state within the obstructed area, allowing the planner to consider overtaking maneuvers while other safety metrics (e.g., predicted collision energy) remain within acceptable limits. The final HJ value function becomes: V(x) = SDF(x) - ReLU(R(x)) + s(x) 。 This mathematical formulation enables vehicles to make informed and efficient decisions without compromising safety.
[0070] In one embodiment of the invention, a leaky rectified linear unit (Leaky ReLU) is used instead of the standard ReLU to compute the intermediate HJ value function. The leaky ReLU activation function allows small negative values to pass through, rather than setting them all to zero. This produces a corrected residual that retains some gradient information even in regions where the residual is negative, resulting in a smoother and finer correction of the SDF.
[0071] On the other hand, the relaxation function s(x) is a non-negative, state-dependent term added to the intermediate value function. It is selectively activated in regions with high uncertainty or in critical scenarios where no perfectly safe trajectory exists. The relaxation function effectively relaxes safety constraints, allowing the planner to consider trajectories that would otherwise be excluded due to conservatism.
[0072] When used together, leaked ReLU and relaxation functions provide complementary mechanisms for improving the flexibility and responsiveness of safety constraints: leaked ReLU allows for soft violations of safety margins in residual representations, thus preserving gradient flow and enabling more stable learning and inference. Relaxation functions provide a structured and bounded way to loosen the conservatism of value functions in specific regions of high uncertainty.
[0073] Consider an autonomous vehicle driving on a narrow city street lined with parked cars on both sides. A pedestrian is partially obscured by a truck, and the SDF derived from sensor data marks the obscured area as unsafe. The main network output residual R(x) = -0.2, indicating a slight correction toward safety. Applying a leaky ReLU with a small negative slope (e.g., 0.01) results in a corrected residual of -0.002 instead of zero. This allows the intermediate value function to reflect soft unsafe states rather than hard boundaries.
[0074] Meanwhile, the relaxation function assigns a small positive value s(x) = 0.05 to the occluded region based on an uncertainty index or prior knowledge. The final HJ value function becomes: V(x) = SDF(x) - LeakyReLU(R(x)) + s(x) 。 This mathematical expression allows the planner to cautiously explore occluded areas when needed, while still adhering to the underlying safety structure.
[0075] The final Hamilton-Jacobi (HJ) value function V(x) can be calculated as: V(x) = SDF(x) - ReLU(R(x)) + s(x) ， Where: SDF(x) is the state x x The signed distance field value represents the baseline geometric safety margin; R(x) is the residual predicted by the main neural network, which corrects the SDF to better approximate the true HJ value function; ReLU(R(x)) ensures that the residual is non-positive, thus preserving conservatism; and s(x) is the state-dependent relaxation function, which is explicitly computed and bounded such that 0 ≤ s(x) ≤ smax.
[0076] The relaxation function s(x) can be implemented using one or more of the following specific mechanisms: 1) Sensor-based uncertainty estimation: The system calculates a local uncertainty index (e.g., entropy of occupancy probability, occlusion probability) based on sensor data. If the uncertainty exceeds a threshold, then x is... x 1) Assign a positive relaxation value, which scales proportionally to the uncertainty. 2) Learned relaxation prediction: A neural network module trained on historical navigation data predicts s(x) based on features such as visibility, proximity to occlusions, or previous successes in similar scenarios. s ( x3) Heuristic or Physics-Based Models: In critical scenarios, relaxation values are calculated based on estimated collision severity (e.g., momentum). States expected to suffer less damage are assigned higher relaxation values to allow the planner to prioritize them. 4) MPC Integrated Relaxation Optimization: In a Model Predictive Control (MPC) framework, s(x) s ( x ) is considered a penalized decision variable in the cost function. The optimizer selects the slack value that relaxes the constraint to the minimum extent while preserving feasibility.
[0077] In the intermediate value function V intermediate The relaxation function can be activated in regions where s(x) = SDF(x) - ReLU(R(x)) is negative due to unknown or occluded spaces. This can be achieved using gating conditions: s(x) = {f(x), if V intermediate (x)<0 and x∈unknown region&f(x) = 0 otherwise}, where f(x) is a bounded function derived from one of the above mechanisms.
[0078] This implementation allows the system to systematically and predictably relax safety constraints in areas of unknown environment—not arbitrarily, but based on quantifiable uncertainty or learned prior knowledge. It enables the planner to explore occluded or partially observable areas when necessary, thereby improving navigation efficiency and avoiding overly conservative behavior. Simultaneously, limits and penalties are imposed on the relaxation amount to ensure that the impact on safety does not exceed acceptable limits.
[0079] Step 170 of method 100 includes performing safe motion planning for the autonomous system using the determined final HJ value function. In this step, the computed HJ value function—now incorporating the learned residuals and relaxations based on slack—is used as a constraint in the motion planning process. The value function defines a set of safe states, typically safe states where V(x) ≥ 0, and the planner is configured to generate trajectories that remain within this set.
[0080] The final HJ value function can be used in various planning frameworks. In one embodiment, it acts as a terminal constraint in the mathematical formulation of Model Predictive Control (MPC), ensuring that the terminal state of the planned trajectory lies within a safe set. In another embodiment, it serves as a control barrier function (CBF) within a safety filter that modifies the control input proposed by the performance controller to maintain safety.
[0081] The term "use" can include enforcing the value function as a hard constraint, incorporating it as a soft constraint with a penalty term, or using it to guide sampling or optimization. The phrase "safe motion planning" covers trajectory generation, control input selection, and real-time replanning in response to environmental changes. The value function can be used in conjunction with other objectives, such as minimizing energy, time, or deviation from a reference path.
[0082] For example, in the MPC framework, the planner solves the optimization problem within a finite range, satisfying dynamic constraints and terminal constraints V(xT)≥0, where xT is the terminal state. This ensures that the vehicle remains within the safe set at the end of the planning range, while the relaxation function allows for adaptive relaxation in uncertain regions.
[0083] In one embodiment, one or more SDFs can be derived from an occupancy grid map (OGM) obtained from onboard sensors. The OGM can represent binary or probabilistic occupancy information of the environment, which is then transformed into a continuous SDF encoded with signed distances to the nearest obstacle. This transformation can be performed using an Euclidean distance transform or a learned mapping function.
[0084] In this embodiment, the OGM can be generated based on multi-sensor data from LiDAR, radar, stereo vision, or fusion. The SDF can be calculated in real time or retrieved from a pre-processed map cache. This allows the system to utilize standard perception pipelines while producing smooth, differentiable representations suitable for neural network processing and optimization-based planning.
[0085] In this embodiment, the two consecutive SDFs can be obtained for the current time step and the previous time step, or for the current time step and the next time step. The pairing of the current time step and the subsequent time step can depend on whether the system is performing retrospective analysis or predictive planning.
[0086] The “current” time step can refer to the current planning iteration, while the “previous” or “next” step can be defined relative to the control loop or sensor update rate. In predictive settings, subsequent SDFs can be generated using learned or model-based predictive modules. This flexibility allows the system to adapt to reactive and forward-looking planning strategies, thereby improving responsiveness and predictability in dynamic environments.
[0087] In an embodiment, the environment representation may include a sequence of differences between consecutive SDFs at multiple time steps, and the supernetwork may be configured to process the sequence to ensure temporal consistency of the learned parameters or the resulting HJ value function. The sequence may be processed using a temporal model such as a recurrent neural network (RNN), temporal convolution, or attention-based mechanisms.
[0088] Temporal consistency can refer to the smoothness of the parameter space, the stability of the value function, or the continuity of the resulting control strategy. Depending on the computational constraints and the planning scope, the sequence can be of fixed or variable length. This enhances the robustness and stability of the system by reducing abrupt changes in safety constraints over time, thereby improving trajectory smoothness and control reliability.
[0089] In one embodiment, the final HJ value function (determined using one or more SDFs from the motion planning time range) can be used as a terminal constraint in the Model Predictive Control (MPC) framework. The terminal constraint can be applied at the last time step of the planning range to ensure that the predicted terminal state lies within a region considered safe according to the value function. In an alternative embodiment, the terminal constraint can be applied at intermediate time steps or across multiple time steps to enforce an asymptotic safety margin.
[0090] The final HJ value function can be incorporated into the MPC mathematical formulation as a hard constraint, a soft constraint with a penalty term, or as part of a constraint relaxation scheme. The MPC framework can be linear, nonlinear, stochastic, or robust, and can operate in discrete or continuous time. The value function can be evaluated directly or approximated using surrogate models or lookup tables.
[0091] In this embodiment, the terminal state of the MPC optimization problem can be constrained to lie within a safe set defined by the final HJ value function. The safe set can be defined as a value function that is positive V(x) ≥ 0 or... (in Let x be the set of all states x (with a small positive threshold). Constraints can be enforced using inequality constraints from the optimization problem or through barrier or penalty functions.
[0092] In some embodiments, the safety set can be defined in a transformed or projected state space (such as a reduced-order model or a latent space learned by a neural network). Probabilistic constraints can also be applied to the terminal state such that the probability of violating the safety set is below a specified threshold. These constraints can be adaptive, tightening or loosening based on environmental uncertainty or task urgency.
[0093] In this embodiment, the final HJ value function can be used as the control barrier function CBF in the safety filter. CBF can be defined such that the time derivative of the value function along the system dynamics is constrained to be non-negative, thereby ensuring the forward invariance of the safety set. The safety filter can operate in parallel with the nominal controller or performance controller, modifying its output only when necessary to maintain safety.
[0094] CBF can be implemented using quadratic programming, linear programming, or other constrained optimization techniques. In alternative embodiments, neural networks or other function approximators can be used to approximate CBF. The security filter can be centralized or distributed and can operate at a different frequency than the main controller.
[0095] In an embodiment, the safety filter can modify the control inputs proposed by the performance controller to ensure they remain within a safety set defined by the HJ value function. The modification may be small in norm (e.g., least-squares deviation), or may prioritize certain control dimensions over others. The filter can operate in real-time, allowing the safety to be evaluated using current state estimates and predicted trajectories.
[0096] The performance controller can be a trajectory tracking controller, a reinforcement learning policy, a rule-based system, or any other control policy. The safety filter can override, fuse, or gate the output of the performance controller. In some embodiments, the filter may include a prediction module to anticipate future violations and take proactive action.
[0097] In an embodiment, a safety filter can project potentially unsafe control inputs onto a safe action space, defined as the control inputs that ensure the system's state remains within a safe set. The projection can be computed using convex optimization, sampling-based methods, or learned mappings. The safe action space can be explicitly defined using constraints derived from the HJ value function, or implicitly defined using a classifier or feasibility oracle.
[0098] Projection can be performed in a control input space, a state control space, or a higher-dimensional augmented space. In some embodiments, projection can be approximate, using heuristics or iterative refinement. The safety action space can be dynamically updated based on environmental changes, system dynamics, or mission objectives.
[0099] In an embodiment, the state-related relaxation function can be determined using at least one of the following methods: analyzing sensor data to assess environmental uncertainty; utilizing a machine learning model trained on historical navigation data; calculating the potential kinetic energy of a collision and assigning higher relaxation values to states with lower damage; integrating relaxation variables into an MPC framework to dynamically relax constraints; and applying heuristics based on proximity to obstacles to incentivize exploration. In another embodiment, the relaxation function can be used to achieve predictable behavior in infeasible scenarios by selecting states that minimize potential damage.
[0100] In embodiments, one or more techniques for assessing environmental uncertainty, contextual risk, or task-specific priorities can be used to determine state-dependent relaxation functions. The relaxation function s(x) is defined on the system's state space and assigns a non-negative scalar value to each state x, which is then used to relax security constraints defined by a Hamilton-Jacobi (HJ) value function. The relaxation function can be computed online or offline and can be static, adaptive, or learning-based.
[0101] In one embodiment, the relaxation function can be derived by analyzing raw or processed sensor data to estimate the level of uncertainty in the environment. This can include evaluating sensor coverage, occlusion maps, signal-to-noise ratio, or confidence scores from the sensing modules. For example, areas outside the field of view of a LiDAR or camera sensor may be assigned higher relaxation values due to a lack of visibility. Alternative implementations may include using entropy or variance from an occupancy grid map to calculate visibility gradients or occlusion probabilities, and / or aggregating uncertainty metrics from multiple sensor modalities.
[0102] In one embodiment, a machine learning model—such as a neural network, decision number, or Gaussian process—is trained based on historical navigation data to predict the region where relaxation should be applied. The model can learn from prior experience in similar environments, identifying patterns in constraint relaxation to achieve successful or safe outcomes. Alternative approaches may include: supervised learning using labeled safe / unsafe regions, reinforcement learning using the relaxation amount as a policy variable, and transfer learning from a simulated to a real-world domain.
[0103] In some embodiments, the relaxation function can be calculated based on the estimated kinetic energy of a potential collision. States associated with lower potential damage (e.g., low-velocity impacts or edge-grabbing collisions) can be assigned higher relaxation values, allowing the system to prioritize these states in infeasible scenarios. Alternative approaches may include using relative velocity and mass to estimate impact severity, using crashworthiness maps or damage risk models, and incorporating terrain or obstacle compliance into damage estimation.
[0104] In another embodiment, the relaxation function can be directly integrated into the model predictive control (MPC) framework as a decision variable. The MPC optimization problem can include the relaxation amount as a soft constraint, with a penalty term in the cost function to suppress over-relaxation. This allows the planner to weigh safety margins against performance objectives in a principled manner. Alternative mathematical formulations can include time-varying relaxation curves, state-dependent relaxation boundaries, and coupling relaxation with control effort or trajectory smoothness.
[0105] In other embodiments, the relaxation function can be determined using heuristic rules based on the system's proximity to known obstacles or boundaries. For example, the relaxation amount can be increased in areas near occluded intersections or blind spots to encourage cautious exploration. Alternative heuristics may include: distance thresholds to obstacles; directional visual cones; and risk maps generated from semantic scene understanding.
[0106] In embodiments, relaxation functions can be used to achieve predictable behavior in infeasible scenarios by selecting states that minimize potential damage. When all candidate trajectories violate safety constraints (i.e., the HJ value function for all future states is negative), relaxation functions allow the system to prioritize and select these states based on secondary criteria such as minimum impact energy, escape feasibility, or consistency with human driving norms. Alternative strategies may include: prioritizing states with lower relaxation costs; using relaxation-weighted risk metrics; and defining a backoff strategy based on a relaxation-enhanced feasibility score.
[0107] As an illustrative example, consider an autonomous vehicle traveling on a rural road when an animal suddenly crosses its path. All currently available trajectories could potentially lead to a collision. The system uses a relaxation function that assigns higher values to states corresponding to steering on a soft shoulder (low damage) and lower values to states involving a head-on collision with a tree (high damage). The planner selects the trajectory with the lowest relaxation amount and total cost of control effort, resulting in a controlled avoidance maneuver.
[0108] In this embodiment, the autonomous system can skip computations for states with zero SDF increments and reuse previously computed values of the HJ value function for those states, thereby reducing redundant computations and improving real-time performance. This optimization reduces redundant computations and improves real-time performance, especially in static or slowly changing environments.
[0109] Alternative implementations may include: caching the HJ value function output in a state-indexed lookup table; using a binary mask to identify unchanged regions and bypass neural network inference; and / or employing a change detection module to only detect changes when they occur. An update is triggered only when the SDF exceeds a threshold.
[0110] For example, on a highway with no obstacles nearby, the SDF remains constant between time steps. The system detects zero. SDF also reuses the previous HJ value function for those regions, thus avoiding unnecessary calculations.
[0111] In embodiments, the supernetwork and the main network can be configured to execute in real time on embedded or edge hardware of an autonomous system, and the supernetwork structure reduces computational overhead by reusing shared features between time steps. The supernetwork can be structured to reduce computational overhead by reusing shared features between time steps (such as through time weight sharing, feature caching, or incremental updates).
[0112] Alternative solutions may include: using lightweight architectures (e.g., MobileNet, TinyML models), quantizing model weights for efficient inference, and deploying the network on specialized hardware (such as GPUs, TPUs, or FPGAs).
[0113] For example, vehicles equipped with embedded processors can use cached features from previous frames to run hypernetworks, thereby reducing latency and enabling real-time planning.
[0114] In embodiments, one or more SDFs or OGMs may include noisy or incomplete observation data, and the supernetwork or main network is trained to be robust to such noise using at least one of the following methods: data augmentation using corrupted or missing sensor data; uncertainty-aware loss function; Dropout or Bayesian inference; and filtering or smoothing of the input map. Robustness can be achieved using at least one of the following methods: data augmentation using corrupted or missing sensor data; uncertainty-aware loss function penalizing overconfidence; Dropout or Bayesian inference for modeling uncertainty; and filtering or smoothing of the input map to reduce spurious values.
[0115] Alternative techniques may include: training with synthetic noise models or domain randomization, averaging predictions using ensemble models, and / or incorporating sensor fusion to mitigate the limitations of individual sensors. For example, foggy conditions may lead to partial loss of LiDAR data. After training with Dropout augmented data and uncertainty-aware loss, the system maintains stable HJ value function estimates despite incomplete input.
[0116] In embodiments, the supernetwork and / or main network can be trained using supervised, unsupervised, or reinforcement learning techniques based on simulated or real-world navigation data, and deployment includes exporting the trained model parameters to an embedded runtime optimized for real-time motion planning. Alternative training strategies may include: supervised learning using labeled safe / unsafe regions, unsupervised learning using autoencoders or contrastive targets, and reinforcement learning combined with safety-aware reward shaping. Deployment alternatives may include: using edge-optimized runtimes (such as TensorFlow Lite or PyTorchMobile) integrated with a real-time operating system (RTOS) for deterministic execution. For example, a model trained using reinforcement learning in a simulation can be exported to the TensorRT runtime and deployed on an NVIDIA Jetson module for real-time planning in a delivery robot.
[0117] In one embodiment, temporal consistency within the planning scope can be enforced by training the supernetwork to minimize a temporal smoothing loss that penalizes abrupt changes in the predicted parameters or the resulting Hamilton-Jacobi (HJ) value function between time steps. This loss function can be applied during training to promote the continuity of the supernetwork's output, thereby producing more stable and predictable behavior during inference.
[0118] Alternative implementations may include: penalizing the L2 norm of the differences between parameters generated in consecutive time steps; applying smoothing regularization to the output of the main network or directly to the HJ value function; using temporal filtering (e.g., exponential moving average) on the output of the supernetwork during training or inference; and incorporating recurrent or temporal convolutional layers into the supernetwork to implicitly enforce consistency.
[0119] For example, during training, a supernetwork can process five time steps. SDF sequences. The time smoothing loss can be calculated by measuring the difference between the parameters generated at each step. This suppresses abrupt changes in safety constraints, resulting in a smoother transition of the HJ value function and more stable motion planning.
[0120] In this embodiment, the activation function applied to the residual can be a leaky rectified linear unit (Leaky ReLU), thereby reducing the conservatism of the resulting HJ value function. Unlike the standard ReLU, which outputs zero for all negative inputs, the leaky ReLU allows small non-zero gradients for negative values and is typically defined as LeakyReLU(x) = max(αx,x), where α... α It is a small positive constant (e.g., 0.01).
[0121] Alternative implementations may include: parameterized ReLU (PReLU), where the slope α is learned during training; Softplus or ELU (Exponential Linear Unit) for smoother transitions; and piecewise linear or spline-based activation functions tailored to specific safety margins.
[0122] For example, if the main network output residual R(x) = -0.2, standard ReLU would set this to zero, potentially overestimating the risk. A leaky ReLU with α = 0.01 would yield -0.002, allowing the HJ value function to reflect a slightly less conservative estimate, which is more suitable in low-risk or uncertain regions.
[0123] Figure 2 The diagram illustrates an embodiment of a system for implementing the method 100 disclosed herein. The diagram labeled "200" illustrates a neural network-based architecture for calculating the Hamilton-Jacobi (HJ) value function used in safe motion planning of an autonomous system. The process begins with a block labeled SDF 210, which receives a series of occupancy grid maps (OGMs) derived from onboard sensors as input. These OGMs are converted into signed distance fields (SDFs), specifically SDF(k) and SDF(k-1), which represent the spatial layout of the environment at the current and previous time steps, respectively. The SDF encodes the distance from each point in the environment to the nearest obstacle, where the sign indicates whether the point is inside or outside the obstacle boundary.
[0124] Calculate the SDF increment of 220 blocks to obtain the two SDFs and calculate their difference to obtain ΔSDF(k). SDF ( k It captures the temporal changes in the environment. The SDF serves as the input to the supernetwork 230, which is a neural network that generates parameters for the downstream model based on observed environmental dynamics. The supernetwork outputs a set of parameters, which are then passed to the main network 240, which also receives the current system state x(k). x ( k The main network uses these inputs to compute the residual R(x(k)). R ( x ( k The residual represents the learned correction to the baseline security estimate provided by the SDF.
[0125] The residuals are then passed through a leaky ReLU 250 block, which applies a leaky rectified linear unit activation function. This function allows small negative values to pass through, thus preserving gradient information and achieving a smoother, less conservative safety boundary. Simultaneously, an SDF 260 block is selected to choose an appropriate SDF—SDF(k)—based on the planning context. SDF ( k (or the future SDF.) Combine the selected SDF with the corrected residuals to compute the intermediate HJ value function.
[0126] The estimation allows for the violation of constraint 270 blocks, receiving input from the relaxation estimation module of the selected SDF, residuals, and master network. It calculates state-related relaxation variables s(x(k)), which are added to an intermediate value function to produce the final HJ value function V^(xk). This final value function is output at the summation node and represents the safety constraint, which takes into account learned corrections and controlled relaxations in uncertain or occluded regions.
[0127] The blocks in Figure 200 correspond to steps in method 100 disclosed herein. Step 110 can be implemented by blocks 210 and 220, which compute the SDF and its difference to form an environment representation. Step 120 can be implemented by a hypernetwork 230, which generates parameters based on this representation. Step 130 can be implemented by a master network 240, which computes the residual of the HJ value function. Step 140 can be implemented by a leaky ReLU block 250, which corrects the residual to ensure safe behavior. Step 150 can be represented by a combination of selecting the SDF 260 and a subtraction operation, which forms an intermediate value function. Step 160 can be completed by an estimating allowable constraint violation block 270, which adds a relaxation function to the intermediate value. Finally, step 170 can be implemented at a summation node, where the final HJ value function is generated and used for safe motion planning.
[0128] The technical advantages of this architecture include the use of... SDF and caching are used to improve real-time performance, context-sensitive parameter generation via hypernetworks is used to enhance adaptability, and conservativeness is reduced by combining leaky ReLU with relaxation-based constraint relaxation. The system also supports robust operation in uncertain environments by integrating sensor-derived uncertainties with learned safety margins into the planning process.
[0129] In this disclosure, unless otherwise stated, any feature described in an embodiment, example, method (e.g., method 100), method step, and / or system (e.g., system 200, 300) may be combined with any feature of another embodiment, example, method, method step, and / or system.
[0130] Figure 3 A block diagram of an embodiment of device 300 is shown schematically, the device including one or more interfaces 310 for communication and one or more processors or data processing circuits 320 configured to perform any of the methods described herein.
[0131] In embodiments, the device may further include a memory or storage medium 330. The storage medium 330 (or data carrier, or computer-readable data carrier, or computer-readable medium) may include a computer program or computer-executable instructions stored thereon, which, when executed by one or more processors 320, are used to perform one of the methods described herein. The processor 320 may communicate directly and / or via one or more interfaces 310 with the storage medium 330.
[0132] In embodiments, one or more interfaces 310 may include wired and / or wireless interfaces for transmitting and / or receiving communication signals while performing the proposed concept. In practice, interfaces may include, for example, pins, wires, antennas, and / or the like. Similarly, interfaces may include means for performing (analog and / or digital) signal or data processing during communication, such as filters, samplers, analog-to-digital converters, signal acquisition and / or reconstruction means, and signal amplifiers, compressors, and / or any encryption / decryption means.
[0133] The data processing circuit 320 can correspond to or include any type of programmable hardware. Therefore, examples of the data processing circuit 320 include, for example, a memory, a microcontroller, a field-programmable gate array (FPGA), or one or more central and / or graphics processing units (CPUs). To perform the proposed method, the data processing circuit 320 can be configured to access or retrieve an appropriate computer program from its memory or a separate memory communicatively coupled to it to perform the proposed method.
[0134] The above text is about Figures 1 to 2 Some or all of the described method steps can be implemented by a computer, i.e., they are executed by (or using) a processor, microprocessor, electronic circuitry, or data processing circuitry 320. For example, the implementation can be performed using a non-transitory storage medium, such as a computer-readable storage medium or data carrier. Such computer-readable media include any medium that can be accessed by a general-purpose or special-purpose computer system.
[0135] Furthermore, any component of device 300 can be embedded locally on the autonomous system or located in the cloud 340. For example, data processing circuitry 320 can be located in an edge device of the autonomous system, in the cloud 340 (e.g., a digital twin), or partially in both. Edge devices equipped with edge AI capabilities can perform real-time data processing and decision-making near the data source, thereby reducing latency and shortening response time. This is particularly helpful for autonomous systems that need to react instantly to dynamic environments.
[0136] The cloud component 340 can leverage high-performance computing (HPC) resources and advanced machine learning models to perform more complex computations that are less time-sensitive. By utilizing the cloud-based digital twin 340 (a virtual copy of the physical system), the autonomous system can simulate various scenarios and optimize its performance based on real-time data and predictive analytics. This hybrid approach ensures that the system can efficiently handle both real-time processing and complex computations.
[0137] Furthermore, the integration of 5G / 6G technologies (e.g., in communication interface 310) can further enhance this setup by providing high-speed, low-latency communication between the edge device and the cloud 340. This ensures seamless data transfer and synchronization, enabling autonomous systems to make informed decisions quickly and accurately.
[0138] In summary, by combining edge AI, HPC, digital twins, and 5G / 6G technologies, these approaches become more robust, scalable, and efficient. This hybrid architecture not only enhances the performance and decision-making capabilities of autonomous systems but also ensures their effective adaptation to various dynamic environments and scenarios.
[0139] Device 300 may also include a cloud implementation 340, which enhances its capabilities by leveraging cloud-based resources. This cloud implementation includes several key components. The cloud implementation may include a cloud interface 310' designed for communication between the local device and the cloud. These interfaces enable data transfer, remote access, and integration with cloud services, thereby ensuring seamless connectivity.
[0140] Additionally, the cloud implementation 340 may include a cloud processor or data processing circuitry 320'. These can be processing units located in the cloud, configured to perform any methods described for the device. By utilizing a cloud processor, the system can handle more complex computations and larger datasets without being limited by the capabilities of local hardware. This makes it more flexible and efficient in processing tasks and allows resources to be dynamically scaled based on demand.
[0141] Furthermore, cloud implementation 340 may include a cloud storage device or storage medium 330', which can be responsible for storing data, datasets, and program and / or method code in the cloud. Cloud storage provides scalability, redundancy, and accessibility, ensuring that data is securely stored and accessible from anywhere. This enhances the overall reliability and availability of the system, providing robust data protection and disaster recovery options.
[0142] The cloud implementation 340 allows for flexibility in how the method is executed. Specifically, any method described herein can be partially executed in the cloud, with some parts of the method processed locally while others are offloaded to the cloud. This hybrid approach optimizes performance and resource utilization by balancing the load between local and cloud resources. Alternatively, the entire method can be executed entirely in the cloud, leveraging its powerful computing and storage capabilities. This dual implementation (local and cloud) ensures that the device can efficiently handle a wide range of tasks, from simple local processing to complex cloud-based computing, providing a robust and scalable solution that can adapt to different workloads and operational requirements.
Claims
1. A method for safe motion planning in autonomous systems, comprising: - An environment representation is obtained from a hypernetwork, the environment representation comprising one or more differences between consecutive signed distance fields SDF obtained at multiple time steps within the motion planning time range; - The parameters are generated by the hypernetwork based on the environment representation; - The residuals of the Hamilton-Jacobi HJ value function are obtained by the main network based on the acquired parameters; - Apply an activation function to the residuals to obtain corrected residuals; - The intermediate HJ value function is determined by subtracting the corrected residual from the selected SDF corresponding to the current or future time step within the motion planning range; - The final HJ value function is determined by adding the intermediate HJ value function to the state-related relaxation function, wherein the relaxation function enables the autonomous system to explore environmental areas marked as unsafe due to unknown space, thereby reducing conservatism and improving navigation efficiency; as well as - Use the determined final HJ value function to perform safe motion planning for the autonomous system.
2. The method of claim 1, wherein the one or more SDFs are derived from an occupancy grid map OGM, which is obtained from an onboard sensor.
3. The method of claim 1 or 2, wherein the two consecutive SDFs are obtained for the current time step and the previous time step, or for the current time step and the next time step.
4. The method of any of the preceding claims, wherein the environment represents a sequence of differences between consecutive SDFs at multiple time steps, and the supernetwork is configured to process the sequence to ensure temporal consistency of the learned parameters or the resulting HJ value function.
5. The method of any of the preceding claims, wherein the final HJ value function determined from one or more SDFs within the said motion planning time range is used as the terminal constraint in the Model Predictive Control (MPC) framework.
6. The method of any of the preceding claims, wherein the terminal state of the MPC optimization problem is constrained to lie within a safe set defined by the final HJ value function.
7. The method of any of the preceding claims, wherein the final HJ value function is used as the control barrier function CBF in the security filter.
8. The method of claim 7, wherein the security filters modify the control inputs proposed by the performance controller to ensure that they remain within the security set defined by the HJ value function.
9. The method of claim 8, wherein the security filter projects potentially unsafe control inputs onto a security action space, the security action space being defined as the control inputs that ensure the state of the system remains within the security set.
10. The method of any preceding claim, wherein the state-related relaxation function is determined using at least one of the following methods: - Analyze sensor data to assess environmental uncertainties; - Utilize machine learning models trained on historical navigation data; - Calculate the potential kinetic energy of the collision and assign a higher relaxation value to the state with less damage; - Integrate slack variables into the MPC framework to dynamically relax constraints; and - Apply heuristics based on proximity to obstacles and encourage exploration.
11. The method of any of the preceding claims, wherein the autonomous system skips the computation for states with zero SDF increments and reuses previously computed values of the HJ value function for those states, thereby reducing redundant computations and improving real-time performance.
12. The method of any of the preceding claims, wherein the activation function applied to the residual is a leaky rectified linear unit, i.e., a leaky ReLU, thereby reducing the conservatism of the resulting HJ value function.
13. A computer program comprising instructions that, when executed by a computer, cause the computer to perform the method as claimed in any one of claims 1 to 12.
14. A computer-readable data carrier having a computer program as described in claim 31 stored thereon.
15. An apparatus (300), comprising: One or more interfaces (310) for communication; Memory (330); as well as A data processing circuit (320) configured to implement the method as described in any one of claims 1 to 12.