JP7817129B2 - Code creation support system, method, and program - Google Patents

Description

This disclosure relates to technology for creating program code for incorporation into a computer system from the results created by a computational notebook.

Many data scientists develop artificial intelligence using computational notebooks, such as Jupyter Notebook. Computational notebooks are environmental tools for data analysis. Data scientists create program fragments called cells in the computational notebook, execute multiple cells in the desired order, and perform data analysis while checking the execution results of each cell. The output obtained as a result of the aforementioned data analysis, an artificial intelligence model in computational notebook format, can be incorporated into a computer system and used.

However, computational notebooks are designed for data analysis, not for creating program code to be incorporated into computer systems. As a result, the execution order of cell-level processing is not clearly defined in computational notebooks. In order to incorporate the results created in computational notebooks into a computer system, it is necessary to use the results as a basis to create program code that clearly defines the execution order of processing units and is executable on a computer system, and then incorporate that program code, which is a cumbersome task. Therefore, there is a need for technology that makes it easier to incorporate results created in computational notebooks into computer systems.

Patent Document 1 discloses a technology that helps analysts other than the creator understand the structure of a calculation notebook by presenting the results of the calculation notebook in a graph format with nodes and links.

Japanese Patent Application Laid-Open No. 2020-68020

As mentioned above, when using the results of a calculation notebook on a computer system, it is necessary to create program code that can be executed on the computer system based on the results, taking into account the specifications of the computer system, etc. However, the technology in Patent Document 1 presents the results of the calculation notebook in a graphical format, which helps to understand the results, but does not make it easy to create program code that can be executed on a computer system.

One objective of this disclosure is to provide technology that makes it easier to incorporate the results of a computational notebook into a computer system.

One aspect of the code creation assistance system included in the present disclosure includes an inter-cell dependency extraction processing unit that extracts inter-cell variable dependencies in a data analysis result in which processing is described in units of cells, which are program fragments; an input data type identification processing unit that identifies a machine learning model from among the inter-cell variables in the result, detects cells that pass the machine learning model as a variable to other cells, and detects a specific data type by tracing back the variable dependencies from the detected cell; and a template matching processing unit that identifies, as a matching target, a template associated with an input data type that matches the detected specific data type from program code templates stored in association with the input data type, and searches for a portion of the result that matches the template.

One aspect of the present disclosure makes it easier to incorporate the results of a calculation notebook into a computer system.

1 is a conceptual diagram illustrating a configuration example of a code creation assistance system corresponding to at least one of the embodiments of the present disclosure. 1 is a conceptual diagram illustrating a processing flow in a code creation assistance system according to at least one embodiment of the present disclosure. FIG. 10 is a conceptual diagram illustrating an example data structure of template information according to at least one embodiment of the present disclosure. FIG. 10 is a conceptual diagram illustrating a template for each data type according to at least one embodiment of the present disclosure. FIG. 10 is a conceptual diagram illustrating a template for each data type according to at least one embodiment of the present disclosure. FIG. 10 is a conceptual diagram illustrating data type information according to at least one embodiment of the present disclosure. 10 is a flowchart illustrating a processing example of inter-cell dependency extraction processing, according to at least one of the embodiments of the present disclosure. FIG. 10 is a conceptual diagram illustrating a cell of a deliverable from which dependencies have been extracted, according to at least one embodiment of the present disclosure. 10 is a flowchart illustrating a processing example of an input data type identification process according to at least one of the embodiments of the present disclosure. FIG. 10 is a conceptual diagram illustrating an example of the operation of an input data type identification process according to at least one of the embodiments of the present disclosure. 10 is a flowchart illustrating a process example of a template matching process according to at least one of the embodiments of the present disclosure. FIG. 10 is a conceptual diagram illustrating an example of matching between a cell and a template, according to at least one embodiment of the present disclosure.

Embodiments of the present invention will be described below with reference to the drawings.

Figure 1 is a conceptual diagram showing an example configuration of a code creation support system corresponding to at least one embodiment of the present disclosure.

In this embodiment, the code creation support system 1 shown in FIG. 1 is an information processing device such as a computer. The information processing device is capable of performing various types of information processing. Note that the code creation support system 1 may be made up of multiple devices, such as one or more client terminals and one or more server devices, which are communicatively connected.

The code creation support system 1 has a processor 10 and a memory 20. The code creation support system 1 has a communication unit 30 that can communicate with external devices via an external network 100. The processor 10, memory 20, and communication unit 30 are connected to each other so that they can communicate with each other via a bus.

The code creation support system 1 may further include input devices such as a mouse and keyboard, and output devices such as a display and speakers.

The processor 10 is composed of, for example, a CPU (Central Processing Unit), GPU (Graphics Processing Unit), FPGA (Field-Programmable Gate Array), etc. The processor 10 performs control processing to oversee the overall operation of each part of the code creation support system 1, data input/output processing with external devices, data calculation processing, and data storage processing.

The memory 20 includes, for example, magnetic storage media such as HDDs (Hard Disk Drives), and semiconductor storage media such as RAMs (Random Access Memory), ROMs (Read Only Memory), and SSDs (Solid State Drives). Other well-known storage media, such as magnetic tape media, may also be included in the memory 20. The memory 20 stores various programs (OS, application software, etc.) and various data executed by the processor 10. The memory 20 also stores template information 21, which will be described later.

The processor 10 executes the programs stored in the memory 20 to realize the functions of the inter-cell dependency extraction processing unit 11, the input data type identification processing unit 12, and the template matching processing unit 13.

The inter-cell dependency extraction processing unit 11 extracts the dependency relationships between cells in a data analysis result in which processing is described in units of cells, which are program fragments. The input data type identification processing unit 12 identifies a machine learning model from the variables between the cells in the result, detects cells that pass the machine learning model as a variable to other cells, and detects a specific data type by tracing back the variable dependencies from the detected cells. The template matching processing unit 13 identifies, as a matching target, a template associated with an input data type that matches the detected specific data type from program code templates stored in association with the input data type, and searches for parts of the result that match the template.

The deliverables are those created using computational notebooks, such as Jupyter Notebooks.

Figure 2 is a conceptual diagram illustrating the processing flow in a code creation assistance system corresponding to at least one embodiment of the present disclosure.

The processor 10 acquires the calculation notebook NB. For example, in the case of a Jupyter notebook, the calculation notebook NB is a file with the extension ".ipynb". The calculation notebook NB may be stored in the memory 20. The processor 10 may also acquire the calculation notebook NB from an external device via the external network 100. The external device may include a cloud server, etc.

Based on the acquired calculation notebook NB, the processor 10 executes processing related to various functions, such as the inter-cell dependency extraction processing unit 11, the input data type identification processing unit 12, and the template matching processing unit 13.

The templates that the template matching processing unit 13 matches are stored in memory 20 as template information 21. The templates are program code templates stored in association with the input data type.

Template information 21 includes templates for each data type. Machine learning involves processes such as inference, learning, and evaluation, and template information 21 includes, for example, one or more templates for inference, learning, and evaluation. That is, for each input data type, memory 20 stores a learning process template that learns learning data and builds a machine learning model, an evaluation process template that evaluates the inference accuracy of the machine learning model, and an inference process template that performs inference using the machine learning model.

The processor 10 outputs the program code created based on the calculation notebook NB to the system embedded pipeline PL.

Figure 3 is a conceptual diagram illustrating the data structure of template information corresponding to at least one embodiment of the present disclosure.

Templates for each data type are stored in memory 20 in association with input data type information. For example, they may be stored in memory 20 in the form of table data listing input data type information and templates for each data type. The template matching processing unit 13 searches the deliverable for parts that match each of the three templates, namely the learning process template, the evaluation process template, and the inference process template. The search will be described later with reference to Figure 11.

Figure 4 is a conceptual diagram showing templates for each data type, corresponding to at least one embodiment of the present disclosure.

A template specifies the number and data type of input data for one or more components, as well as the variable dependencies between those components, as constraints. The template may also specify the number and data type of output data for one or more components. Data type refers to the type of variable, such as numeric or the text type described below. The number of data items refers to the number of different types of data, i.e., the number of pieces of data. For example, if the input data for a task is numeric variable a, text variable b, and text variable c, the number of input data items is three.

An example of a component is a task included in a program. A task is a fragment of the processing flow executed by that template. The data type template shown in Figure 4 shows multiple tasks, such as task1, task2, and task3, as components. Tasks have an execution order, and in the data type template shown in Figure 4, they are executed in the order task1, task2, and task3. Note that tasks are not necessarily executed one by one sequentially; multiple tasks may be executed simultaneously in parallel.

Figure 5 is a conceptual diagram illustrating templates for each data type, corresponding to at least one embodiment of the present disclosure.

Artificial intelligence processing includes multiple processes such as learning, evaluation, and inference. In this embodiment, learning templates, evaluation templates, and inference templates for numerical data are illustrated as examples.

In each template shown in Figure 5, the open rectangles represent processing. For example, "preprocess" means preprocessing, and "split (in row)" means data splitting. The open rectangles correspond to tasks such as task1 in Figure 4. On the other hand, the dotted rectangles represent data. For example, the dotted rectangle labeled "df" represents a data frame that expresses multiple data columns in matrix format.

The learning template will now be described. Note that the execution entity for executing each task included in the template will be the processor 10, for example.

In task T101, processor 10 obtains labeled data as input data. Processor 10 loads and reconstructs the input data, and outputs target data df.

In task T102, processor 10 performs preprocessing on the input data, target data df. Preprocessing is a common process in machine learning, so a detailed explanation will be omitted. The output data of task T102 is the preprocessed target data df.

In task T103, processor 10 divides the input data, preprocessed target data df, row-wise into training data train_df and test data test_df. The output data of task T102 is two types: the divided training data train_df and test data test_df.

In task T104, processor 10 trains the learning model using the input data, training data train_df. Training a learning model is a common process in machine learning, so a detailed explanation will be omitted. The trained model after training becomes the output data for task T104 and the input data for task T106, which will be described later. Note that the trained model as input data or output data may be just a set of weight data, or it may be both weight data and data indicating the network structure.

In task T105, processor 10 extracts explanatory variable df_f from the input data, test data test_df, and outputs it to task T106, and extracts objective variable df and outputs it to task T107.

In task T106, processor 10 inputs the explanatory variable df_f, which is input data, into the trained model obtained in task T104. As a result, the trained model outputs a prediction result Prediction_result.

In task T107, processor 10 evaluates the prediction result using the input data, prediction_result, and the input data, objective variable df, and outputs the evaluation result, result.

Next, we will explain the evaluation template. Note that tasks T201, T202, T205, and T207 perform the same processing as tasks T101, T102, T105, and T107, respectively, and therefore will not be explained here.

In task T203, the processor 10 assigns the preprocessed target data df, which is the input data, to the test data test_df.

In task T206, the processor 10 inputs the explanatory variable df_f, which is input data, into the trained model that has already been introduced. As a result, the trained model outputs a prediction result Prediction_result.

Next, we will explain the inference template. Note that tasks T301 and T302 perform the same processing as tasks T101 and T102, respectively, so their explanation will be omitted.

In task T303, the processor 10 assigns the preprocessed target data df, which is the input data, to the inference target data df_f.

In task T306, the processor 10 inputs the inference target data df_f, which is the input data, into the trained model that has already been introduced. As a result, the trained model outputs the inference result Prediction_result.

The above provides examples of three types of templates for each data type of numeric data: learning templates, evaluation templates, and inference templates. Different templates may be provided depending on the data type. For example, learning templates, evaluation templates, and inference templates may be provided for time-series data types, and further learning templates, evaluation templates, and inference templates may be provided for text data types.

Figure 6 is a conceptual diagram illustrating data type information corresponding to at least one embodiment of the present disclosure.

Example data types are (a) time series type, (b) image type, and (c) text type. The input data type includes at least one of these three data types.

An example of a time series data type is DataFrame. DataFrame has a Timestamp column and a Number column. Timestamp columns do not allow nulls. Number columns allow nulls. DataFrames do not allow nulls.

For image types, the data type is image (the image itself) and does not allow null. The image format is either png, jpg, or bmp. The image size has fixed values for both width and height.

For text data, the data type is Text. The language is the language of the country, such as English or Japanese; in this case, it is English. The character code is, for example, UTF-8 or UNICODE; in this case, it is UTF-8.

Note that the input data type information included in template information 21 does not need to include all of the data type information shown in FIG. 6. For example, reference numbers may be set in advance, such as 0001 for (a) time series data types, 0002 for (b) image data types, and 0003 for (c) text data types, and template information 21 may include the reference numbers as input data type information.

In addition, data type information specifying data types other than (a) time series type, (b) image type, and (c) text type may be included as input data type information in template information 21 (see Figure 3). In addition to the aforementioned Dataframe, data types include tensor, numpy array, dataset, etc.

Figure 7 is a flowchart showing an example of inter-cell dependency extraction processing corresponding to at least one embodiment of the present disclosure.

The inter-cell dependency extraction processing unit 11 extracts cells containing program code from the calculation notebook deliverables (S101).

The inter-cell dependency extraction processing unit 11 identifies, for the extracted cell, the instruction (A) that assigns to the variable in the cell and the instruction (B) that references or uses the variable (S102).

The inter-cell dependency extraction processing unit 11 determines the input variables and output variables of each extracted cell and the dependencies between each cell (S103). For example, when a variable assigned in a first cell is referenced or used in a second cell, the inter-cell dependency extraction processing unit 11 identifies a dependency in which the output variable of the first cell is an input variable of the second cell.

The inter-cell dependency extraction processing unit 11 refers to the dependencies extracted in S103 and orders the cells so that the instruction (B) for a certain variable is executed after the instruction (A) for that variable (S104). The order of the cells can be determined as follows. When the output and input variables between two cells are extracted using the method shown in Figure 11 and described below, it can be seen that the output variable of cell 1 is used as the input variable of cell 2. In this case, it can be said that cell 2 depends on the output of cell 1, and therefore it can be seen that cell 2 must be executed after cell 1.

The inter-cell dependency extraction processing unit 11 executes the deliverable in which the extracted cells are connected based on their dependencies, and confirms that the processing has completed successfully (S105). When executing the deliverable, the inter-cell dependency extraction processing unit 11 references the values of the input and output variables before and after the execution of each cell, and creates data type information for the input and output data.

The inter-cell dependency extraction processing unit 11 creates data type information for the input and output data by inferring the data types of the variables and associated schema information from the values of the referenced input and output variables.

Figure 8 is a conceptual diagram illustrating an example of a cell of a deliverable from which dependencies have been extracted, according to at least one embodiment of the present disclosure.

The deliverable shown in Figure 8 corresponds to the deliverable executed in step S105 of Figure 7. The deliverable shown in Figure 8 has three cells: Cell 1, Cell 2, and Cell 3. The execution order of the cells is Cell 1, Cell 2, and Cell 3.

Cell 1 contains an instruction to assign 100 to variable var1. This instruction is instruction (A) that assigns a value to variable var1 within the cell.

Cell 2 has an instruction to assign the execution result of function1 (var1, ...) to variable var2. This instruction is an instruction (A) that assigns to variable var2 within the cell. Also, because var1 is listed as an input parameter of function1, this instruction is an instruction (B) that references or uses variable var1.

Cell 3 has an instruction to execute function2 (var1, var2, ...). Because var1 and var2 are listed as input parameters for function2, this instruction is an instruction (B) that references or uses variables var1 and var2.

Next, we will explain dependencies. The variable var1, which is assigned in cell 1, is referenced in cells 2 and 3. Therefore, variable var1 is an output variable for cell 1. Also, variable var1 is an input variable for cells 2 and 3.

The variable var2, which is assigned in cell 2, is referenced in cell 3. Therefore, variable var2 is an output variable for cell 2. Also, variable var2 is an input variable for cell 3.

Figure 9 is a flowchart showing an example of input data type identification processing corresponding to at least one embodiment of the present disclosure.

The input data type identification processor 12 references the data type information of the output variables of each cell in the deliverable and extracts cells whose type information is a predefined artificial intelligence model (AI model) (S201). For example, the input data type identification processor 12 pre-registers type information of known artificial intelligence models in memory 20, etc., and compares the data type information of the output variables of each cell in the deliverable with this information to extract cells whose type information is an artificial intelligence model (AI model) that matches the registered type information. Note that when using a programming language such as Python (registered trademark), data type information cannot be directly referenced from the source code. However, when checking for normal operation in S105, it is possible to estimate what data type information will be stored during execution by, for example, saving the values of input and output variables before and after executing each cell, and then use the results to obtain data type information.

The input data type identification processing unit 12 determines whether the cell was extracted (S202). If the cell was extracted (S202: YES), processing proceeds to S203. If the cell was not extracted (S202: NO), processing proceeds to step S210. Step S210 is failure processing. Failure processing is a common process, so a detailed explanation will be omitted.

The cell extracted in step S201 is designated as cell X. The input data type identification processing unit 12 extracts cells that output variables for the extracted cell X (S203).

The input data type identification processing unit 12 obtains the data type information of the input variable in cell X and checks whether the data type information has the same conditions as the input data type information in the template information 21 (S204). Methods for checking whether the data or data type discovered in step S201 matches the type information in the template information include checking whether the class names match, whether the value conditions match, or whether the class name is a subclass of the class of the input data type information described in the template information. This check may be performed for all input data type information included in the template information 21. If this check is successful, it is determined that entry Y in the data row of the corresponding template information has been found.

The input data type identification processing unit 12 determines whether or not a corresponding entry Y of the template information 21 has been found. If it has been found (S205: YES), processing proceeds to step S206. If it has not been found (S205: NO), processing ends. Note that, while an example processing flow has been shown here in which the input data type identification processing unit 12 ends processing if a corresponding entry Y of the template information 21 has not been found in step S205 (S205: NO), other processing flows are also possible. For example, if a corresponding entry Y of the template information 21 has not been found in step S205 (S205: NO), the input data type identification processing unit 12 may proceed to step S207.

The input data type identification processing unit 12 acquires a template for each data type based on the information contained in entry Y. If the acquired template differs from the previously matched templates, the acquired template is added to the array Z of templates to be used and recorded (S206).

The input data type identification processing unit 12 determines whether there is a cell that is outputting a variable in cell X (S207). If there is (S207: YES), processing proceeds to step S208. If there is not (S207: NO), processing proceeds to step S209.

In step S208, the input data type identification processing unit 12 designates the cell that is outputting a variable to cell X as the new cell X. Processing then returns to step S203, and the search is repeated recursively.

In step S209, the input data type identification processing unit 12 returns the template array Z as the result.

Figure 10 is a conceptual diagram showing an example of the operation of input data type identification processing corresponding to at least one embodiment of the present disclosure.

Figure 10 shows the result of a calculation notebook. In (1), the cell that outputs the artificial intelligence model is detected from the result (step S201). In (2), the dependencies between cells are traced back from the detected cell (steps S203 to S208), and a specific data type is detected (steps S204 to S205). Furthermore, in (3), a template corresponding to the detected specific data type is obtained (step S206), and this is used as the target for matching processing (step S209).

Figure 11 is a flowchart showing an example of template matching processing corresponding to at least one embodiment of the present disclosure.

The processing from steps S301 to S307 below corresponds to the matching process for one template. Here, the array of template Z in step S209 may include multiple templates, and the template matching processing unit 13 may perform the processing from steps S301 to S307 for each of the multiple templates.

The template matching processing unit 13 extracts any partial cell string that is connected based on dependency relationships (S301). A partial cell string is a group of cells that are included in the deliverable and are connected based on dependency relationships (see step S105). A partial cell string does not necessarily have to be a group of multiple cells, but can also be a single cell.

The template matching processing unit 13 searches for a portion where the partial cell string matches the template by comparing the partial cell string with the template based on the number and data type of input data for cells in the deliverable and the variable dependency between cells (S302). "Matching" here refers to a complete match or a partial match between the number and data type of input data and the variable dependency between cells with the template.

If a matching portion is found, the template matching processing unit 13 associates the partial cell string with the matching portion of the template (S303).

The template matching processing unit 13 determines whether all cells extracted since the start of the process shown in FIG. 11 match the components of the template (S304). If they match (S304: YES), the process proceeds to step S307. If they do not match (S304: NO), the process proceeds to step S305.

In step S305, the template matching processing unit 13 determines whether all combinations have been tried for one or more partial cell strings included in the deliverable (S305). If all combinations have been tried (S305: YES), processing proceeds to step S306. If not all combinations have been tried (S305: NO), processing returns to step S301, where the next partial cell string is extracted.

In step S306, the template matching processing unit 13 calculates the degree of match, which is the degree to which the partial cell string of the deliverable matches the components included in the template. For example, the degree of match may be calculated as the proportion of cells included in the partial cell string that match the tasks included in the template. The template matching processing unit 13 outputs at least the degree of match for templates whose degree of match is equal to or greater than a predetermined threshold. Note that the template matching processing unit 13 may also output information other than the degree of match. For example, it may further output some or all of the template information whose degree of match is equal to or greater than a predetermined threshold, or information about the partial cell string.

In step S307, the template matching processing unit 13 outputs the extracted flow as a result, and outputs information indicating that the flow is 100% compliant with the template. Note that a flow refers to a group of connected cells that match the template. A flow is, for example, a partial cell string.

Figure 12 is a conceptual diagram showing an example of matching between a cell and a template, corresponding to at least one embodiment of the present disclosure.

Let's say the calculation notebook product includes cells 1 to 9. The template matching processing unit 13 extracts any partial cell string connected based on dependency relationships (S301). For example, it extracts a partial cell string consisting of cells 2, 3, and 4.

The template matching processing unit 13 searches for a portion where the partial cell string matches the template by comparing the partial cell string with the template based on the number and data type of input data for cells in the deliverable and the variable dependencies between cells (S302). As a result of the search, the partial cell string consisting of cells 2, 3, and 4 matches task T102. Therefore, the template matching processing unit 13 associates the partial cell string consisting of cells 2, 3, and 4 with task T102, which is the matching portion of the template (S303).

The template matching processing unit 13 performs similar processing for the other partial cell strings (loop from S301 to S305). As a result, cell 1 is associated with task T101, cell 5 with task T103, cell 6 with task T104, cell 7 with task T105, cell 8 with task T106, and cell 9 with task T107.

As a result, all cells match the components of the template (S304: YES), so the template matching processing unit 13 outputs the extracted flow as a result and outputs information indicating that the flow is 100% compliant with the template. In this case, a flow refers to a group of connected cells that match the template. More specifically, the group of connected cells from cell 1 to cell 9 is output as the result.

As described above, the coding support system 1 includes an inter-cell dependency extraction processing unit 11 that extracts inter-cell variable dependencies in a data analysis deliverable that describes processing at the cell-by-cell level, which are program fragments. The coding support system 1 includes an input data type identification processing unit 12 that identifies a machine learning model from among the variables between cells in the deliverable, detects cells that pass the machine learning model as a variable to other cells, and detects a specific data type by tracing back the variable dependencies from the detected cell. The coding support system 1 includes a template matching processing unit 13 that identifies, as a matching target, a template associated with an input data type that matches the detected specific data type from program code templates stored in association with the input data type, and searches for a portion of the deliverable that matches the template. This searches for a portion of the data analysis deliverable that matches a template that is easily applicable to a computer system, making it easier to incorporate the deliverable into a computer system using a calculation notebook.

The artifact is a work product created using the calculation notebook. This makes it easy to incorporate the artifact created by the calculation notebook into a computer system.

For each input data type, a learning process template is stored: one for learning the training data and constructing a machine learning model; one for evaluating the inference accuracy of the machine learning model; and one for inference processing that performs inference using the machine learning model. The template matching processing unit searches the deliverables for parts that match each of the three templates. This searches the deliverables for parts that match templates corresponding to the typical machine learning processes of learning, evaluation, and inference, making it easy to incorporate machine learning deliverables into computer systems.

The template matching processing unit 13 calculates the degree of match, which is the degree to which the partial cell string of the deliverable matches the components included in the template. The template matching processing unit 13 outputs at least the degree of match for templates whose degree of match is equal to or greater than a predetermined threshold. This makes it possible to visualize the degree of match between the deliverable and the template, and to modify the deliverable according to the degree of match or incorporate it into a computer system.

The template specifies the number and data type of input data for one or more components, as well as the variable dependencies between those components, as constraints. The template matching processing unit 13 searches for parts that match the template by comparing each partial cell string of the deliverable with the template based on the number and data type of input data for cells in the deliverable and the variable dependencies between cells. This makes it possible to match partial cell strings with a matching number of input variables and input data types to the components of the template.

The input data type includes at least one of image, time series, and text. This allows matching with templates to be searched for according to the specific data types used in machine learning: image, time series, and text.

The inter-cell dependency extraction processing unit 11 extracts cells containing program code from the deliverable, identifies the instructions that assign to variables in the cells and the instructions that reference or use the variables, and identifies a dependency where the output variable of the first cell is an input variable of the second cell when a variable assigned in a first cell is referenced or used in a second cell. This makes it possible to reliably identify inter-cell dependencies based on the handling of variables in each cell, even though the cells included in the deliverable are not necessarily arranged in chronological order of execution.

A code creation support method using a code creation support system 1 equipped with a processor 10 and memory 20 includes an inter-cell dependency extraction process that extracts inter-cell variable dependencies in a data analysis deliverable in which processing is described in units of cells, which are program fragments. The code creation support method includes an input data type identification process that identifies a machine learning model from among the variables between cells in the deliverable, detects cells that pass the machine learning model as a variable to other cells, and detects a specific data type by tracing back the variable dependencies from the detected cell. The code creation support method also includes a template matching process that identifies, as a matching target, a template associated with an input data type that matches the detected specific data type from program code templates stored in association with the input data type, and searches for a portion of the deliverable that matches the template. This searches for a portion of the data analysis deliverable that matches a template that is easily applicable to a computer system, making it easier to incorporate the deliverable into a computer system using a calculation notebook.

The code creation support program causes the code creation support system 1, which includes a processor 10 and memory 20, to implement an inter-cell dependency extraction function that extracts inter-cell variable dependencies in a data analysis result in which processing is described at the cell level, which are program fragments. The code creation support program causes the code creation support system to implement an input data type identification function that identifies a machine learning model from among the variables between cells in the result, detects cells that pass the machine learning model as a variable to other cells, and traces back the variable dependencies from the detected cell to detect a specific data type. The code creation support program causes the code creation support system to implement a template matching function that identifies, as a matching target, a template associated with an input data type that matches the detected specific data type from program code templates stored in association with the input data type, and searches for portions of the result that match the template. This searches for portions of the data analysis result that match templates that are easily applicable to a computer system, making it easier to incorporate the result into a computer system using a calculation notebook.

The above-described embodiments of the present invention are illustrative examples of the present invention and are not intended to limit the scope of the present invention to these embodiments alone. Those skilled in the art may implement the present invention in various other forms without departing from the scope of the present invention.

10... Processor, 11... Inter-cell dependency extraction processing unit, 12... Input data type identification processing unit, 13... Template matching processing unit, 20... Memory, 30... Communication unit, 100... External network

Claims (9)

an inter-cell dependency extraction processing unit that extracts dependencies between variables in cells in a data analysis result in which processing is described in units of cells, which are program fragments;
an input data type identification processing unit that identifies a machine learning model from variables between cells of the deliverable, detects cells that pass the machine learning model as a variable to other cells, and detects a specific data type by tracing back the dependency relationships of variables from the detected cells;
a template matching processing unit that identifies a template associated with an input data type that matches the detected specific data type as a matching target from among program code templates stored in association with the input data type, and searches for a portion in the deliverable that matches the template;
A code creation support system having the above. The deliverable is a deliverable created by a calculation notebook.
The code creation support system according to claim 1 . For each input data type, a learning process template for learning learning data to construct a machine learning model, an evaluation process template for evaluating the inference accuracy of the machine learning model, and an inference process template for performing inference using the machine learning model are stored;
the template matching processing unit searches the deliverable for a portion that matches each of the three templates;
The code creation support system according to claim 1 . the template matching processing unit calculates a degree of match, which is a degree to which the partial cell string of the deliverable matches the constituent element included in the template, and outputs at least the degree of match for the template whose degree of match is equal to or greater than a predetermined threshold.
The code creation support system according to claim 1 . The template defines, as constraints, the number and data type of input data of one or more components and dependency relationships between variables of the components;
the template matching processing unit searches for a part that matches the template by comparing each partial cell string of the deliverable with the template based on the number and data type of input data of cells in the deliverable and the dependency relationship between variables between cells;
The code creation support system according to claim 1 . The code creation support system of claim 3, wherein the input data type includes at least one of an image type, a time series type, and a text type. The inter-cell dependency extraction processing unit
extracting cells containing program code from the deliverable;
Identifying an instruction that assigns an assignment to a variable in the cell and an instruction that references or uses the variable,
Identifying a dependency in which, when a variable assigned in a first cell is referenced or used in a second cell, an output variable of the first cell is an input variable of the second cell;
The code creation support system according to claim 1 . An information processing device including a processor and a memory,
Extracting the dependencies between variables in the data analysis results that describe processing in units of cells, which are fragments of programs,
Identifying a machine learning model from variables between cells of the deliverable, detecting cells that pass the machine learning model as a variable to other cells, tracing back the dependency relationships of variables from the detected cells to detect a specific data type,
identifying, as a matching target, a template associated with an input data type that matches the detected specific data type from among program code templates stored in association with the input data type, and searching for a portion in the deliverable that matches the template;
How to help write code that does this. An information processing device having a processor and a memory,
Extracting the dependencies between variables in the data analysis results that describe processing in units of cells, which are fragments of programs,
Identifying a machine learning model from variables between cells of the deliverable, detecting cells that pass the machine learning model as a variable to other cells, tracing back the dependency relationships of variables from the detected cells to detect a specific data type,
identifying, as a matching target, a template associated with an input data type that matches the detected specific data type from among program code templates stored in association with the input data type, and searching for a portion in the deliverable that matches the template;
A code creation support program to make things happen.