A method for visualizing rapid implementation of robot simulation operation display

Abstract

This invention relates to the fields of data processing and artificial intelligence technology, and discloses a method for rapidly visualizing and displaying robot simulation operations. The method includes the following steps: defining a data flow processing model containing a dynamic metadata container; generating an initial model and reinforcement learning optimization strategy using AI based on business constraints; monitoring the operational status and generating feedback signals by quantifying the deviation between operator intervention and system autonomy; analyzing the status to locate anomalies and writing the structured analysis results back to the metadata container; combining the feedback signals and analysis results to correct the reinforcement learning reward function, iteratively optimizing the strategy and driving model evolution; finally, rendering the simulation data output from the processing pipeline in real time and displaying the simulation process visually. This invention utilizes a dynamic metadata container and generative AI to construct a dual closed loop of online fine-tuning and offline structural evolution, and quantifies operator feedback to guide reinforcement learning, achieving deep adaptive optimization.

Description

Technical Field

[0001] This invention relates to the fields of data processing and artificial intelligence technology, specifically to a method for quickly and visually displaying robot simulation operations. Background Technology

[0002] With the rapid development of fields such as the Internet of Things, fintech, and real-time communications, low-latency, high-reliability real-time processing of massive data streams has become a core requirement for many application scenarios. Data stream processing systems typically need to cope with dynamic changes in data volume, data distribution, and business logic. Static, pre-configured processing strategies often struggle to maintain optimal performance in continuously changing operating environments. Therefore, developing intelligent data stream processing technologies that can self-adjust and continuously optimize is an important direction for current technological development.

[0003] To address these challenges, several automated data stream processing solutions have emerged in existing technologies. These solutions typically implement this by defining a processing pipeline consisting of multiple processing nodes, where the behavior of each node is controlled by a set of configurable parameters. Simultaneously, the system deploys monitoring components to collect key performance indicators of the processing pipeline in real time, such as throughput and latency. When performance indicators deviate from preset targets, an independent optimization controller adjusts certain parameters in the processing pipeline based on predefined rules or simple predictive models. For example, it dynamically increases or decreases the parallelism of nodes or adjusts the buffer size, aiming to bring system performance back to normal levels.

[0004] While existing technologies have achieved some degree of automation in adjusting data stream processing systems, several shortcomings remain: their optimization capabilities are limited to shallow parameter fine-tuning, lacking the ability to deeply evolve the processing model's structure. This is because the processing model or configuration file in existing technologies is essentially a static design blueprint, separate from the system's actual runtime history. The system lacks an inherent mechanism to structurally record and correlate recurring performance bottlenecks or anomalies at specific nodes. Therefore, when optimization problems are rooted in the topology of the processing pipeline or inappropriate operator selection, parameter adjustments alone cannot fundamentally solve the problem. Furthermore, existing technologies suffer from gaps in integrating human expert experience. When domain experts manually intervene in system parameters based on experience, this intervention is typically a one-off, open-loop operation. The system lacks a standardized mechanism to transform this valuable intervention into a quantifiable feedback signal that can be understood and absorbed by the machine learning model. This prevents the expert's tacit knowledge from being effectively transferred to the automated optimization strategy, causing the AI's learning process to become disconnected from valuable human experience. Finally, the initial deployment and configuration process of existing systems remains complex and inefficient, heavily reliant on manual design by domain experts. The root cause is that there is a lack of an automated translation and generation bridge between high-level, vague business requirements and specific, refined technical implementations, which makes the entire construction process time-consuming and labor-intensive, and makes it difficult to guarantee the rationality of the initial configuration. Summary of the Invention

[0005] To address the shortcomings of existing technologies, this invention provides a method for quickly and visually displaying robot simulation operations. This method solves the problems in existing data stream processing technologies, where optimization mechanisms are limited to parameter adjustments, lack structural evolution capabilities, and cannot effectively integrate human expert intervention to achieve deep adaptive optimization.

[0006] To achieve the above objectives, the present invention provides the following technical solution: a method for quickly and visually displaying robot simulation operations, the method comprising the following steps: The data stream processing pipeline is defined in a structured manner, generating a processing model file containing a dynamic metadata container; Based on business constraints, an initial version of the processing model file is generated using a generative artificial intelligence model, and a reinforcement learning framework is constructed as the initial dynamic optimization strategy. The operation status of the data stream processing pipeline is monitored in real time, and the operator's interactive intervention is quantified into an operator feedback signal by calculating the cumulative deviation between the performance trajectory under the autonomous control of the system and the performance trajectory after operator intervention. By integrating multiple key performance indicators to calculate a comprehensive health score, the operating status is analyzed and abnormal events are located. The analysis results are then written back to the dynamic metadata container of the processing model file in a structured form. Based on the operator feedback signals and the analysis results, the reward function of the reinforcement learning framework is modified to iterate the dynamic optimization strategy and drive the evolution of the processing model file; The simulation state data output from the data stream processing pipeline is rendered in real time to display the robot's simulation operation process in a visual form.

[0007] Preferably, the dynamic metadata container is used to store at least one set of runtime information selected from performance metric snapshots, exception event logs, and operator intervention records.

[0008] Preferably, generating the initial version using a generative artificial intelligence model includes: The business constraints are formalized into constraint vectors; The constraint vector is input into the generative artificial intelligence model to output an initial version of the processed model file.

[0009] Preferably, constructing a reinforcement learning framework includes: The reward function of the reinforcement learning framework is initially defined as a weighted combination of task completion reward, system efficiency reward, and comprehensive penalty term.

[0010] Preferably, the operator's interactive intervention includes at least one of the following methods: direct parameter modification, policy rule injection.

[0011] Preferably, after locating the abnormal event, the analysis results include event type, timestamp, severity level, and context snapshot.

[0012] Preferably, the modified reward function of the reinforcement learning framework includes: The operator feedback signal and the analysis results read from the dynamic metadata container are used to instantiate the comprehensive penalty term in the reward function.

[0013] Preferably, iterating the dynamic optimization strategy includes: Based on the revised reward function, the policy of the reinforcement learning framework is updated online to continuously fine-tune the configurable parameters in the processing model file.

[0014] Preferably, the process of driving the evolution of the processing model file includes: When the preset triggering conditions are met, the processing model file containing the analysis results is used as input, and the generative artificial intelligence model is used to generate a new version of the processing model file with improved structure.

[0015] Preferably, the preset triggering conditions include at least one of the following: the time period has elapsed, the overall health score of the system remains below a threshold, or the number of negative events accumulated in the dynamic metadata container exceeds a threshold.

[0016] This invention provides a method for quickly and visually displaying robot simulation operations. It offers the following advantages: 1. This invention achieves deep self-optimization and high environmental adaptability by constructing a dual closed-loop optimization system that nests online parameter fine-tuning and offline structural evolution. Unlike traditional methods that can only optimize parameters, this invention sets up a dynamic metadata container in the processing model file, enabling the system to accumulate abnormal events and operator intervention records generated during runtime. When triggering conditions are met, this accumulated metadata will be used as input to guide the generative artificial intelligence model to fundamentally regenerate the topology of the processing pipeline, thereby repairing deep-seated design flaws and enabling the system to adapt to long-term and fundamental changes in data patterns.

[0017] 2. This invention transforms a single operator intervention into a clear feedback signal by calculating the cumulative deviation between the two performance trajectories after autonomous system control and manual intervention. This signal is directly used to correct the reward function in the reinforcement learning framework, thereby transforming the implicit experience of human experts into explicit knowledge that machines can learn, guiding the AI ​​agent to quickly learn better control strategies, and improving the accuracy and robustness of the optimization strategy.

[0018] 3. The AI ​​generation and optimization engine of this invention can automatically transform these business constraints into an executable processing model file with a complete structure and initially effective parameters, and simultaneously initialize the corresponding dynamic optimization strategy, thereby significantly shortening the cycle from requirements to system launch, reducing the dependence on the professional skills of configuration personnel, improving the deployment efficiency of the data flow processing system, and reducing the complexity of initial configuration. Attached Figure Description

[0019] Figure 1 This is a schematic diagram of the method flow of the present invention; Figure 2 This is a schematic diagram of the data stream processing model structure of the present invention; Figure 3 This is a schematic diagram illustrating the working principle of the AI ​​generation and optimization engine of the present invention; Figure 4 This is a functional block diagram of the real-time monitoring and interaction module of the present invention; Figure 5 This is a schematic diagram of the workflow of the intelligent analysis and annotation module of the present invention; Figure 6 This is a schematic diagram of the workflow of the intelligent analysis and annotation module of the present invention. Detailed Implementation

[0020] The technical solutions in 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 embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0021] Please refer to the appendix. Figure 1 , Figure 1 This is a schematic diagram of a method flow according to an embodiment of the present invention. The present invention provides a method for rapidly realizing closed-loop visualization of robot simulation operation display. This method uses a closed-loop, data-driven mechanism to automate and intelligently adjust and optimize the closed-loop data stream processing of robot simulation. In a specific implementation, the method may include the following steps: S1: Define and initialize the closed-loop data flow processing pipeline for closed-loop robot simulation in a structured manner, and generate an evolvable processing model file containing a dynamic metadata container.

[0022] S2: Based on the preset closed-loop simulation task closed-loop business constraints, AI technology is used to automatically generate the initial processing model and its dynamic optimization strategy.

[0023] S3: During the operation of the closed-loop simulation closed-loop system, the data flow processing process is monitored in real time, and interactive interventions from the operator are quantitatively collected as feedback signals.

[0024] S4: Performs intelligent analysis of the system's real-time operating status, locates potential performance bottlenecks or abnormal events, and annotates the analysis results in a structured form and writes them back to the processing model file.

[0025] S5: Based on real-time operator feedback signals and system status analysis results, perform closed-loop iteration of AI optimization strategies and drive the continuous evolution of processing models.

[0026] Closed-loop S6: Real-time rendering of the simulation status data output from the processing pipeline to visualize the closed-loop simulation operation process of the robot.

[0027] The method provided in this embodiment of the invention is executed by a closed-loop robot simulation and optimization system. This system may include: a dynamic model definition module 10, an AI generation and optimization engine 20, a real-time monitoring and interaction module 30, an intelligent analysis and annotation module 40, and a visualization rendering engine 50.

[0028] In step S1, the dynamic model definition module 10 is responsible for defining and generating a structured processing model file. This file represents the entire closed-loop robot simulation closed-loop data flow processing pipeline as an ordered composition of a series of processing functions. For example, a typical grasping task pipeline can be defined as a series structure of environment perception, posture calculation, path planning, and dynamic control. Each function corresponds to a processing node and contains a set of configurable parameters. In this structured file, a metadata container is predefined for each processing node, which is used to write runtime feedback information in subsequent steps.

[0029] In step S2, the AI ​​generation and optimization engine 20 generates a processing model based on the initial business constraints. In the robot grasping scenario, the business constraints can be a target grasping success rate of no less than 98% and a simulation time of no more than 2 seconds for a single task planning and execution.

[0030] The AI ​​generation and optimization engine 20 includes a generative model trained to learn the mapping relationship from input business constraints to the complete processing model file. Simultaneously, the AI ​​generation and optimization engine 20 constructs a reinforcement learning framework for dynamic optimization, whose behavior is guided by a reward function. This reward function is initially defined as a weighted combination of the task completion closed loop (e.g., capture success rate), the system efficiency closed loop (e.g., simulation frame rate, planning time), and a penalty term. The content of the penalty term will be dynamically determined by the output of subsequent steps.

[0031] In step S3, the real-time monitoring and interaction module 30 is responsible for monitoring the system and collecting operator feedback. When the operator intervenes manually, for example, observing a continuous shift in the robot's target object position in the visualization interface and manually adjusting the confidence threshold of the target recognition algorithm in the environmental perception node, the real-time monitoring and interaction module 30 quantifies the intervention behavior into a feedback signal. The value of this signal represents the cumulative deviation between the closed loop of the system's performance trajectory under autonomous control (such as the grasping success rate curve under autonomous control) and the closed loop of the actual performance trajectory achieved after operator intervention (such as the grasping success rate curve after parameter adjustment) over a period of time.

[0032] In step S4, the intelligent analysis and annotation module 40 analyzes the real-time status of the system. This module establishes a system health assessment model, calculating a comprehensive health score by fusing multiple key performance indicators, such as processing delay loops (e.g., computational delays in path planning), throughput and error rate loops (e.g., failure rates in inverse kinematics calculations). When this score falls below a preset threshold, the intelligent analysis and annotation module 40 identifies the root cause of the problem (e.g., identifying a path planning node computation timeout due to increased environmental complexity) and writes the structured information of this abnormal event back to the metadata container of that node in the processing model file.

[0033] In step S5, the AI ​​generation and optimization engine 20 performs closed-loop iterative optimization. Based on the outputs of steps S3 and S4, it modifies and instantiates the penalty term in the reward function, that is, it integrates the quantified operator feedback signals and the abnormal event information read from the processing model file into the reward calculation. Based on this modified reward function, the AI ​​generation and optimization engine 20 continuously updates its optimization strategy and can regenerate the structure of the processing model itself based on the accumulated metadata annotations. For example, if metadata shows that a path planning algorithm repeatedly times out in complex scenarios, the AI ​​engine can replace the algorithm node in the processing model with a new algorithm node that is more computationally efficient, thus forming a complete and adaptive optimization loop.

[0034] In step S6, the visualization rendering engine 50 is responsible for displaying the robot's simulation operations. This engine continuously receives real-time data streams from the end of the processing pipeline (such as dynamic control nodes). These data streams contain the precise state of the robot at each simulated step in the virtual world, such as the angles of each joint, the 3D spatial pose of the end effector, and the position information of target objects in the scene. Based on this real-time state data, the visualization rendering engine 50 drives the pre-loaded 3D digital model of the robot and the virtual scene model, performing real-time rendering through graphics calculations. Ultimately, this results in a continuous and smooth animation of the robot's operation in the virtual 3D environment, displayed on the display device. Simultaneously, this visualization interface also serves as the entry point for the operator to observe and interact in step S3.

[0035] Please see the appendix Figure 2 , Figure 2 This is a schematic diagram of a data stream processing model structure according to an embodiment of the present invention. Step S1 in this embodiment, namely the structured definition and initialization of the data stream processing model, is the foundation for realizing the entire closed-loop self-optimizing system. The goal of this step is to generate a processing model file that can not only be accurately parsed and executed by the machine, but also carry and transmit runtime dynamic information.

[0036] In one specific implementation, this step may further include the following sub-steps: S11: Mathematically abstracting a complete data stream processing pipeline as an ordered composition of a series of processing operators. A data stream processing pipeline consists of multiple processing nodes connected in a specific topology. Each processing node performs one or more data transformation, filtering, aggregation, or analysis functions. The overall function of the pipeline can be expressed as a composite function:

[0037] ; In the formula, This is the final output data stream after processing through the entire processing pipeline; The raw input data stream that enters this processing pipeline; To handle the first in the pipeline Each processing node executes a data processing operator that represents a specific data transformation, analysis, or filtering function. In order to be with the first Processing operator The associated configurable parameter vector contains control parameters. All adjustable parameters of the behavior; This represents the total number of processing nodes in the processing pipeline.

[0038] S12: Based on the above mathematical abstraction, design a structured, machine-readable description file format for instantiating and defining the processing pipeline. This format can be, but is not limited to, Extensible Markup Language (XML), JavaScript Object Notation (JSON), or YAML markup language. This file precisely describes the topology of the processing pipeline, including the definitions of all processing nodes and their data flow.

[0039] For each processing node, its definition in the description file must include at least: a unique node identifier, and the processing operator it executes. The type or reference, and its initial configuration parameter vector. For example, a processing node that performs a sliding window average will explicitly specify the operator type as MovingAverage in its definition and include parameters such as windowSize=1.

[0040] S13: In this structured description file format, a dynamic metadata container is innovatively added to the definition of each processing node. This container is a core technical feature that distinguishes this invention from existing static configuration files. The purpose of this container is not to statically configure the processing logic of the nodes, but to serve as a reserved data structure for the intelligent analysis and annotation module 40 of the system to dynamically and structurally write feedback information during system operation.

[0041] This metadata container is used to store various types of runtime information, including but not limited to: Performance metric snapshot: Records key performance metrics of a node at a specific point in time, such as average processing latency, instantaneous throughput, and CPU and memory resource utilization.

[0042] Exception Event Log: Records exception events that occurred at this node and whose root causes have been identified, such as a sudden increase in data processing error rate, abnormal deviation in output data distribution, or prolonged blocking / waiting. Each log entry includes the event type, timestamp, severity level, and relevant contextual parameters.

[0043] Operator Intervention Record: Records the parameters configured by the operator for this node. The manual adjustment history includes parameter values ​​before and after the adjustment, adjustment time, etc.

[0044] By adding this dynamic metadata container, the processing model file is transformed from a static design blueprint into a dynamic runtime archive. It carries the historical performance and health status of the processing pipeline in a real operating environment, providing direct and verifiable data input for subsequent intelligent closed-loop optimization.

[0045] S14: Execute the initialization generation process of the execution model. In one embodiment, the dynamic model definition module 10 calls a preset template or initialization service to automatically generate a complete processing model file that conforms to the above format definition, based on the initial business requirements (e.g., the data type to be processed, the expected processing goal).

[0046] This file contains the initial topology of the processing pipeline, as well as the initial configuration parameter vectors for all processing nodes. At this point, the dynamic metadata containers in all nodes are empty, awaiting system startup to be filled. This automated generation process replaces the traditional manual configuration file writing, ensuring the standardization and efficiency of model initialization.

[0047] Please see the appendix Figure 3 , Figure 3This is a schematic diagram illustrating the working principle of an AI generation and optimization engine according to an embodiment of the present invention. Step S2 in this embodiment, namely, the automated generation of the initial processing model and its dynamic optimization strategy, is executed by the AI ​​generation and optimization engine 20. The goal of this step is to transform high-level, unstructured business requirements into a concrete, immediately deployable, and initially self-optimizing intelligent processing system.

[0048] In one specific implementation, this step may further include the following sub-steps: S21: Formalize the input business constraints. Business constraints are a set that defines the objectives and limitations of the data processing task, and may specifically include: Task objective constraints: For example, for a real-time fraud detection task, the objective is to maximize the detection accuracy or F1 score; for a time series prediction task, the objective is to minimize the root mean square error (RMSE).

[0049] Performance constraints: For example, the average end-to-end processing latency must not exceed 1 millisecond; the resource utilization rate of the system should be less than 80% when processing peak data streams.

[0050] Data characteristic constraints: such as the format of the input data stream, the statistical distribution range of key features, etc.

[0051] These business constraints are transformed into a machine-readable constraint vector. , as input to the AI ​​generation and optimization engine 20.

[0052] S22: Based on constraint vectors This approach utilizes generative artificial intelligence models to automatically generate initial processing model files. In one embodiment, this functionality can be implemented using a variational autoencoder (VAE) architecture. The model is trained by maximizing the lower bound of evidence (ELBO), with the objective function being:

[0053] ; In the formula, The lower bound objective function for evidence is used to train the generative model; The parameter set of the decoder network controls the process of generating the processing model from the latent variables; The set of parameters for the encoder network controls the process of mapping business constraints to latent variables; The input business constraints include requirements such as task objectives, performance metrics, and data characteristics; The output processing model file contains the complete structure and parameter configuration of the data flow processing pipeline; These are latent variables, representing business constraints in a low-dimensional latent space; Define a given service constraint for the encoder network. Latent variables The posterior probability distribution; Decoder network, defining a given latent variable Time-based processing model The likelihood probability; This is the KL divergence operator, used to measure the difference between two probability distributions; Latent variables The prior probability distribution of is usually assumed to be the standard normal distribution.

[0054] Through this process, the AI ​​generation and optimization engine 20 can automatically and from scratch build an initial, structurally sound processing model with preliminarily effective parameter configuration based on business needs.

[0055] S23: Simultaneously with generating the processing model, construct and initialize a reinforcement learning (RL) framework for online dynamic optimization. The goal of this framework is to continuously fine-tune the parameters of the processing model based on real-time states during system runtime. The establishment of this framework includes a clear definition of the three elements of a Markov decision process (MDP): State : Defines the system in All observable, decision-related information at any given moment. In a specific embodiment, the state vector... This may include: key statistical characteristics of the input data stream (such as mean, variance, arrival rate), buffer queue lengths of key nodes in the processing pipeline, real-time processing latency of each node, and the utilization rate of system hardware resources (CPU, memory).

[0056] Action This defines a set of discrete or continuous operations that an AI agent can perform to adjust system behavior. In one specific embodiment, the action space may include: a configuration parameter vector for any processing node. You can fine-tune a parameter in the system (e.g., increase or decrease the threshold of a filter) or adjust the resource allocation strategy between nodes.

[0057] Reward Function Defines the state of the AI ​​agent. Next action Subsequently, the system provides immediate feedback signals to guide its learning. During the initialization phase, the reward function is set to a basic version:

[0058] ; In the formula, In time step The system provides an immediate reward value to the AI ​​agent. The weighting coefficient for task completion rewards is used to adjust the importance of the task objective in the total reward. Rewards are given based on task completion, quantifying the degree to which data processing tasks (such as accuracy and error) are achieved. This is a weighting coefficient for system efficiency rewards, used to adjust the importance of efficiency indicators in the total reward. To reward system efficiency, quantify the degree of optimization of performance indicators such as resource utilization, throughput, or latency; This represents the weighting coefficient of the comprehensive penalty item; This is a comprehensive penalty item used to punish negative events such as operator intervention or system anomalies. In this initialization phase, this penalty item only includes penalties for serious system errors, such as actions that cause system crashes or violate hard constraints.

[0059] After this step is completed, a reinforcement learning agent with a preliminary optimization strategy is created and associated with the processing system, preparing it for subsequent online and closed-loop learning.

[0060] Please see the appendix Figure 4 , Figure 4 This is a functional block diagram of a real-time monitoring and interaction module according to an embodiment of the present invention. Step S3 in this embodiment, namely, real-time monitoring and quantitative collection of operator feedback during system operation, is executed by the real-time monitoring and interaction module 30. This step serves as a bridge connecting the automated system and human experts, aiming to make the system's internal operating status transparent to the operator and capture valuable interventions made by the operator based on their experience and knowledge, transforming them into structured information that can be learned by AI.

[0061] In one specific implementation, this step may further include the following sub-steps: S31: Performs multi-dimensional, real-time data acquisition and visualization of key performance indicators (KPIs) in the data stream processing pipeline. The real-time monitoring and interaction module 30 continuously collects runtime data from various nodes of the processing pipeline through built-in data probes.

[0062] The collected indicators include, but are not limited to: Data flow metrics: input / output data rate of each node, average size of data packets, and real-time statistical distribution of key data features (such as mean, variance, and quantiles).

[0063] Performance metrics: end-to-end processing latency, throughput, buffer queue length, and wait time for each node.

[0064] Resource metrics: number of CPU cores used by each node, memory usage, and network bandwidth.

[0065] The collected real-time data is presented through a visual monitoring interface. This interface uses various formats such as topology diagrams, time series diagrams, and dashboards to intuitively display the health status and bottlenecks of the entire processing pipeline, providing data support for operator judgment and intervention.

[0066] S32: Provides a human-machine interface that allows authorized operators to intervene and adjust parameters of the running processing pipeline online. When operators find through the visual interface that the system's automatic optimization strategy is failing to achieve the expected results, or is slow to respond to sudden changes in data patterns, they can intervene manually.

[0067] Specific forms of intervention include: Direct parameter modification: Operators can directly modify the configuration parameter vector of any processing node. One or more parameter values ​​in the table. For example, in an anomaly detection node, the detection threshold can be manually increased to reduce the false alarm rate.

[0068] Policy rule injection: Operators can set temporary or permanent coverage rules. For example, a rule can be set to force the parallelism of node X to be set to Y when the input data rate exceeds a certain threshold. This rule has higher priority than the autonomous decision-making of the AI ​​agent.

[0069] S33: Capture and record every effective intervention by the operator, and mathematically quantify it into a feedback signal. This is key to transforming the tacit knowledge of human experts into explicit signals that machines can understand. When an intervention occurs, the real-time monitoring and interaction module 30 records the entire context of the intervention, including the target node of the intervention, the modified parameters, the values ​​before and after the modification, and the time point of the intervention.

[0070] The system then quantifies this intervention as a scalar signal. In one embodiment, this signal is defined as the cumulative deviation between the key performance indicators (KPIs) autonomously controlled by the system and the KPIs expected after operator intervention, over a time window following the intervention. The calculation formula is as follows:

[0071] ; In the formula, This is the quantified operator feedback signal; The start time when operator intervention takes effect; To assess the end time of the time window; The time series of a key performance indicator that is autonomously controlled by the system before operator intervention; The actual time series of this key performance indicator after manual adjustment by the operator; This is a norm operator used to calculate the distance between two time series; Let be the time derivative, and represent the integral variable.

[0072] Please see the appendix Figure 5 , Figure 5 This is a schematic diagram of the workflow of an intelligent analysis and annotation module according to an embodiment of the present invention. Step S4 in this embodiment, namely, intelligent analysis of the system's operating status and execution of dynamic model annotation, is performed by the intelligent analysis and annotation module 40. This step constitutes the system's automated diagnostic center, aiming to proactively and continuously assess the system's health status, accurately pinpoint the root cause when performance degrades or anomalies occur, and solidify this valuable diagnostic information into the processing model itself.

[0073] In one specific implementation, this step may further include the following sub-steps: S41: Establish a comprehensive system health assessment model to quantitatively evaluate the overall operational status of the data flow processing pipeline. This model does not rely on a single performance metric, but rather weights and integrates multiple key performance indicators (KPIs) to generate a unified health score H. The formula for calculating this score is as follows:

[0074] ; In the formula, This represents the system's overall health score. The total number of key performance indicators included in the evaluation model; For the first The weighting coefficients of each key performance indicator are preset according to business needs and meet the normalization conditions. For application to the The normalization function of each key performance indicator is used to map the original indicator values ​​to a uniform evaluation scale. For the first Real-time observations of key performance indicators.

[0075] S42: After detecting an abnormal system health status, execute the root cause localization algorithm to determine the specific processing node or parameter causing the decrease in the health score H. Root cause localization is a prerequisite for achieving accurate optimization. In one embodiment, it can be achieved by combining one or more techniques: Contribution analysis: Through the analysis of various factors... The contribution of the overall score decline to identify which key performance indicators (KPIs) contributed to it. The deterioration of [something] is the main reason.

[0076] Correlation analysis: The deteriorating performance indicators are correlated with the runtime parameters and resource consumption of each processing node over time to identify the nodes with the highest correlation to performance degradation.

[0077] Dependency graph tracing: Based on the data flow topology dependency graph of the processing pipeline, starting from the output end where the problem is observed, trace upstream to check whether the intermediate outputs of each node meet expectations, thereby locating the first node that has an anomaly.

[0078] The final output of this sub-step is a unique identifier for one or more processing nodes that caused this system anomaly.

[0079] S43: The root cause localization analysis results are structured and encapsulated, and then written back to the processing model file in the form of dynamic annotations. This is the core mechanism for transforming transient system diagnostic results into persistent, learnable model memory.

[0080] Once the problem node is located in step S42, the intelligent analysis and annotation module 40 will generate a structured risk event object. This object contains a complete profile of this abnormal event, and specific fields may include: Event Type: For example, latency exceeding limits, throughput decrease, error rate surge.

[0081] Timestamp: The precise time when an event was detected.

[0082] Severity level: For example, warning, serious, fatal.

[0083] Problematic Parameter: If a specific parameter is misconfigured, record the name of that parameter.

[0084] ContextualData: Records the system state related to the event when it occurs, such as the characteristics of the input data stream at that time and the resource usage of the node.

[0085] Subsequently, the intelligent analysis and annotation module 40 will parse the currently used processing model file, locate the definition section of the node in the file based on the located node identifier, and then add the risk event object generated above. The data is completely written into the dynamic metadata container reserved for that node. This write operation has evolved the content of the processing model file itself. It is no longer just a static configuration, but a living document that dynamically accumulates its own running history, fault records, and performance bottlenecks, providing accurate and rich historical data for the closed-loop optimization in step S5.

[0086] Please see the appendix Figure 1 In this embodiment of the invention, step S5, namely the iterative optimization of the system based on closed-loop feedback, is executed by the AI ​​generation and optimization engine 20. This step is the convergence point and driving core of the entire self-optimization method. Its goal is to integrate all feedback information from internal system state analysis and external operator intervention to form a continuous, dual-loop optimization mechanism, thereby driving the continuous evolution of the processing model and its optimization strategy.

[0087] In one specific implementation, this step may further include the following sub-steps: S51: Dynamically and feedback-drivenly modify the reward function in the reinforcement learning framework. This step incorporates the discrete feedback signals collected and generated in steps S3 and S4 into the real-time reward calculation defined in step S2. Specifically, the reward function... Comprehensive penalty items Instantiated as:

[0088] ; In the formula, This represents the weighting coefficient of the comprehensive penalty item; Penalty weights for operator feedback signals; The quantized value of the operator feedback signal; For the first The penalty weighting for different types of risk events; For the first read from the processing model file Quantitative values ​​of various risk events; Index for the types of risk events.

[0089] When the system receives this signal, it is used to calculate a one-time penalty to prompt the AI ​​agent's strategy to adjust in the direction desired by the operator.

[0090] Through this correction mechanism, the reward function is transformed from a static evaluation function based solely on tasks and efficiency into a dynamic, context-aware evaluation function that can reflect comprehensive feedback from both internal and external systems in real time.

[0091] S52: Performs online, continuous policy fine-tuning and optimization. The reinforcement learning agent within the AI ​​generation and optimization engine 20 continuously learns and updates the policy based on the revised reward function, which includes complete feedback information.

[0092] In one specific implementation, the agent operates in a continuous loop: at each decision moment... It observes the current system state. It outputs an action based on its internal policy network (such as a deep neural network). (That is, a parameter adjustment), after this action is performed, the system transitions to the new state. And calculate the instant reward The agent uses this (state, action, reward) tuple to update the weights of its policy network using algorithms such as Policy Gradient or Q-Learning.

[0093] This continuous fine-tuning process enables the AI ​​agent to adjust the configuration parameters of each node in the processing pipeline online and in small, rapid steps, in order to adapt to subtle fluctuations in data flow characteristics in real time and gradually learn to avoid behavioral patterns that would lead to operator intervention or system anomalies.

[0094] S53: When specific triggering conditions are met, perform offline, structured processing model regeneration. Online strategy fine-tuning mainly addresses parameter-level optimization, while this step aims to address deeper, structural model defects.

[0095] Conditions that trigger this step may include: Time-cycle triggering: For example, the model is regenerated every 24 hours of system operation or after processing 1TB of data.

[0096] Performance degradation trigger: When the system's overall health score H remains below a certain threshold and online fine-tuning fails to restore it.

[0097] Metadata accumulation trigger: When processing the metadata container of a node in the model file, accumulated negative events (such as risk events) are triggered. When the number of operator intervention records exceeds a preset threshold.

[0098] Once triggered, the AI ​​generation and optimization engine 20 will perform the following operations: It will use the currently processed model file, which carries rich runtime metadata annotations, as additional input to the generative AI model (e.g., VAE) defined in step S22. At this point, it not only learns from business constraints... To model The mapping learns to map from a model with specific historical flaws (metadata) to a better new model.

[0099] Generative models analyze failure modes in metadata and make fundamental, structural modifications to the topology of the processing pipeline or the selection of node operators during their decoding process. For example, they may replace a processing operator that has been found to be ineffective or add a data preprocessing node in front of a node that frequently causes data bottlenecks.

[0100] Ultimately, this step outputs a completely new, structurally improved next-generation processing model file. This new model can then be deployed online to begin a new round of online fine-tuning and data accumulation, thus forming a dual closed-loop optimization system that nests higher-dimensional, longer-cycle online parameter fine-tuning and offline structural evolution.

[0101] Please refer to the appendix. Figure 6 , Figure 6 This is a functional block diagram illustrating the interaction between a visualization rendering engine and a data processing pipeline according to an embodiment of the present invention. In this embodiment, the final display of the robot simulation operation is the process of transforming the high-dimensional, abstract simulation state data generated by the data stream processing pipeline into a continuous and smooth three-dimensional dynamic image that is intuitively perceptible to humans. This process is not only the presentation of results but also a key carrier for realizing human-computer interaction and closed-loop feedback. In a specific implementation, this step is executed by a visualization rendering engine 50, which, as an independent module, is tightly coupled with the aforementioned data stream processing pipeline. Its specific implementation may include the following sub-steps: S61: Establish a low-latency, high-throughput data subscription and distribution interface for real-time acquisition of the robot simulation status output from the data stream processing pipeline. This interface is fundamental to achieving synchronization between visualization and simulation calculations. In one embodiment, this interface can be implemented based on a shared memory mechanism. The final node of the data stream processing pipeline directly writes the calculated status data packets into a pre-allocated shared memory region, while the visualization rendering engine 50 polls this memory region frequently in read-only mode, thereby minimizing the overhead of data copying and inter-process communication.

[0102] A state data packet is a structured collection of data whose specific content is clearly defined. It includes at least: an N-dimensional floating-point vector describing the real-time angles of all N joints of the robot, and a septon describing the pose of the robot's end effector center point in the world coordinate system. ), as well as the pose information of all dynamic objects in the scene (such as the workpiece to be grabbed) and the timestamp of the simulation world.

[0103] S62: Performs time-series interpolation and smoothing on the received discrete state data packets to generate a continuous and smooth visual state sequence that matches the display device's refresh rate. Since the update frequency of the backend simulation calculation (e.g., 200Hz) and the refresh rate of the frontend display (e.g., 60Hz) may not be consistent, directly using simulation data can cause screen stuttering or jumps. To solve this problem, the visualization rendering engine 50 internally maintains a state buffer to store several recent historical state data packets. When a new frame needs to be rendered, the engine obtains the current rendering time point and finds the two simulation state data packets before and after that time point in the buffer.

[0104] Subsequently, an interpolation algorithm is used to calculate the precise state that should exist at the current rendering time point. For linear quantities such as position, linear interpolation (LERP) can be used for calculation; while for rotational quantities such as pose, spherical linear interpolation (SLERP) is used to ensure the shortest and smoothest rotation path. For example, at the rendering time... Visual pose of end effector The calculation method is as follows:

[0105] ; In the formula, The final calculation result represents the result at the rendering time. Smoothed robot end effector pose used to drive the display of a 3D digital twin model; This is the current rendering time point; For data received from the data stream processing pipeline, timestamp is The simulated pose data represents the initial state of the interpolation time interval; For data received from the data stream processing pipeline, timestamp is The simulated pose data represents the end state of the interpolation time interval; Initial simulation state The corresponding simulation timestamp; To end the simulation state The corresponding simulation timestamp; To be based on the current rendering time point Normalized interpolation coefficients calculated based on the relative positions between two simulation timestamps; It is a generalized interpolation operator.

[0106] This step ensures that even if the simulation data update frequency fluctuates, the robot movement footage seen by the user remains stable and smooth.

[0107] S63: Based on the interpolated and smoothed state data, it drives the real-time rendering of a 3D digital twin scene. This 3D digital twin scene is an accurate visual replica of the physical simulation environment, pre-loaded with high-precision 3D robot models, workpiece models, and environment models.

[0108] In the rendering process of each frame, the engine first performs state synchronization: it applies the smooth joint angle vectors calculated by S62 to the skeletal animation system of the robot model, and accurately updates the posture of each link of the model through forward kinematics calculation; at the same time, it directly assigns the calculated poses of the end effector and each workpiece to the corresponding 3D objects in the scene.

[0109] Once state synchronization is complete, the rendering pipeline starts, executing a series of graphics operations including but not limited to view transformation, lighting calculation, shadow generation, texture mapping, and final rasterization. This process renders the entire 3D scene into a 2D image and sends it to the display. This cyclical execution of the process ultimately creates the robot simulation animation seen by the user.

[0110] S64: This visual interface serves as a unified entry point for human-computer interaction, capturing operator intervention commands and feeding them back in a structured manner to the system's real-time monitoring and interaction module 30. This visual interface is not only used for display but also overlaid with rich graphical user interface (GUI) elements and supports direct interaction within a 3D scene.

[0111] The specific implementation is as follows: when an operator drags a slider in the parameter adjustment panel of the GUI to modify a weight parameter of a path planning node, the event listener on the front end of the interface will capture this operation and record the parameter identifier, the values ​​before and after the modification, and the current timestamp. Alternatively, when an operator directly drags the robot's end effector to a new desired position in the 3D view with the mouse, the system will capture this target pose.

[0112] These captured interaction events are encapsulated into standardized intervention instruction data packets and immediately sent to the real-time monitoring and interaction module 30 for quantification processing in step S33. This seamlessly integrates the intuitive operation of human experts into the entire AI optimization loop, forming a complete technical chain of display, observation, intervention, quantification, optimization, and re-display.

[0113] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A method for rapidly visualizing and displaying robot simulation operations, characterized in that, The method includes the following steps: The data stream processing pipeline is defined in a structured manner, generating a processing model file containing a dynamic metadata container; Based on business constraints, an initial version of the processing model file is generated using a generative artificial intelligence model, and a reinforcement learning framework is constructed as the initial dynamic optimization strategy. The operation status of the data stream processing pipeline is monitored in real time, and the operator's interactive intervention is quantified into an operator feedback signal by calculating the cumulative deviation between the performance trajectory under the autonomous control of the system and the performance trajectory after operator intervention. By integrating multiple key performance indicators to calculate a comprehensive health score, the operating status is analyzed and abnormal events are located. The analysis results are then written back to the dynamic metadata container of the processing model file in a structured form. Based on the operator feedback signals and the analysis results, the reward function of the reinforcement learning framework is modified to iterate the dynamic optimization strategy and drive the evolution of the processing model file; The simulation state data output from the data stream processing pipeline is rendered in real time to display the robot's simulation operation process in a visual form.

2. The method for quickly visualizing and displaying robot simulation operations according to claim 1, characterized in that, The dynamic metadata container is used to store at least one type of runtime information selected from performance metric snapshots, exception event logs, and operator intervention record groups.

3. The method for quickly visualizing and displaying robot simulation operations according to claim 1, characterized in that, The process of generating an initial version using a generative artificial intelligence model includes: The business constraints are formalized into constraint vectors; The constraint vector is input into the generative artificial intelligence model to output an initial version of the processed model file.

4. The method for quickly visualizing and displaying robot simulation operations according to claim 1, characterized in that, The construction of a reinforcement learning framework includes: The reward function of the reinforcement learning framework is initially defined as a weighted combination of task completion reward, system efficiency reward, and comprehensive penalty term.

5. The method for rapidly visualizing and displaying robot simulation operations according to claim 1, characterized in that, The operator's interactive intervention includes at least one of the following methods: direct parameter modification, policy rule injection.

6. The method for rapidly visualizing and displaying robot simulation operations according to claim 1, characterized in that, After locating the abnormal event, the analysis results include the event type, timestamp, severity level, and context snapshot.

7. The method for quickly visualizing and displaying robot simulation operations according to claim 4, characterized in that, The modified reward function of the reinforcement learning framework includes: The operator feedback signal and the analysis results read from the dynamic metadata container are used to instantiate the comprehensive penalty term in the reward function.

8. The method for rapidly visualizing and displaying robot simulation operations according to claim 7, characterized in that, Iterating the dynamic optimization strategy includes: Based on the revised reward function, the policy of the reinforcement learning framework is updated online to continuously fine-tune the configurable parameters in the processing model file.

9. The method for rapidly visualizing and displaying robot simulation operations according to claim 1, characterized in that, The evolution of the process model file is driven by: When the preset triggering conditions are met, the processing model file containing the analysis results is used as input, and the generative artificial intelligence model is used to generate a new version of the processing model file with improved structure.

10. The method for rapidly visualizing and displaying robot simulation operations according to claim 9, characterized in that, The preset triggering conditions include at least one of the following: the time period has been reached, the overall health score of the system is continuously lower than the threshold, or the number of negative events accumulated in the dynamic metadata container exceeds the threshold.

Images