Artificial intelligence application development system

Abstract

The present invention relates to an artificial intelligence application development system making it possible to easily develop an artificial intelligence application on the basis of graphics. The artificial intelligence application development system according to the present invention is configured to comprise: an IDE providing device (1) that provides an IDE in which a developer may develop an application on the basis of graphics; and a storage device (2) including a node library (2a), a project library (2b), and a flow graph library (2c). The IDE providing device (1) includes a user interface (20) through which the developer may create a flow graph by using nodes and edges. The user interface (20) includes: a node calling means for the developer to call the nodes into a workspace; a flow graph calling means for calling the flow graph into the workspace; and an edge connection means for connecting the edges for establishing a process flow or a data flow between the nodes. In addition, the IDE providing device (1) includes a flow graph engine (12) for analyzing and executing the flow graph.

Description

Artificial Intelligence Application Development System

[0001] The present invention relates to an artificial intelligence application development system that enables easy development of artificial intelligence applications based on graphics.

[0002] Recently, artificial intelligence (AI) based on machine learning or deep learning has been widely spread. Machine learning is based on statistical logic for efficiently analyzing a vast amount of data. As a typical example, machine learning usually sets a hypothesis function for analyzing sample data called training data or training set, and generates a loss function or cost function corresponding to the error between the hypothesis and the actual data. Then, using the gradient descent algorithm, weights and bias values for minimizing the loss (cost) are calculated, and an AI model or application capable of predicting or deriving the desired result by the user is completed.

[0003] When creating an AI application, a data flow graph is created considering the data flow, and coding is executed using an appropriate programming language. Programming languages for AI generation include Python, R, C / C++, Java, JavaScript, Julia, Scala, Ruby, MATLAB, Octave, and SA, etc. These are text-based programming languages. To create an AI algorithm or an AI application using these programming languages, specialized knowledge of the programming language is required. In particular, AI algorithms involve very complex and difficult mathematical operations, and coding them requires a lot of workers and working hours.

[0004] Recently, generative AI applications such as Amazon CodeWhisperer have been proposed to support developers in quickly and safely building AI applications by utilizing large language models (LLMs) and foundation models (FMs) in an integrated development environment (IDE).

[0005] In addition, Korean Patent Publication No. 10-2021-0123152 (Title: Command Automatic Generation Device for Artificial Intelligence Processor and Its Optimization Method), Patent No. 10-2271449 (Title: Artificial Intelligence Model Platform and Artificial Intelligence Model Platform Operation Method), and Patent No. 10-2352991 (Title: Artificial Intelligence Model Generation Method Using Artificial Intelligence Model Generation Platform Providing System), etc. disclose methods for users to easily create AI applications. The above methods simply enable the development of the desired artificial intelligence model by using existing artificial intelligence algorithms or models that have been developed.

[0006] In addition, Republic of Korea Patent No. 10-0633241 (Title: Integrated Development Environment System for Embedded Linux Education), Patent No. 10-0553707 (Title: SCORM-Based Content Generation System), Patent No. 10-0860963 (Title: Apparatus and Method for Component-Based Software Development), Published Patent No. 10-2018-0048213 (Title: Method and Apparatus for Configuring an Integrated Development Environment User-Defined Member Edit Window), Patent No. 10-2622652 (Title: Method and Apparatus for Automatic Software Development for a Group of Controller-Based Devices), Published Patent No. 10-2022-0050362 (Title: GUI-Based Integrated Development Environment Providing System for Algorithm Configuration), and Published Patent No. 10-2023-0089495 (Title: Spiking Neural Network Input Data Processing System of GUI-Based Integrated Development Environment), etc., disclose systems that provide a graphic-based integrated development environment (IDE). These inventions enable the development of content such as applications using a graphic base or with minimal program coding. However, the above-mentioned inventions have a problem in that they cannot appropriately respond to the development of applications having a diverse and complex decision tree structure such as artificial intelligence.

[0007] An object of the present invention is to provide a development system that enables a developer to easily and simply develop an artificial intelligence application.

[0008] The artificial intelligence application development system according to the present invention includes an IDE providing device that provides an IDE allowing a developer to develop an application based on a graphic, and a storage device having a node library, a project library, and a flowchart library. The IDE providing device has a user interface allowing a developer to generate a flowchart using nodes and edges, and the user interface has a node calling means for a developer to call a node into a work space, a flowchart calling means for calling a flowchart into the work space, and an edge connecting means for connecting an edge for setting a process flow or a data flow between nodes. In addition, the IDE providing device includes a flowchart engine for analyzing and executing the flowchart.

[0009] According to the present invention, an IDE is provided that allows a developer to develop an AI application based on a graphic. The IDE has a user interface allowing a developer to generate a flowchart based on a graphic using nodes and edges, and a flowchart generator for storing flowchart information corresponding to the flowchart in a project library. In addition, the IDE has a flowchart engine allowing a developer to test or debug an application developed by the developer. The developer can develop an AI application desired by the developer only by creating a flowchart based on a graphic through the IDE, and can test and debug the application using the flowchart engine.

[0010] FIG. 1 is a block diagram showing the configuration of an artificial intelligence application development system according to an embodiment of the present invention.

[0011] FIG. 2a is a diagram showing an example of a user interface (20) provided by the IDE providing device (1) in FIG. 1.

[0012] Figure 2b shows an example of a flowchart registration window (201) provided by the IDE providing device (1) when the flowchart registration menu (222) is selected in Figure 2a.

[0013] Figure 2c shows an example of an interface screen provided by the IDE providing device (1) when the developer selects the flowchart expansion menu (224) in Figure 2a.

[0014] Figure 2d shows an example of a category list (225a) that can be selected through the node selection menu (225) in Figure 2a,

[0015] Figure 2e shows an example of a node list (225b) that can be selected by selecting the category list (225a) in Figure 2d.

[0016] Figure 2f shows an example of a method of loading a desired node from the node list (225b) into the work space (21).

[0017] Figure 2g shows an example of another method of calling the node (30) into the work space (21).

[0018] Figure 2h shows an example of a parameter setting window (212) provided by the IDE providing device (1).

[0019] Figure 2i shows an example of a selection window (213) related to the node (30) provided by the user interface (20).

[0020] Figure 3 shows an example of a working process of generating a flowchart in the work space (21) using the user interface (20).

[0021] Figure 4 shows the types of nodes for setting data flow and their configuration examples.

[0022] Figure 5 shows the types of nodes for setting process flow and their configuration examples.

[0023] FIG. 6a is a diagram showing an example of a setting window (214) provided corresponding to the path selection node (301) in FIG. 5.

[0024] FIG. 6b is a diagram showing an example of a setting window (215) provided corresponding to the loop control node (302) in FIG. 5.

[0025] FIG. 6c is a diagram showing an example of a setting window (216) provided corresponding to the match-branch node (303) in FIG. 5.

[0026] FIG. 7 is a diagram showing an example of a state where the developer presses the execution button (227) after creating a flowchart.

[0027] An artificial intelligence application development system according to the present invention is a development system for developing an artificial intelligence application. The development system includes an IDE providing device that provides an IDE for a developer to develop an application based on a graphic, and a storage device having a node library, a project library, and a flowchart library. The IDE providing device has a user interface that allows a developer to create a flowchart using nodes and edges. The user interface has a work space, and includes a node calling means for a developer to call a desired node into the work space, a flowchart calling means for a developer to call a desired flowchart into the work space, and an edge connecting means for connecting an edge for setting a process flow or a data flow between nodes. The IDE providing device includes a flowchart engine for analyzing and executing a flowchart, and the user interface has a control means for controlling the execution of the flowchart engine.

[0028] In addition, the flowchart calling means includes a list of flowcharts that can be selected and called by a developer.

[0029] In addition, the flowchart list includes sub-flowcharts.

[0030] In addition, the user interface is characterized by having a sub - flowchart calling means that allows a developer to call a flowchart as a sub - flowchart.

[0031] In addition, the user interface is characterized by having control means for controlling the execution of the flowchart engine.

[0032] In addition, the artificial intelligence application development system is further configured to include a hyperparameter engine that provides hyperparameter setting means for setting hyperparameters for a node called into a work space.

[0033] In addition, the node library has node information related to nodes that can be called by a developer, the node information includes program source or code information corresponding to the node, the project library stores flowchart information corresponding to the flowchart generated through the work space, and the flowchart information includes node information and edge information of the nodes included in the flowchart.

[0034] In addition, the node information is characterized by being written in JSON.

[0035] In addition, the node is characterized by having a process port connected to an edge.

[0036] In addition, the node has a data port connected to an edge, and the data port includes a data input port and a data output port.

[0037] In addition, the edge includes a first edge connected to a process port to set a process flow and a second edge connected to a data port to set a data flow.

[0038] Hereinafter, embodiments according to the present invention will be described with reference to the drawings. However, the embodiments described below are exemplary illustrations of one preferred implementation example of the present invention, and such examples of the embodiments are not intended to limit the scope of the rights of the present invention. The present invention can be implemented in various modifications within the scope not departing from its technical idea.

[0039] FIG. 1 is a block diagram showing the configuration of an AI application development system according to an embodiment of the present invention. The AI application (hereinafter simply referred to as AI) development system includes an IDE providing device (1) that provides an integrated development environment (IDE) in which a developer can develop AI based on graphics, and a storage unit (2) in which various data necessary for the operation of the IDE and the development of AI are stored.

[0040] The IDE providing device (1) is programmatically configured. The IDE providing device (1) includes a flowchart generator (11) and a user interface (20). The flowchart generator (11) provides means for generating a flowchart including a data flow and a process flow by a developer in cooperation with the user interface (20). The user interface (20) preferably includes a GUI (Graphical User Interface). The developer can generate a flowchart based on graphics through the user interface (20).

[0041] In addition, the IDE providing device (1) includes a flowchart engine (12). The flowchart engine (12) analyzes and executes the flowchart generated by the developer. The flowchart engine (12) manages data input, conditional branching, and interaction with external devices. The flowchart engine (12) can preferably be utilized as means for testing and debugging the flowchart, that is, the application, generated by the developer.

[0042] In a preferred embodiment of the present invention, the IDE providing apparatus (1) includes a hyperparameter engine (13). The hyperparameter engine (13) provides means for a developer to easily set various hyperparameters necessary for the execution of AI in conjunction with the user interface (20).

[0043] The storage unit (2) includes a node library (2a) in which node information for flowchart generation is stored, a project library (2b) in which integrated information related to an application that a developer wants to develop is stored, and a flowchart library (2c) in which flowchart information that a developer can search for or adopt is stored. These libraries will be described in detail later.

[0044] FIG. 2a is a diagram showing an example of the user interface (20) provided by the IDE providing apparatus (1). The user interface (20) basically includes a work space (21) and a plurality of selection menus (22). The work space (21) is for generating a flowchart. As will be described later, the developer calls nodes into the work space (21) and appropriately connects the nodes using edges, thereby generating a flowchart in a graphic base.

[0045] The selection menu (22) can be selected by a developer, for example, by clicking on the corresponding area with a mouse (not shown). Of course, in other preferred implementation examples, the selection menu (22) can be implemented to be selected by a developer using keyboard shortcuts. The selection menu (22) includes a project name selection menu (221) for registering and selecting a project name, a flowchart registration menu (222) for registering a new flowchart, and a flowchart selection menu (223) for selecting and loading an existing registered flowchart. FIG. 2b is a diagram showing an example of a flowchart registration window (201) provided by the user interface (20) when the flowchart registration menu (222) is selected. In the diagram, the flowchart registration window (201) includes a name field (201a) for entering a flowchart name, a category field (201b) for selecting or registering a category, and a registration button (201c). The flowchart registered through the flowchart registration window (201) is stored in the project library (2b) together with the project name and can then be retrieved and selected through the flowchart selection menu (223).

[0046] Above the work area (21), there is a display window (23) for displaying the project name and the flowchart name. In the display window (23), the project name and the flowchart name selected by the developer through the project name selection menu (221) and the flowchart selection menu (223) are displayed. That is, in the display window (23), the project name and the flowchart name related to the application currently being developed are displayed.

[0047] On one side of the flowchart registration menu (222), an extended menu (224) related to the flowchart is provided. FIG. 2c is a diagram showing an example of an interface screen provided by the IDE providing device (1) when the developer selects the flowchart extended menu (224). In the figure, the flowchart extended menu (224) has a number of selection items (224a to 224f) that the developer can select in relation to the currently working flowchart. These selection items include a deletion item (224a) for initializing the work space (21), an edit item (224b) for returning to the flowchart registration window (201) of FIG. 2b to modify or edit flowchart-related information, a copy item (224c) for copying the work content, a download item (224d) for storing the flowchart in the local memory or other storage means, a flowchart deletion item (224e) for deleting the corresponding flowchart list, and an upload item (224f) for uploading the downloaded flowchart, etc.

[0048] On the other hand, in FIG. 2a, the user interface (20) has a node selection menu (225). The node selection menu (225) preferably has a category list and a node list. These can be viewed and selected by the developer by selecting the node selection menu (225). FIG. 2d is a diagram showing an example of the category list (225a) that can be selected through the node selection menu (225). In the present invention, the list of node categories provided through the user interface (20) and the method of providing them are not specified.

[0049] In addition, FIG. 2e is a diagram showing an example of the node list (225b) that can be selected through the node selection menu (225). When the developer selects the desired node category in FIG. 2d, the user interface (20) provides a node list (225b) corresponding to the category. In the present invention, the node list provided by the user interface (20) and the method of providing it are not specified and can be variously modified.

[0050] Each node provided in the node list (225b) corresponds to an operation to be performed in a program, including operation processing. One node may correspond to one program module. A developer can create a desired flowchart by obtaining an appropriate flowchart or node from the flowchart selection menu (223) and the node selection menu (225).

[0051] FIG. 2f is a diagram showing an example of a method of loading a desired node from the node list (225b) into the work space (21). When a developer wants to call a desired node into the work space (21), the developer clicks on the desired node item in the node list (225b) with the mouse and then calls the node (30) to a desired position in the work space (21) in a drag and drop manner. The node (30) called into the work space (21) can be moved to a desired position again in a drag and drop manner. The method of calling the node (30) into the work space (21) is not specified.

[0052] FIG. 2g is a diagram showing an example of another method of calling the node (30) into the work space (21). When a developer clicks the right button of the mouse on an arbitrary empty area of the work space (21), a selection window (211) with an item 'add node' is provided in the clicked area of the work space (21). The developer can call a desired node (30) into the work space (21) by selecting the desired node item from the category list (225a) and the node list (225b) displayed step by step from this selection window (211).

[0053] Returning to Fig. 2f, the node (30) includes a number of elements (31 to 33) arranged schematically. The node (30) basically includes an element (31) for defining the work content. In addition, the node (30) includes elements (32, 33) for input and output of data as required. The types and functions of the elements included in the node (30) may vary depending on the type of the node (30), that is, the work to be performed by the corresponding node (30).

[0054] Generally, there are a number of hyperparameters, i.e., superparameters, in the program source constituting an application, and it is necessary to appropriately set their values during the programming work. In Fig. 1, the hyperparameter engine (13) provides a tool that enables a developer to easily set hyperparameters for the node (30). Fig. 2h is a diagram showing an example of the hyperparameter setting means provided by the hyperparameter engine (13). When a specific node (30) is a node including hyperparameters, when the developer clicks on the element (31) of the node (30) with the left button of the mouse, the hyperparameter engine (13) provides a setting window (212) for inputting or setting hyperparameters at the lower side of the work space (21). In addition, in a preferred implementation example, the setting window (212) is provided with a lock button (212a) for the developer to lock or unlock the hyperparameter value in a toggle manner. The developer can set or input the hyperparameter value through the setting window (212) and confirm the set value using the lock button (212a). In addition, the provision of such a setting window (212) is not limited to the setting of hyperparameter values. For example, when a specific node requires a command or prompt input, the IDE providing device (1) can provide an input window in the same manner.

[0055] FIG. 2i is a diagram showing an example of a selection window (213) related to a node (30) provided by a user interface (20). When a developer clicks on the area of the node (30) with the right button of the mouse, the user interface (20) provides a selection window (213) related to the corresponding node (30). At this time, the selection window (213) includes a selection item for setting the corresponding node as the start node of the flowchart, and selection items for cutting, copying, duplicating, and deleting the corresponding node. In addition, the selection window (213) preferably includes a selection item for collectively releasing the locked state of all hyperparameters input and locked through the setting window (212) in FIG. 2h.

[0056] Returning to FIG. 2f again, the node (30) has ports (31a, 32a, 33a) that can be connected to other nodes (30). The node (30) basically has a process port (31a) for setting a process flow, and optionally includes data ports (32a, 33a) for setting a data flow. In addition, the data ports (32a, 33a) may include an input port (32a) for data input and an output port (33a) for data output. In a preferred embodiment, the ports (31a, 32a, 33a) are set to have different shapes or colors according to their functions so that the developer can easily distinguish the corresponding port. The developer creates a flowchart by appropriately connecting the ports (31a, 32a, 33a) of the nodes (30) using edges.

[0057] FIG. 3 is a diagram showing an example of a process of generating a flowchart in a work space (21) using a user interface (20). When generating a flowchart in the work space (21), first, a desired node (30) is called from a node list (225b) and the node (30) is placed in the work space (21). Then, the process ports (31a) and data ports (32a, 33a) of the node (30) are connected by edges (40) to set the process flow and data flow in the flowchart. The generation or connection of the edge (40) is executed by dragging the mouse to a desired other port (31a, 32a, 33a) while clicking on one port (31a, 32a, 33a) with the mouse. Also, in a preferred implementation example, the IDE providing device (1) sets different colors for the edges setting the process flow and the edges setting the data flow so that the developer can easily recognize the process flow and the data flow. Further, in another preferred implementation example, when the developer inappropriately sets the process flow or the data flow, for example, connects the process port (31a) of one node to the data ports (32a, 33a) of another node, or the developer inappropriately executes the connection of the input / output ports between nodes, such as inappropriately executing the edge connection between nodes, the IDE providing device (1) prevents the occurrence of errors in the flowchart by rejecting the generation of the edge.

[0058] In a preferred embodiment of the present invention, a data flow category having a node list for setting a data flow is provided in a category list (225a) of a node selection menu (225). FIG. 4 is a diagram showing the types and configuration examples of nodes included in the data flow category, that is, nodes for setting a data flow.

[0059] In a more preferred embodiment of the present invention, the category list (225a) of the node selection menu (225) includes a flow control category having a list of nodes for setting a process flow. FIG. 5 is a diagram showing the types and configuration examples of nodes included in the flow control category, that is, nodes for setting a process flow. The nodes for setting a process flow include a path selection node (301), a loop control node (302), and a match-branch node (303).

[0060] The path selection node (301) provides a function for a user to select a path of a process flow. The IDE providing device (1) provides a setting window for a developer to set the number of branches of the path selection node (301). FIG. 6a is a diagram showing an example of the setting window (214) provided corresponding to the path selection node (301). As described above, the setting window (214) is generated by a developer clicking on the path selection node (301) area with a mouse. The setting window (214) has a branch addition button (214a) for a developer to add a branch port and a branch removal button (214b) for removing a branch port. In addition, the setting window (214) has a lock button (214c) for locking or unlocking a value set by a developer, that is, the number of branch ports. In the figure, the node (301a) shows a state where a developer has increased the number of branch ports of the path selection node (301) using the setting window (231).

[0061] The loop control node (302) provides a function for a developer to control the repetitive execution of a process flow. The IDE providing device (1) provides a setting window for a developer to set the number of repetition times of a process flow. FIG. 6b is a diagram showing an example of the setting window (215) provided corresponding to the loop control node (302).

[0062] The match-branch node (303) provides a function to branch the input according to patterns. The IDE providing device (1) provides a setting window in which a developer can set a match pattern and a branch. FIG. 6c is a diagram illustrating an example of the setting window (216) provided corresponding to the match-branch node (303). The setting window (216) includes a field (216a) for a developer to define a pattern, buttons (216b, 216c) for adding and removing the field and the branch, and a lock button (216d) for locking or unlocking setting values through the setting window (216). In the figure, the node (303a) shows a state in which a developer has added a branch port of the match-branch node (303) using the setting window (216).

[0063] FIGS. 4 and 5 illustratively show examples of nodes for setting a process flow and a data flow, and the configuration and type of these nodes are not specified. The configuration and type of the nodes may be appropriately changed according to an application or a programming language. The nodes for setting a process flow and a data flow simplify the overall structure of the flowchart and provide an effect that enables a developer to easily create the flowchart. The flowchart according to the present invention includes a process flow as well as a data flow in one flowchart. This provides a basis for setting loops, decision trees, and interactions with a user, which are impossible in a flowchart of only a data flow.

[0064] Returning to FIG. 1, the storage unit (2) includes a node library (2a), a project library (2b), and a flowchart library (2c). In the node library (2a), node information for each node corresponding to the nodes provided to the developer by the IDE providing device (1), that is, the node list (225b) provided through the node selection menu (225) in FIG. 2e, is stored. Here, the node information includes program source or code information corresponding to the corresponding node. In a preferred embodiment, the node information is written in, for example, JSON (JavaScript Object Notation). Of course, the programming language for writing the node information in the present invention is not specified.

[0065] In the project library (2b), the flowchart information created by the developer through the work space (1) is stored. This flowchart information is stored corresponding to the flowchart name registered by the developer. Here, the flowchart information includes program source or code information corresponding to the nodes included in the flowchart, and connection information between the nodes, that is, edge (40, FIG. 3) information. That is, in the project library (2b), node information, process flow information, and data flow information constituting the flowchart are stored corresponding to the flowchart name. The flowchart information may correspond to source or code information written in a programming language related to the application.

[0066] And in the flowchart library (2c), various types of flowcharts that the developer can use or refer to for flowchart generation are stored. In a preferred embodiment, the flowcharts stored in the flowchart library (2c) are provided to the user interface (20) together with their category information, and are displayed as a list of flowcharts that the developer can view and select through the flowchart selection menu (223).

[0067] In addition, in a preferred embodiment, the flowchart category includes sub - flowchart categories. A sub - flowchart can be adopted by a developer as a part of the flowchart that the developer wants to create. In a preferred embodiment, one sub - flowchart can correspond to one AI agent. The developer can easily implement a multi - agent system by using a number of agents provided in the flowchart library (2c).

[0068] Also, in another preferred embodiment, the user interface (20) provides a calling function that allows a developer to adopt a flowchart provided in the flowchart list as a sub - flowchart. For example, when the developer selects the flowchart list with the right - click of the mouse, the user interface (20) provides a selection button that allows the developer to adopt the flowchart as a sub - flowchart. The developer can use this sub - flowchart calling function to adopt a number of flowcharts as sub - flowcharts and easily create diverse and complex flowcharts.

[0069] In FIGS. 1 and 2b, when the developer registers a flowchart through the input window (201), the IDE providing device (1), i.e., the flowchart generator (11), generates a flowchart file in the project library (2b) together with directory information. When the developer calls a node (30) to the work space (21) in FIG. 3, the flowchart generator (11) obtains node information from the node library (2a) and stores it in the flowchart file. When the developer connects between nodes using an edge (40), the flowchart generator (11) generates the connection information and stores it in the flowchart file. Accordingly, the flowchart file stores the node information corresponding to the flowchart created by the developer and their connection information. In addition, the hyperparameter engine (13) provides a hyperparameter setting window (212) to the developer as needed. After the developer inputs or sets hyperparameters and locks the lock button (212a), the corresponding hyperparameter value is registered in the flowchart file.

[0070] On the other hand, in FIG. 2a, the user interface (20) has a flowchart operation button (226) for flowchart editing and an execution button (227) for executing the generated flowchart. The developer (227) can use these buttons to execute or modify the flowchart. The execution button (227) is for driving the flowchart engine (12) in FIG. 1. FIG. 7 is a diagram showing an example in a state where the developer presses the execution button (227) after generating a flowchart. When the developer selects the execution button (227), the IDE providing device (1) activates the execution display window (228) of the user interface (20) and drives the flowchart engine (12). The flowchart engine (12) analyzes the node information and edge information stored in the flowchart file of the project library (2b) to execute the flowchart.

[0071] In a preferred embodiment, when an error occurs in the flowchart during the execution of the flowchart by the flowchart engine (12), the IDE providing device (1) provides an interface screen for the developer to correct the error. For example, when there is an error in the prompt input node (70a) in the flowchart, the IDE providing device (1) enables the developer to recognize the node with the error by, for example, displaying the color of the node differently, and activates the prompt input window (71) of the prompt input node (70a) so that the developer can reset the prompt input. At this time, the operation of the flowchart engine (12) is paused, and the display of the execution button (228) of the user interface (20) is set to the paused state. For the prompt input window (71), when the developer executes an appropriate prompt input and presses the completion button (71b) along with setting the lock of the lock button (71a), the IDE providing device (1) resumes the operation of the flowchart engine (12). The above operation is executed in the same manner even when the developer inappropriately sets the hyperparameters for a specific node. Preferably, the flowchart engine (12) can be utilized for the developer to test and debug the application.

[0072] The embodiments according to the present invention have been described above. However, the present invention is not limited to the above-described embodiments, and can be variously modified and implemented within the scope not departing from the technical idea thereof.

[0073] According to the present invention, an IDE is provided that enables a developer to develop an AI application based on a graphic. The developer can develop the AI application desired by the developer only by creating a flowchart based on the graphic through the IDE, and can test and debug the application using the flowchart engine.

Claims

1. In a development system for developing artificial intelligence applications, An IDE provider that provides an IDE that allows developers to develop applications based on graphics, It consists of a storage device that includes a node library, a project library, and a flowchart library, The above IDE providing device has a user interface that allows a developer to create a flowchart using nodes and edges, and the user interface has a workspace, a node calling means for the developer to call a desired node to the workspace, a flowchart calling means for the developer to call a desired flowchart to the workspace, and an edge connecting means for connecting edges to establish a process flow or data flow between nodes. The above IDE provider is configured to include a flowchart engine for interpreting and executing flowcharts, An artificial intelligence application development system, characterized in that the user interface comprises a control means for controlling the execution of the flowchart engine.

2. In paragraph 1, An artificial intelligence application development system characterized in that the above flowchart calling means includes a list of flowcharts that can be selected and called by a developer.

3. In paragraph 2, An artificial intelligence application development system characterized in that the above flowchart list includes sub-flowcharts.

4. In paragraph 2 or 3, An artificial intelligence application development system characterized in that the user interface has a sub-flowchart calling means that allows a developer to call a flowchart as a sub-flowchart.

5. In paragraph 1, An artificial intelligence application development system, characterized in that the user interface comprises a control means for controlling the execution of the flowchart engine.

6. In paragraph 1, An artificial intelligence application development system characterized in that the above artificial intelligence application development system further comprises a hyperparameter engine that provides a hyperparameter setting means for setting hyperparameters for a node called as a workspace.

7. In paragraph 1, The above node library has node information related to a node that can be called by a developer, and the node information includes program source or code information corresponding to the node. An artificial intelligence application development system characterized in that the above project library stores flowchart information corresponding to a flowchart created through a workspace, and the flowchart information includes node information and edge information of nodes included in the flowchart.

8. In paragraph 7, An artificial intelligence application development system characterized in that the above node information is written in JSON.

9. In paragraph 1, An artificial intelligence application development system, characterized in that the above node has a process port connected to an edge.

10. In paragraph 9, An artificial intelligence application development system, characterized in that the above node has a data port connected to an edge, and the data port includes a data input port and a data output port.

11. In paragraph 1, An artificial intelligence application development system characterized in that the above edge includes a first edge connected to a process port to establish a process flow, and a second edge connected to a data port to establish a data flow.

Images