Deep Fuzzy Optimization for Batch-Size and Nearest Neighbors in Optimal Robot Motion Planning

TL;DR

This paper introduces LIT*, a deep fuzzy learning-based motion planner that adaptively optimizes batch size and nearest neighbor parameters based on environment obstacle density, improving efficiency and solution quality in high-dimensional robotic planning.

Contribution

The paper presents a novel deep fuzzy neural network approach for adaptive parameter tuning in sampling-based motion planning, enhancing performance in complex environments.

Findings

LIT* achieves faster convergence than existing planners.

LIT* produces lower-cost paths in high-dimensional spaces.

Validated on dual-arm robot manipulation tasks.

Abstract

Efficient motion planning algorithms are essential in robotics. Optimizing essential parameters, such as batch size and nearest neighbor selection in sampling-based methods, can enhance performance in the planning process. However, existing approaches often lack environmental adaptability. Inspired by the method of the deep fuzzy neural networks, this work introduces Learning-based Informed Trees (LIT*), a sampling-based deep fuzzy learning-based planner that dynamically adjusts batch size and nearest neighbor parameters to obstacle distributions in the configuration spaces. By encoding both global and local ratios via valid and invalid states, LIT* differentiates between obstacle-sparse and obstacle-dense regions, leading to lower-cost paths and reduced computation time. Experimental results in high-dimensional spaces demonstrate that LIT* achieves faster convergence and improved solution quality. It outperforms state-of-the-art single-query, sampling-based planners in environments ranging from R^8 to R^14 and is successfully validated on a dual-arm robot manipulation task. A video showcasing our experimental results is available at: https://youtu.be/NrNs9zebWWk

Tables

Table 1. Table I : Benchmarks evaluation comparison (Fig.  6 )

	Flexible Informed Trees [19]			Learning-based Informed Trees			$t_{\text{init}}^{\text{med}}\Uparrow$ (%)
	$t_{\text{init}}^{\text{med}}$	$c_{\text{init}}^{\text{med}}$	$c_{\text{final}}^{\text{med}}$	$t_{\text{init}}^{\text{med}}$	$c_{\text{init}}^{\text{med}}$	$c_{\text{final}}^{\text{med}}$
$\text{RR}-{ℝ}^4$	0.0626	2.3295	1.9951	0.0597	1.0621	1.8383	4.63
$\text{RR}-{ℝ}^8$	0.1247	3.7650	3.1704	0.1114	3.1188	2.8034	10.67
$\text{RR}-{ℝ}^{16}$	0.2778	6.2709	4.2460	0.2385	4.9677	3.9552	14.15
$\text{NP}-{ℝ}^4$	0.0084	1.3681	0.5395	0.0060	1.1506	0.5096	28.6
$\text{NP}-{ℝ}^8$	0.0291	2.7310	2.0761	0.0217	2.5802	1.9441	25.43
$\text{NP}-{ℝ}^{16}$	0.0383	4.7280	3.8258	0.0262	4.0591	2.9497	31.59

Equations

$$r(q):=\eta {\left(2\left(1+\frac{1}{n}\right)\left(\frac{\lambda (X_{\text{free}})}{\lambda \left(B_{1,n}\right)}\right)\left(\frac{\log (q)}{q}\right)\right)}^{\frac{1}{n}},$$

$$k(q):=\eta e\left(1+\frac{1}{n}\right)\log (q),$$

$${\xi }^{\ast }=\arg \underset{\xi \in \Xi }{\min }c(\xi )$$

$$\xi (0)={\mathbf{x}}_{\text{init}},\xi (T)\in X_{\text{goal}},\xi (t)\in X_{\text{valid}}(t),\forall t\in [0,1],$$

$$\underset{\mathbf{\pi }}{\mathrm{argmax}}\mathcal{R}$$

$$\tilde{\mathcal{B}}={\mathbf{\pi }}_B({\mathbf{s}}_t;{\mathbf{W}}_B),\widetilde{{\psi }_{\mathcal{K}}}={\mathbf{\pi }}_K({\mathbf{s}}_t;{\mathbf{W}}_K),$$

$$\rho =\frac{|X_{\text{invalid}}|}{|X_{\text{valid}}|+|X_{\text{invalid}}|},$$

$$k(q):=\eta e\cdot {\psi }_{\mathcal{K}}\cdot \left(1+\frac{1}{n}\right)\log (q),$$

$${\mu }_{\mathcal{O},i}({\rho }_{\text{global}})=\exp \left(-\frac{({\rho }_{\text{global}}-{\vartheta }_{\text{global},i}{)}^2}{2{\sigma }_{\text{global},i}^2}\right),$$

$$\mathbf{i}=[{\mu }_{{\mathcal{O}}_1,1}(x_1),{\mu }_{{\mathcal{O}}_1,2}(x_1),...,{\mu }_{{\mathcal{O}}_3,3}(x_3){]}^T,$$

$$z^{\ast }=\frac{{\sum }_{i=1}^N{w}_i{f}_i}{{\sum }_{i=1}^N{w}_i},$$

$$Q_{\varphi }({\mathbf{s}}_t,{\mathbf{a}}_t)=r_t+\gamma Q_{{\varphi }^{\prime }}({\mathbf{s}}_{t+1},A_{{\theta }^{\prime }}({\mathbf{s}}_{t+1})),$$

$${\mathcal{R}}_B={\alpha }_B\cdot \frac{\kappa }{t}+{\beta }_B\cdot \frac{\kappa }{c(\xi )}-{\gamma }_B\cdot n_{\text{update}},$$

$$\kappa (n_{\text{update}})=\max \left({\nu }_{\min },\nu \cdot {\log }_2(6.8-n_{\text{update}})\right).$$

$${\mathcal{R}}_K={\alpha }_K\cdot \frac{1}{t}+{\beta }_K\cdot \frac{1}{c(\xi )}+{\gamma }_K\cdot \#\xi ,$$

$${\mathbf{W}}_{\theta }^{\ast }=\underset{{\mathbf{W}}_{\theta }}{\mathrm{argmax}}\mathbb{E}\left[Q_{\varphi }(\mathbf{s},A_{\theta }(\mathbf{s}))\right].$$

$$\mathcal{L}({\mathbf{W}}_{\theta })=-\frac{1}{m}\sum _t{Q}_{\varphi }(\mathbf{s},A_{\theta }(\mathbf{s};{\mathbf{W}}_{\theta })).$$

$$\mathcal{L}({\mathbf{W}}_{\varphi }^{\ast })=\underset{{\mathbf{W}}_{\varphi }}{\mathrm{argmin}}\mathbb{E}\left[{\delta }^2\right]$$

$$\mathcal{L}({\mathbf{W}}_{\theta })=-\frac{1}{m}\sum _t{Q}_{\varphi }(s_t,A_{\theta }(s_t;{\mathbf{W}}_{\theta })).$$

$${\mathbf{W}}_{\varphi }^{{}^{\prime }}$$

Full text

Index Terms — Sampling-based motion planning, deep fuzzy network, reinforcement learning

I Introduction

Motion planning is a fundamental problem in robotics and autonomous systems, particularly in high-dimensional continuous spaces [1]. Traditional graph-based algorithms, such as Dijkstra’s algorithm [2] and A* [3], rely on discretized search spaces, making them computationally expensive and resolution-dependent. In contrast, sampling-based methods, such as Rapidly-exploring Random Trees (RRT) [4] and Probabilistic Roadmaps (PRM) [5], achieve more efficient exploration. The improved variants, PRM* and RRT*, further guarantee asymptotic optimality [6]. Informed RRT* [7] refines RRT* by restricting sampling to an ellipsoid derived from the initial solution cost, accelerating convergence.

Several algorithms have extended these approaches. Fast Marching Tree (FMT*) [8] leverages batch processing for computational efficiency. Batch Informed Trees (BIT*) [9] balances exploration and optimization through incremental batch processing. Effort Informed Trees (EIT*) [10] prioritizes regions with higher potential for path improvement, while Adaptively Informed Trees (AIT*) [10] refines computational efficiency through heuristics. These methods have advanced sampling-based motion planning [11], making them widely applicable in navigation and bio-robotics.

To further improve planning efficiency, researchers have explored learning-based approaches [12]. Motion Planning Networks (MPNet) [13] eliminate explicit trajectory optimization by directly mapping sensory inputs to motion sequences. Neural Exploration-Exploitation Trees (NEXT) [14] and Neural Informed RRT* [15] integrate neural networks to guide sampling, reducing unnecessary exploration. Deep fuzzy methodologies have also been introduced to enhance adaptability. Wu et al. [16] proposed a deep fuzzy framework that refines velocity commands through defuzzification.

Recent work has focused on optimizing sampling strategies [17] and nearest neighbor optimization [18]. Flexible Informed Trees (FIT*) [19] dynamically adjust batch size to improve convergence, while Adaptive Prolated Trees (APT*) [18] employ prolated elliptical r-nearest neighbors to accelerate path search. However, these methods lack dynamic adaptation of batch size and neighbor selection [20], potentially reducing accuracy and increasing search complexity. Moreover, reliance only on Coulomb’s law limits their applicability.

Inspired by neural behavior, where the networks perceive a broader field of view in obstacle-sparse environments and navigate more directly, this work introduces Learning-Based Informed Trees (LIT*). LIT* integrates a deep fuzzy framework to address these challenges by leveraging invalid sampled states to encode environmental complexity and dynamically adjusting both sampling density and neighbor selection. By determining the number of sampled points and selected neighbors based on real-time conditions, LIT* enhances both planning efficiency and path quality.

The main contributions of this work are:

• •

A Fuzzy Reinforcement Learning Framework: Encodes environmental complexity through global invalid rate, local invalid rate, and the Lebesgue measure of the informed set, enabling adaptive motion planning.

• •

Learning-based batch size selection: Dynamically adjusts batch size to balance exploration and exploitation.

• •

Learning-based neighbor selection: Replaces the fixed $k$-nearest neighbor approach (Fig. 2) with an adaptive strategy, improving sampling efficiency in both obstacle-dense and obstacle-sparse regions.

II Preliminaries and Problem formulation

This section introduces the background of neighbor search and deep fuzzy systems as preliminaries. It then formulates the problem in the deep fuzzy framework, explaining how it improves motion planning efficiency and solution quality.

II-A Preliminaries

II-A1 $R$-Nearest $\&$ K-Nearest Neighbors Search

The $r$-nearest neighbors search defines connectivity based on a fixed radius around each state. A state $q$ is connected to all other states within a radius $r(q)$, The $k$-nearest neighbors search method connects each state $q$ to its $k$ closest states regarding Euclidean distance. Their can be formulated as:

[TABLE]

where $\eta$ is a normalization constant, $n$ is the dimensionality of the space, $\lambda(\cdot)$ denotes the Lebesgue measure, $X_{\text{free}}$ is the free space, $B_{1,n}$ is the unit ball in $n$-dimensional space [10].

[TABLE]

where $\eta$ is a tuning parameter, $e$ is the base of the natural logarithm, and $n$ denotes dimension [21].

II-A2 Deep Fuzzy Systems

Deep fuzzy systems combine fuzzy logic with learning methods. [22]. A general deep fuzzy framework consists of three key components: Fuzzification: transforming raw input data into fuzzy membership values; Fuzzy rules: defines the relationships between fuzzy variables through a set of rules; and Defuzzification: applies fuzzy logic to derive crisp conclusions based on fuzzy rules.

This work replaces the fuzzy rule component with a reinforcement learning algorithm, Deterministic Policy Gradient (DDPG) architecture, as illustrated in Fig. 1. It generates a deterministic policy as the fuzzy rule and facilitates seamless integration into subsequent planning stages.

II-B Problem Formulations

II-B1 Problem Formulation 1 (Optimal Planning)

We define the motion planning problem within the framework of sampling-based methods [23]. The state space is denoted as $X\subseteq\mathbb{R}^{n}$, where obstacle regions occupy $X_{\text{invalid}}$, the set of valid, collision-free states is defined as $X_{\text{valid}}$, and the goal states is $X_{\text{goal}}\subset X_{\text{valid}}$. The motion planning problem is defined to compute a path $\xi:[0,1]\to X_{\text{valid}}$ such that $\xi(0)=\mathbf{x}_{\text{init}}$ and $\xi(1)\in X_{\text{goal}}$. The optimal path denoted as $\xi^{*}$; $\Xi$ denotes the set of all nontrivial paths. The path planning problem can be described as:

[TABLE]

where $c(\xi):\Xi\mapsto\mathbb{R}_{\geq 0}$ is the cost function of each feasible path, and the optimal cost is $c^{*}$.

II-B2 Problem Formulation 2 (Fuzzy-DDPG)

Beyond solving the motion planning problem, this work aims to improve the solution quality using the deep fuzzy framework, where reward functions $\mathcal{R}$ are designed to guide learning. During training, the objective is to maximize reward, ensuring efficient learning of key parameters.

The reinforcement learning observation $\textbf{s}_{t}$ is fuzzified global, local ratio and Lebesgue measure. Each state $\textbf{s}_{t}$ is associated with an action $\textbf{a}_{t}\in\mathbb{R}^{3}$. After defuzzification , a crisp number of batchsize $\mathcal{B}\in\mathbb{N}^{+}\cap[20,200]$ and a factor of neighbor selection $\psi_{\mathcal{K}}\in\mathbb{R}^{+}\cap[3.0,15.0]$ will be applied in the following algorithm. The limits of batchsize are based on SOTA algorithms’ upper and lower limits, while the factor’s limits consider the connectivity.

The Fuzzy-DDPG’s task is to determine an optimal policy $\bm{\pi}:\mathbb{S}\to\mathbb{A}$, where $\mathbb{S}$ is the state space, and $\mathbb{A}$ is the action space. The learned policy $\bm{\pi}$ aims to accelerate convergence and reduce solution cost, which are valued by the reward function $\mathcal{R}$. Formally, the problem can be described as:

[TABLE]

where $\bm{W}_{B}$ and $\bm{W}_{K}$ represent the parameters of the neural network trained via reinforcement learning.

III Learning-Based Informed Trees (LIT*)

Notation: In the Fuzzy-DDPG framework, observation $\textbf{s}_{t}$ encodes the map information through a fuzzification process; action $\textbf{a}_{t}$ represents the membership values in the defuzzification phase; $\mathcal{E}$ denotes the set of factors involved in reward calculation. Each step of reward $r_{t}$ is calculated based on $\mathcal{E}$. The policy network (Actor) and the value network (Critic) are denoted as $\pi_{\theta}$ and $Q_{\phi}$, their loss is $\mathcal{L}_{\theta}$ and $\mathcal{L}_{\phi}$. To encode the map information, this work else takes invalid states $X_{\textnormal{invalid}}$ into account and defines the invalid ratio as:

[TABLE]

where the $|\cdot|$ denotes the size of corresponded set.

III-A Architecture of Fuzzy-DDPG

LIT* deconstructs the solving process from a microscopic algorithmic perspective, simulating a network’s field of view and autonomously selects optimal actions based on the current environment. Fig. 3 illustrates the architecture of Fuzzy-DDPG. The process begins with fuzzifying three inputs, Fuzzy-DDPG then iteratively trains the Actor and Critic. Finally, leveraging the trained Actor, the system computes membership degrees and applies defuzzification to generate a continuous action based on the learned policy. Specificlly, for B-Net the defuzzied $z^{*}$ is batchsize $\mathcal{B}$ and for K-net the $z^{*}$ is $\psi_{\mathcal{K}}$, and $\mathcal{K}$ is calculated as:

[TABLE]

III-A1 Inputs Fuzzification

This work extracts three key parameters to encode the map: $\rho_{\textnormal{global}}$, $\rho_{\textnormal{local}}$, and $\lambda(X_{\hat{f}})$. To further enhance the expressiveness of the input representation, this work fuzzifies these inputs into the DDPG neural network to improve its feature representation capability.

This work selects three fuzzy sets and Gaussian membership functions to balance expressiveness and computational complexity. For each input in $\mathcal{O}=\{\rho_{\text{global}},\rho_{\text{local}},\lambda(X_{\hat{f}})\}$, this study employs fuzzy sets for modeling and designs three fuzzy sets to describe their characteristics: S (sparse), M (medium), and D (dense).

[TABLE]

Correspondingly, each element in $\mathcal{O}$ has three membership functions ($i,j,k\in\{1,2,3\}$), corresponding to different levels of its fuzzy feature. The parameters $\vartheta_{|\cdot|}$ and $\sigma_{|\cdot|}$ control the shape and position of each membership function. Then, the final fuzzy mapping can be represented as a $9\times 1$ vector:

[TABLE]

where $x_{1},x_{2},x_{3}$ correspond to the three components of the input $\mathcal{O}$. This fuzzy logic mapping transforms the original input data into a continuously fuzzy representation, making it more effectively processable by the neural network.

III-A2 Actor and Critic

In Fuzzy-DDPG, there are two primary networks: the Actor $A_{\theta}(\mathbf{s})$ and the Critic $Q_{\phi}(\mathbf{s,a})$. The Actor network takes a 9-dimensional input and passes it through a convolutional layer with kernel sizes 3, 5 and 7, and outputs 9 channels, followed by a fully connected multi-layer perceptron (MLP). The MLP consists of five hidden layers with neuron sizes (64, 128, 128, 64, 32) activated by ReLU. The final output layer has 3 neurons, corresponding to the number of defuzzification-membership functions, and applies a TSK defuzzification [26] for discrete and continuous actions. The Critic network follows a similar architecture but takes the concatenation of state s and defuzed-result as input. The output layer is a single neuron representing the estimated Q-value of current (s, a) pair.

III-A3 Defuzzification

This work select the Takagi-Sugeno-Kang (TSK) defuzzification [27] method due to its effectiveness in modeling complex nonlinear systems and its widespread use in control and decision-making applications. It employs a weighted sum approach, allowing a smooth transition between rules and enabling more adaptive decision-making. Specifically, the defuzzified output is computed as:

[TABLE]

where $w_{i}$ represents the weight of the $i$-th fuzzy rule, and $f_{i}$ is a constant functions to control the output range.

III-B Training of Fuzzy-DDPG

Deep Deterministic Policy Gradient (DDPG) is an actor-critic reinforcement learning algorithm designed for continuous control problems. The key feature of DDPG is its ability to optimize policies over a continuous action space by leveraging an off-policy training framework with target networks and soft updates.

The Bellman equation for the critic network is defined as:

[TABLE]

where: $r_{t}$ is the reward at time step $t$, $Q_{\phi^{\prime}}$ and $A_{\theta^{\prime}}$ are the target networks for the critic and actor, respectively, $\gamma\in[0,1]$ is the discount factor.

III-B1 Reward Definition

This work defines different reward functions for two sub-networks: BatchSize-Net (B-Net) and NearestK-Net (K-Net) as in Fig. 1. Processing more information each step in an obstacle-free space can lead to more direct solutions and increase computational effort. Therefore, the reward function must account for key parameters to balance efficiency and solution quality.

BatchSize-Net Reward

The reward function for B-Net is defined as:

[TABLE]

where: $\alpha_{B}$, $\beta_{B}$, and $\gamma_{B}$ are scaling factors to ensure that the corresponding terms remain within a reasonable range, preventing them from becoming excessively large or small; t denoted the time cost for each solution update; $n_{\text{update}}$ represents the number of solution updates, $\gamma_{B}$ is a scale parameter for $n_{\text{update}}$, $\kappa$ is a decay function about $n_{\text{update}}$, which is given by:

[TABLE]

This reward function encourages rapid convergence by assigning high rewards in early updates if a solution is found quickly and high rewards in later updates if a more stable, faster-converging solution is achieved.

K-Net Reward

The reward function for NearestK-Net is defined as:

[TABLE]

specially, $\#\xi$ denotes the number of states in a solution path. Since neighbor selection influences path efficiency, this function encourages more direct paths with fewer intermediate states, leading to higher efficiency and better trajectory planning. This work also incorporates Prioritized Experience Replay (PER) [28] to address the sparse rewards problem.

III-B2 Actor and Critic Network Training

The objective of the actor network is to maximize the expected Q-value:

[TABLE]

This is transformed into a loss function for training:

[TABLE]

where: $\bm{W}_{\theta}$ represents the actor network parameters, $m$ is the batch size used during training.

For the critic network, the goal is to minimize the Temporal Difference (TD) error:

[TABLE]

where $\delta=Q_{\phi^{\prime}}(\mathbf{s},\mathbf{a})-Q_{\phi}(\mathbf{s},\mathbf{a})$ is the TD error.

For mini-batch training, the loss function becomes:

[TABLE]

III-B3 Network Update

To stabilize training, soft updates are applied to the target networks:

[TABLE]

where $\bm{W}_{\theta}^{{}^{\prime}}$ and $\bm{W}_{\phi}^{{}^{\prime}}$ are target network parameters, $\tau\ll 1$ is a small update factor ensuring stability.

This gradual update strategy prevents sudden oscillations in policy updates and improves learning efficiency.

Given that the Fuzzy-DDPG’s output is deterministic, this study pre-maps the neural network outputs into a tensor (Fig. 5), where the three tensor dimensions correspond to the three input variables. Each unique three-dimensional coordinate directly determines a specific output value. In C++, querying this tensor has a time complexity of $\bm{O}(1)$, achieving microsecond-level access speed.

The overall process is as follows: during sampling and neighbor node expansion, the current map information is retrieved; based on this information, a lookup is performed in the tensor; the corresponding action is obtained, and the path planning algorithm continues execution.

IV Experimental Results

LIT* was evaluated against several existing algorithms, including different versions of RRT-Connect, Informed RRT*, BIT*, AIT*, EIT*, and FIT* from the Open Motion Planning Library (OMPL) [29]. Tests were conducted in simulated environments ranging from $\mathbb{R}^{4}$ to $\mathbb{R}^{16}$ and simulation manipulation scenarios using an Intel i7 3.90 GHz processor with 32GB of LPDDR3 4800 MHz memory. The main goal was to minimize the median initial path length ($c^{\textit{med}}_{\textit{init}}$) over 100 runs. For all planners, the RGG constant $\eta$ was set to 1.1, and the rewire factor to 1.001. RRT-based algorithms used a 5% goal bias, with maximum edge lengths adjusted for space dimensionality. This work also tests the algorithm in the Open Robotics Automation Virtual Environment (OpenRAVE [25], Fig. 4 (c) and (d)) by a dual-Barrett Whole-Arm Manipulator (dual-WAM-$\mathbb{R}^{14}$). The learning-based mechanism optimizes the convergence speed and solution quality.

As observed in Table I, there’s a median cost improvement across varied benchmark scenarios, correlating with dimensionality. In the case of the NP-$\mathbb{R}^{16}$ scenario, the initial median solution cost exhibits a reduction of up to 31.59%.

V Discussion & Conclusion

This paper introduces Learning-based Informed Trees (LIT*), a planner using Fuzzy-DDPG to determine batchsize and nearest neighbors. It also encodes the invalid states as input of the Fuzzy-DDPG framework, thereby self-adjusting according to the valid/invalid ratio. Since multiple neighbor expansion steps occur in each epoch, and the motion planning algorithm is implemented in C++ while Fuzzy-DDPG runs in Python, the communication between the two can be significant. This work facilitates data exchange by a shared file, which may introduce latency. Future work could focus on improving communication efficiency to reduce training time. LIT* demonstrated its adaptability by achieving short path lengths and quickly generating solutions.

In conclusion, LIT* leverages valid and invalid states to dynamically determine batchsize and the number of neighbors, ensuring adaptive and efficient motion planning.