Robot autonomous navigation method and device based on local information, and storage medium

Abstract

The application relates to a robot autonomous navigation method based on local information, which comprises the following steps: step 1, a virtual navigation platform is built, an autonomous navigation model is designed, and training data of a virtual navigation process are collected; step 2, based on the training data, a deep reinforcement learning algorithm is used to train the autonomous navigation model; step 3, the trained autonomous navigation model is derived and encapsulated; and step 4, the encapsulated autonomous navigation model is applied to an actual navigation task. Compared with the prior art, the application has the advantages of high scene applicability and low calculation complexity.

Description

Technical Field

[0001] This invention relates to the field of autonomous robot navigation, and in particular to a method, device and storage medium for autonomous robot navigation based on local information. Background Technology

[0002] Robots are widely used in various fields, including warehousing, rescue, cleaning, and security. The increasingly complex and varied application scenarios place ever-higher demands on robots' autonomous navigation capabilities. Based on their understanding of environmental information, traditional robot navigation primarily relies on two schemes: global path planning and local path planning.

[0003] Global path planning first constructs a global map using SLAM (Simultaneous Localization and Mapping) technology. Then, it iteratively solves for the optimal collision-free path connecting the starting and ending points on the known map using path planning algorithms. Finally, considering the robot's motion constraints and optimization objectives, it solves for a composite curve coupling path and velocity. The robot can safely move from the starting point to the target location by strictly following the designed trajectory. While global path planning can assist robots in navigation tasks in known environments, it has two significant drawbacks: First, global path planning involves multiple tasks such as mapping, localization, path planning, and trajectory generation, requiring substantial computing power and often requiring a scheduling system, thus increasing the overall implementation cost. Second, global path planning methods must be based on a known environment map, making it difficult to handle dynamically changing scenarios.

[0004] Unlike global path planning, local path planning requires robots to make decisions in real time based on the local environmental information perceived at the current moment, giving robots a higher degree of autonomous decision-making ability. The Dynamic Window Approach (DWA) is a common local path planning algorithm. Its core idea is to generate multiple predicted trajectories based on the small velocity space of a non-omnidirectional robot and its kinematic model, and then determine the most suitable trajectory through constraints and a cost function. The drawback of this method is that it usually only considers the immediate value of the trajectory without evaluating its impact on the overall navigation task, resulting in insufficient foresight.

[0005] In recent years, advancements in computer technology and hardware have once again sparked a research boom in artificial intelligence, with AI-based robot navigation becoming a popular research area. Supervised learning-based robot navigation involves hiring experts to capture color and depth images from RGB-D depth cameras, labeling them, and then using these labeled images to train a neural network model. The trained object detection model is then loaded into the robot. In actual navigation tasks, real-time image data captured by the robot's onboard cameras is fed into the neural network model, and the model's output motion control strategy guides the robot safely toward the target location, achieving autonomous navigation. However, this method relies heavily on the prior knowledge of human experts, and its performance depends entirely on the provided samples and labels.

[0006] In summary, existing navigation solutions have three main problems:

[0007] 1) Traditional path planning algorithms rely heavily on global map information, require high computing power, and are difficult to cope with dynamically changing scenarios;

[0008] 2) Learning-based navigation algorithms often only achieve good navigation performance in a single scenario;

[0009] 3) The exploration navigation algorithm requires powerful computing power, which is difficult to implement on ordinary navigation tools. Summary of the Invention

[0010] The purpose of this invention is to overcome the shortcomings of the prior art and provide a robot autonomous navigation method, device and storage medium based on local information that has high applicability to various scenarios and low computational complexity.

[0011] The objective of this invention can be achieved through the following technical solutions:

[0012] According to a first aspect of the present invention, a robot autonomous navigation method based on local information is provided, the method comprising the following steps:

[0013] Step 1: Build a virtual navigation platform, design an autonomous navigation model, and collect training data for the virtual navigation process;

[0014] Step 2: Based on the training data, train the autonomous navigation model using a deep reinforcement learning algorithm;

[0015] Step 3: Export and package the trained autonomous navigation model;

[0016] Step 4: Apply the encapsulated autonomous navigation model to actual navigation tasks.

[0017] Preferably, step 1 includes the following sub-steps:

[0018] Step 1.1: Build a virtual navigation platform: Determine the robot navigation model, select the kinematic model, and load various sensor modules, including a real-time positioning device, a lidar sensor, and an odometer;

[0019] Step 1.2: Design an autonomous navigation model: Design a corresponding neural network model as the autonomous navigation model according to the complexity of the scene, so as to perceive the current state of the robot and output action a; design a reward function to evaluate the reward r brought by action a;

[0020] Step 1.3: Set up the task: Randomly set multiple target points and collect data generated during the virtual navigation process;

[0021] Step 1.4: Data Integration: Integrate data from multiple sensors to obtain the robot's real-time state s = [s o ,s m ]; where s o For obstacle information returned by the LiDAR sensor scanning the environment in the robot's direction of travel, s m The robot's motion state;

[0022] Step 1.5, LiDAR data preprocessing: The LiDAR data is preprocessed using a preprocessing function, which has the characteristics of narrowing the value range of the original LiDAR data and increasing the rate of change of small values;

[0023] Step 1.6: Send action command: The next action 'a' of the robot is obtained through neural network model reasoning, and the robot is controlled to move into the next state 's' according to the command;

[0024] Step 1.7: Collect training data: Store the robot's current state s, action a, reward r, and the state s- at the next moment in the experience pool [s,a,r,s-].

[0025] Preferably, in step 1.4, the motion state s m = [d,θ,v,w], where d is the distance from the robot to the destination, θ is the angular difference between the robot's direction α and the destination direction β, v is the robot's real-time linear velocity, and w is the robot's real-time angular velocity.

[0026] Preferably, the obstacle information s in the robot's forward direction o =[l1,l2,…,l K ],include:

[0027] The sampling resolution is set, and the lidar sensor provides ranging data within a set range along the robot's motion direction. The minimum value of M adjacent elements in the ranging data is selected to reduce the original data to a K-dimensional vector [l1, l2, ..., l]. K], information about obstacles in the direction the robot is moving. o .

[0028] Preferably, the mathematical expression of the preprocessing function in step 1.5 is:

[0029]

[0030] Where: m is the preprocessed value; m max l is the maximum value after preprocessing; l is the original data; l min ζ is the minimum value of the original data; ζ is a user-defined constant used to control the slope of the preprocessing function. The larger ζ is, the larger the slope of the preprocessing function in the initial stage.

[0031] Preferably, step 2 uses a deep reinforcement learning algorithm to train the autonomous navigation model, including the following sub-steps:

[0032] Step 2.1: Initialize the neural network model: Set up one action network π φ and 2 rating networks The corresponding adjustable parameters are φ, θ1, and θ2, and the input-output relationships are as follows: Action Network π φ Input state s, output action a, evaluate the network Input [s, a], output value assessment q;

[0033] Step 2.2, Initialize parameters: Initialize action noise ε, future reward discount γ, network update interval f, and network update amplitude τ;

[0034] Step 2.3: Define the target network: Use the neural network model from Step 2.1 as the target network.

[0035] Step 2.4: Update the network: Randomly select N data points from the experience pool as sample data (s, a, r, s - ), update the evaluation network

[0036]

[0037] Step 2.5, repeat step 2.4, at intervals of f steps, and update the action network π using equation (3). φ Use equation (4) to update all target networks;

[0038]

[0039]

[0040] Step 2.6: Output a neural network model π with autonomous navigation capabilities. φAs an autonomous navigation model.

[0041] Preferably, in step 3, exporting and encapsulating the trained autonomous navigation model specifically involves:

[0042] The neural network model trained in the PyTorch framework is converted into a navigation model in ONNX format and encapsulated. The model supports reading one-dimensional vectors and performing internal inference, and synchronously outputs control commands to the robot.

[0043] Preferably, step 4 includes the following sub-steps:

[0044] Step 4.1: Receive the target location for the current navigation from the system;

[0045] Step 4.2: Select a suitable robot model and configure the required sensors to build a positioning system within the robot's working range to provide the robot's real-time pose.

[0046] Step 4.3: Equip the system with the same type of sensor as the virtual navigation platform and process the relevant information in the same way to obtain the input vector of the autonomous navigation model;

[0047] Step 4.4: Directly transfer the autonomous navigation model trained on the virtual navigation platform to the robot equipped for the actual task;

[0048] Step 4.5: The autonomous navigation model infers the desired speed based on the input vector and sends commands to control the robot's speed;

[0049] Step 4.6: The robot continuously adjusts its speed according to the action instructions output by the autonomous navigation model until it successfully reaches the set target point, and then waits for the system to issue a new task.

[0050] According to a second aspect of the present invention, an electronic device is provided, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the program to implement any of the methods described above.

[0051] According to a third aspect of the invention, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, implements any of the methods described herein.

[0052] Compared with the prior art, the present invention has the following advantages:

[0053] 1) As the application scenarios of robots become more dynamic and diverse, path planning algorithms based on known environments are no longer sufficient for complex autonomous navigation tasks. Neural networks trained by deep reinforcement learning output speed commands in real time based on sensor information at the current moment, assisting robots in quickly handling various emergencies and greatly improving the autonomous navigation capabilities of robots.

[0054] 2) This invention adds an input preprocessing method to the traditional deep reinforcement learning algorithm to preprocess the original LiDAR data. On the one hand, it expands the rate of change of LiDAR data in the interval, making the rate of change of LiDAR data with small values ​​larger, which to some extent amplifies the differences in LiDAR data in crowded areas, making the trained neural network more accurate in making decisions in crowded areas. On the other hand, the preprocessing function narrows the value range of LiDAR data, so that all types of data can be obtained in one scene. This not only reduces the number of training times for the neural network model, but also improves the generalization ability of the navigation model in multiple scenarios.

[0055] 3) In practical applications of autonomous robot navigation, this invention only requires data inference on the trained network, which greatly reduces the performance requirements of the robot processor and thus reduces the overall cost of the robot. Attached Figure Description

[0056] Figure 1 This is a flowchart of the method of the present invention;

[0057] Figure 2 This is a diagram of the overall architecture of the present invention;

[0058] Figure 3 A flowchart for collecting training data for a robot in a virtual navigation platform;

[0059] Figure 4 A flowchart for updating a neural network model;

[0060] Figure 5 This is a flowchart illustrating the direct application of a pre-trained autonomous navigation model in this embodiment. Detailed Implementation

[0061] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of the present invention.

[0062] Example

[0063] like Figure 1 and Figure 2 As shown in the figure, this embodiment presents a robot autonomous navigation method based on local information, which includes the following steps:

[0064] Step 1: Build a virtual navigation platform, design an autonomous navigation model, and collect training data for the virtual navigation process, such as... Figure 3As shown, the specific steps include the following:

[0065] Step 1.1: Build a virtual navigation platform:

[0066] A virtual navigation platform based on the ROS system is built to simulate real-world scenarios, allowing scripts to acquire relevant data from the navigation platform and control the mechanical movement of objects within the platform, which is used to train the robot's autonomous navigation model.

[0067] Building a virtual navigation platform involves determining the robot's navigation model, selecting a kinematic model, and installing various sensor modules, including real-time positioning devices, lidar sensors, cameras, and odometry.

[0068] Step 1.2: Design the autonomous navigation model:

[0069] Design a corresponding neural network model as an autonomous navigation model based on the complexity of the scenario, so as to perceive the current state of the robot and output action command a; design a reward function to evaluate the reward r brought by action a.

[0070] In this embodiment, the neural network is expected to directly output the linear velocity and angular velocity a = [v] that the robot should reach in the next moment. - ,w - Based on the input and output settings, a fully connected neural network is designed to minimize the complexity of the network while effectively completing the navigation task.

[0071] In this embodiment, the action network has 4 layers (r1=24, r2=1024, r3=512, r4=2), with the input being state s and the output being a. It adopts a fully connected form, with 3 hidden layers and ReLU() activation function added. The output layer uses the tan() function to scale the velocity value. The evaluation network has 4 layers (r1=26, r2=1024, r3=512, r4=1), with the input being s+a. - The output is the network's predicted reward R, which is a fully connected network with 3 hidden layers and a ReLU() activation function.

[0072] The reward and punishment functions are set as follows:

[0073]

[0074] Where, d t d is the distance d is the current distance of the robot from the destination. t+1 It is the distance from the endpoint at the next moment.

[0075] Step 1.4, Set up the task:

[0076] The virtual navigation platform provides a world coordinate system, allowing any location in the scene to be represented by two-dimensional coordinates. Multiple coordinates are randomly set as target points, enabling the robot to continuously interact with the environment and generate training data. The entire data collection process is as follows: Figure 2 As shown.

[0077] Step 1.3: Integrate Data

[0078] The LiDAR module provides ranging data within the range of [-90°, 90°] in the robot's motion direction. The LiDAR sampling resolution is 0.5°, therefore the subscribed LiDAR data is a list containing 360 elements, each element representing... The distance to obstacles in a direction is used to reduce the original list to a 20-dimensional vector [l1, l2, ..., l] by taking the minimum value of the 18 adjacent elements in the list. 20 ], used to represent obstacle information s in the robot's direction of movement o Furthermore, the robot's real-time linear velocity v, angular velocity w, distance d to the endpoint, and the angular difference θ between the robot's orientation α and the endpoint direction β form a 4-dimensional vector representing the motion state s. m s o and s m The robot's real-time state s = [l1, l2, ..., l] is represented by a 24-dimensional vector. 20 ,d,θ,v,w], are used as inputs to the neural network model.

[0079] Step 1.5: LiDAR Data Preprocessing

[0080] A 20-dimensional vector [l1,l2,…,l 20 [This refers to raw, unprocessed LiDAR data. While using it directly as the input vector for a neural network can enable navigation, the model can only achieve good navigation performance in one scenario.]

[0081] The LiDAR data is preprocessed using an input preprocessing function, the expression of which is:

[0082]

[0083] In the formula, m is the preprocessed value; m max This is the maximum value after preprocessing, which is 4 in this example; l is the original data, l min ζ is the minimum value of the original data, which is 0.2 in this embodiment; ζ is set to 0.8.

[0084] The above preprocessing function reduces the range of LiDAR data to [0,4]. The function is monotonically increasing but the slope is monotonically decreasing, improving the difference of small values. At this time, the robot's real-time state is represented as s=[m1,m2,…,m 20,d,θ,v,w).

[0085] Step 1.6: Send action command

[0086] In this embodiment, the neural network model outputs the desired linear velocity and angular velocity of the robot in real time, a = [v - ,w - When a topic message is published and subscribed to by the robot, the robot immediately adjusts its speed to change its movement state, aiming to avoid obstacles or move closer to the finish line. At this time, the robot's real-time state becomes: s - =[m 1- ,m 2- ,…,m 20- ,d-,θ-,v - ,w - ].

[0087] Step 1.7: Collect training data:

[0088] The robot's current state s, action a, reward r, and next state s are... - Stored in the experience pool [s,a,r,s - ]middle.

[0089] Step 2: Based on the training data, train the autonomous navigation model using a deep reinforcement learning algorithm, such as... Figure 4 As shown, the specific steps include the following:

[0090] Step 2.1: Initialize the neural network model: Set up one action network π φ and 2 rating networks The corresponding adjustable parameters are φ, θ1, and θ2, and the input-output relationships are as follows: Action Network π φ Input state s, output action a, evaluate the network Input [s, a] and output the value assessment q.

[0091] Step 2.2 Initialize parameters: In this embodiment, the motion noise ε is set to conform to a Gaussian distribution with a mean of 0 and a variance of 0.2, the future reward discount γ = 0.99, the network update interval f = 5, and the soft update amplitude of network parameters τ = 0.005.

[0092] Step 2.3: Define the target network: Use the neural network model from Step 2.1 as the target network.

[0093] Step 2.4: Update the network: Randomly select N data points from the experience pool as sample data (s, a, r, s - ), update the evaluation network

[0094]

[0095] Step 2.5, repeat step 2.4, at intervals of f steps, and update the action network π using equation (3). φ Use equation (4) to update all target networks;

[0096]

[0097]

[0098] Step 2.6: Output a neural network model π with autonomous navigation capabilities. φ As an autonomous navigation model.

[0099] In this embodiment, the robot continuously moves and updates its state in the Gazebo simulation environment, moving a maximum of 500 steps per round, and storing the data generated by each step in the experience pool. Referring to the training process in step 2.3, experience data is collected in real time, and the evaluation network is updated using formula (2) at the end of each round, the action network is updated using formula (3) every 5 rounds, and all target networks are updated using formula (4). To increase the diversity of the robot's early exploration, random noise is added to the output of the action network and passed to the robot for execution. Through 2000 rounds of training, the neural network gradually converges, and the robot is able to safely move from the starting point to the target position.

[0100] Step 3: Export and package the trained autonomous navigation model;

[0101] This embodiment uses the PyTorch framework to build a neural network model and complete the network training process, saving the neural network in .pth format. After training, the network is exported as .onnx format and packaged into an autonomous navigation model for the robot, allowing it to be loaded on processors of various architectures and read by multiple languages, including Python and C++.

[0102] Step 4: Apply the encapsulated autonomous navigation model to actual navigation tasks, such as... Figure 5 As shown, the specific steps include the following:

[0103] Step 4.1, Task Reception:

[0104] In this example, the navigation model is applied to a cargo transportation scenario. The robot is required to reach a designated location within the scenario, stop and wait for cargo to be loaded, and then safely deliver the cargo to the unloading point. Obstacles may randomly appear in this scenario, hindering the robot's progress. The robot is required to make autonomous decisions based on the actual situation and complete the navigation task. A complete task includes two target points: the loading point and the unloading point.

[0105] Step 4.2, Robot Navigation Platform:

[0106] This example demonstrates autonomous navigation on a robot equipped with a Jetson Nano, a four-wheeled robot with Mecanum wheels, a lidar sensor on its top, and internal sensors including an odometer. An Ultra Wide Band (UWB) indoor positioning system is also installed, capable of capturing the real-time location of positioning tags and transmitting the data to various terminals. Positioning tags are placed on the robot and at various target locations, providing real-time location information. Positioning data is transmitted via a local area network and received by the robot.

[0107] Step 4.3, Sensor Data Processing:

[0108] The scanning coverage of the lidar sensor mounted on the robot is a 360° fan-shaped area around it. The lidar data within the range [-90°, 90°] along the robot's movement direction is extracted, and discrete lidar data s are obtained using the same processing method as in steps 1.2 and 1.4. o =[m1,m2,…,m 20 The odometer records the robot's pose changes, and combined with the positioning system, the robot's motion state s is obtained. m Then, the relevant data is integrated and processed into a navigation model input vector s = [m1, m2, ..., m] consistent with step 1.4. 20 ,d,θ,v,w).

[0109] Step 4.4, Pre-trained model inference:

[0110] The navigation model trained on the virtual navigation platform is exported and packaged into a "model.onnx" file. In this example, the packaged navigation model is directly transferred to the robot and loaded using a Python script.

[0111] Step 4.5, Speed ​​Command Issuance:

[0112] The desired linear and angular velocities are obtained through model inference using scripts. Speed ​​commands are then sent to the microcontroller controlling the robot's speed. A PID algorithm quickly adjusts the wheel rotation speed to the ideal value. Commands are sent approximately 10 times per second, sufficient to control the robot's motion state according to real-time conditions.

[0113] Step 4.6: Task completed and wait.

[0114] The electronic device of this invention includes a central processing unit (CPU), which can perform various appropriate actions and processes according to computer program instructions stored in read-only memory (ROM) or loaded from a storage unit into random access memory (RAM). The RAM may also store various programs and data required for device operation. The CPU, ROM, and RAM are interconnected via a bus. Input / output (I / O) interfaces are also connected to the bus.

[0115] Multiple components in the device are connected to the I / O interface, including: input units such as keyboards and mice; output units such as various types of displays and speakers; storage units such as disks and optical discs; and communication units such as network interface cards (NICs), modems, and wireless transceivers. The communication unit allows the device to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0116] The processing unit executes the various methods and processes described above, such as methods S1 to S4. For example, in some embodiments, methods S1 to S4 may be implemented as computer software programs tangibly contained in a machine-readable medium, such as a storage unit. In some embodiments, part or all of the computer program may be loaded and / or installed on the device via ROM and / or a communication unit. When the computer program is loaded into RAM and executed by the CPU, one or more steps of methods S1 to S4 described above may be performed. Alternatively, in other embodiments, the CPU may be configured to execute methods S1 to S4 by any other suitable means (e.g., by means of firmware).

[0117] The functions described above in this document can be performed at least in part by one or more hardware logic components. For example, exemplary types of hardware logic components that can be used, without limitation, include: field programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload programmable logic devices (CPLDs), and so on.

[0118] The program code used to implement the methods of the present invention can be written in any combination of one or more programming languages. This program code can be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing device, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code can be executed entirely on the machine, partially on the machine, as a standalone software package partially on the machine and partially on a remote machine, or entirely on a remote machine or server.

[0119] In the context of this invention, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. Machine-readable media can include, but are not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0120] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any person skilled in the art can easily conceive of various equivalent modifications or substitutions within the technical scope disclosed in the present invention, and these modifications or substitutions should all be covered within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A robot autonomous navigation method based on local information, characterized in that, The method includes the following steps: Step 1: Build a virtual navigation platform, design an autonomous navigation model, and collect training data for the virtual navigation process, including the following sub-steps: Step 1.1: Build a virtual navigation platform: Determine the robot navigation model, select the kinematic model, and load various sensor modules, including a real-time positioning device, a lidar sensor, and an odometer; Step 1.2: Design an autonomous navigation model: Design a corresponding neural network model as the autonomous navigation model based on the complexity of the scene, so as to perceive the robot's current state and output actions. Design reward function to evaluate actions The rewards brought ; Step 1.3: Set up the task: Randomly set multiple target points and collect data generated during the virtual navigation process; Step 1.4: Data Integration: Integrate data from multiple sensors to obtain the robot's real-time status. ;in, The obstacle information returned by the LiDAR sensor scanning the environment in the robot's direction of travel is used. The robot's motion state; Step 1.5, LiDAR data preprocessing: The LiDAR data is preprocessed using a preprocessing function, which has the characteristics of narrowing the value range of the original LiDAR data and increasing the rate of change of small values; Step 1.6: Sending Action Commands: The robot's next action is determined through neural network model reasoning. Control the robot's movement according to instructions to enter the next state. ; Step 1.7: Collect training data: Record the robot's current state. ,action ,award And the state in the next moment. Stored in the experience pool middle; Step 2: Based on the training data, train the autonomous navigation model using a deep reinforcement learning algorithm; Step 3: Export and package the trained autonomous navigation model; Step 4: Apply the encapsulated autonomous navigation model to actual navigation tasks.

2. The robot autonomous navigation method based on local information according to claim 1, characterized in that, The motion state in step 1.4 ,in, This represents the distance the robot travels to the destination. Orienting the robot and the direction of the destination The angle difference between them For the robot's real-time linear velocity, This refers to the robot's real-time angular velocity.

3. The robot autonomous navigation method based on local information according to claim 1, characterized in that, Information on obstacles in the robot's direction of travel. ,include: By setting the sampling resolution, the lidar sensor provides ranging data within a set range along the robot's motion direction. The minimum value of M adjacent elements in the ranging data is selected to reduce the original data to a K-dimensional vector. Information about obstacles in the direction the robot is moving. .

4. The robot autonomous navigation method based on local information according to claim 1, characterized in that, The mathematical expression for the preprocessing function in step 1.5 is: （1） in: This is the preprocessed value; It is the maximum value after preprocessing; It is the raw data; It is the minimum value of the original data; This is a user-defined constant used to control the slope of the preprocessing function. The larger the value, the greater the initial slope of the preprocessing function.

5. The robot autonomous navigation method based on local information according to claim 1, characterized in that, Step 2 employs a deep reinforcement learning algorithm to train the autonomous navigation model, including the following sub-steps: Step 2.1: Initialize the neural network model: Set up one action network. and 2 rating networks The corresponding adjustable parameters are as follows: The input-output relationships are as follows: Action Network Input status Output Action Evaluation network enter Output Value Assessment ; Step 2.2, Initialize parameters: Initialize motion noise Future reward discounts Network update interval and network update range ; Step 2.3: Define the target network: Use the neural network model from Step 2.1 as the target network. ; Step 2.4, Update the network: Randomly select from the experience pool One data point as sample data Update the evaluation network : （2） Step 2.5, repeat step 2.4, with an interval. Step, update the action network using formula (3). Use equation (4) to update all target networks; （3） （4） Step 2.6: Output a neural network model with autonomous navigation capabilities. As an autonomous navigation model.

6. The robot autonomous navigation method based on local information according to claim 1, characterized in that, The process of exporting and encapsulating the trained autonomous navigation model in step 3 is as follows: The neural network model trained in the PyTorch framework is converted into an autonomous navigation model in ONNX format and encapsulated. The model supports reading one-dimensional vectors and performing internal inference, and synchronously outputs control commands to the robot.

7. The robot autonomous navigation method based on local information according to claim 1, characterized in that, Step 4 includes the following sub-steps: Step 4.1: Receive the target location for the current navigation from the system; Step 4.2: Select a suitable robot model and configure the required sensors to build a positioning system within the robot's working range to provide the robot's real-time pose. Step 4.3: Equip the system with the same type of sensor as the virtual navigation platform and process the relevant information in the same way to obtain the input vector of the autonomous navigation model; Step 4.4: Directly transfer the autonomous navigation model trained on the virtual navigation platform to the robot equipped for the actual task; Step 4.5: The autonomous navigation model infers the desired speed based on the input vector and sends commands to control the robot's speed; Step 4.6: The robot continuously adjusts its speed according to the action instructions output by the autonomous navigation model until it successfully reaches the set target point, and then waits for the system to issue a new task.

8. An electronic device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the program, it implements the method as described in any one of claims 1 to 7.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the program is executed by the processor, it implements the method as described in any one of claims 1 to 7.

Images