A large model-based variable description generation method, system, device and medium

Abstract

The application discloses a variable description generation method, system, device and medium based on a large model. The method comprises the following steps: determining a pre-set simulation model, determining a model file of the simulation model, and performing format conversion on the model file according to a pre-set file format; analyzing the model file after the format conversion, to determine a variable name of the simulation model, and to determine a historical variable library and an abbreviation rule library; generating a variable description according to the variable name, the historical variable library and the abbreviation rule library, and outputting the variable description in a structured format. The application realizes automatic extraction of the variable name through format conversion and analysis, generates a standard description by means of a large language model in combination with the historical variable library and the abbreviation rule library, and outputs the standard description in a structured format, so that the generation efficiency and quality of variable annotation are significantly improved, the accuracy and consistency of the description are ensured, and the artificial maintenance cost is reduced.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to a method, system, device, and medium for generating variable descriptions based on large models. Background Technology

[0002] Simulink is a visual simulation and model design tool within the MATLAB environment, widely used for modeling control systems, dynamic systems, and other fields. During the development of electronic control strategies, variables in Simulink models, such as Inport, Outport, and Constant modules, require descriptive annotations to facilitate model understanding, maintenance, and team collaboration. Currently, adding variable descriptions to Simulink models primarily relies on manual writing, which suffers from inefficiency, poor quality and consistency, weak maintainability, and increases the difficulty of automated processing. Summary of the Invention

[0003] To address the aforementioned issues, this application proposes a variable description generation method based on a large model, comprising: determining a pre-set simulation model and a model file of the simulation model; converting the model file according to a pre-set file format; parsing the converted model file to determine the variable names of the simulation model and to determine a historical variable library and an abbreviation rule library; generating variable descriptions based on the variable names, the historical variable library, and the abbreviation rule library; and outputting the variable descriptions in a structured format.

[0004] In one example, the model file is converted to a pre-set file format, specifically including: obtaining the model file of the simulation model and determining the format corresponding to the model file; calling the save function in MATLAB to convert the format corresponding to the model file to XML format.

[0005] In one example, parsing the format-converted model file to determine the variable names of the simulation model specifically includes: reading the format-converted model file using the lxml library based on Python; traversing the tree structure of the model file to determine all nodes in the tree structure; and extracting the corresponding variable names through the block attributes of all nodes.

[0006] In one example, the historical variable library stores the names of historical variables and their corresponding descriptions, and the abbreviation rule library stores the naming rules and abbreviation meanings of electronic control strategy variables. The historical variable library and the abbreviation rule library together provide reference information for the large language model.

[0007] In one example, generating a variable description based on the variable name, the historical variable library, and the abbreviation rule library specifically includes: inputting the variable name, the historical variable library, and the reference information retrieved from the abbreviation rule library into a pre-set large language model; and using a preset prompt word strategy, causing the large language model to output a natural language description corresponding to the variable name; wherein, the large language model includes a knowledge base node, a large model node, a loop node, and a code node; the knowledge base node is used to call the historical variable library and the abbreviation rule library; the large model node is used to generate a variable description based on prompt word constraints, wherein the prompt word constraints the large language model to only output variable annotations.

[0008] In one example, the method further includes: collecting user usage data and / or feedback data on the generated variable descriptions, storing the usage data and / or feedback data into a monitoring database through a preset data writing interface; and iteratively optimizing the prompt word strategy of the historical variable library and the large language model based on the data stored in the monitoring database.

[0009] In one example, the variable descriptions are output in a structured format, specifically including: writing the correspondence between variable names and generated descriptions into a table file, wherein the table file is in CSV or Excel format; and writing the correspondence between variable names and generated descriptions into a database, wherein the table structure of the database includes a variable name field, a generated description field, a user identifier field, a generation time field, and a user feedback field.

[0010] On the other hand, this application also proposes a variable description generation system based on a large model, comprising: a format conversion module for determining a pre-set simulation model and its model file, and converting the model file according to a pre-set file format; a parsing and extraction module for parsing the converted model file to determine the variable names of the simulation model; a knowledge base construction module for determining a historical variable library and an abbreviation rule library; a generation and output module for generating variable descriptions based on the variable names, the historical variable library, and the abbreviation rule library, and outputting the variable descriptions in a structured format; and a data feedback module for collecting user usage data and / or feedback data on the generated variable descriptions, and storing the usage data and / or feedback data in a monitoring database.

[0011] On the other hand, this application also proposes a variable description generation device based on a large model, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the variable description generation device based on a large model to perform: the method described in any of the examples above.

[0012] On the other hand, this application also proposes a non-volatile computer storage medium storing computer-executable instructions, wherein the computer-executable instructions are configured to be the method described in any of the examples above.

[0013] This application automates the entire process from Simulink model parsing to variable description generation, significantly improving variable annotation efficiency and reducing the workload of traditional manual work (which used to take several days) to minutes. By converting .slx files to .xml and recursively traversing the XML tree using the lxml library to accurately locate the BlockType of modules such as Inport, Outport, and Constant to extract the Name attribute, it ensures that variable name extraction is unaffected by Simulink versions, exhibiting good compatibility and accuracy. Furthermore, it provides rich domain knowledge references for large language models by combining historical variable libraries and abbreviation rule libraries, and strictly constrains the output content with a dedicated prompt word strategy, ensuring that the generated variable descriptions are both accurate and standardized without requiring subsequent cleaning. Finally, it outputs standardized spreadsheet files such as CSV or Excel, facilitating direct integration into existing development toolchains. Simultaneously, a data feedback mechanism writes fields such as variable names, generated descriptions, user identifiers, and feedback to the database, supporting continuous optimization of model generation effects and comprehensively improving the quality, consistency, and maintainability of electronic control strategy model development. Attached Figure Description

[0014] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings: Figure 1 This is a flowchart illustrating a variable description generation method based on a large model in an embodiment of this application; Figure 2 This is a schematic diagram of the Inport module variables in an embodiment of this application; Figure 3 This is a schematic diagram of the agent architecture in the embodiments of this application; Figure 4 This is a schematic diagram illustrating the configuration of large model nodes in an embodiment of this application; Figure 5 This is a schematic diagram illustrating the configuration of knowledge base nodes in an embodiment of this application; Figure 6 This is a schematic diagram of the data monitoring table structure in an embodiment of this application; Figure 7 This is a schematic diagram of a variable description generation device based on a large model, as described in an embodiment of this application. Detailed Implementation

[0015] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below in conjunction with specific embodiments and corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0016] The technical solutions provided by the various embodiments of this application are described in detail below with reference to the accompanying drawings.

[0017] like Figure 1 As shown, in order to solve the above problems, this application provides a variable description generation method based on a large model, the method including: S101. Determine the pre-set simulation model and the model file of the simulation model, and convert the model file according to the pre-set file format.

[0018] The simulation model is specifically a Simulink model used in the development of electronic control strategies. Simulink is a visual simulation and model design tool in the MATLAB environment, widely used in modeling control systems, dynamic systems, and other fields. Simulink model files are in .slx format, which has been the standard storage format for Simulink models since MATLAB R2012a, containing model structure, parameters, and metadata. Since .slx files are in binary format and cannot be directly read and parsed by code, they need to be converted into a parsable structured data format.

[0019] Specifically, the model file is converted to a pre-set file format to obtain the simulation model file, which is in .slx format. In MATLAB, the `save_system` function is called to convert the model file from .slx to .xml format. In one specific embodiment, for a Simulink model named "LVMag", the format conversion method is: `save_system('LVMag', 'LVMag.xml','ExportToXML', true)`. This method converts the binary .slx file into a structured data file based on XML format for subsequent parsing. The generated .xml file structure contains the model's structured information, including elements such as blocks, lines, and parameters.

[0020] S102. Parse the model file after format conversion to determine the variable names of the simulation model, and determine the historical variable library and abbreviation rule library.

[0021] The converted model file is parsed to determine the variable names of the simulation model. Specifically, the converted model file is read using the lxml library in Python. The model file is the .xml format file generated in step S101. The XML tree structure of the model file is traversed, and the variable names are extracted by judging the BlockType attribute of each node.

[0022] In one embodiment, each node of the XML tree structure is recursively traversed. When the BlockType attribute of a node is Inport, Outport, Constant, S-Function, or Reference, the Name attribute of that node is extracted as the variable name. Specifically, variables are mainly concentrated in modules such as Inport, Outport, Constant, S-Function, and Reference, and the variable name is obtained by determining the BlockType. For the Inport module, its BlockType is "Inport", and the Name attribute is the variable name, which can be extracted by reading this attribute. The lxml library is a third-party library in Python for processing XML and HTML documents. It is built based on a high-efficiency parser in C, has excellent parsing speed and low memory usage, and can efficiently handle the traversal and query operations of large XML files.

[0023] In one embodiment, a historical variable library and an abbreviation rule library are also determined. The historical variable library stores the names of existing variables and their corresponding descriptive information, while the abbreviation rule library stores the naming rules for electronic control strategy variables and the meanings of their abbreviations. The historical variable library and the abbreviation rule library together provide reference information for the large language model. Figure 2 As shown, the historical variable library contains data from existing Simulink models and their corresponding descriptions, while the abbreviation rule library contains data from variable naming convention documents in the field of electronic control strategy development. The historical variable library stores the names of existing variables and their corresponding descriptions, such as the variable name "VehSpd" corresponding to the description "vehicle speed." The abbreviation rule library stores the naming rules for electronic control strategy variables and the meanings of their abbreviations, such as "Spd" corresponding to "Speed" and "Veh" corresponding to "Vehicle." Together, they provide reference information for the large language model, helping to generate accurate and standardized variable descriptions.

[0024] S103. Generate a variable description based on the variable name, the historical variable library, and the abbreviation rule library, and output the variable description in a structured format.

[0025] The variable descriptions are generated using a pre-defined large language model. A large language model (LLM) is a deep learning-based language model with massive parameters that can understand and generate natural language text. In this application, it is used to generate semantic descriptions based on variable names.

[0026] Large language models are pre-built intelligent agents. For example... Figure 3 As shown, the intelligent agent is built on a large model application platform, specifically including a knowledge base node, a large model node, a loop node, and a code node. The execution logic of the intelligent agent workflow is as follows: First, the code node passes the list of variable names extracted above into the workflow; second, the loop node iterates through each variable name, and for each variable name, the knowledge base node retrieves relevant reference information from the historical variable library and the abbreviation rule library; then, the large model node generates the corresponding variable description based on the variable name, the historical variable library reference information, and the abbreviation rule library reference information.

[0027] Large model nodes are used to generate variable descriptions based on cue word constraints. For example... Figure 4 As shown, the configuration of the large model node includes: selecting a large language model, setting model parameters, and designing dedicated prompt words. These prompt words constrain the large language model to output only variable annotations without any other content. Specifically, the prompt words explicitly instruct the large language model to output only descriptive annotations corresponding to the variables, without outputting any additional explanations, descriptions, or formatting marks, thereby ensuring that the generated content is directly usable and avoiding subsequent cleaning and processing work.

[0028] The knowledge base node is used to access the historical variable library and the abbreviation rule library. For example... Figure 5 As shown, the configuration of the knowledge base node includes: specifying the data source for the historical variable library and the abbreviation rule library, setting the search method, and configuring the number of search results returned.

[0029] In one embodiment, the variable descriptions are output in a structured format. Specifically, the correspondence between variable names and generated descriptions is written into a table file, which can be in CSV or Excel format. Variable comments are saved in Excel format, with each row recording a variable name and its corresponding generated description in the format of "variable name-generated description". Saving the generated content as a standardized table file facilitates integration into existing development processes and toolchains, enabling convenient review, batch import, or further processing. The generated results are shown in Table 1 below.

[0030] Table 1 Excel output

[0031] In one embodiment, the mapping between variable names and generated descriptions is written to the database, enabling the return of user-used data. For example... Figure 6 As shown, the database table structure includes variable name fields, generation description fields, user identifier fields, generation time fields, and user feedback fields. Calling the data writing interface writes the mapping between variable names and generation descriptions into the database. By constructing a data monitoring system, user usage data feedback is achieved, providing a data foundation for subsequent model optimization and performance evaluation.

[0032] In one embodiment, this application also provides a variable description generation system based on a large model, comprising: The format conversion module is used to determine the pre-set simulation model and its model file, and convert the model file to a pre-defined format. In this embodiment, the simulation model is an electronic control strategy model developed based on the Simulink platform, and its model file format is .slx. The format conversion module calls the `save_system` function in the MATLAB environment, using the `ExportToXML` parameter to convert the .slx model file into a .xml structured data file. The generated .xml file has a clear tree structure, facilitating subsequent programmatic parsing.

[0033] The parsing and extraction module is used to parse the converted model file to determine the variable names of the simulation model. In this embodiment, the parsing and extraction module uses Python's lxml library to read .xml format model files. By traversing the tree structure of the model file, all nodes are identified, and the corresponding variable names are extracted by judging the BlockType attribute of each node, including module types such as Inport, Outport, Constant, S-Function, and Reference. Since this parsing method does not depend on the specific Simulink version number, it can ensure the completeness and accuracy of variable name extraction.

[0034] The knowledge base construction module is used to determine the historical variable library and the abbreviation rule library. The historical variable library stores the names of historical variables and their corresponding descriptions, while the abbreviation rule library stores the naming rules for electronic control strategy variables and the meanings of their abbreviations. Together, they provide reference information for the large language model, helping to generate accurate and efficient variable descriptions.

[0035] The output generation module is used to generate variable descriptions based on variable names, a historical variable library, and an abbreviation rule library, and output the variable descriptions in a structured format. In this embodiment, the output generation module is built on the Weichai large model application platform and includes a knowledge base node, a large model node, a loop node, and a code node. The knowledge base node is used to call the historical variable library and the abbreviation rule library, and filter reference information associated with the current variable name based on the search quantity threshold and the similarity threshold; the large model node is configured with preset model parameters, including model name, temperature parameter, and kernel sampling parameter, and is used to generate variable descriptions based on variable names and retrieved reference information under the constraint of prompt words; the loop node is used to control the batch processing flow of multiple variables; the code node is used to perform data format conversion and generate output files. The generated variable descriptions are saved as Excel spreadsheet files.

[0036] The data feedback module collects user usage data and / or feedback data on the generated variable descriptions and stores this data in the monitoring database. In this embodiment, the system constructs a data monitoring system. The monitoring database contains a predefined table structure and collects user usage logs and feedback information through a preset data writing interface. The data stored in the monitoring database can be used to iteratively optimize the prompt word strategy of the historical variable library and / or the large language model, forming a complete data closed loop of "generation—use—feedback—optimization".

[0037] like Figure 7 As shown in the embodiments of this application, a variable description generation device based on a large model is also provided, including: At least one processor; and, A memory that is communicatively connected to at least one processor; wherein, The memory stores instructions that can be executed by at least one processor to enable a variable description generation device based on a large model to perform the method as described in any of the embodiments above.

[0038] This application also provides a non-volatile computer storage medium storing computer-executable instructions, which are configured as described in any of the above embodiments.

[0039] In the 1990s, improvements to a technology could be clearly distinguished as either hardware improvements (e.g., improvements to the circuit structure of diodes, transistors, switches, etc.) or software improvements (improvements to the methodology). However, with technological advancements, many methodological improvements today can be considered direct improvements to the hardware circuit structure. Designers almost always obtain the corresponding hardware circuit structure by programming the improved methodology into the hardware circuit. Therefore, it cannot be said that a methodological improvement cannot be implemented using hardware physical modules. For example, a Programmable Logic Device (PLD) (such as a Field Programmable Gate Array (FPGA)) is such an integrated circuit whose logic function is determined by the user programming the device. Designers can program and "integrate" a digital system onto a PLD themselves, without needing chip manufacturers to design and manufacture dedicated integrated circuit chips. Furthermore, nowadays, instead of manually manufacturing integrated circuit chips, this programming is mostly implemented using "logic compiler" software. Similar to the software compiler used in program development, the original code before compilation must also be written in a specific programming language, called a Hardware Description Language (HDL). There are many HDLs, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, and RHDL (Ruby Hardware Description Language). Currently, the most commonly used are VHDL (Very-High-Speed ​​Integrated Circuit Hardware Description Language) and Verilog. Those skilled in the art should also understand that by simply performing some logic programming on the method flow using one of these hardware description languages ​​and programming it into an integrated circuit, the hardware circuit implementing the logical method flow can be easily obtained.

[0040] The controller can be implemented in any suitable manner. For example, it can take the form of a microprocessor or processor and a computer-readable medium storing computer-readable program code (e.g., software or firmware) executable by the (micro)processor, logic gates, switches, application-specific integrated circuits (ASICs), programmable logic controllers, and embedded microcontrollers. Examples of controllers include, but are not limited to, the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicon Labs C8051F320. A memory controller can also be implemented as part of the control logic of the memory. Those skilled in the art will also recognize that, in addition to implementing the controller in purely computer-readable program code form, the same functionality can be achieved by logically programming the method steps to make the controller take the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers. Therefore, such a controller can be considered a hardware component, and the means included therein for implementing various functions can also be considered as structures within the hardware component. Alternatively, the means for implementing various functions can be considered as both software modules implementing the method and structures within the hardware component.

[0041] The systems, devices, modules, or units described in the above embodiments can be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, a computer can be, for example, a personal computer, laptop computer, cellular phone, camera phone, smartphone, personal digital assistant, media player, navigation device, email device, game console, tablet computer, wearable device, or any combination of these devices.

[0042] For ease of description, the above devices are described in terms of function, divided into various units. Of course, in implementing this specification, the functions of each unit can be implemented in one or more software and / or hardware components.

[0043] The various embodiments in this application are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the device and medium embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the description of the method embodiments.

[0044] The devices and media provided in this application are one-to-one with the methods. Therefore, the devices and media also have similar beneficial technical effects as their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media will not be repeated here.

[0045] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0046] 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.

[0047] 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.

[0048] 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.

[0049] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0050] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0051] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic magnetic disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0052] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such process, method, article, or apparatus. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes that element.

[0053] The above are merely embodiments of this application and are not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of the claims of this application.

Claims

1. A variable description generation method based on a large model, characterized in that, include: Determine the pre-set simulation model and the model file of the simulation model, and convert the model file according to the pre-set file format; The converted model file is parsed to determine the variable names of the simulation model and to determine the historical variable library and abbreviation rule library; Variable descriptions are generated based on the variable names, the historical variable library, and the abbreviation rule library, and the variable descriptions are output in a structured format.

2. The method according to claim 1, characterized in that, The model file is converted according to a pre-set file format, specifically including: Obtain the model file of the simulation model and determine the format of the model file; In MATLAB, call the save function to convert the format of the model file to XML format.

3. The method according to claim 1, characterized in that, The converted model file is parsed to determine the variable names of the simulation model, specifically including: The lxml library in Python is used to read the model file after format conversion; Traverse the tree structure of the model file to determine all nodes in the tree structure; Extract the corresponding variable names based on the block attributes of all the nodes.

4. The method according to claim 1, characterized in that, The historical variable library stores the names of historical variables and their corresponding descriptions, while the abbreviation rule library stores the naming rules for electronic control strategy variables and the meanings of their abbreviations. Together, the historical variable library and the abbreviation rule library provide reference information for the large language model.

5. The method according to claim 1, characterized in that, The variable description is generated based on the variable name, the historical variable database, and the abbreviation rule database, specifically including: The variable name, the historical variable database, and the reference information retrieved from the abbreviation rule database are input into a pre-set large language model. Through a preset prompt word strategy, the large language model outputs a natural language description corresponding to the variable name. The large language model includes knowledge base nodes, large model nodes, loop nodes, and code nodes. The knowledge base node is used to call the historical variable library and the abbreviation rule library; The large model node is used to generate variable descriptions based on prompt word constraints, which constrain the large language model to only output variable annotations.

6. The method according to claim 1, characterized in that, The method further includes: Collect user usage data and / or feedback data on the generated variables, and store the usage data and / or feedback data into the monitoring database through a preset data writing interface; Based on the data stored in the monitoring database, the prompt word strategy of the historical variable library and the large language model is iteratively optimized.

7. The method according to claim 1, characterized in that, The variable descriptions are output in a structured format, specifically including: Write the correspondence between variable names and generated descriptions into a table file, which is in CSV or Excel format. The mapping between variable names and generated descriptions is written into the database. The table structure of the database includes variable name field, generated description field, user identifier field, generated time field, and user feedback field.

8. A variable description generation system based on a large model, characterized in that, include: The format conversion module is used to determine the pre-set simulation model and the model file of the simulation model, and to convert the model file according to the pre-set file format. The parsing and extraction module is used to parse the model file after format conversion in order to determine the variable names of the simulation model; The knowledge base construction module is used to determine the historical variable library and abbreviation rule library; The output generation module is used to generate variable descriptions based on the variable names, the historical variable library, and the abbreviation rule library, and output the variable descriptions in a structured format; The data feedback module is used to collect user usage data and / or feedback data on the generated variable descriptions, and store the usage data and / or feedback data into the monitoring database.

9. A variable description generation device based on a large model, characterized in that, include: At least one processor; as well as, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions executable by the at least one processor to enable the large model-based variable description generation device to perform the method as described in any one of claims 1-8.

10. A non-volatile computer storage medium storing computer-executable instructions, characterized in that, The computer-executable instructions are configured to be the method as described in any one of claims 1-8.

Images