Deep learning model code generation method and system based on JSON

Abstract

The embodiment of the invention discloses a deep learning model code generation method and system based on JSON (JavaScript Object Notation), and the method comprises the steps: packaging deep learning codes into building blocks, enabling a user to connect the selected building blocks through a visual interface according to the demands, achieving the logic of a deep learning model, and improving the user experience. And storing the connected building blocks as a JSON file, and restoring the deep learning code according to the JSON file during operation. According to the embodiment of the invention, the workload of a developer for writing deep learning model codes is greatly reduced, the development efficiency is improved, the maintainability and the expandability of the codes are improved by using a unified JSON description format, the model structure can be more conveniently modified, a large number of codes do not need to be manually modified, and the development efficiency is improved. And errors possibly caused by operation of developers are reduced.

Description

Technical Field

[0001] The embodiments of the present invention relate to the field of deep learning technology, and specifically to a deep learning model code generation method and system based on JSON. Background Art

[0002] Deep learning technology is becoming more and more popular in today's society and has been widely used in many fields, such as autonomous driving, speech recognition, medical diagnosis, financial forecasting, etc. These applications have not only promoted the advancement of science and technology, but also greatly changed people's lifestyles. In this context, learning deep learning has become particularly important. In order to lower the learning threshold of deep learning and artificial intelligence technology, popularize deep learning related knowledge and technology, and make it easier for learners to understand and operate in primary and secondary education and vocational education, the present invention modularizes and visualizes the deep learning program design, model training and model deployment that were originally implemented and executed through program code. This technology is used to narrow the professional level and thinking mode differences between developers. The visualization form can also help improve learners' understanding of the method.

[0003] Deep learning systems and their related services and functions are implemented through complex program codes. However, learning and writing codes has a high technical threshold for most ordinary users. This makes it difficult for ordinary people to quickly get started with deep learning development, thus limiting the popularity of this technology. In addition, existing code documents are often too abstract. For people without a deep technical background, it is extremely challenging to understand the logical relationship and architectural details between deep learning modules. In the teaching process of deep learning, there is also a lack of intuitive ways to help learners understand the collaborative relationship between modules and the topological structure of the model. Summary of the invention

[0004] To this end, an embodiment of the present invention provides a JSON-based deep learning model code generation method and system to solve the technical problems that the code writing work in the prior art is cumbersome and error-prone, maintainability and scalability are poor, and the technical threshold for ordinary users to enter the field of deep learning is too high.

[0005] In order to achieve the above purpose, the embodiment of the present invention provides the following technical solutions:

[0006] According to a first aspect of an embodiment of the present invention, a method for generating deep learning model code based on JSON is provided, the method comprising:

[0007] Acquire deep learning codes and encapsulate the deep learning codes into building block units respectively, and store them in a database;

[0008] Obtain user needs and receive user requests to call building blocks, and call building block units from the database;

[0009] Receive the user's building block connection request and connect the called building block units, implement the deep learning model logic and store it as a JSON configuration file;

[0010] Restore the deep learning model code using the JSON configuration file;

[0011] Use the JSON configuration file to restore the deep learning model code, including:

[0012] Read the JSON configuration file, and obtain and parse component information from the JSON configuration file;

[0013] Using the parsed component information, recursively build the class structure of the model;

[0014] Generate initialization functions and instantiate each class in the component to generate instantiation code;

[0015] Generate a forward propagation function and generate calling codes for each component, and transfer and return input and output variables;

[0016] Recursively traverse all units in the JSON configuration file, obtain all import information, and add the import information to the function generation code;

[0017] Call the function to generate code and write it into the output file to generate the model code, thereby completing the automatic generation of deep learning model code.

[0018] Further, the JSON configuration file is read, and component information is obtained and parsed from the JSON configuration file, including:

[0019] Obtaining a component file name, indentation level, and attachment information, and using the component file name, indentation level, and attachment information to read the component file content;

[0020] Add the component file content to the code line and copy the attachment file to the specified output path.

[0021] Furthermore, the parsed component information is used to recursively construct the class structure of the model, including:

[0022] Extract component type from parsed component information;

[0023] When the component type is component, continue to recurse and parse the corresponding subcomponents;

[0024] When the component type is unit, it is determined according to the component attributes whether the component is a class, function or custom class from an external library and corresponding processing is performed.

[0025] Furthermore, an initialization function is generated and each class in the component is instantiated to generate instantiation code, including:

[0026] Preprocessing the component ID, including: lowercase letters and removing specific parts;

[0027] Use the initialization function, component type and input parameters to generate the corresponding implementation code, and handle the inheritance relationship of the class.

[0028] Furthermore, a forward propagation function is generated and calling codes for calling each component are generated to transfer and return input and output variables, including:

[0029] Generate function header and component calling form according to input and output parameters, and handle variable passing and return values.

[0030] Further, recursively traverse all units in the JSON configuration file, obtain all import information, and add the import information to the function generation code, including:

[0031] Generate multi-level component code through recursion, and continue recursion on sub-components;

[0032] Traverse all units in the JSON configuration file, read the source code file and process the input and output parameters and attachment files to generate the main class of the project.

[0033] Further, the function is called to generate code and write it into the output file to generate the model code, including:

[0034] Read the JSON configuration file and call the function to generate code;

[0035] The function is used to generate code and write it into an output file to generate model code.

[0036] Furthermore, the method further comprises:

[0037] Topologically sort the preset layer data to ensure the correct component generation order;

[0038] Sort each component according to the number of structural parameter incidents to obtain the generation order of components in the initialization function;

[0039] Obtain the generation order of components in the forward propagation function according to the number of incident structural parameters;

[0040] Perform topological sorting based on component input dependencies to determine the component execution order.

[0041] Furthermore, the method further comprises:

[0042] Train, verify, or run the generated code according to task requirements to form a complete deep learning task.

[0043] According to a second aspect of an embodiment of the present invention, a JSON-based deep learning model code generation system is provided, the system comprising:

[0044] A packaging module, used to obtain deep learning codes and package the deep learning codes into building blocks, and store them in a database;

[0045] A user demand acquisition module is used to acquire user demand and receive a user's request to call a building block, and call a building block unit from a database;

[0046] The building block unit construction module is used to receive the user's building block connection request and connect the called building blocks to implement the deep learning model logic and store it as a JSON configuration file;

[0047] The restoration module is used to restore the deep learning model code using the JSON configuration file.

[0048] The embodiments of the present invention have the following advantages:

[0049] The embodiment of the present invention obtains a JSON model description file and an output file path; calls the main function to automatically generate a code file of the deep learning model, dictionaries the model component functions and hierarchical relationships, incident relationships and other information, saves them as a JSON file, and then restores the model through the JSON file. The embodiment of the present invention greatly reduces the workload of developers in writing deep learning model codes, improves development efficiency, and improves the maintainability and scalability of the code by using a unified JSON description format. The model structure can be modified more conveniently without manually modifying a large amount of code, reducing errors caused by the developer's operations. BRIEF DESCRIPTION OF THE DRAWINGS

[0050] In order to more clearly illustrate the implementation methods of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for the implementation methods or the description of the prior art. Obviously, the drawings in the following description are only exemplary, and for ordinary technicians in this field, other implementation drawings can be derived from the provided drawings without creative work.

[0051] The structures, proportions, sizes, etc. illustrated in this specification are only used to match the contents disclosed in the specification so as to facilitate understanding and reading by persons familiar with the technology. They are not used to limit the conditions under which the present invention can be implemented, and therefore have no substantial technical significance. Any structural modification, change in proportion or adjustment of size shall still fall within the scope of the technical contents disclosed in the present invention without affecting the effects and purposes that can be achieved by the present invention.

[0052] Figure 1 A schematic diagram of the logical structure of a JSON-based deep learning model code generation system provided by an embodiment of the present invention;

[0053] Figure 2 A flowchart of a method for generating deep learning model code based on JSON provided in an embodiment of the present invention;

[0054] Figure 3 A schematic diagram of a low-code visualization interface in a JSON-based deep learning model code generation method provided in an embodiment of the present invention;

[0055] Figure 4 A schematic diagram of a neural network construction form in a JSON-based deep learning model code generation method provided in an embodiment of the present invention;

[0056] Figure 5 A schematic diagram of a method for setting parameters of structural building blocks in a JSON-based deep learning model code generation method provided by an embodiment of the present invention;

[0057] Figure 6 A schematic diagram of the use process of a JSON-based deep learning model code generation method provided in an embodiment of the present invention;

[0058] Figure 7 A schematic diagram of the process from building block records to deep learning network model algorithm in a JSON-based deep learning model code generation method provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0059] The following is a description of the implementation of the present invention by specific embodiments. People familiar with the art can easily understand other advantages and effects of the present invention from the contents disclosed in this specification. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0060] Deep learning systems and their related services and functions are implemented through complex program codes. However, learning and writing codes has a high technical threshold for most ordinary users. This makes it difficult for ordinary people to quickly get started with deep learning development, thus limiting the popularity of this technology. In addition, existing code documents are often too abstract. For people without a deep technical background, it is extremely challenging to understand the logical relationship and architectural details between deep learning modules. In the teaching process of deep learning, there is also a lack of intuitive ways to help learners understand the collaborative relationship between modules and the topological structure of the model.

[0061] In order to solve the above technical problems that code writing is cumbersome and error-prone, maintainability and scalability are poor, and the technical threshold for ordinary users to enter the field of deep learning is too high.

[0062] refer to Figure 1 The embodiment of the present invention discloses a deep learning model code generation system based on JSON, which includes: an encapsulation module 1; a user demand acquisition module 2; a building block unit construction module 3; and a restoration module 4.

[0063] The embodiment of the present invention solves these problems in the prior art by modularly disassembling and visually displaying the deep learning method. It combines complex code with easy-to-understand building blocks, allowing users to build deep learning models in an intuitive way. The modular design not only reduces the need to write code, but also makes the logical relationship and structure of the model clearer, helping users to quickly understand the composition of the model. In this way, the threshold for ordinary users to enter the field of deep learning is greatly reduced, and a more efficient and intuitive tool is provided for teaching, thereby improving the shortcomings of the prior art.

[0064] Corresponding to the above-disclosed system for generating deep learning model code based on JSON, an embodiment of the present invention further discloses a method for generating deep learning model code based on JSON. The following describes in detail a method for generating deep learning model code based on JSON disclosed in an embodiment of the present invention in combination with the above-described system for generating deep learning model code based on JSON.

[0065] Dictionary the model component functions, hierarchical relationships, incident relationships and other information, save them as JSON files, and then restore the model through the JSON files.

[0066] The JSON dictionary includes: component id, level, in-degree, component name, component naming, component attributes, import information and other information.

[0067] refer to Figures 2 to 7The present invention discloses a deep learning model code generation method based on JSON, the method comprising: obtaining deep learning code and encapsulating the deep learning code into building block units respectively, and storing them in a database; obtaining user requirements and receiving user building block call requests, and calling building block units from the database; receiving user building block connection requests and connecting the called building block units, realizing deep learning model logic and storing them as JSON configuration files; and restoring the deep learning model code using the JSON configuration files.

[0068] The deep learning model code is restored by using the JSON configuration file, including: reading the JSON configuration file, obtaining and parsing component information from the JSON configuration file; using the parsed component information, recursively building the class structure of the model; generating an initialization function and instantiating each class in the component to generate instantiation code; generating a forward propagation function and generating a calling code for calling each component, passing and returning input and output variables; recursively traversing all units in the JSON configuration file, obtaining all import information, and adding the import information to the function generation code; calling the function generation code to write an output file to generate the model code, thereby completing the automatic generation of the deep learning model code.

[0069] Furthermore, the JSON configuration file is read, and component information is obtained and parsed from the JSON configuration file, including: obtaining the component file name, indentation level and attachment information, and reading the component file content using the component file name, indentation level and attachment information; adding the component file content to the code line, and copying the attachment file to the specified output path.

[0070] Read component files and process attachments: Based on the given file name, indentation level, and attachment information, read the component file content and add it to the code line, and copy the attachment file to the specified output path.

[0071] Use Python's json module to read the given JSON configuration file to obtain the information required for model generation and optimization.

[0072] Furthermore, the parsed component information is used to recursively construct the class structure of the model, including: extracting the component type from the parsed component information; when the component type is component, continuing to recurse and parse the corresponding subcomponent; when the component type is unit, determining whether the component is a class, function or custom class from an external library based on component properties and performing corresponding processing.

[0073] Furthermore, an initialization function is generated and each class in the component is instantiated to generate instantiation code, including: preprocessing the component ID, the preprocessing includes: lowercasing letters and removing specific parts of the content; using the initialization function, component type and input parameters to generate corresponding implementation code, and processing the inheritance relationship of the class.

[0074] ID processing and function generation: perform specific processing on component IDs, including lowercase letters and removal of specific parts; generate initialization functions corresponding to each component, instantiate various types in the component, and generate corresponding instantiation codes based on component types and input parameters, while handling class inheritance relationships; generate forward functions corresponding to each component, integrate various parts of the component to form running code, generate function headers and component call forms based on input and output parameters, and handle variable transfer and return values.

[0075] Furthermore, a forward propagation function is generated and a calling code for calling each component is generated, and the input and output variables are transferred and returned, including: generating a function header and a component calling form according to the input and output parameters, and processing variable transfer and return values.

[0076] Furthermore, all units in the JSON configuration file are recursively traversed to obtain all import information, and the import information is added to the function generation code, including: generating multi-level component code by recursion, and continuing to recurse on sub-components; traversing all units in the JSON configuration file, reading source code files and processing input and output parameters and attachment files, and generating the project main class.

[0077] Recursively generate component code: recursively traverse all units in the JSON data, obtain import information and add it to the generated code; recursively generate multi-level component code, continue recursively for sub-components, read source code files for units and process input and output parameters and attachment files, and finally generate the main class of the project, including initialization function and forward function.

[0078] Furthermore, calling a function to generate code and write it into an output file to generate a model code includes: reading a JSON configuration file and calling a function to generate code; and using the function to generate code and write it into an output file to generate a model code.

[0079] Read the JSON configuration file, call the above function to generate code and write it to the output file.

[0080] Furthermore, the method also includes: topologically sorting the preset layer data to ensure that the component generation order is correct; sorting each component according to the number of structural parameter incidences to obtain the generation order of the components in the initialization function; obtaining the generation order of the components in the forward propagation function according to the number of structural parameter incidences; topologically sorting according to the component input dependency to determine the component execution order.

[0081] Topological sorting related functions: perform topological sorting on the given layer data to ensure that the component generation order is correct and avoid circular dependencies; sort the components according to the number of structural parameter incidences to determine the generation order of the components in the initialization function; also determine the generation order of the components in the forward function based on the number of structural parameter incidences; perform topological sorting based on component input dependencies to determine the component execution order.

[0082] Furthermore, the method also includes: training, verifying or running the generated code according to task requirements to form a complete deep learning task.

[0083] After generating the model code, generate training / validation / running code according to task requirements to build a complete deep learning task.

[0084] In the process of generating the corresponding training / validation / running code:

[0085] Read JSON configuration file: Use Python's json module to read the given JSON configuration file to obtain the information required for model optimization.

[0086] Generate import units: Recursively traverse all units in the JSON data, obtain all import information, and add it to the generated code.

[0087] Read component files: Read specific component files based on the information in the JSON configuration file and add their contents to the generated code, maintaining the hierarchical relationship.

[0088] Generate optimization function: Generate an optimization function based on the optimization information in the JSON configuration file. This function includes functions such as loading models, reading data files, batch data loading, loss history, etc. It also accepts some parameters such as training data path, validation data path, model path, result path, etc., and optimizes the model based on these parameters.

[0089] Generate a loss function container: Generate a loss function container based on the batch loss function information in the JSON configuration file. This container accepts a batch of data and a model, and calculates the loss based on the model's output and the batch data.

[0090] Generate an overall processing function: Generate an overall processing function that reads the path information in the configuration file and calls the optimization function to optimize the model.

[0091] Generate thread function: Generate a thread class to run the model optimization process in the background.

[0092] Generate main function: Generate a main function to start the thread and return the thread object. When the script is run as the main program, the main function will be called to start the optimization process of the model.

[0093] Write the generated code into an output file for subsequent use, completing the task of generating the corresponding training / validation / running code.

[0094] refer to Figures 3 to 5 , Figure 3 It is a low-code visual interface that displays the building block area, construction area, and result area. Figure 4 for Figure 3 A partial enlarged view of the building block area in the game, showing the network-based construction and the connection of building blocks. Figure 5 This is a parameter setting method for structural building blocks. By setting the parameters of the building blocks in this way, developers no longer need to set the parameters by modifying the source code.

[0095] refer to Figure 6 , organize the input and output parameters and implementation codes of the deep learning algorithm; build building block modules and add them to the database; developers use the building block spire deep learning tasks to obtain low-code visual deep learning building block models; convert building blocks into code through algorithms and perform code formatting to run tasks.

[0096] refer to Figure 7 ,The algorithm process from building building block records to deep learning network model is: read node records and edge records and initialize data structures; traverse each layer and establish dependencies between layers, start topological sorting of nodes, detect circular dependencies, ensure that there are no loops, and no loops; if no circular dependency is found, return a legal topological sorting list and rebuild the deep learning network model.

[0097] In this way, a model optimization script can be automatically generated based on a given JSON configuration file, improving development efficiency and flexibility.

[0098] The definitions of related functions include:

[0099] read_component_file: Reads a component file and handles the copying of attachment files.

[0100] topological_sort: Performs topological sorting on components to determine the order in which they are generated.

[0101] generate_init: Generates an initialization function.

[0102] topological_sort_components_init: Determines the order in which components are generated in the initialization function.

[0103] topological_sort_components_forward: Determines the order in which components are generated in the forward pass.

[0104] topological_sort_components: Alternative sorting method to determine which components are called first.

[0105] processIdStr: Perform special processing on the component ID.

[0106] generate_forward: Generates the forward propagation function.

[0107] generate_imports: Recursively traverse all units and obtain import information.

[0108] generate_components: Recursively generate multi-level component code.

[0109] generate_code_from_json_model: Main function, generates deep learning model code based on JSON file.

[0110] For example, given a JSON model description file manifest.json and an output file path ALModel.py, the generate_code_from_json_model(json_file, output_file) function should be called to automatically generate the Python code file of the deep learning model.

[0111] In practical applications, the JSON model description file can be customized according to specific needs to adapt to different deep learning model structures. At the same time, the generated code can also be further optimized and adjusted to meet specific performance requirements.

[0112] The embodiments of the present invention have the following advantages:

[0113] 1) Modular design: By decomposing deep learning methods into structural units and operation units, "building block" modularization is achieved, which greatly improves the flexibility and efficiency of model construction;

[0114] 2) Graph structure generation: The connection relationship between building blocks is converted into a graph structure, and the graph data structure features such as the in-degree of each building block are calculated and recorded. The model is constructed and restored according to the graph structure features. The logical relationship between modules is clearly displayed through the graph structure, which enhances the comprehensibility and maintainability of the model combination.

[0115] 3) Visual construction interface: It provides an intuitive graphical interface that allows users to build models by dragging, which lowers the threshold for using deep learning and enables non-professionals to participate in development;

[0116] 4) Flexible module configuration: supports users to freely design and configure building blocks according to new task requirements, facilitates rapid adaptation to different application scenarios, and improves the scalability of the system;

[0117] 5) JSON format storage and generation: Storing model combination relationships in structured JSON format improves model portability and version management efficiency, and reduces resource waste.

[0118] The embodiment of the present invention is developed based on the pytorch deep learning library, and can also be developed using deep learning libraries such as tensorflow, caffe, and paddlepaddle.

[0119] Although the present invention has been described in detail above by general description and specific embodiments, it is obvious to those skilled in the art that some modifications or improvements can be made to the present invention. Therefore, these modifications or improvements made without departing from the spirit of the present invention all belong to the scope of protection claimed by the present invention.

Claims

1. A method for generating deep learning model code based on JSON, characterized in that: The method comprises: Acquire deep learning codes and encapsulate the deep learning codes into building block units respectively, and store them in a database; Obtain user needs and receive user requests to call building blocks, and call building block units from the database; Receive the user's building block connection request and connect the called building block units, implement the deep learning model logic and store it as a JSON configuration file; Restore the deep learning model code using the JSON configuration file; Use the JSON configuration file to restore the deep learning model code, including: Read the JSON configuration file, and obtain and parse component information from the JSON configuration file; Using the parsed component information, recursively build the class structure of the model; Generate initialization functions and instantiate each class in the component to generate instantiation code; Generate a forward propagation function and generate calling codes for each component, and transfer and return input and output variables; Recursively traverse all units in the JSON configuration file, obtain all import information, and add the import information to the function generation code; Call the function to generate code and write it into the output file to generate the model code, thereby completing the automatic generation of deep learning model code.

2. A JSON-based deep learning model code generation method as described in claim 1, characterized in that: Read the JSON configuration file, and obtain and parse component information from the JSON configuration file, including: Obtaining a component file name, indentation level, and attachment information, and using the component file name, indentation level, and attachment information to read the component file content; Add the component file content to the code line and copy the attachment file to the specified output path.

3. A JSON-based deep learning model code generation method as described in claim 2, characterized in that: Using the parsed component information, recursively build the class structure of the model, including: Extract component type from parsed component information; When the component type is component, continue to recurse and parse the corresponding subcomponents; When the component type is unit, it is determined according to the component attributes whether the component is a class, function or custom class from an external library and corresponding processing is performed.

4. A JSON-based deep learning model code generation method as described in claim 3, characterized in that: Generate an initialization function and instantiate each class in the component, and generate instantiation code, including: Preprocessing the component ID, including: lowercase letters and removing specific parts; Use the initialization function, component type and input parameters to generate the corresponding implementation code, and handle the inheritance relationship of the class.

5. A JSON-based deep learning model code generation method as described in claim 4, characterized in that: Generates the forward propagation function and the calling code for each component, and transfers and returns the input and output variables, including: Generate function header and component calling form according to input and output parameters, and handle variable passing and return values.

6. A JSON-based deep learning model code generation method as described in claim 5, characterized in that: Recursively traverse all units in the JSON configuration file, obtain all import information, and add the import information to the function generation code, including: Generate multi-level component code through recursion, and continue recursion on sub-components; Traverse all units in the JSON configuration file, read the source code file and process the input and output parameters and attachment files to generate the main class of the project.

7. A JSON-based deep learning model code generation method as claimed in claim 6, characterized in that: Call the function to generate code and write it to the output file to generate the model code, including: Read the JSON configuration file and call the function to generate code; The function is used to generate code and write it into an output file to generate model code.

8. A JSON-based deep learning model code generation method as claimed in claim 7, characterized in that: The method further comprises: Topologically sort the preset layer data to ensure the correct component generation order; Sort each component according to the number of structural parameter incidents to obtain the generation order of components in the initialization function; Obtain the generation order of components in the forward propagation function according to the number of incident structural parameters; Perform topological sorting based on component input dependencies to determine the component execution order.

9. A JSON-based deep learning model code generation method as claimed in claim 8, characterized in that: The method further comprises: Train, verify, or run the generated code according to task requirements to form a complete deep learning task.

10. A JSON-based deep learning model code generation system, characterized in that: The system comprises: A packaging module, used to obtain deep learning codes and package the deep learning codes into building blocks, and store them in a database; A user demand acquisition module is used to acquire user demand and receive a user's request to call a building block, and call a building block unit from a database; The building block unit construction module is used to receive the user's building block connection request and connect the called building blocks to implement the deep learning model logic and store it as a JSON configuration file; The restoration module is used to restore the deep learning model code using the JSON configuration file.

Images