Gpu-based neural network bug injection testing method and storage medium thereof

Abstract

The application discloses a GPU-based neural network error injection test method and a storage medium thereof, and the neural network model is parsed by using a pre-acquired error injection script to acquire GPU dynamic instructions; based on the acquired GPU dynamic instructions, the instructions of all computing kernels are obtained; and the fault recorded in the error injection script is injected into the instructions of the computing kernel according to the pre-acquired error injection configuration file. The application is more comprehensive in analyzing the running results after error injection, and comprehensive data is obtained from aspects of hardware instructions, neural network layers and the like, and the neural network layer position and the neural network function level position of the neural network error are reversely obtained according to the running results, so as to serve as a basis for evaluating and modifying the neural network model.

Description

Technical Field

[0001] This invention relates to a GPU-based neural network error injection testing method and its storage medium, belonging to the field of neural network error injection testing technology. Background Technology

[0002] GPU-based neural network systems have been widely used in fields such as artificial intelligence, machine learning, autonomous vehicles, and high-performance computing. These fields share a common characteristic: the need to process large amounts of data rapidly, while simultaneously requiring high reliability, availability, and security. Reliability refers to the neural network system's ability to recover from soft errors. Identifying the vulnerabilities of GPU-based neural network systems will be crucial for hardening them.

[0003] Potential fault points in GPU-based neural network systems can be categorized into three levels: instruction level, neural network layer level, and neural network function level. Traditional fault injection methods involve simulating neural networks using FPGAs, which is time-consuming to build and inefficient. Summary of the Invention

[0004] The technical problem to be solved by this invention is to overcome the defects of the prior art and provide a GPU-based neural network error injection testing method and its storage medium. The core of this method is to run the neural network model in the error injection system, automatically inject errors into the neural network model by configuring the error injection method, obtain the fault type, write it into the log for storage, and analyze the running results. This invention can quickly obtain comprehensive running data from hardware instructions and various layers of the neural network, and analyze the neural network from multiple dimensions.

[0005] To achieve the above objectives, this invention provides a GPU-based neural network error injection testing method, comprising: The neural network model is parsed using a pre-acquired error-annotated script to obtain dynamic GPU instructions; Based on the acquired GPU dynamic instructions, obtain the instructions for all computing cores; Based on the pre-obtained error injection configuration file, the faults recorded in the error injection script are injected into the instructions of the computing kernel.

[0006] Prior to this, the faults recorded in the error script include single-bit flip, double-bit flip, random number, bitwise flip, zeroing operation, left or right shift by several bits, and set-to-1 operation.

[0007] Prior to this, the fault injection configuration file includes the SM ID, core number, fault injection type, number of fault injections, fault injection location, and instruction encoding location.

[0008] Firstly, based on the error injection configuration file, the faults recorded in the error injection script are injected into the instructions of the computing kernel. After the instructions of the computing kernel are executed, the output results are obtained, and the fault type of the output results is analyzed.

[0009] Prioritized fault types include SDC, DUE, and masked; SDC indicates that the output of the neural network model differs from the standard output of the neural network model. DUE indicates a fatal error; "masked" indicates that the error is masked and does not cause an exception. Save the fault type to the log; If the fault type is SDC or DUE, then the neural network model is hardened.

[0010] Prioritize, if the fault type is SDC or DUE, then harden the neural network model by the following steps: For instructions of the computing kernel that cause SDC fault type, triple redundancy design is implemented; for instructions of the computing kernel that cause DUE fault type, the calculation results of the previous computing kernel instructions are backed up before the instruction of the computing kernel is called, and when DUE fault type occurs, the calculation is quickly restored to the location of the computing kernel instruction where the DUE fault type occurred last time and recalculated.

[0011] Firstly, based on the error injection configuration file, the faults recorded in the error injection script are injected into the instructions of the computing kernel through the following steps: Randomly select a key-value pair x, x∈N, from the instructions of N computing kernels, modify the key-value pair based on the fault recorded in the error injection script, and write the key-value pair into the instructions of the computing kernel.

[0012] Firstly, AVF is used to evaluate the fault type to obtain the probability that instruction faults in the computation kernel will cause different fault types to appear in the output of the neural network model. By using PVF to evaluate fault types, the probability of visible errors appearing in the output of the neural network model due to different fault types can be obtained.

[0013] A computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of any of the methods described above.

[0014] The beneficial effects achieved by this invention are as follows: In this invention, Python error-injection scripts are automatically implanted into the running positions of various neural network models, obtain GPU dynamic instructions, and inject faults into the error-injection positions of GPU dynamic instructions according to the error-injection configuration file. After running, fault types including Masked, SDC, and DUE are obtained. This invention provides a more comprehensive analysis of the running results after error injection, obtaining comprehensive data from hardware instructions, neural network layers, etc. Based on the running results, the neural network layer and function level positions where the neural network errors occur are obtained in reverse, serving as the basis for evaluating and modifying the neural network model. This invention improves the error injection method and supports multiple error injection modes. In addition to supporting single-bit flipping, double-bit flipping, and random number injection, it also adds free configuration operations such as bit-by-bit flipping, data zeroing, and data left or right shift by n bits to create more faults.

[0015] This invention introduces AVF to analyze the anti-interference and stability of neural networks. It analyzes which type of computing kernel instructions or which type of registers have a higher probability of DUE. The analysis methods and means provided by this invention provide important basis for strengthening neural network models and improve the reliability and anti-interference of the model in evaluation and improvement. Compared with traditional FPGA hardware simulation error injection methods, the error injection method of this invention has higher operating efficiency and shorter error injection time; since the fault is directly injected into the GPU, resources are more abundant, and arbitrarily large neural network models can be executed. This invention supports testing any neural network model. Based on the performance of the neural network model on different datasets and the failure analysis of running the same dataset under different GPU dynamic instructions, the vulnerability of the neural network model is analyzed, and triple redundancy design is implemented at the vulnerability to enhance stability. This invention injects faults into RNN neural network models on different datasets, and performs error analysis on register files, GPU dynamic instructions, low-level instructions, and neural network model levels of different datasets. Attached Figure Description

[0016] Figure 1 This is a schematic diagram of the principle of the present invention; Figure 2 This is a flowchart of the present invention; Figure 3 This is a schematic diagram of the register file error injection results for different datasets in an embodiment of the present invention; Figure 4 This is a schematic diagram of the instruction error annotation results for different datasets in an embodiment of the present invention; Figure 5 This is a schematic diagram of the error injection results of different underlying instructions in an embodiment of the present invention; Figure 6 This is a schematic diagram of the GPU architecture. Detailed Implementation

[0017] The following embodiments are only used to illustrate the technical solutions of the present invention more clearly, and should not be used to limit the scope of protection of the present invention.

[0018] Example 1

[0019] GPU-based neural network error injection testing methods include: The neural network model is parsed using a pre-acquired error-annotated script to obtain dynamic GPU instructions; Based on the acquired GPU dynamic instructions, obtain the instructions for all computing cores; Based on the pre-obtained error injection configuration file, the faults recorded in the error injection script are injected into the instructions of the computing kernel.

[0020] Furthermore, the faults recorded in the error-annotation script in this embodiment include single-bit flip, double-bit flip, random number, bitwise flip, zeroing operation, left or right shift by several bits, and set-to-1 operation.

[0021] Furthermore, in this embodiment, the error injection configuration file includes the SM ID, core number, error injection type, number of error injections, fault injection location, and instruction encoding location.

[0022] Furthermore, in this embodiment, based on the error injection configuration file, the faults recorded in the error injection script are injected into the GPU dynamic instructions. After the GPU dynamic instructions are executed, the output results are obtained, and the fault type to which the output results belong is analyzed.

[0023] Furthermore, in this embodiment, the fault types include SDC, DUE, and masked; SDC indicates that the output of the neural network model differs from the standard output of the neural network model. DUE indicates a fatal error; "masked" indicates that the error is masked and does not cause an exception. Save the fault type to the log; If the fault type is SDC or DUE, then the neural network model is hardened.

[0024] Furthermore, in this embodiment, if the fault type is SDC or DUE, the neural network model is hardened through the following steps: For instructions of computing kernels that cause SDC (Software-Defined Computation) fault types, triple redundancy is implemented; for instructions of computing kernels that cause DUE (Device-Defined Computation) fault types, the calculation results of previous computing kernel instructions are backed up before the instruction is called, and when a DUE fault type occurs, the GPU dynamic instruction where the DUE fault type occurred is quickly restored and recalculated.

[0025] Triple redundancy design is existing technology and will not be described in detail in this embodiment. Furthermore, in this embodiment, based on the error injection configuration file, the faults recorded in the error injection script are injected into the instructions of the computing kernel, which is achieved through the following steps: Randomly select a key-value pair x, x∈N, from the instructions of N computing kernels, modify the key-value pair based on the fault recorded in the error injection script, and write the key-value pair into the instructions of the computing kernel.

[0026] Furthermore, in this embodiment, the injection script is combined with the injection configuration file to generate the injection list; The injection list includes the instruction count for the instruction group and the instruction count for each individual instruction.

[0027] Furthermore, in this embodiment, AVF is used to evaluate the fault type and obtain the probability that the instruction fault of the computing kernel will cause different fault types to appear in the output of the neural network model. By using PVF to evaluate fault types, the probability of visible errors appearing in the output of the neural network model due to different fault types can be obtained.

[0028] A computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of any of the methods described above.

[0029] Specifically, this embodiment is achieved through the following steps: Step 1: The Python error-injection script is automatically implanted into the running position of each neural network model, obtains the GPU dynamic instructions, and injects faults into the instructions of the computing kernel according to the error-injection configuration file, resulting in fault types including Masked, SDC, and DUE. Fault types include SDC, DUE, and masked. For SDC, DUE, and masked faults, refer to "Evaluating the Impact of the Instruction Set on Microprocessor Reliability to Soft Errors".

[0030] The execution location of a neural network model is at the instruction level, which reflects the layer and function level of the neural network.

[0031] Step 2: Save the fault type after the error is logged to the log; The error injection configuration file includes the SM ID, core ID, error injection type, number of errors, fault injection location, and instruction code location. The Python error injection script detects GPU dynamic instructions and generates an injection list based on the error injection configuration file. The injection list includes the instruction count of the instruction group and the instruction count of each computation kernel instruction. The script then detects and analyzes the binary instructions in the executable program and injects errors into the target register value of the GPU dynamic instructions or the instructions of the computation kernel to complete the error injection. Step 3: Analyze the logs, which include information such as the test runtime, the location of the GPU dynamic instruction error, and the type of fault caused after the injected fault.

[0032] AVF and PVF are referenced in the paper "Eliminating Microarchitectural Dependency from Architectural Vulnerability". If the fault type is SDC or DUE, the neural network model is hardened through the following steps: If the fault type is SDC or DUE, then the neural network model is hardened through the following steps: If the fault type is SDC, the instruction of the computing kernel that caused the SDC fault type is obtained, and the instruction of the computing kernel is designed with triple redundancy to obtain three computing results. A voting decision mechanism is executed on the three computing results, and the one with the highest vote is selected as the instruction execution result of the computing kernel.

[0033] If the fault type is DUE, the instructions of the computation kernel that caused the DUE fault type are retrieved. The DUE fault type may cause the GPU to crash or malfunction. Therefore, an operation to save intermediate computation results is added before the instructions of the computation kernel that may cause the DUE fault type. When a DUE fault type is encountered, the GPU operation is restored, and the saved intermediate computation results are used to quickly restore the neural network model program so that the neural network model can continue to run. Without this operation of saving intermediate computation results and restoring, when a DUE fault type occurs, the entire neural network model needs to be re-run and recalculated. In the case of a GPU crash, the system also needs to be restarted.

[0034] Example 2

[0035] First, you need to set up the Linux runtime environment and install basic runtime libraries, install Anaconda, and configure the Python environment. In this example, Python 3.6 is used. Next, introduce a neural network model, specifically the Darknet neural network framework. This invention chooses the RNN neural network model, which stands for Recurrent Neural Network. The grrm, shakespeare, and tolstoy datasets are selected and run on the RNN. After running, analyze the types of faults, mainly focusing on three fault types: Masked, SDC (Silent Data Corruptions), and DUE (Detected Unrecoverable Errors).

[0036] A GPU-based neural network bug-injection testing method includes an x86_64 server, a GPU, and a PC for remote control of the server; the server is equipped with Python bug-injection scripts and an RNN neural network model, and stores the grrm, shakespeare, and tolstoy datasets. Figure 6 This is a diagram of the GPU architecture. A GPU consists of multiple SM core components, which in turn include multiple cores, shared memory, registers, and an instruction set. During the execution of a neural network model program, the program is loaded into the GPU's SM. The SM allocates cores according to the computational resources required by the program, and the cores execute related operations according to the instructions. Data exchange and control are accomplished through registers.

[0037] Figure 6 The SM core components, cores, registers, and instruction sets are all assigned unique numbers. The number of SM core components varies depending on the GPU model, with each SM core component containing 32 cores. NVIDIA GPUs commonly use 8 instruction sets, resulting in 172 GPU instructions, all of which are existing technologies and will not be detailed in this embodiment. The GPU instruction set consists of 172 instructions. Dynamic instructions refer to the total number of instructions executed in each program run; dynamic instructions are repeated combinations of instructions within the instruction set.

[0038] The entire execution process of the neural network model program can be understood as decomposing the program into the x-th SM (Structured Module) and the ij-th core, where corresponding calculations are performed according to instructions. The binary code of the neural network model program is composed of dynamic instructions in this way. This invention analyzes the binary code to determine which GPU dynamic instruction will be executed on the x-th SM and the ij-th core. Based on this information, desired faults can be injected into the execution statement of that GPU dynamic instruction in advance.

[0039] A single bug report configuration file can have the following structure: "InNu":"1200" specifies the position of the GPU dynamic instruction in the entire neural network model execution program. SMID, COREID, and INSTType use this information to find the instruction of the computation kernel that will be injected with errors, and then inject the specific fault according to MaskMode.

[0040] The configuration file includes SMID, COREID, MaskMode, InstType, InNu, G_FP64, G_FP32, G_LD, G_PR, G_NODEST, G_OTHERS, G_GPPR, and G_GP, with the following specific meanings: SMID: The unique identifier for each SM. Each GPU has multiple SMs, and each identifier is fixed and unique. COREID: Core ID. Each SM has 32 cores, numbered 0-31. MaskMode: Error type, single-bit flip = 0, double-bit flip = 1, random number = 2, bitwise flip = 3, left shift n bits = 4, right shift n bits = 5, n = 0-31 random number; InstType: Instruction code, 0-171; InNu: This is the location of the instruction within the entire binary program, specifying where error injection should be performed.

[0041] There are a large number of instructions, and commonly used instructions include various categories of GPU dynamic instructions. Commonly used instruction groups include: G_FP64: 64-bit floating-point instruction set; G_FP32: 32-bit floating-point instruction set; G_LD: Memory read instruction set; G_PR: Write instruction set for the PR register; G_NODEST: Instruction set without destination register; G_OTHERS: Other instruction groups; G_GPPR: General-purpose register and compare register write instruction set; G_GP: General Purpose Register Write Instruction Group.

[0042] The structure of the configuration file is as follows: "SMID":"1", "COREID":"3", "MaskMode":"1", "InstType":"1", "InNu":"1200".

[0043] The error injection method involves parsing the neural network model's runtime program using an error injection script. It analyzes and detects the GPU dynamic instructions in the binary representation of the neural network model's runtime program, identifying all the instructions executed by the computational kernels. The total number of computational kernel instructions is a set from 1 to N, uniformly distributed. A number x (x∈N) is randomly selected from the N computational kernel instructions. x can be understood as a key-value pair, where the key includes hardware information (kernel name, kernel number, instruction code), and the key value is the instruction written to the computational kernel. The randomly selected key is modified based on the fault recorded in the error injection script. When the neural network model's runtime program runs, the erroneous key value is written into the computational kernel instructions stored in the register after the GPU dynamic instructions are executed, thus completing the fault injection.

[0044] The exact error mode depends on the error configuration file for the program. The faults recorded in the error configuration script include single-bit flip, double-bit flip, random number, bit-by-bit flip, zeroing operation, left or right shift by a certain number of bits, and set-to-1 operation. The error configuration file includes the SM ID, core number, error type, number of errors, fault injection location, instruction code, and location of GPU dynamic instructions.

[0045] The number of times to inject errors depends on the testing requirements. When the target program is large, multiple runs of this method are needed to ensure a more stable range of fault types. The fault injection location can be set to randomly generate the injection location or to inject all faults sequentially. For simulating real-world scenarios, it is recommended to choose randomly generated injection locations.

[0046] The results of the neural network model execution program after fault injection can be divided into three types: SDC, DUE, and masked.

[0047] SDC (Silent Data Corruptions) is determined when the output of a neural network model differs from the standard output, the content of the output file differs from the standard file, or a specific application fails to check for errors. DUE (Detected Unrecoverable Errors) is a fatal error that typically causes the GPU to prematurely terminate the current kernel. Masked errors are masked and do not cause any exceptions. For each running program of a neural network model, add a check script to determine whether SDC or DUE has occurred.

[0048] Experiments were conducted on the RNN neural network on three datasets: grrm, shakespeare, and tolstoy. One fault was injected each time, and to ensure a 95% confidence level, the error in the fault type result obtained from the injection was at most 5%. For each fault recorded in the injection script, 3000 injections were performed. The output results of register files, GPU dynamic instructions, and different low-level instructions for different datasets were analyzed, and AVF and PVF were introduced to evaluate the results.

[0049] Taking the image recognition and classification task of neural network model as an example, suppose there is a well-trained neural network classification model for two types of objects A and B. For a given well-trained neural network model, the output result obtained from a given photo as input is fixed.

[0050] The standard output result is as follows: A: 0.85143 B: 0.00213 This means that the probability of the input photo j being object A after inference by the neural network model is 85.143%, and the probability of it being object B is 0.213%. If the input photo j is processed by the neural network model's inference, and a random error injection script is used to inject errors, the output of the neural network model will be obtained as follows: A: 0.42312 B: 0.53214 If the output differs significantly from the standard result, it indicates that an SDC fault type has occurred.

[0051] If the input photo j is processed by the neural network model's inference, and a random error injection script is used to inject errors, the output of the neural network model will be obtained as follows: A: 0.85143 B: 0.00213 This is consistent with the standard result and is considered masked.

[0052] If the input photo j is processed by the neural network model and a random error is injected into the error injection script, resulting in no output, then the program will malfunction and fall under the DUE (Due to Unknown Error) fault type.

[0053] AVF is a well-defined and measurable quantity that provides insights into the vulnerability behavior of a structure. Faults in the processor architecture will result in different probabilities of different fault types appearing in the output of a neural network model running a program.

[0054] PVF is a part of AVF, used to indicate the probability that a visible error will appear in the output of the neural network model's program due to a malfunction in the program's execution instructions.

[0055] Using AVF and PVF to evaluate fault types are both existing statistical methods for determining the probability of errors, used to represent the magnitude of the error rate. In the absence of error correction techniques, any fault in the ACE (Accurate Error Correction) storage units will result in a visible error in the output of the neural network model's execution program; these are called ACE bits.

[0056] ; ; B represents the total number of bits in the hardware structure, M represents the number of loop executions, ACEs represent the number of times an ACE occurs during each execution, and I represents the total number of GPU dynamic instructions.

[0057] Icon Result Analysis: like Figure 3 The displayed fault types, with the bars in this graph representing SDC, DUE, and Masked AVF, respectively. These values ​​are displayed on a logarithmic scale for better visualization. Single and Random represent bit flips and random numbers, respectively. It can be seen that for SDC, there is a subtle difference between single-bit flips and random numbers, while DUE AVF varies significantly between single-bit flips and random numbers. For example, DUE AVF caused by random numbers ranges from 0.3354 to 0.3414, while DUE AVF caused by single-bit flips ranges from 0.2267 to 0.2335. Furthermore, DUE AVF is significantly higher than SDC for either single-bit flips or random numbers.

[0058] Figure 4 The error rate data in Table 1 shows the PVF of the instructions. No SDC or DUE fault types appeared in the CC and PR instructions; therefore, both CC and PR instructions have very high error recovery capabilities. The STORE dynamic instruction has the lowest occurrence rate in the RNN and a DUE PVF of 0, while the SDC PVF varies between 0.0007 and 0.0009. GPR has a higher DUE PVF (from 0.3983 to 0.4104) and an SDC PVF ranging from 0.0033 to 0.0042.

[0059] Table 1 Occurrence rate of instruction groups

[0060] Figure 5As shown, among all instruction groups, the low-level instructions (i.e., IADD, MAD, MOV, and MISC) generate the majority of DUE (i.e., the total DUE PVF is as high as 0.4506). SDC is triggered by arithmetic instructions (i.e., IADD, MAD, FADD, and FFMA) and memory instructions (LD).

[0061] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0062] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0063] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0064] The above description is only a preferred embodiment of the present invention. It should be noted that for those skilled in the art, several improvements and modifications can be made without departing from the technical principles of the present invention, and these improvements and modifications should also be considered within the scope of protection of the present invention.

Claims

1. A GPU-based neural network bug injection testing method, characterized in that, include: The neural network model is parsed using a pre-acquired error-annotated script to obtain GPU dynamic instructions; the GPU consists of multiple SMs, each containing multiple cores, shared memory, registers, and instruction sets; Based on the acquired GPU dynamic instructions, obtain the instructions for all computing cores; Based on the pre-obtained error injection configuration file, the faults recorded in the error injection script are injected into the instructions of the computing kernel; The bug injection configuration file includes the SM ID, core ID, bug injection type, number of bug injections, bug injection location, and instruction code location; According to the error injection configuration file, the faults recorded in the error injection script are injected into the instructions of the computing kernel. After the instructions of the computing kernel are executed, the output results are obtained, and the fault type of the output results is analyzed. Fault types include SDC, DUE, and masked; SDC indicates that the output of the neural network model differs from the standard output of the neural network model. DUE indicates a fatal error; "masked" indicates that the error is masked and does not cause an exception. Save the fault type to the log; If the fault type is SDC or DUE, then the neural network model is hardened. Based on the error injection configuration file, the faults recorded in the error injection script are injected into the instructions of the computing kernel through the following steps: Randomly select a key-value pair x, x∈N, from the instructions of N computing kernels, modify the key-value pair based on the fault recorded in the error injection script, and write the key-value pair into the instructions of the computing kernel. The faults recorded in the error-checking script include single-bit flip, double-bit flip, random number, bitwise flip, zeroing operation, left or right shift by several bits, and set-to-1 operation.

2. The GPU-based neural network error injection testing method according to claim 1, characterized in that, If the fault type is SDC or DUE, then the neural network model is hardened through the following steps: For the instructions of the computing kernel that cause SDC fault types, triple redundancy design is implemented; For instructions of the computing kernel that cause DUE (Due to Unknown Error) fault type, the calculation results of the previous computing kernel instructions are backed up before the computing kernel instructions are called. When a DUE fault type occurs, the calculation is quickly restored to the location of the computing kernel instructions that last caused the DUE fault type and recalculated.

3. The GPU-based neural network error injection testing method according to claim 1, characterized in that, AVF is used to evaluate fault types and obtain the probability that instruction faults in the computation kernel will cause different fault types in the output of the neural network model. By using PVF to evaluate fault types, the probability of visible errors appearing in the output of the neural network model due to different fault types can be obtained.

4. A computer-readable storage medium having a computer program stored thereon, characterized in that, When executed by a processor, the computer program implements the steps of the method according to any one of claims 1 to 3.

Images