AI graphical programming platform and method based on unsupervised learning

Abstract

The invention discloses an AI graphical programming platform and method based on unsupervised learning. The method comprises the steps that programming instruction building blocks are used for selecting and configuring an AI model based on unsupervised learning; programming instruction building blocks are used for conducting graphical programming to obtain graphical codes of a target program, the graphical codes comprise the programming instruction building blocks used for indicating characteristic parameters and the programming instruction building blocks used for calling the AI model, and the characteristic parameters are used for indicating training data of the AI model; and when the target program runs, acquiring the training data in real time based on the feature parameters, and optimizing the AI model by using an unsupervised learning method based on the training data to realize the target program. The technical problem that an unsupervised learning platform is poor in user experience for beginners is solved.

Description

Technical Field

[0001] The present invention relates to the field of AI, and in particular to an AI graphical programming platform and method based on unsupervised learning. Background Art

[0002] In recent years, with the rapid development of artificial intelligence and machine learning technologies, unsupervised learning has played an increasingly important role in fields such as data analysis, pattern recognition, and data mining. Unsupervised learning is a machine learning method that does not rely on labeled data sets, but instead uses the characteristics of the data itself to perform operations such as classification, clustering, and dimensionality reduction. Existing unsupervised learning platforms usually require users to have a high level of programming and mathematics background, making it difficult for beginners to get started. Many platforms lack intuitive graphical interactive interfaces, making it difficult for users to understand the inner workings and results of the algorithm. In addition, existing platforms are usually not flexible enough in supporting new algorithms and new modules, making it difficult for users to customize and expand them according to actual needs.

[0003] To address the above-mentioned problems, no effective solution has been proposed yet. Summary of the invention

[0004] The embodiments of the present invention provide an AI graphical programming platform and method based on unsupervised learning, so as to at least solve the technical problem that the unsupervised learning platform has a poor user experience for beginners.

[0005] According to one aspect of an embodiment of the present invention, there is provided an AI graphical programming method using unsupervised learning, comprising: selecting and configuring an AI model based on unsupervised learning using programming instruction blocks; performing graphical programming using programming instruction blocks to obtain a graphical code of a target program, wherein the graphical code includes a programming instruction block for indicating a characteristic parameter and a programming instruction block for calling the AI ​​model, the characteristic parameter being used to indicate training data of the AI ​​model; when running the target program, acquiring the training data in real time based on the characteristic parameter, and optimizing the AI ​​model based on the training data using an unsupervised learning method to implement the target program.

[0006] According to another aspect of an embodiment of the present invention, a graphical programming platform using unsupervised learning is also provided, including: a model initialization module, configured to select and configure an AI model based on unsupervised learning using programming instruction blocks; a target program encoding module, configured to perform graphical programming using programming instruction blocks to obtain a graphical code of a target program, wherein the graphical code includes a programming instruction block for indicating a characteristic parameter and a programming instruction block for calling the AI ​​model, and the characteristic parameter is used to indicate training data of the AI ​​model; an optimization module, configured to obtain the training data in real time based on the characteristic parameter when running the target program, and optimize the AI ​​model based on the training data using an unsupervised learning method to implement the target program.

[0007] In an embodiment of the present invention, an AI model based on unsupervised learning is selected and configured using programming instruction blocks; graphical programming is performed using programming instruction blocks to obtain a graphical code of a target program, wherein the graphical code includes programming instruction blocks for indicating characteristic parameters and programming instruction blocks for calling the AI ​​model, and the characteristic parameters are used to indicate the training data of the AI ​​model; when running the target program, the training data is acquired in real time based on the characteristic parameters, and the AI ​​model is optimized using an unsupervised learning method based on the training data to implement the target program. Through the above scheme, the technical problem of poor user experience of unsupervised learning platforms for beginners is solved. BRIEF DESCRIPTION OF THE DRAWINGS

[0008] The drawings described herein are used to provide a further understanding of the present invention and constitute a part of this application. The exemplary embodiments of the present invention and their descriptions are used to explain the present invention and do not constitute an improper limitation of the present invention. In the drawings:

[0009] Figure 1 is a flowchart of an AI graphical programming method using unsupervised learning according to an embodiment of the present invention;

[0010] Figure 2 is a comprehensive flow chart of a web browser-based graphical programming platform according to an embodiment of the present invention;

[0011] Figure 3 is a flow chart of an unsupervised learning algorithm according to an embodiment of the present invention;

[0012] Figure 4 is a flow chart of a PCA algorithm according to an embodiment of the present invention;

[0013] Figure 5 is a flowchart of an AI graphical programming method using unsupervised learning, taking a flying bird as an example according to an embodiment of the present invention;

[0014] Figure 6 is an interface diagram of an initialization model according to an embodiment of the present invention;

[0015] Figure 7 is an interface diagram for setting role variables according to an embodiment of the present invention;

[0016] Figure 8 is an interface diagram of variables involved in modifying a script building block according to an embodiment of the present invention;

[0017] Fig. 9 is an interface diagram of modifying a trigger event building block according to an embodiment of the present invention;

[0018] Fig.10 is an interface diagram for determining input and output information according to an embodiment of the present invention;

[0019] Fig.11 This is an interface diagram that encapsulates an event (flight) triggered by a mouse click in the game itself with a function according to an embodiment of the present invention;

[0020] Fig.12 is an interface diagram for selecting an AI character usage behavior according to an embodiment of the present invention;

[0021] Fig.13 is an interface diagram for determining a character's death condition according to an embodiment of the present invention;

[0022] Fig.14 This is an interface diagram for setting a real-time read AI character feature value according to an embodiment of the present invention;

[0023] Fig.15 is an interface diagram of GameAI decision making according to an embodiment of the present invention;

[0024] Fig.16 is an interface diagram of a genetic algorithm according to an embodiment of the present invention;

[0025] Fig.17 This is an interface diagram of restarting GameAI according to an embodiment of the present invention;

[0026] Fig.18 is an interface diagram for retaining previous training results according to an embodiment of the present invention;

[0027] Fig.19 is an interface diagram of a graphical code for starting GameAI according to an embodiment of the present invention;

[0028] Fig. 20 It is an architecture diagram of a graphical programming platform using unsupervised learning according to an embodiment of the present invention. DETAILED DESCRIPTION

[0029] In order to enable those skilled in the art to better understand the scheme of the present invention, the technical scheme in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only 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 should fall within the scope of protection of the present invention.

[0030] It should be noted that the terms "first", "second", etc. in the specification and claims of the present invention and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchanged where appropriate, so that the embodiments of the present invention described herein can be implemented in an order other than those illustrated or described herein. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device that includes a series of steps or units is not necessarily limited to those steps or units that are clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0031] According to an embodiment of the present invention, a method embodiment of an AI graphical programming method using unsupervised learning is provided. It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a set of computer executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described may be executed in an order different from that shown here.

[0032] Figure 1 is an AI graphical programming method using unsupervised learning according to an embodiment of the present invention, such as Figure 1 As shown, the method comprises the following steps:

[0033] Step S102, using programming instruction blocks to select and configure an AI model based on unsupervised learning.

[0034] For example, the AI ​​model is initialized by dragging a programming instruction block for initializing the model to the code area of ​​the graphical programming platform; and parameters are set for the AI ​​model, where the set parameters include an optimization algorithm for the AI ​​model. The set parameters also include at least one of the following: an input layer of the AI ​​model, an output layer of the AI ​​model, a hidden layer of the AI ​​model, and the number of runs per round of the AI ​​model.

[0035] Step S104, using programming instruction blocks to perform graphical programming to obtain a graphical code of the target program, wherein the graphical code includes programming instruction blocks for indicating characteristic parameters and programming instruction blocks for calling the AI ​​model, and the characteristic parameters are used to indicate training data of the AI ​​model.

[0036] Step S106, when running the target program, the training data is acquired in real time based on the characteristic parameters, and an unsupervised learning method is used to optimize the AI ​​model based on the training data to implement the target program.

[0037] First, obtain training data in real time.

[0038] Next, the training data is preprocessed. Multiple data points are randomly selected from the training data as multiple centroids; the following is repeated until the position of the centroid no longer changes: each data point is processed, the Euclidean distance from each data point to each centroid in the multiple centroids is calculated, and each data point is assigned to the cluster to which the corresponding centroid belongs based on the Euclidean distance, and then, after the data point assignment is completed, the corresponding centroid is updated based on the average value of the coordinates of each data point. After that, each data point is centralized and the covariance matrix of the centralized data is calculated; the covariance matrix is ​​eigenvalue decomposed to obtain eigenvalues ​​and eigenvectors; the first k eigenvectors are selected as principal components according to the size of the eigenvalues, and each data point is transformed with the selected principal components to obtain new data after dimensionality reduction as preprocessed training data.

[0039] Afterwards, the AI ​​model is optimized using an unsupervised learning method based on the training data.

[0040] Finally, the running effect of the target program is visually displayed in the stage area of ​​the graphical programming platform.

[0041] This application lowers the threshold of use through a graphical interface, allowing beginners to get started quickly. In addition, this application provides a real-time visualization function to help users intuitively understand the algorithm process and results. At the same time, the component library is flexibly designed to support users to customize and expand according to actual needs. Finally, this application is based on a web browser and does not require the installation of a complex software environment, so users can use it anytime, anywhere. In summary, the present invention has significant advantages in simplifying the use process of unsupervised learning algorithms, improving user interaction experience, and enhancing scalability.

[0042] The present invention provides a web browser-based graphical programming platform for unsupervised learning. The platform enables users to intuitively build and run unsupervised learning algorithms in a browser through drag-and-drop components and modular design.

[0043] The web browser-based graphical programming platform mainly includes the following parts: user interface layer, which is used to provide a graphical programming interface, and users build algorithm processes by dragging and dropping components; algorithm engine layer, which is used to provide implementations of various unsupervised learning algorithms, such as K-means, PCA, hierarchical clustering, etc.; data processing layer, which is responsible for data preprocessing, feature extraction and result visualization; background service layer, which is used to process user requests and store user data and models.

[0044] The user interface layer includes a component library and a process editor. The component library contains various algorithm components, data processing components, and visualization components. The process editor is used to drag and drop components and connect them into a complete algorithm process.

[0045] The algorithm engine module is the core of the entire system and is responsible for executing various unsupervised learning algorithms. This module supports multiple algorithms and allows users to configure and run these algorithms through a graphical interface, such as K-means clustering and principal component analysis (PCA) algorithms.

[0046] In order to fully demonstrate the workflow of the entire algorithm engine module in the system, the above specific algorithms can be embedded into a comprehensive process, such as Figure 2 As shown, the comprehensive process of the web browser-based graphical programming platform includes the following steps:

[0047] Step S202: The user selects and configures an unsupervised learning algorithm.

[0048] The user selects the algorithm and configures the parameters.

[0049] Step S204, the algorithm engine is initialized.

[0050] Initialize the algorithm engine and load data.

[0051] Step S206, executing a specified unsupervised learning algorithm.

[0052] In the K-means algorithm, Figure 3 As shown, the following steps are included:

[0053] Step S2062, initialize the centroid.

[0054] Randomly select k points from the data set as the initial centroids C = {c1, c2, ..., ck}.

[0055] Step S2064, assigning data points.

[0056] For each data point, calculate its Euclidean distance to all centroids. Assign the data point to the nearest centroid. Perform data assignment: P(i)->cj, where i represents the data point and j represents the centroid number.

[0057] Step S2066, update the centroid.

[0058] For each centroid, calculate the average of all its assigned data points and update the centroid position. New centroid: cj = mean(P(i)), P(i) belongs to cj.

[0059] Repeat steps S2064 and S2066 until the centroid position no longer changes or the maximum number of iterations is reached. The termination condition is that the maximum number of iterations max_iterations is reached or the distance between the two centroid positions is less than the threshold, that is, ||C_new-C_old|| <threshold。

[0060] Finally, output the results. Output the cluster assignment results and final centroid position of each data point.

[0061] Step S208: data preprocessing and dimensionality reduction.

[0062] Execute the PCA algorithm, such as Figure 4 As shown, the following steps are included:

[0063] Step S2082, data centering.

[0064] Subtract the mean of each feature to center the data, Xcentered=X-mean(X).

[0065] Step S2084, calculate the covariance matrix.

[0066] Calculate the covariance matrix of the centralized data. The specific covariance matrix formula is:

[0067] Where n represents the number of Xcentered samples.

[0068] Step S2086, eigenvalue decomposition.

[0069] Perform eigenvalue decomposition on the covariance matrix to obtain eigenvalues ​​and eigenvectors. The formula for eigenvalue decomposition is: eigenvectors = eig (Cov (Xcentered)).

[0070] Step S2088, select the principal component.

[0071] Select the first k eigenvectors as principal components according to the eigenvalue. PrincipalComponents = eigenvectors[:,:k], which means selecting the first k columns from the eigenvector matrix (these columns are eigenvectors sorted by eigenvalue). If there is nothing before the colon, it means selecting all rows; if there is :k after the colon, it means selecting the first k columns.

[0072] Step S2089, convert data.

[0073] Use the selected principal component to transform the original data to obtain the new data X after dimensionality reduction new =X centered ·PrincipalComponents, where PrincipalComponents represents the principal components. Finally, the reduced-dimensional data and the corresponding principal components are output.

[0074] Step S210: result processing and visualization.

[0075] Run the above algorithm to obtain the processing results and visualize them.

[0076] This embodiment covers the entire process from user selection and configuration of algorithms to algorithm execution, and finally to result processing and visualization. This modular, visual, and user-friendly design not only lowers the threshold for use, but also improves the application flexibility and efficiency of unsupervised learning algorithms.

[0077] The web browser-based graphical programming interface provided by this application allows users to build unsupervised learning algorithms without programming. In addition, flexible data preprocessing and feature extraction functions are provided. In addition, real-time visualization of results can be achieved to help users better understand the algorithm effects.

[0078] The embodiment of the present application also provides an AI graphical programming method using unsupervised learning, taking GameAI as an example. GameAI is game artificial intelligence, which refers to the technology and algorithms used to simulate intelligent behavior in electronic games. GameAI aims to provide realistic behavior for non-player characters in the game, so that they can show reaction and decision-making capabilities similar to those of human players. The application of game AI is not limited to controlling the behavior of characters, but can also affect the game environment, plot generation, path planning, strategy decision-making and other aspects.

[0079] The unsupervised learning mode is to let AI learn to play the game by itself, using a genetic algorithm. In the unsupervised mode of GameAI, the initial model is randomly generated, not trained. By generating a large number of random models, the AI ​​characters are allowed to try continuously in the game. Some of these models will be eliminated quickly, while others can get high scores. Then, through the genetic algorithm, the model structures with high scores are retained, and they are allowed to evolve with each other like organisms, and finally a model that can get higher scores, perform better, and become stronger from generation to generation is trained.

[0080] The present application embodiment uses the game FlappyBird to illustrate the unsupervised learning model. Figure 5 As shown, the method comprises the following steps:

[0081] Step S502, initializing the model.

[0082] Unsupervised is the same as supervised. Select the bird as the AI ​​character, such as Figure 6 As shown, a model is initialized: Model 1 is the AI ​​model. First, the hidden layer structure is set to a single layer of 4 neurons. For unsupervised learning, if only one role is run at a time, the efficiency is relatively low. Therefore, it is necessary to set the number of multiple roles. Here, the number of runs per round is set to 100.

[0083] Step S504, setting role variables and event initiation.

[0084] In order to make these 100 birds run independently, some game settings need to be changed: role variables and event start blocks.

[0085] 1) Set the role variable.

[0086] For the bird flying game, you need to modify the bird's global variable Y speed to a character variable, such as Figure 7 After that, modify the variables involved in the script blocks, such as Figure 8 shown.

[0087] 2) Modify the trigger event block

[0088] Because it takes a certain amount of time to clone 100 birds, in order to prevent some cloned birds from moving before other birds, it is necessary to change the trigger event at the start of the game to "When GameAI starts" so that all birds move synchronously, such as Fig. 9 shown.

[0089] Step S506, determining input and output information.

[0090] First, determine the information of the input layer. Select two features: 1. The Y coordinate value of the bird, 2. The Y coordinate value under the pillar. Fig.10 shown.

[0091] After that, determine the information of the output layer. When playing this game, there will be two operation results: do nothing, and click the mouse. Then corresponding to GameAI, there will be two output results: 1. Do nothing, 2. Make the bird fly. You need to first encapsulate the event (flight) triggered by the mouse click in the game itself with a function, such as Fig.11 As shown, you can then select the AI ​​character to use: No Operation and Flying, as shown Fig.12 shown.

[0092] Next, determine the character's death condition. Set the AI ​​character's death condition, such as Fig.13Then set the AI ​​character feature value to be read in real time. Unlike the classifier, the input feature value in GameAI changes in real time, such as Fig.14 shown.

[0093] Finally, complete the number of input and output. After confirming the input and output information, you need to fill in the number of input and output layers at the location of the initialization model to complete the setting of the entire model.

[0094] Step S508, GameAI decision.

[0095] Let the AI ​​decide whether to operate or fly. Fig.15 When the AI ​​character makes a decision, the Y coordinate value of the bird and the Y coordinate value under the pillar are obtained in real time according to the above configured feature parameters, i.e., the Y coordinate value of the bird and the Y coordinate value under the pillar, and are input into the AI ​​model as training data to train the AI ​​model. The AI ​​model outputs the result "no operation" or "make the bird fly".

[0096] Before the training data is input into the AI ​​model, k-mean and PCA processing as described above can also be performed.

[0097] Step S510: genetic algorithm.

[0098] When an AI character dies, record the score of the AI ​​character. When all AI characters die, you can find the better model in this batch, such as Fig.16 shown.

[0099] In some embodiments, the score of the AI ​​role can be obtained through a fitness function: determine the weight of the performance indicator based on the environmental state; obtain the weighted sum of the AI ​​strategy on different performance indicators based on the weight of the performance indicator and the performance indicator; determine the contribution of diversity to fitness based on the diversity score and diversity weight coefficient of the AI ​​strategy; determine the contribution of robustness to fitness based on the robustness score and robustness weight coefficient of the AI ​​strategy; finally, determine the score of the fitness function based on the weighted sum of the AI ​​strategy on different performance indicators, the contribution of diversity to fitness, and the contribution of robustness to fitness.

[0100] Specifically, the fitness function can be expressed as:

[0101]

[0102] Where D(AI) represents the diversity score of the AI ​​strategy, and γ is the diversity weight coefficient, which adjusts the influence of diversity in the fitness function. AI represents a specific AI strategy. The AI ​​strategy can be an algorithm model, such as a genetic algorithm model. E represents the environment state, which is used to describe the external environment conditions in which the AI ​​strategy is located, including dynamically changing factors such as data distribution, network conditions, input and output requirements, etc. The introduction of the environment state can help the fitness function dynamically adjust its evaluation criteria according to changes in the external environment. Mi(AI) represents the i-th performance indicator, which is usually used to evaluate the performance of the AI ​​strategy. These indicators can be accuracy, recall, and F1 score. wi(E) represents the weight of the i-th performance indicator, and the weight depends on the environment state E. By dynamically adjusting the weight wi(E), the fitness function can give different performance indicators different priorities according to different states of the environment. For example, in some environments, more attention is paid to accuracy rather than recall. In this case, the weight of accuracy will be higher. D(AI) represents the diversity score of the AI ​​strategy. The diversity score measures the degree of difference between individuals in the population, encouraging the optimization process to generate more diverse AI strategies and avoiding the population from falling into a local optimal solution. For example, D(AI) can be quantified by calculating the distribution difference of AI strategies in parameter space or feature space. R(AI) represents the robustness score of the strategy. Robustness measures the stability and consistency of AI strategies under different test conditions or environmental changes. For example, if an AI strategy can still maintain high performance in the face of changes in data distribution or noise interference, it means that the strategy has good robustness. δ is the robustness weight coefficient, which controls the influence of the robustness score R(AI) on the fitness function. A higher δ value indicates that more emphasis is placed on the robustness of the strategy, ensuring that the AI ​​strategy performs stably in a changing environment.

[0103] When all AI characters die, use the "genetic algorithm" to optimize the model and restart GameAI for the next prediction, such as Fig.17 After training, if you want to keep the previous training results, you need to remove the initialization model block so that the program can continue to optimize the model based on the previous model 1. Fig.18 shown.

[0104] Step S512, using the model.

[0105] After the model training is completed, you can use the model to let the AI ​​character play the game automatically. Use the model and start GameAI, such as Fig.19 shown.

[0106] The web browser-based graphical programming platform of this application allows users to use unsupervised learning algorithms more intuitively and conveniently, thereby lowering the technical threshold and is widely used in many fields such as education, scientific research and business.

[0107] The present application also provides a graphical programming platform using unsupervised learning, such as Fig. 20 As shown, it includes: a model initialization module 22, which is configured to select and configure an AI model based on unsupervised learning using programming instruction blocks; a target program encoding module 24, which is configured to perform graphical programming using programming instruction blocks to obtain a graphical code of the target program, wherein the graphical code includes a programming instruction block for indicating a characteristic parameter and a programming instruction block for calling the AI ​​model, and the characteristic parameter is used to indicate the training data of the AI ​​model; an optimization module 26, which is configured to obtain the training data in real time based on the characteristic parameter when running the target program, and optimize the AI ​​model based on the training data using an unsupervised learning method to achieve the target program

[0108] It should be noted that the graphical programming platform using unsupervised learning provided in the above embodiment is only illustrated by the division of the above functional modules. In actual applications, the above functions can be assigned to different functional modules as needed, that is, the internal structure of the device is divided into different functional modules to complete all or part of the functions described above. In addition, the graphical programming platform using unsupervised learning provided in the above embodiment and the embodiment of the AI ​​graphical programming method using unsupervised learning belong to the same concept. The specific implementation process is detailed in the method embodiment and will not be repeated here.

[0109] The above is only a preferred implementation of the present application. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the present application. These improvements and modifications should also be regarded as the scope of protection of the present application.

Claims

1. An AI graphical programming method using unsupervised learning, characterized in that: include: Use programming instruction blocks to select and configure AI models based on unsupervised learning; Performing graphical programming using programming instruction blocks to obtain a graphical code of a target program, wherein the graphical code includes programming instruction blocks for indicating characteristic parameters and programming instruction blocks for calling the AI ​​model, wherein the characteristic parameters are used to indicate training data of the AI ​​model; When the target program is running, the training data is acquired in real time based on the characteristic parameters, and an unsupervised learning method is used to optimize the AI ​​model based on the training data to implement the target program.

2. The method according to claim 1, characterized in that: Use programming instruction blocks to select and configure unsupervised learning-based AI models, including: Initializing the AI ​​model by dragging a programming instruction block for initializing the model to a code area of ​​the graphical programming platform; Parameters are set for the AI ​​model, and the set parameters include an optimization algorithm for the AI ​​model.

3. The method according to claim 1, characterized in that The set parameters also include at least one of the following: the input layer of the AI ​​model, the output layer of the AI ​​model, the hidden layer of the AI ​​model, and the number of runs per round of the AI ​​model.

4. The method according to claim 1, characterized in that: Before optimizing the AI ​​model using an unsupervised learning method based on the training data, the method further includes preprocessing the training data, wherein the preprocessing includes: Randomly selecting a plurality of data points from the training data as a plurality of centroids; Repeat the following until the position of the centroid no longer changes: process each data point, calculate the Euclidean distance from each data point to each of the multiple centroids, and assign each data point to the cluster to which the corresponding centroid belongs based on the Euclidean distance. Then, after the data point assignment is completed, update the corresponding centroid based on the average value of the coordinates of each data point.

5. The method according to claim 4, characterized in that After the position of the center of mass no longer changes, the method further includes: Centralize each of the data points and calculate the covariance matrix of the centralized data; Performing eigenvalue decomposition on the covariance matrix to obtain eigenvalues ​​and eigenvectors; The first k eigenvectors are selected as principal components according to the size of the eigenvalues, and each data point is transformed by the selected principal components to obtain new data after dimensionality reduction as preprocessed training data.

6. The method according to any one of claims 1 to 5, characterized in that The running effect of the target program is visually displayed in the stage area of ​​the graphical programming platform.

7. An AI graphical programming platform using unsupervised learning, characterized in that: include: A model initialization module, configured to select and configure an unsupervised learning-based AI model using programming instruction blocks; a target program coding module, configured to perform graphical programming using programming instruction blocks to obtain a graphical code of the target program, wherein the graphical code includes programming instruction blocks for indicating characteristic parameters and programming instruction blocks for calling the AI ​​model, wherein the characteristic parameters are used to indicate training data of the AI ​​model; The optimization module is configured to obtain the training data in real time based on the characteristic parameters when running the target program, and optimize the AI ​​model using an unsupervised learning method based on the training data to implement the target program.

8. A computer-readable storage medium, characterized in that: The computer-readable storage medium includes a stored program, wherein when the program is executed, the device where the computer-readable storage medium is located is controlled to execute the method according to any one of claims 1 to 6.

9. A computer device, characterized in that: include: Memory and processor, The memory stores a computer program; The processor is used to execute the computer program stored in the memory, and when the computer program is run, the processor is enabled to execute the method according to any one of claims 1 to 6.

10. A computer program product, comprising a computer program, characterized in that When the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 6 are implemented.

Images