Industrial robot software reliability test profile generation method and device based on large model and operation data and storage medium

Abstract

The invention discloses an industrial robot software reliability test profile generation method and device based on a large model and operation data, and a storage medium. The method comprises the following steps: collecting multi-modal data of an industrial robot in actual operation; on the basis of the aligned multi-modal data, segmenting a continuous data stream into independent motion segments according to a software event or a motion boundary, and constructing a feature representation for describing an event-response relationship; based on the extracted feature vectors, constructing a software event-motion response association model, and identifying a typical operation mode and an abnormal mode; and based on the obtained correlation model analysis result, carrying out inductive reasoning and probabilistic modeling by utilizing a large model, and generating a JSON format test profile. According to the method, low-frequency and hidden time sequence defects and logic errors can be efficiently and automatically found, and the test coverage rate and the fault reproduction capability are remarkably improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of industrial robot software testing and reliability engineering, and in particular to an industrial robot software reliability test profile generation method and device based on a large model and running data and a storage medium. BACKGROUND

[0002] Industrial robots, as the core equipment of intelligent manufacturing, directly affect the stability of the production line and the quality of the product. Traditional software reliability testing methods have problems such as insufficient extraction of motion / running mode, insufficient description of dynamic correlation between software and hardware levels, and difficulty in effectively capturing hidden defects caused by software and hardware interaction. Existing test profiles are mostly constructed based on static statistics or expert experience, and lack the ability to model dynamic, multi-scale coupled behaviors in actual operation. With the development of large model technology, its application in the field of software engineering provides a new possibility for constructing data-driven and dynamically evolving test profiles. SUMMARY

[0003] The technical problem to be solved by the present application is how to provide an industrial robot software reliability test profile generation method based on a large model and running data, which can efficiently and automatically discover low-frequency and hidden timing defects and logical errors, and significantly improve test coverage and fault reproduction capability.

[0004] To solve the above technical problems, the technical solution adopted by the present application is: an industrial robot software reliability test profile generation method based on a large model and running data, comprising the following steps: Collecting multi-modal data of the industrial robot in actual operation and aligning them with unified timestamps to form a multi-parameter time series set; Based on the aligned multi-modal data, the continuous data stream is divided into independent motion segments according to software events or motion boundaries, and a feature vector is extracted from the software event sequence and physical response data for each segment to construct a feature representation describing the event-response relationship; Based on the extracted feature vectors, a software event-motion response correlation model is constructed through unsupervised clustering and supervised learning methods to identify typical operating modes and abnormal modes, and to quantify the influence of events on motion states; Based on the analysis results of the obtained correlation model, a large model is used for inductive reasoning and probabilistic modeling to generate a structured, machine-readable JSON format test profile; Based on the generated test profile, software reliability test case sequences are automatically sampled and generated, the test is executed, and the results are verified using test prediction to discover and reproduce hidden defects in the software.

[0005] The application further discloses a computer device, which comprises a memory, a processor, and a computer program stored in the memory and executable on the processor, and the processor executes the computer program to realize the industrial robot software reliability test profile generation method.

[0006] The application further discloses a computer readable storage medium, which stores a computer program, and the computer program is executed by a processor to realize the industrial robot software reliability test profile generation method.

[0007] The method has the advantages that the method improves the discovery ability of low-frequency and hidden defects, especially time sequence and logical errors, reduces the dependence on expert experience, realizes the automation and standardization of the test process, and the generated test profile has clear probability semantics and interpretable structure, supports state machine level test case generation and assertion checking, and the effectiveness of the method in reproducing typical faults such as virtual pressure is verified through actual application cases. BRIEF DESCRIPTION OF DRAWINGS

[0008] The application will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0009] Figure 1 A main flowchart of the method according to the embodiments of the application is shown in the figure. Figure 2 A structure diagram of a computer device according to the embodiments of the application is shown in the figure. DETAILED DESCRIPTION

[0010] The technical solutions in the embodiments of the application will be described clearly and completely below with reference to the accompanying drawings in the embodiments of the application. In the following description, a large number of specific details are set forth in order to facilitate a thorough understanding of the application, but the application can also be implemented in other ways different from those described herein, and those skilled in the art can make similar generalizations without departing from the connotation of the application, so the application is not limited by the specific embodiments disclosed below.

[0011] Embodiment one: As shown in the figure, the embodiments of the application disclose an industrial robot software reliability test profile generation method based on a large model and running data, which comprises the following steps: Figure 1 S1: Collecting multi-modal data of an industrial robot in actual running, including software state sequence, control instruction data, joint space physical quantity, Cartesian space physical quantity and environment interaction data, and performing unified timestamp alignment to form a multi-parameter time sequence set; S1: Collecting multi-modal data of an industrial robot in actual running, including software state sequence, control instruction data, joint space physical quantity, Cartesian space physical quantity and environment interaction data, and performing unified timestamp alignment to form a multi-parameter time sequence set; S2: Based on the alignment data in step S1, the continuous data stream is segmented into independent motion segments according to software events or motion boundaries, and feature vectors are extracted from software event sequences and physical response data for each segment respectively, and a feature representation describing the "event-response" relationship is constructed; S3: Based on the feature vectors extracted in step S2, the "software event-motion response" correlation model is constructed by unsupervised clustering and supervised learning method, and the typical operation mode and abnormal mode are identified, and the influence of events on motion state is quantified; S4: Based on the correlation model analysis results obtained in step S3, the large model is used for inductive reasoning and probabilistic modeling to generate structured, machine-readable JSON format test profiles, which include state definition, transition rule, trigger event and its probability, data generation rule and test prediction; S5: Based on the test profile generated in step S4, the software reliability test case sequence is automatically sampled and generated, the test is executed and the result is checked by using the test prediction, so as to find and reproduce the hidden defects in the software.

[0012] The above steps will be described in detail in combination with specific methods: Step S1: Collecting multi-modal data of industrial robots in actual operation, including software state sequence, control instruction data, joint space physical quantity, Cartesian space physical quantity and environment interaction data, and performing unified timestamp alignment to form a multi-parameter time series set; Industrial robot operation mode analysis is the basis for establishing industrial robot software and hardware reliability test profile. In the analysis of industrial robot motion behavior, the traditional method only concerns about the end position, joint angle, speed and other basic indicators. The data granularity is coarse, and the analysis dimension is less. With the improvement of information technology, not only the position where the robot moves is mastered, but also how to move is seen, that is, the logic, state and decision process of the underlying control software are analyzed how to be reflected on the external motion. The core is to correlate and synchronize the external, continuous motion trajectory data with the internal, discrete software state and logic events, establish a unified mathematical model for industrial robot multi-modal data collection, and realize the dynamic system driven by internal software state and generating external physical response under unified time reference.

[0013] Its overall mathematical model can be expressed as a multi-parameter time series set: Dataset = { T, S(t), E, C(t), Θ(t), Φ(t), M(t)} Where: T is a unified time reference, which is the synchronization basis of all data collection, ensuring that data from different sources can be accurately aligned on the same time axis. T = {t0, t1, t2,..., tk}, where tk represents the kth sampling time.

[0014] S(t) is internal software state data (discrete events and states), reflecting the data of the internal logic, decision-making, and state machine of the control software. S_main(t) ∈ {S_IDLE, S_MOVING, S_ERROR, S_HOMING,...} is the state of the main control state machine at time t (e.g., idle, moving, error, homing).

[0015] E is external environment and task data, which is a discrete event sequence (Discrete Event Sequence), E = {(τ1, e1, d1), (τ2, e2, d2),..., (τ_m, e_m, d_m)}, τ is the timestamp of event occurrence, e is the event type, and d is the event additional data.

[0016] C(t) is control layer data (planning and servo), which is the expected motion command and bottom layer closed-loop control data calculated by the controller, connecting the bridge between software decision and physical execution. Reference Trajectory q_ref(t) = (q_{ref,1}(t), q_{ref,2}(t),..., q_{ref,n}(t))^T is the ideal position trajectory calculated by the planner, which is expected to be followed by the robot joints, and n is the number of joints Θ(t) is joint space physical data, which is directly measured by the robot body sensor and reflects the actual motion of the joint Φ(t) is Cartesian space physical data, which is the actual pose and motion information of the robot end effector (Tool Center Point, TCP) in three-dimensional space obtained through external measurement devices.

[0017] M(t) is robot and environment interaction physical data, which describes the information of the task performed by the robot and the environment it is in, providing context for motion analysis.

[0018] Step S2: Based on the aligned data in step S1, the continuous data stream is segmented into independent motion segments according to software events or motion boundaries, and feature vectors are extracted from software event sequences and physical response data for each segment, constructing a feature representation that describes the event-response relationship; The core idea of building the software event-motion response correlation model is to align the discrete software event sequence with the continuous physical signal on a unified time axis, and through feature engineering and machine learning model, to quantify the influence of events on the motion state, so as to discover the causal and statistical patterns.

[0019] First, all heterogeneous data (including event logs, trajectories, torques, etc.) are aligned to the same time axis using a unified high-precision timestamp T. Then, according to the triggering of software events or the natural boundaries of motion (such as start / stop), the continuous long-time sequence data is divided into multiple independent motion segments (Segment). Each segment represents a complete and meaningful motion unit, such as "moving from point A to point B". The continuous data stream Dataset is divided into M independent segments {Seg1, Seg2,..., Seg_M}, and the event types e_segment_start and e_segment_end are selected as the start and end markers of the segment.

[0020] Step S3: Based on the feature vectors extracted in step S2, the software event-motion response correlation model is built through unsupervised clustering and supervised learning methods, to identify typical and abnormal patterns, and to quantify the influence of events on the motion state; Multi-modal feature extraction: For each motion segment, a series of features are extracted from its internal software data (including S(t), C(t)) and external physical data (including Θ(t), Φ(t), M(t)). For each segment Seg_k, the event feature vector Fe describes the types, frequencies, sequences, and intensities of software events within the segment, and the response feature vector Fr describes the performance, quality, and physical state of the robot motion within the segment.

[0021] Correlation model construction represents each motion segment as a feature vector, and each motion segment is finally represented as a comprehensive feature vector F = [Fe, Fr]. Through unsupervised clustering, similar F vectors are clustered into a class, and each class represents a typical software event-motion response pattern. The K-Means or DBSCAN algorithm is used to cluster {F}, obtaining the clustering label L∈ {1, 2,..., C}, thereby dividing all motion segments into C clusters (Cluster). Subsequently, cluster pattern interpretation is performed to convert the data-driven clustering result into software event-motion response patterns with explicit engineering semantics.

[0022] The specific interpretation process includes: Centroid: For each cluster, compute the mean of all feature vectors in each dimension, and form the centroid feature vector F_center, which represents the typical feature of the mode.

[0023] Decompose the centroid vector F_center back to its sub-components, i.e., the typical event feature vector Fe_center and the typical response feature vector Fr_center. Analyze the values in the event feature vector Fe_center to identify the software cause of the physical manifestation. For example, if the event feature vector Fe_center of a cluster is "high frequency of E_OVERCURRENT events," then the software cause of the physical manifestation is "software bug in the overcurrent protection logic." Analyze the values in the response feature vector Fr_center to define the physical manifestation of the mode. For example, if the response feature vector Fr_center of a cluster is "high joint current peak" and "zero end force," then the physical manifestation is "actuator slip." Quantify the impact and make predictions through supervised learning, learn the mapping function f from event features Fe to response features Fr; if the response features Fr are continuous values, then train the model ; through the analysis of feature importance, determine which event types contribute most to performance degradation; if the response features are discretized, then train the model Label_k = f(Fe), which can be used to predict potential failures in real time based on software events; through statistical analysis, calculate the correlation, mutual information, and other statistical quantities between event features and response features; through clustering analysis, find repeatedly occurring event-response patterns, and classify the motion segments; through classification and regression models, establish a prediction model from event features to response features, quantifying the impact of events; through anomaly detection, identify abnormal segments where the expected response does not match the actual response.

[0024] Pattern application: interpret the key patterns discovered by the model and translate them into practical applications, such as: fault root cause analysis, control parameter adaptive optimization, and predictive maintenance strategy development, etc.

[0025] Step S4: Based on the correlation model analysis results obtained in step S3, use large models for inductive reasoning and probabilistic modeling, generate structured, machine-readable JSON format test profiles, which contain state definitions, transition rules, trigger events and their probabilities, data generation rules and test predictions; The core of this step is to build a data-driven software operation profile that reflects the operational probability distribution. This profile is not just a simple interface call statistic, but a deep description of how the control software's internal state machine evolves under the influence of external physical responses in different task contexts, ultimately manifesting as a complex process of event sequences.

[0026] Large models such as DeepSeek play the roles of knowledge extractor, model synthesizer, and probability estimator in this process. Based on the "software event-motion response" association rules (such as the clusters and classification models obtained from the previous analysis) mined from real running data, induction, completion, and probability are performed to ultimately generate a structured, machine-readable test profile model (JSON format). This model is essentially an enhanced probabilistic state machine that can be used for software reliability test case generation.

[0027] Large model operation and prompt engineering strategy: 1) System role setting (System Prompt): used to set the role and task boundary of the large model, "You are a senior robot and software reliability test engineer. Your task is to induce and generate a complete and structured industrial robot control software test profile based on the analysis results I provide. Your output must strictly follow the JSON format I specify, and the content must be accurate, complete, and consistent with engineering common sense." 2) Few-shot learning (Few-Shot Learning): Prompt example: "Here's an example: input analysis results: 'Found a pattern: in state S_MOVING, if vibration energy exceeds threshold V_th, there is a 95% probability that event E_VIBRATION_ALARM will be triggered, and then state S_ALERT will be entered.

[0028] Expected JSON output fragment: { "transitions": [ { "from": "S_MOVING", "to": "S_ALERT", "trigger":{ "event_type": "E_VIBRATION_ALARM", "probability": 0.95, "condition": "vibration_energy>V_th"}} ]} Please make similar inferences based on the real analysis results provided later.

[0029] 3) Structured Output Demand: Explicitly require the large model to output in JSON format, and directly provide or reference a detailed JSON Schema (data model) as a constraint, ensuring that the output is machine-readable and structurally stable.

[0030] 4) Step-by-Step Reasoning: Require the large model to "think step by step", first list the states, events and rules it identifies from the input, and then map them into a JSON structure. This improves the accuracy and interpretability of the output, facilitating human expert review.

[0031] JSON test profile data model structure description: This JSON model is an enhanced probabilistic state machine, which is the information carrier for test case generation. Its core structure is shown in Table 1: Table 1: Core structure of JSON model

[0032] Through the above engineering and JSON data model, the reasoning ability of the large model is transformed into a reliable and automated engineering tool, improving the efficiency and depth of robot software reliability testing.

[0033] Step five: Based on the test profile generated in step four, automatically sample software reliability test case sequences, execute tests and use test predictions for result verification, to discover and reproduce hidden defects in the software. This step can be combined with the embodiment to reflect the actual effect.

[0034] Example two: Precision assembly robot reliability test profile generation: The object of this application verification is a six-axis industrial robot used for the precision assembly of mobile phone mainboards. The robot mainly performs pick-and-place and press operations, which have high requirements for force control and positioning accuracy. During long-term operation, occasional virtual press faults occur (software records that the press is complete, but in fact it has not been pressed into place), which are difficult to reproduce. By using historical running data, a high-fidelity reliability test profile is automatically generated to stimulate and discover more software defects in such edge scenarios.

[0035] 1) Running data extraction and association model establishment Collect 1000 fragments of data for the robot to perform press operations. Each fragment starts from receiving the CMD_PRESS instruction and ends when the task is completed (successfully or unsuccessfully). The collected raw data is shown in Table 2 (only for illustration, actual data volume is larger): Table 2: Collected raw data

[0036] Preprocessing: First, based on CMD_PRESS and the end event, all data is cut into 1000 independent motion segments.

[0037] Example 3: In one exemplary embodiment, the present invention also provides a computer device, which may be a server or a terminal, and its internal structure diagram may be as follows. Figure 2 As shown, the computer device includes a processor, memory, input / output (I / O) interfaces, and a communication interface. The processor, memory, and I / O interfaces are connected via a system bus, and the communication interface is also connected to the system bus via the I / O interfaces. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and a database. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The I / O interfaces are used for exchanging information between the processor and external devices. The communication interface is used for communicating with external terminals via a network connection. When the computer program is executed by the processor, it implements the industrial robot software reliability test profile generation method described in Embodiment 1.

[0038] Those skilled in the art will understand that Figure 2 The structures shown are merely block diagrams of some structures related to the present application and do not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than shown in the figures, or combine certain components, or have different component arrangements. In an exemplary embodiment, a computer device is provided, including a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the steps in the above-described method embodiments.

[0039] In one exemplary embodiment, the present invention also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps in the above-described method embodiments.

[0040] In one exemplary embodiment, the present invention also provides a computer program product, including a computer program that, when executed by a processor, implements the steps in the above-described method embodiments.

[0041] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of the relevant data must comply with relevant regulations.

[0042] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium. When executed, the computer program can include the processes of the embodiments described above. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM).

[0043] The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic units, data processing logic units, etc., and are not limited to these.

[0044] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0045] This document uses specific examples to illustrate the principles and implementation methods of this application. The descriptions of the above embodiments are only for the purpose of helping to understand the methods and core ideas of this application. Furthermore, those skilled in the art will recognize that, based on the ideas of this application, there will be changes in the specific implementation methods and application scope. Therefore, the content of this specification should not be construed as a limitation of this application.

Claims

1. A method for generating a reliability test profile for industrial robot software based on a large model and operational data, characterized in that... Includes the following steps: Collect multimodal data of industrial robots in actual operation, and align them with unified timestamps to form a multi-parameter time series set; Based on aligned multimodal data, a continuous data stream is segmented into independent motion segments according to software events or motion boundaries. For each segment, feature vectors are extracted from software event sequences and physical response data to construct a feature representation describing the event-response relationship. Based on the extracted feature vectors, a software event-motion response correlation model is constructed through unsupervised clustering and supervised learning methods to identify typical operating modes and abnormal modes, and to quantify the impact of events on motion state. Based on the obtained correlation model analysis results, inductive reasoning and probabilistic modeling are performed using a large model to generate a structured, machine-readable JSON format test profile. Based on the generated test profile, a sequence of software reliability test cases is automatically sampled, tests are executed, and test predictions are used to verify the results, thereby discovering and reproducing hidden defects in the software.

2. The method for generating industrial robot software reliability test profiles based on large models and operational data as described in claim 1, characterized in that: The multimodal data includes software state sequences, control command data, joint space physical quantities, Cartesian space physical quantities, and environmental interaction data.

3. The method for generating industrial robot software reliability test profiles based on large models and operational data as described in claim 1, characterized in that: The test profile includes state definitions, transition rules, triggering events and their probabilities, data generation rules, and test predictions.

4. The method for generating industrial robot software reliability test profiles based on large models and operational data as described in claim 1, characterized in that, The multi-parameter time series set is as follows: Dataset = { T, S(t), E, ​​C(t), Θ(t), Φ(t), M(t)}; Where: T is a unified time base, T = {t0, t1, t2, ..., t k }, where t k This represents the k-th sampling time. S(t) represents the internal software state data, used to reflect the data of the internal logic, decision-making, and state machine of the control software; E represents the external environment and task data, which is a discrete event sequence: E = {(τ1, e1, d1), (τ2, e2, d2),..., (τ_m, e_m, d_m)}, where τ is the timestamp of the event, e is the event type, and d is the additional data of the event. C(t) represents the control layer data, which is the desired motion command calculated by the controller and the underlying closed-loop control data, serving as a bridge connecting software decision-making and physical execution. Θ(t) represents the joint space physical data, a physical quantity that reflects the actual movement of the joint and is directly measured by the robot's body sensors. Φ(t) represents Cartesian space physical data, which is the actual pose and motion information of the robot end effector in three-dimensional space obtained through external measurement equipment. M(t) represents the physical data of the robot's interaction with the environment, describing the tasks performed by the robot and the information of its environment, providing context for motion analysis.

5. The method for generating industrial robot software reliability test profiles based on large models and operational data as described in claim 1, characterized in that: First, using a unified high-precision timestamp T, all heterogeneous data are aligned to the same timeline. Then, based on the triggering of software events or the natural boundaries of motion, the continuous long-term data series is divided into multiple independent motion segments, each segment representing a complete and meaningful motion unit. The continuous data stream Dataset is divided into M independent segments {Seg1, Seg2, ..., Seg_M}, and the event types e_segment_start and e_segment_end are selected as the start and end markers of the segments.

6. The method for generating industrial robot software reliability test profiles based on large models and operational data as described in claim 1, characterized in that, Multimodal feature extraction includes the following steps: For each motion segment, a series of features are extracted from its internal software data and external physical data; for each segment Seg_k, an event feature vector Fe is extracted to describe the type, frequency, sequence and intensity of software events in the segment, and a response feature vector Fr describes the performance, quality and physical state of the robot motion in the segment.

7. The method for generating industrial robot software reliability test profiles based on large models and operational data as described in claim 1, characterized in that, Methods for constructing association models include: Each motion segment is represented as a feature vector, and each motion segment is ultimately represented as a comprehensive feature vector F = [Fe, Fr], where Fe represents the event feature and Fr represents the response feature. Through unsupervised clustering, similar F vectors are clustered into a class, each class representing a typical software event-motion response pattern. K-Means or DBSCAN algorithms are used to cluster {F}, obtaining cluster labels L∈ {1, 2, ..., C}, dividing all motion segments into C clusters. Subsequently, cluster pattern interpretation is performed, transforming the data-driven clustering results into software event-motion response patterns with explicit engineering semantics. Supervised learning is used to quantify impact and make predictions by learning a mapping function f from event features Fe to response features Fr; if the response feature Fr is a continuous value, the model is trained. By analyzing the importance of features, we can determine which event types contribute the most to performance degradation. If the response features are discretized, we can train the model Label_k = f(Fe) to predict potential failures in real time based on software events. Through statistical analysis, we can calculate the correlation and mutual information between event features and response features. Through cluster analysis, we can discover recurring event-response patterns and classify motion segments. Through classification and regression models, we can establish a prediction model from event features to response features and quantify the impact of events. Through anomaly detection, we can identify abnormal segments where the expected response does not match the actual response.

8. The method for generating industrial robot software reliability test profiles based on large models and operational data as described in claim 1, characterized in that, The method for inductive reasoning and probabilistic modeling using large models includes the following steps: 1) System Role Settings: Used to set the roles and task boundaries of large models; 2) Few-shot learning: used to perform similar inferences based on subsequently provided real analysis results; 3) Structured output requirements: Explicitly require large models to be output in JSON format, and directly provide or reference a detailed JSON schema as a constraint; 4) Step-by-step reasoning and verification: The large model is required to think step by step, first listing the states, events and rules it identifies from the input, and then mapping them into a JSON structure.

9. A computer device, comprising: A memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that the processor executes the computer program to implement the industrial robot software reliability test profile generation method according to any one of claims 1-8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When executed by a processor, the computer program is used to implement the method for generating a software reliability test profile for industrial robots as described in any one of claims 1-8.

Images