Method, apparatus, medium, device and product for generating a visualization component

Abstract

A method, device, medium, equipment and product for generating a visualization component, relating to the technical field of artificial intelligence, the method comprising: receiving a first request, the first request being used to indicate generation of a visualization component or being used to indicate editing of a visualization component; identifying the first request to obtain an identification result, the identification result being from a first intelligent system; if the identification result includes a first identifier, sending the identification result to a second intelligent system, the second intelligent system and the first identifier having an association relationship; and generating a first visualization component, the first visualization component being from the second intelligent system. Through identification of the first identifier, information related to the first request is accurately routed to the second intelligent system, thereby effectively improving the accuracy of generation of the visualization component.

Description

Technical Field

[0001] This article relates to the field of artificial intelligence technology, specifically to a method, apparatus, medium, device, and product for generating visualization components. Background Technology

[0002] With the development of data visualization technology, the automatic generation of visualization components has gradually become an important research direction in the field of data analysis. However, currently, the generation of visualization components usually requires manual completion by users. For non-professional users, this is not only inefficient, but the generated visualization components often do not meet their needs. Therefore, how to automatically generate visualization components that meet user requirements is a technical problem that urgently needs to be solved. Summary of the Invention

[0003] This content section is provided to briefly introduce the ideas, which will be described in detail in the examples section later. This content section is not intended to identify key or essential features of the claimed content, nor is it intended to limit the scope of the claimed content.

[0004] Firstly, a method for generating visual components is provided, including: Receive a first request, the first request being used to instruct the generation of a visualization component or to instruct the editing of a visualization component; The first request is identified, and an identification result is obtained, wherein the identification result comes from the first intelligent system; If the identification result includes a first identifier, the identification result is sent to the second intelligent system, and there is an association relationship between the second intelligent system and the first identifier; A first visualization component is generated, which originates from the second intelligent system.

[0005] Secondly, a device for generating visualization components is provided, comprising: A receiving module is configured to receive a first request, wherein the first request is used to instruct the generation of a visualization component or to instruct the editing of a visualization component; The identification module is used to identify the first request and obtain an identification result, wherein the identification result comes from the first intelligent system; The acquisition module is used to send the identification result to the second intelligent system if the identification result includes a first identifier, wherein there is an association between the second intelligent system and the first identifier; A generation module is used to generate a first visualization component, which comes from the second intelligent system.

[0006] Thirdly, a computer-readable medium is provided having a computer program stored thereon, which, when executed by a processing device, implements the steps of the method described in the first aspect.

[0007] Fourthly, an electronic device is provided, comprising: A storage device on which computer programs are stored; A processing device for executing the computer program in the storage device to implement the steps of the method described in the first aspect.

[0008] Fifthly, a computer program product is provided, comprising a computer program that, when executed by a processor, implements the steps of the method described in the first aspect.

[0009] Through the above technical solution, upon receiving a first request, the first intelligent system identifies the first request, which is used to instruct the generation of a visualization component or the editing of a visualization component. Subsequently, if the first intelligent system determines that the first request includes a first identifier, the first request is routed to the corresponding second intelligent system so that the visualization component can be generated or modified by the second intelligent system to obtain the first visualization component. In this way, different types of requests can be distributed hierarchically to specialized intelligent systems for processing, thereby reducing the generation failure problem caused by a single intelligent system carrying all knowledge and improving the accuracy of visualization component generation to a certain extent.

[0010] Other features and advantages will be described in detail in the following examples section. Attached Figure Description

[0011] The above and other features, advantages, and aspects of this document will become more apparent when taken in conjunction with the accompanying drawings and the following examples. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic, and elements are not necessarily drawn to scale. In the drawings: Figure 1 This is a schematic diagram illustrating an implementation environment according to an exemplary embodiment.

[0012] Figure 2 This is a flowchart illustrating a method for generating a visual component according to an exemplary embodiment.

[0013] Figure 3 This is an overall framework diagram of a method for generating a first visual component, as illustrated in an exemplary embodiment.

[0014] Figure 4 This is an example diagram illustrating the interaction of various intelligent systems when generating a first visual component in a method for generating a visual component according to an exemplary embodiment.

[0015] Figure 5 This is an example diagram illustrating a method for generating a visualization component according to an exemplary embodiment, showing the initiation of a new session.

[0016] Figure 6 This is an example diagram illustrating the initiation of an existing session in a method for generating a visualization component according to an exemplary embodiment.

[0017] Figure 7 This is an example diagram showing a text clarification card in a method for generating a visualization component according to an exemplary embodiment.

[0018] Figure 8 This is an example diagram illustrating a method for generating a visualization component according to an exemplary embodiment, in which a structured clarification card corresponding to a scene is created.

[0019] Figure 9 This is an example diagram illustrating a method for generating a visualization component according to an exemplary embodiment, in which a structured clarification card corresponding to a scene is edited.

[0020] Figure 10 This is an example diagram illustrating the association between a first processing stage and a second processing stage in a second intelligent system of a method for generating a visualization component according to an exemplary embodiment.

[0021] Figure 11 This is an internal flowchart illustrating the skill reading process in a method for generating a visualization component according to an exemplary embodiment.

[0022] Figure 12 This is an example diagram illustrating the dependencies of a first registry module in a method for generating a visual component according to an exemplary embodiment.

[0023] Figure 13 This is a sequence diagram illustrating the registration interaction in a method for generating a visual component according to an exemplary embodiment.

[0024] Figure 14 This is an example diagram illustrating a method for generating a visualization component according to an exemplary embodiment, showing the addition of a new visualization component.

[0025] Figure 15 This is an example diagram illustrating verification and repair in a method for generating a visual component according to an exemplary embodiment.

[0026] Figure 16 This is an example diagram illustrating the structure of a dimension manager in a method for generating a visualization component according to an exemplary embodiment.

[0027] Figure 17This is an example diagram of a data update chain in a method for generating a visualization component according to an exemplary embodiment.

[0028] Figure 18 This is an example diagram of a dashboard display in a method for generating a visualization component according to an exemplary embodiment.

[0029] Figure 19 This is an example diagram of an interface for editing a visual component in a method for generating a visual component according to an exemplary embodiment.

[0030] Figure 20 This is a block diagram illustrating a visualization component generation apparatus according to an exemplary embodiment.

[0031] Figure 21 This is a schematic diagram of the structure of an electronic device according to an exemplary embodiment. Detailed Implementation

[0032] The following description will be given in more detail with reference to the accompanying drawings. While certain scenarios are shown in the drawings, it should be understood that this document can be implemented in various forms and should not be construed as limited to the scenarios described herein. Rather, these scenarios are provided to provide a more thorough and complete understanding of this document. It should be understood that the accompanying drawings and the scenarios depicted are for illustrative purposes only and are not intended to limit the scope of this document.

[0033] It should be understood that the steps described in the method may be performed in different orders and / or in parallel. Furthermore, the method may include additional steps and / or omit the steps shown. The scope of this document is not limited in this respect.

[0034] The term "comprising" and its variations can be open-ended, meaning "including but not limited to". The term "based on" can mean "at least partially based on". The term "one case" means "at least one case"; the term "another case" means "at least one additional case"; the term "some cases" means "at least some cases". Definitions of other terms will be given in the following description.

[0035] It should be noted that the concepts of "first" and "second" are only used to distinguish different devices, modules or units, and are not used to limit the order of the functions performed by these devices, modules or units or their interdependencies.

[0036] It should be noted that the modifiers “one” and “multiple” can be illustrative rather than restrictive, and those skilled in the art should understand that, unless otherwise expressly indicated in the context, they should be understood as “one or more”.

[0037] The names of messages or information exchanged between multiple devices are for illustrative purposes only and are not intended to limit the scope of these messages or information.

[0038] It is understandable that the data involved in the technical solution (including but not limited to the data itself, the acquisition or use of the data) should comply with the requirements of relevant regulations.

[0039] In related technologies, visualization components can be charts. Their generation is usually completed by a single intelligent system in one go, including intent understanding, component type selection, field mapping, and rendering configuration. When supporting multiple component types, there is a context bloat problem, and the reasoning process is coupled with the execution process. When there is insufficient information, the intelligent system usually guesses the configuration directly, resulting in a high failure rate of visualization component generation. At the same time, the generated results are difficult to integrate into the dashboard ecosystem.

[0040] In one context, an intelligent system is an information processing system. This intelligent system uses at least one or more models to process one or more inputs. The intelligent system may include the one or more models as components, or it may use models external to the system for processing. Those skilled in the art will recognize that there are various implementations of intelligent systems in the industry, including but not limited to agents, AI assistants, AI workers, copilot systems, and chatbots. The inputs include data in one or more modalities. The modal data includes, but is not limited to, text, audio, images, video, application-specific data, or scientific computing data. The models include, but are not limited to, one or more combinations of the following: large-scale parametric models, deep learning models, neural network models, machine learning models, statistical models, rule-based models, or other models capable of processing the inputs. The specific implementation of the models can employ various existing or improved models. The intelligent system may involve one or more of the following operations: receiving single-round or multi-round input; recognizing and / or understanding the input; generating answers, decisions, or processing results using one or more models; invoking one or more external tools, interfaces, knowledge bases, or other systems to obtain information or perform operations; processing in a self-decision-making or human-machine collaborative manner, or transferring tasks to human or other systems for processing. Self-decision-making refers to execution without human intervention. Human-machine collaboration refers to partial human participation or confirmation. The above explanation of "intelligent system" is illustrative, and each description is an example, not necessarily necessary, and does not constitute an exhaustive list.

[0041] Furthermore, the relevant technologies primarily rely on a single agent (intelligent system) combined with a ReAct (Reason Act) loop to comprehensively generate visualization components. This allows the construction of a single intelligent system encompassing multiple tools such as data retrieval, field inference, visualization component generation, and visualization component editing. ReAct can then process requests related to any visualization component in a loop. However, this approach suffers from several drawbacks, including a hybrid approach of reasoning and execution, limited knowledge capacity, a high failure rate in one-time generation, and a disconnect between the generated results and the dashboard ecosystem.

[0042] To address the aforementioned issues, this paper proposes a method, apparatus, medium, device, and product for generating visualization components. Upon receiving a first request, if a first intelligent system determines that the first request includes a first identifier, it can route the first request to a second intelligent system. The first identifier indicates that the first request is related to a visualization component. Subsequently, the second intelligent system can accurately and efficiently generate the visualization component. This ensures that sessions entering from the visualization component generation or editing entry point are not misassigned to other domains due to semantic similarity. This can, to some extent, eliminate intent drift caused by guessing at a single intent recognition layer, thereby generating visualization components that better meet user needs.

[0043] Figure 1 This is a schematic diagram illustrating an application scenario of a method for generating a visual component according to an exemplary embodiment. For example... Figure 1 As shown, the application scenario can include terminal 101 and server 102. Terminal 101 and server 102 are connected in communication.

[0044] Terminal 101 can be at least one of the following devices: smartphone, smartwatch, desktop computer, laptop, virtual reality terminal, augmented reality terminal, wireless terminal, and laptop computer. Terminal 101 has communication capabilities and can access wired or wireless networks. Terminal 101 can refer to one of multiple terminals; those skilled in the art will understand that the number of such terminals can be more or less.

[0045] Server 102 can be a single physical server, a server cluster consisting of multiple physical servers, or a distributed file system. It can also be a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN (Content Delivery Network), and artificial intelligence platforms.

[0046] For example, server 102 and terminal 101 can be connected directly or indirectly through wired or wireless communication, without limitation.

[0047] The terminal 101 can receive visualization component generation or editing request information and send this information to the server 102. When the server 102 receives the request information, it can generate the corresponding visualization component based on the request information. Subsequently, it can send the generated visualization component to the terminal 101 and instruct the terminal 101 to output the visualization component.

[0048] Figure 2 This is a flowchart illustrating a method for generating a visual component according to an exemplary embodiment, such as... Figure 2 As shown, the method may include the following steps.

[0049] In step S210, the first request is received.

[0050] In some implementations, the first request can be used to instruct the generation of a visualization component or to instruct the editing of an existing visualization component. Here, the first request can be entered through a first input field, which can be, for example... Figure 3 The user entry point 300 shown may include a dialog panel, a chart component (visual component) card entry point, a dashboard editor, etc. In other words, users can input natural language requests through the dialog panel, component card entry point (visual component card entry point), or dashboard editor. This natural language request can serve as the first request, based on which new visual components can be generated, or existing visual components can be edited and modified.

[0051] For example, users can create new visual components or conduct general dialogues through the dialog panel entry; users can edit specific visual components through the visual component card entry, which can automatically carry the entity identifier of the target visual component and a snapshot of the current visual component's state; and users can arrange the dashboard as a whole through the dashboard editor entry.

[0052] For example, when a user is detected entering a request like "Help me check sales trends" through the dialog panel, it is determined that the first request is used to instruct the generation of a new visualization component. Similarly, when a user is detected clicking the "AI Edit" button next to an existing visualization component and selecting "Add Year-on-Year Curve," it is determined that the first request is used to instruct the modification of the existing visualization component.

[0053] In some implementations, the first request may carry a session identifier, request type, context information, and a first identifier, etc. The context information may include the current dashboard identifier, the current dataset identifier, the current visualization component identifier, etc., and this context information can be used to assist in subsequent intent recognition and visualization component generation.

[0054] It should be noted that the visualization components in this article include at least one of the following: chart components, structured data components, metric display components, relational structure components, process sequence components, and container components. Here, the visualization components are merely examples; this article does not limit the specific types of visualization components. Subsequent embodiments will use charts as an example to illustrate the specific process of generating visualization components.

[0055] In step S220, the first request is identified, and the identification result is obtained.

[0056] As an alternative approach, upon receiving a first request, the first intelligent system can identify the request to obtain an identification result. Here, identification can be intent identification; by using the first intelligent system to identify the first request, it can be determined whether the first request carries a first identifier. If it is determined that the first request includes the first identifier, then the second intelligent system can be accessed.

[0057] In some implementations, the first intelligent system can be a decision agent, and the second intelligent system can be a visualization component intelligent system, which can be a chart agent or a domain agent. The first intelligent system identifies the request intent and routes it to the appropriate second intelligent system. The second intelligent system can be used to generate new individual visualization component entities or to incrementally edit existing visualization components; it can be the actual executor of clarifying and defining data retrieval or generating rendering specifications.

[0058] This article can be applied to, for example Figure 3The visualization component generation architecture shown may include an intent distribution layer 301, a hierarchical intelligent system 302, a first registry 303, a visualization component generation and verification module 304, and a clarification interaction module 305. The intent distribution layer 301 can be a multi-entry intent distribution layer, capable of receiving natural language requests from multiple entry points such as dialog panels, component card entry points, and dashboard editors, and sending them to the hierarchical intelligent system 302. The hierarchical intelligent system 302 may include a first intelligent system, a second intelligent system, and a third intelligent system. The first intelligent system is a decision-making intelligent system, the second intelligent system is a chart intelligent system, and the third intelligent system is a dashboard intelligent system. The third intelligent system can be a domain intelligent system parallel to the second intelligent system, capable of multi-chart arrangement at the dashboard level, and can serve as an extension direction of the hierarchical architecture.

[0059] Here, the hierarchical intelligent system 302 can be used to route user intents layer by layer. For example, the first, second, and third intelligent systems can exchange information through structured semantic parameters, which may include information such as the target chart type (visual component type), field roles (dimensions / measures), aggregation and filtering or sorting intents, etc.

[0060] The first registry 303 can be used to manage the skill information and rendering implementation of various charts. It can be stored in a dynamic skill library, which can be used to split various chart types (visual component types) skills, field inference skills, editing skills, and clarification skills into separate skill modules and dynamically load them into the context of the intelligent system as needed. The visualization component generation and validation module 304 can be used to generate simplified intermediate representations, compile them into rendering specifications, enter the language / specification dual layer, run the rendering engine, and then perform validity validation. If the validation fails, it enters the automatic repair loop. Otherwise, if the validation succeeds, it enters the front-end rendering module.

[0061] The clarification interaction module 305 can be a clarification card interaction module, which can solicit key decisions from users using structured UI (User Interface) cards when information is insufficient. Here, structured cards can include chart-type (visual component type) clarification cards or field mapping clarification cards. The above modules can communicate with each other through standardized interfaces to achieve hierarchical processing and collaborative work of requests.

[0062] In one scenario, the first intelligent system can serve as an entry layer, receiving user requests from different entry points and performing intent recognition to obtain recognition results. These results may include intent type, domain identifier, key entity information, and confidence level. Additionally, the recognition results in this paper may include the first request.

[0063] As an example, when a user enters "generate a sales revenue bar chart," the First Intelligence System identifies the intent as "generate visualization components," with the domain identifier being "chart," meaning the domain identifier is First Identifier, and key entities include sales revenue and bar charts. As another example, when a user enters "help me adjust the dashboard layout," the First Intelligence System identifies the domain identifier as "dashboard" (First Identifier).

[0064] When the recognition result contains the first identifier, the first intelligent system can route the request to the corresponding second intelligent system. Here, the first identifier can be a chart domain identifier, which can be an identifier added when it is determined that the request is a visualization component generation request or a chart editing request. That is, when it is determined that the user input request is related to the chart (visual component), the first identifier can be added to the request.

[0065] Optionally, the first request may carry a mandatory intent identifier. When this identifier exists and its value is valid, the first intelligent system can directly route the request to the intelligent system of the corresponding domain, that is, send the request to the second intelligent system, skipping the general intent recognition reasoning. For details of the interaction process, please refer to [link to relevant documentation]. Figure 4 The first intelligent system can receive a first request input through the front-end interface, identify the first request, and obtain the identification result.

[0066] Optionally, based on Figure 4 It can be seen that when the second intelligent system receives the first request and recognition result from the first intelligent system, it can invoke the Model Context Protocol (MCP) tool provided by the large model to generate and edit charts. Simultaneously, it can send knowledge information about the changes to the dashboard domain and receive the execution results. Furthermore, when the second intelligent system receives interaction information from the MCP tool, it can send session information to the first intelligent system. Based on this information, the first intelligent system can send a visualization component generation message to the front-end interface. Upon receiving this message, the front-end interface can display the generated or modified charts.

[0067] By strongly binding pre-labeling of entry points with session identifiers, intent attribution can be determined by the architecture rather than semantic guessing, thus structurally eliminating the intent drift problem in multi-entry scenarios. Context remains unbroken when users switch between the editing panel and the dialogue panel.

[0068] In addition, the recognition results may also include a session identifier, which may have a predefined association with the second intelligent system. This association can be maintained through a configuration file or registry. By binding the second intelligent system with the session identifier, the request can be accurately distributed, avoiding misjudgment by the general intent recognition layer, thereby improving the overall response efficiency of the visualization component.

[0069] For example, this paper can assign a stable session identifier (Thread Identifier, ThreadID) to each ongoing AI session. When initiating a request, a mandatory intent identifier (first identifier) ​​can be carried in the entry parameters. This first identifier is used to indicate the routing value of the second intelligent system. Here, the session identifier can be a stable session identifier, which can be used to carry multi-turn context and decision items. This session identifier can be bound to entry points, objects, users, etc. For example, the session can span all stages, including intent routing, the first processing stage - the second processing stage, skill loading, clarification, data retrieval definition, rendering specification generation and repair, etc., to uniformly carry multi-turn context.

[0070] In addition, for the editing entry, its entry parameters may include not only the first identifier, but also the target chart entity identifier and its current state snapshot, etc., which are used to characterize the data retrieval definition and rendering specification of the chart to be edited.

[0071] Upon receiving a first request, it can be identified whether the first request includes a first identifier. This is achieved by reading the entry parameters of the first request to determine if it carries a first identifier. If it does, the first request can be directly routed to the second intelligent system pointed to by the first identifier. This bypasses the semantic determination of the general intent recognition layer, thus skipping the semantic determination step of the first intelligent system. Consequently, dialogues entering from the diagram creation / editing entry point will not be misassigned to other domains due to semantic similarity, thereby eliminating intent drift caused by guesswork from a single intent recognition layer.

[0072] It should be noted that after the initial route is successfully hit, the session identifier can be bound to the selected second intelligent system. Subsequent multiple rounds of dialogue under the same session identifier, as well as dialogues re-initiated from historical dialogue records, can directly hit the bound second intelligent system without needing to go through the intent recognition layer again. Furthermore, when the task is completed, such as after the chart is created or edited, or if the request is rejected (rejected recognition), the binding between the session identifier and the second intelligent system can be released, meaning the session can exit that second intelligent system.

[0073] As an example, when a session is a newly initiated session, the corresponding session creation process can be as follows: Figure 5 As shown, based on Figure 5 It can be seen that a newly initiated session can include two situations: the first is to create an AI chart, and the second is to edit an AI chart. After the session identifier is created, it can be routed to the corresponding chart domain intelligent system (second intelligent system), that is, to send the first request and the recognition result obtained based on the first request to the second intelligent system.

[0074] Here, for sessions entered through the editing entry point, the snapshot of the target chart state carried in the first request can be maintained with the session as the baseline for subsequent incremental editing, allowing the second intelligent system to modify it in a minimum-difference manner during multiple rounds of editing. This approach ensures the stability of intent and the continuity of multi-round context in the visualization component generation scenario.

[0075] As another example, when the session is a dialogue within an existing session, the corresponding session procedure can be as follows: Figure 6 As shown, based on Figure 6 It is understood that when a conversation is already in progress, it can include two scenarios. The first is to initiate other conversations, which utilize the previously determined graph domain intelligence system (the second intelligence system). The second is to reject and complete artifact creation; this type of conversation can continue to initiate other conversations after the current conversation ends. Here, other conversations can be implemented through a combination of decision intelligence systems and other intelligence systems. For example, other intelligence systems can include TableAgent, Dashboard Agent, Perm Agent, and Form Agent, etc.

[0076] After successful initial routing, this paper establishes an association between the current dialogue identifier and the second intelligent system. Subsequent multi-turn requests under the same dialogue identifier can be directly routed to the bound second intelligent system without repeated intent determination. When the task is completed or a rejection recognition condition is triggered, the association between the first identifier and the second intelligent system can be severed. For the editing entry point, the state snapshot of the target chart can serve as the baseline for incremental editing, which can be maintained throughout the session. This allows subsequent editing operations to make minimal differential modifications based on the existing configuration.

[0077] In summary, the first intelligent system can be an intelligent system that undertakes general intent recognition and routing functions. It can be used to recognize the intent of the natural language content and entry context of the first request, determine whether the request belongs to visualization component generation, visualization component modification, dashboard arrangement, or other types, and output the recognition result. For example, the recognition result obtained by the first intelligent system in recognizing the first request may include an intent type identifier and a routing identifier corresponding to that intent type, where the routing identifier can be the aforementioned first identifier.

[0078] In step S230, if the identification result includes the first identifier, the identification result is sent to the second intelligent system.

[0079] As described above, the first identifier can be a domain-specific identifier for visualization components. If the first request contains this first identifier, the corresponding second intelligent system can be retrieved based on it, and the identification result can be sent to the second intelligent system. The second intelligent system can be a domain-specific intelligent system dedicated to handling the generation and editing of visualization components.

[0080] In other words, the second intelligent system is a domain-specific intelligent agent that is associated with the first identifier. For example, when the first identifier represents the intention to generate or modify a single visualization component, the second intelligent system can be a visualization component intelligent agent that undertakes the function of generating and editing a single visualization component entity; when the first identifier represents the intention to arrange a dashboard, the second intelligent system can be a dashboard intelligent agent that undertakes the function of arranging multiple charts. The hierarchical architecture of the first and second intelligent systems can decouple general intent recognition from specific domain execution.

[0081] Here, the association can be a binding relationship, which can be stored in the intelligent system registry. This registry can use the domain identifier as the key and the corresponding domain intelligent system instance or reference as the value. When the first intelligent system identifies that a request belongs to a certain domain, it can retrieve the corresponding domain intelligent system instance by looking up the registry, i.e., retrieve the corresponding second intelligent system, and forward the identification result and the original request to that instance, i.e., route the identification result and the first request to the second intelligent system. For example, each session can be associated with a domain intelligent system instance, which can be done through a session identifier. This ensures that the context information within the same user session is continuously retained in the domain intelligent system, thereby enabling accurate request routing and session-level context management, and avoiding context interference between multi-domain tasks.

[0082] In step S240, the first visualization component is generated.

[0083] In some implementations, the second intelligent system can combine the first processing stage and the second processing stage to generate the first visualization component. The first processing stage can be a reasoning (Think) stage, and the second processing stage can be an execution (Execute) stage. Here, the first and second processing stages correspond to the ReAct loop within the second intelligent system. Therefore, the second intelligent system can adopt a two-stage ReAct (reasoning-action) architecture of Think-Execute.

[0084] As an optional approach, during the generation of the first visualization component based on the second intelligent system, reasoning (thinking) can be performed on the recognition results based on the first processing stage to obtain first information. This first information may include component type information and field mapping information. The component type information indicates the component type, which is related to the first request; the field mapping information indicates the field mapping relationship, which is also related to the first request. If the first information satisfies the first condition, the process can proceed to the second processing stage, after which the first visualization component is generated based on the second processing stage.

[0085] Here, the first processing stage can be a pure reasoning and decision-making stage, which can be executed by a large language model. Based on this first processing stage, a deep understanding and analysis of the user request can be performed. It is understandable that, in the process of reasoning from the recognition results based on the first processing stage to obtain the first information, skill information can be loaded into the first registry based on the recognition results. Then, reasoning from the skill information based on the first processing stage yields the first information. Here, the first registry can be configured by the second intelligent system; that is, the second intelligent system can be configured with the first registry.

[0086] Optionally, skill loading can be done by loading skill units as a whole, or by loading them into paragraph-level slices and then assembling them. Furthermore, a skill can be a dynamically loadable visual component, field, or editable or clarifying knowledge unit, which can correspond to the visual component type, editing action, etc.

[0087] In one scenario, during the first processing stage, the second intelligent system can determine the session scenario based on the recognition results. Specifically, it determines whether the current request is related to a visualization component; that is, whether the current scenario involves creating a new visualization component, modifying a visualization component, or any other scenario. The acquired scenario can be used in subsequent execution processes; different scenarios result in different execution flows.

[0088] Optionally, in the first processing stage, the second intelligent system can also be used to determine whether a request is a rejection request, that is, to determine whether the request exceeds the generation capabilities of the visualization component. For example, if it is determined that the request exceeds the generation capabilities of the visualization component, rejection can be triggered.

[0089] Optionally, in the first processing stage, the second intelligent system can also be used to infer the type of the visual component, that is, to infer the matching type of the visual component based on the user's description and provide component type information, which can be used as the component type confidence level. Additionally, the second intelligent system can also be used to infer field mappings to map the business concepts mentioned by the user to specific fields in the data source and provide field mapping information, which can be used as the field mapping confidence level. Furthermore, in the first processing stage, the second intelligent system can determine whether to directly proceed to the second processing stage (execution stage) based on the confidence level and conditional judgment, or determine whether clarification needs to be initiated to the user.

[0090] In summary, upon entering the first processing stage, the second intelligent system can perform operations such as scene judgment, rejection judgment, key decision item inference, and gating decision. Specifically, the inference of key decision items may include inferring the type / subtype of a visualization component from the supported range of visualization component types, inferring the role of each field in the current intent from data table fields, and recording the filtering intent, sorting intent, and additional visual intent in natural language, providing a confidence assessment for each item, with assessment results categorized as high, medium, or low. For example, visual intent may include information such as color scheme, whether to display data labels, and coordinate axis style.

[0091] In this paper, component type information can be used to indicate the component type, which is related to the first request; field mapping information can be used to indicate the field mapping relationship, which is related to the first request. The above-mentioned gated state machine can be implemented through a first condition, that is, the first condition can be a gate condition from the first processing stage to the second processing stage. The first condition can include at least one of the following: the component type information belongs to a first range, which is the range of visual component types supported by the second intelligent system; the field mapping relationship satisfies the field mapping condition; the first request is related to the visual component; and the second intelligent system is in an execution-ready state.

[0092] For example, component type information may include component type confidence, and the component type information belonging to a first range may be that the component type confidence exceeds a first threshold; field mapping information may include field mapping confidence, and the field mapping relationship satisfying the field mapping condition may be that the field mapping confidence exceeds a second threshold; the first request is related to the visualization component; and the second intelligent system is in an execution-ready state. Here, the second intelligent system being in an execution-ready state may mean that the current round of dialogue is not in a clarification waiting state.

[0093] As an example, when the confidence level of the component type is greater than or equal to the medium confidence level, the confidence level of the field mapping is greater than or equal to the medium confidence level, the current round of dialogue has not triggered rejection, and the user is not in a clarification waiting state, it is determined that the first information meets the first condition, and at this time the user can move from the first processing stage to the second processing stage.

[0094] It should be noted that the first condition mentioned above can be configured according to business needs. For example, in scenarios with high accuracy requirements, the threshold can be appropriately increased; in scenarios with high response speed requirements, the threshold can be appropriately decreased. In addition, the first condition may also include a rejection status check, i.e., no rejection judgment has been triggered, and may also include a clarification waiting status check, i.e., the current state is not waiting for user clarification.

[0095] As an alternative approach, if it is determined that the first information does not meet the first condition, clarification information can be output. This clarification information can be used to indicate supplementary component type information and / or field mapping information. If a clarification result based on this clarification information is received, a first visualization component can be generated based on the clarification result. In other words, if it is determined that the aforementioned first information does not meet the gating condition, clarification information can be output to instruct the user to input the associated clarification result.

[0096] As an example, when the component type confidence (component type information) is determined to be low, a text clarification can be initiated. This clarification can list candidate visual component types for the user to choose from, and the clarification information can be output in the form of text cards. For example, the text clarification card can be as follows: Figure 7 As shown, based on Figure 7 It is known that when the system receives a user's request to "create an AI component", the second intelligent system cannot determine what type of visualization component the user wants to generate. At this time, it can output a text clarification card to prompt the user to input the type of visualization component they want to create and the fields, etc.

[0097] In other words, when the type of visualization component is uncertain, this paper can output text clarification information (text clarification card) to list candidate visualization component types for users to choose from through text clarification. That is, text clarification can be given priority when the type of visualization component is uncertain.

[0098] As another example, when the field mapping confidence level (field mapping information) is determined to be low, and the number of available fields is greater than or equal to a preset number, a structured clarification can be initiated. This structured clarification can be output through a structured clarification card. Here, the structured clarification card can be used to create and edit scenarios. For example, in creating a scenario, when it is determined that the first information does not meet the first condition, the following can be output: Figure 8 The first structured clarification card shown indicates to the user what specific information is needed, and lists the required information. The user can then select the information according to their needs. Figure 8 The diagram shows the specific goals that the components are designed to achieve.

[0099] In other words, when the field role mapping is uncertain or incomplete, and there are a large number of available fields, a limited number of field configuration candidate schemes inferred by the intelligent system can be presented. Users can make a decision by clicking to select, which can be achieved by outputting clarification information in the form of structured clarification cards. For example, a preset number of suggestions and other input items can be displayed through structured clarification cards. For instance, field role mapping can be used to represent which fields serve as X-axis, Y-axis, color dimension, size dimension, etc.

[0100] Optionally, in an editing scenario, when it is determined that the first information does not meet the first condition, the following can be output: Figure 9 The second structured clarification card shown indicates to the user how they wish to edit the visual components, listing the desired editing methods. The user can then select from the listed information. For example... Figure 9 The second structured clarification card, as shown, allows users to list the specific edits they want to make to the AI ​​components.

[0101] Understandably, in editing scenarios, structured clarification cards can carry the existing configuration information of the current visualization component. Based on this, candidate modification schemes can be presented, allowing users to make incremental choices based on existing configurations. It should be noted that the aforementioned clarification cards can support single selection, single selection with additional text, multiple selection, or multiple selection with additional text.

[0102] In addition, clarification cards can reuse existing structured forms or clarification description structures. For example, clarification information may include a card title, a list of questions, operation buttons, and information identifying the business type and scenario type. The question list may include a list type, radio buttons / dropdowns, question stems, options, whether it includes an 'other' input field, and embedded answer feedback; the scenario type may include creating a scenario and editing a scenario; the operation buttons may include confirm or skip; and the business type identifier may include a visual component.

[0103] Optionally, after outputting the clarification information, if the user inputs a clarification result (answer) via a clarification card, this clarification result can be embedded into the question structure. This question structure can be the selected option identifier and the input content, serving as the updated first information. The updated first information can then be fed back into the first processing stage. The first processing stage can re-evaluate the confidence gating based on the updated first information, i.e., re-determine whether the updated first information satisfies the first condition. If it is determined to satisfy the condition, the structured semantic parameters can be transferred to the second processing stage. In other words, the subsequent generation of the first visualization component can be based on the clarification result.

[0104] The aforementioned clarification cards can utilize UI formats such as graphical cards, interactive speech bubbles, sidebar panels, and floating toolbars. Furthermore, clarification cards can pop up synchronously or as asynchronous notifications, and they support interactive styles including multi-selection, single-selection, drag-and-drop, fill-in-the-blank, and secondary search.

[0105] In summary, when the type of the visualization component is uncertain, text clarification should be prioritized. Furthermore, clarification in the editing scenario can be completed in the first processing stage; the second processing stage primarily involves generating the visualization component, and no clarification operation will be initiated during this stage.

[0106] It should be noted that during a single-turn dialogue, the number of times clarification information is output is less than a preset number. When it is determined that the number of clarifications exceeds the preset number, the output of clarification information can be prohibited. For example, when it is determined that the number of times clarification information is output exceeds the preset number, the output of clarification information is stopped, a default clarification information is inferred based on historical clarification information, and a first visualization component is generated based on this default clarification information. This can avoid the repeated output of clarification information from affecting the user experience. The preset number can be 1.

[0107] To better illustrate the judgment process of the first condition, the following is given: Figure 10 The example diagram shown is based on Figure 10It is understood that the second intelligent system may involve a reasoning sub-intelligent system and an execution sub-intelligent system. The execution sub-intelligent system may include a creation sub-intelligent system and an editing sub-intelligent system. Upon receiving the recognition result and the first request, the reasoning sub-intelligent system can first perform initialization operations, namely, initializing the context and initializing the model. Based on this, it enters the reasoning execution loop to call the model context protocol tool. According to the first information from the call, it can determine whether the first condition is met, such as whether the rejection condition is met. If it is, the process ends. For example, it can determine whether the component type confidence and / or field mapping confidence have reached the confidence threshold. If not, it can output clarification information to instruct the user to input a clarification result (user response information). When it is determined that the first condition is met, it enters the task execution stage (second processing stage). This second processing stage can be used to call the next executor. The scheduling process may include stage parameters, intelligent system input requests, and clarified request information, etc.

[0108] In the first processing stage, the session scenario can be obtained. Different session scenarios will lead to different sub-intelligent systems. For example, when the session scenario is determined to be a creation scenario, the creation sub-intelligent system (CreateAgent) can be entered. Within this sub-intelligent system, the context and model are initialized, and inference is performed by repeatedly calling the model context protocol tool. This tool includes layout, creation of visual components, and skill reading. Subsequently, skills can be read to inject the dynamic context of the visual components, and operations such as layout generation and visual component creation can be performed. If the creation process is confirmed to be successful, a summary operation can be performed, and the creation of the visual components can be terminated.

[0109] Optionally, when the session scenario is determined to be an editing scenario, the system can enter the Edit Agent sub-intelligence system. Upon entering this sub-intelligence system, the context and model are initialized first, and then the model context protocol tool is invoked repeatedly. This tool includes layout, editing visual components, and skill reading. Subsequently, skills can be read to inject the dynamic context of the visual components and perform operations such as editing the visual components. Once the creation process is confirmed to be successful, the editing of the visual components can be terminated.

[0110] As described above, the first piece of information can be obtained based on skill information, which can then be loaded from the first registry based on the recognition results. Here, the first registry can be a chart skill registry, which can store skill information corresponding to various chart component types. Once the first processing stage infers the possible chart component types, the corresponding skill information can be dynamically loaded from this first registry and injected into the context of the large language model to aid in reasoning and decision-making.

[0111] In one scenario, skill information may include at least one of meta-information, template information, type information, constraint information, and attribute information. Meta-information can be used to match visualization component types. For example, meta-information may be information obtained by describing the name, type identifier, and applicable scenarios of a visualization component; that is, meta-information can be used for the selection and matching of visualization component types.

[0112] Template information may include rendering specification templates, which can be used to define the structural template of rendering specifications. For example, template information may include the basic structure and field constraints of a visualization component type rendering specification (Spec). Type information can be used to characterize subtypes of visualization components; that is, type information may include a list of subtypes, which can be subtypes of visualization components under a major category, such as a bar chart being subdivided into a regular bar chart, a stacked bar chart, a percentage stacked bar chart, etc.

[0113] Constraint information can be used to limit the number of dimensions and measures, assign roles, and define data transformation rules. This constraint information can be a data structure constraint, which characterizes the requirements of the visualization component type for the number and roles of dimensions / measures, as well as data transformation rules. Attribute information can be used to provide candidate editing operations for the visualization component. It can include candidate editing attributes. Here, attribute information can include several commonly used editing commands in the visualization component type, such as color scheme switching, axis settings, and label display.

[0114] For example, skill information may include a visual component type identifier, a visual component type name, an applicable scenario description, a list of subtypes, a rendering specification template and field constraints, data retrieval structure constraints and data transformation rules (dimension / metric mapping), and candidate editable attributes for the target type. The visual component type identifier can serve as a loading key, and the number of candidate editable attributes can be preset to obtain a number of candidate editable attributes.

[0115] In this paper, each visualization component type corresponds to a single skill unit, which can be a visualization component type definition. The skill unit can be stored as a plain text prompt or a structured description file. The skill index can be local keywords / regular expressions / decision trees, or a vector database / hybrid search.

[0116] For example, the domain knowledge of the visual components that originally needed to be fully pre-installed in the system prompts can be broken down into skill units that are granular at the visual component type, can be registered individually, and can be loaded on demand. The intelligent system context can be dynamically assembled by loading at runtime according to the visual component type. For details, please refer to [link to relevant documentation]. Figure 11 .

[0117] based on Figure 11 It is understood that upon receiving a user request including visualization component types and configuration information, the intelligent system planning phase can be executed. Afterwards, the requirements can be analyzed using a large language model, and a tool call can be initiated to retrieve skills. This skill retrieval can include obtaining the skill name and its corresponding description. Additionally, the runtime can be invoked to deserialize structured data to obtain the skill name, and configuration can be retrieved from the configuration center. If the skill name is confirmed to exist, a first result can be returned. For example, the first result could be {Success: true, skill loading complete, data: document content}. Conversely, if the skill name is not confirmed, a second result can be returned, which could be {Success: true, configuration does not exist, currently supporting A, B...}. Based on this, the large language model can formulate an execution plan based on the document, and the ExecuteAgent can continue the subsequent planning process.

[0118] In some implementations, the system suggests storing a lightweight index that supports visualization component type retrieval. After determining the target visualization component type / subtype in the first processing stage, the second processing stage can use this visualization component type as the key to call the skill reading tool to dynamically load the rendering specification template and data retrieval structure description of the corresponding skill unit. Furthermore, the hit key for the skill unit can be a determined visualization component type / subtype, which can be inferred from the visualization component type in the first processing stage. That is, the visualization component type can be determined first, and then knowledge can be loaded based on the type, rather than loading all visualization component type knowledge at once.

[0119] It should be noted that the skills for each type of visualization component in this article can be stored as units and registered in the registry. For a new visualization component type, a new skill unit can be added and registered in the registry without modifying the main flow prompts. Here, updating a single visualization component type skill will not affect other visualization component types. By dynamically querying the dictionary by type, the coverage of visualization component types can be continuously expanded without causing the context size to monotonically increase with the number of visualization component types.

[0120] As an optional approach, the implementation of each AI visualization component type can be separated into a separate directory. For example, data transformation and style configuration information can be separated into separate directories. The AI ​​chart adapter can decouple from the specific chart logic by dynamically loading and calling different visualization component types. It should be noted that newly added visualization component types can be integrated in a plug-in manner, thus avoiding impact on existing logic.

[0121] For example, this paper can extend the first registry (chart registry) through plug-ins. During the extension process, the AI ​​chart adapter (visual component adapter) no longer directly depends on specific chart implementations, but instead depends on an abstract chart registry, i.e., it depends on the first registry. Each chart module can register its own implementation with the first registry at startup. In this process, the AI ​​chart adapter can query the registry for the corresponding implementation module based on the chart type (visual component type) name at runtime, and call its data transformation information and default configuration. The data transformation information can be implemented through the AI ​​converter; the default configuration can be implemented through the default rendering specification plugin.

[0122] To better understand the dependencies of the first registry module, this article provides the following: Figure 12 The example diagram shown is based on Figure 12As can be seen, the rendering and expansion process of the first registry (chart registry) involves chart registration files, AI chart adapter builder, AI chart adapter, AI chart converter, default rendering specification plugin, the first registry, and chart definition modules. Among these, the chart registration file serves as a unified entry point for chart rendering. Based on this file, various adapter builders can be registered, such as the AI ​​chart adapter builder. The AI ​​chart adapter (aiChartAdapter) is the core module for obtaining dependencies in the first registry, and it can dynamically load various chart types (visual component types) through the Chart Registry. Here, each chart type (visual component type) can be registered in the registry as a separate plugin. Furthermore, the AI ​​chart adapter can be used to manage the lifecycle, events, and rendering pipeline of AI charts.

[0123] The AI ​​chart converter can be part of the AI ​​chart adapter, used to convert upstream data models into rendering specifications for the underlying visualization rendering engine. After refactoring, the AI ​​chart converter can invoke the data transformation logic of specific charts by querying the first registry. The default rendering specification plugin is responsible for default styles; after refactoring, it can also obtain the style configuration of specific charts by querying the registry. The first registry stores singletons of all AI chart definitions. The chart definition module is the concrete implementation of each AI chart, which can follow a unified interface, such as being registered in a unified first registry. Different types of visualization components have different corresponding definition modules; for example, the chart definition module corresponding to the first type of visualization component can be the first definition module, and the chart definition module corresponding to the second type of visualization component can be the second definition module.

[0124] Figure 12 This is a diagram of the front-end registry and plug-in architecture. Based on this diagram, we can see that the specific implementation of each type of chart can be broken down into separate definition modules. These modules can be automatically registered with the central registry at startup, and the core adapter can query the registry by type name and call the modules at runtime. The dependency, registration, and usage relationships in this paper can be divided into four layers from top to bottom: the page layer, the component layer, the core business layer (block layer / worksheet block), the registry layer, and also include the external dependency layer.

[0125] For information on the interactions between the aforementioned visualization components, AI chart adapter, AI chart converter, default rendering specification plugin, first registry, underlying visualization rendering engine, and chart definition module, please refer to [link / reference needed]. Figure 13 ,based on Figure 13As can be seen, the rendering process allows for two separate table lookups, separating data conversion and style configuration. The AIChartConverter and the DefaultSpecPlugin can each be called once, specifically the function `getChartDefinitionByName`, which retrieves the chart definition based on the visualization component type. When adding a new chart type, only data conversion and style configuration need to be implemented in the definition module, with each side querying and calling its own definition. The partial rendering specification (partialSpec) is a pure data structure without styles, while the final rendering specification (finalSpec) can be obtained by merging data and styles.

[0126] It should be noted that the extensibility of the chart definition can be broken down into multiple stable abstractions, such as... Figure 14 The three stable abstractions shown are as follows: the first stable abstraction can be a chart definition module, which can be used to generate chart definitions; the second stable abstraction can be a registration entry point, which can be used to select and register a set of charts enabled for a specified scenario; and the third stable abstraction can be a chart definition registration, which is used for registration, validation queries, and list export. Additionally, Figure 14 The first user in the system can be a developer, who can create new charts as needed.

[0127] As described above, after entering the second processing stage, the first visualization component can be generated based on this stage. This second processing stage can be an execution stage. Here, the second processing stage can be a pure execution layer, used to translate the data description language and generate the rendering specification based on the decision items determined in the first processing stage. The second processing stage does not perform clarification operations; that is, once it enters the second processing stage, even if uncertainties are encountered, it cannot pause consulting the user, but instead executes according to the existing decision items or reports errors.

[0128] With dynamic skill loading, adding a new visual component type only requires adding a separate skill unit; the main prompt does not need to be modified, and the context length of the intelligent system does not expand linearly with the number of visual component types. In other words, the number of visual component types that the intelligent system can support is no longer limited by the upper limit of the context length of a single system prompt.

[0129] As an optional approach, during the generation of the first visualization component based on the second processing stage, a first language can be generated based on the first information. This first language includes a domain-specific language, and the first information can be compiled to obtain a rendering specification. Subsequently, the first visualization component is generated based on the first language and the rendering specification. The domain-specific language (DSL) is a structured description language for configuring visualization components, which can be used to describe configuration information such as the type, data mapping, and style attributes of the visualization component. The rendering specification is a configuration object that the underlying rendering engine can directly consume, and it can be compiled from the first language.

[0130] For example, the first language can be a simplified intermediate representation oriented towards the graph's intent, which can be generated by a large language model, and the rendering specification can be a complete graph configuration oriented towards the rendering engine, which can be generated by a deterministic compiler. Here, the compiler can be implemented by a programmatic rule engine, or by a template engine, decision tree, or state machine. Furthermore, the compiler can execute on the server or the client; it can be a single large function or a registry pattern of graph types (visual component types) and compiled submodules.

[0131] In one scenario, the first information may include semantic information. When generating the first language based on the first information, the semantic information can be translated into the first language based on a first mapping rule. The first mapping rule can be a pre-configured mapping rule in the second intelligent system. For example, the first mapping rule may include at least one of inference rules, filtering rules, and sorting rules. The first language can be decomposed into multiple sub-schemas according to the visualization component type, or it can adopt a generic schema. Furthermore, the first language may or may not include data source references, as long as it can satisfy the requirement of being generated by a large language model and compiled into a lower-level rendering specification by a deterministic compiler.

[0132] For example, the inference rule can be an aggregation inference rule, which can comprehensively determine the final aggregation method based on aggregation hints, field names, and field types. Here, the aggregation method can include summation, counting, deduplication counting, averaging, maximum, and minimum, etc. For numeric fields without explicit semantics, summation can be used by default. The filtering rule can be a filtering operator mapping rule, which can map each natural language filtering intent to the corresponding filtering operator and value. Here, the filtering operator can include equal to / not equal to, contain / not contain, empty / not empty, greater than, less than, greater than or equal to, less than or equal to, and range, etc. The sorting rule can be a sorting mapping rule, which can map the natural language sorting intent to the sorting field and ascending or descending order.

[0133] Here, the first language has a first key feature, a second key feature, and a third key feature. The first key feature is data-oriented, not pixel-oriented. For example, it can describe information such as data source, dimensions, metrics, filtering, sorting, and pagination. That is, the first key feature does not involve rendering details such as axis scales, legend positions, or data label formats (the latter are handled by rendering specifications). The second key feature is mainly related to field reference identifiers. Stable identifiers can be used for field and data source references in the second key feature, ensuring correct binding with the data table. The third key feature can be incrementally differentiable. Based on this third key feature, any subfield can be replaced as the smallest difference unit, meaning it supports minimum difference modification and edit output in editing scenarios.

[0134] In summary, the second processing stage can deterministically translate semantic parameters into a first language based on fixed mapping rules. This first language is data query-oriented and can be used to describe data retrieval capabilities. Fields in the first language can include data sources, dimensions, measures, filters, sorting, and pagination. Here, fields in the first language can be referenced using a unified field identifier and do not support multi-table unions or complex pipelines. The mapping rules upon which the translation is based can at least include inference rules, filtering rules, and sorting rules.

[0135] It should be noted that during the process of generating the first language based on the first information, the corresponding skill unit can be dynamically loaded from the skill library according to the visualization component type determined in the first processing stage, and the first language (data retrieval description language) can be generated based on the skill unit. Furthermore, during the process of dynamically loading the corresponding skill unit from the skill library according to the determined visualization component type, the list of resident visualization component type ranges can be used as a lightweight index in the system prompt information. After determining the visualization component type, the complete content of the corresponding skill unit can be dynamically loaded from the skill library using the visualization component type as the key. Each visualization component type can correspond to a single skill unit, which can encapsulate a rendering specification template, a subtype list, data retrieval structure constraints, and candidate editing attributes. As described above, each skill unit can be stored separately and registered in the registry. Adding a new visualization component type can be achieved through adding the corresponding skill unit and registering it in the registry, thus enabling plug-in access.

[0136] Once the visualization component type is determined in the first processing stage, the second processing stage can dynamically load the full text of the corresponding skill unit from the skill library using that type as the key and inject it into the context. This on-demand loading mechanism allows the context of a single interaction to include knowledge of the currently required visualization component type, thereby significantly reducing context load. When adding a new visualization component type, simply adding the corresponding skill unit file and registering a record in the registry is sufficient; it will not affect any existing logic, thus enabling true plug-in-style expansion.

[0137] Optionally, the rendering specification can be oriented towards a visualization rendering engine. This rendering specification can be generated by loading a rendering specification template from a skill unit based on the visualization component type in the second processing stage, populating it, and then injecting additional visual intents into the template according to fixed mapping rules. The data array in the rendering specification is set to empty, and real data can be injected by the platform at runtime, while retaining fixed constraints such as rendering optimization flags.

[0138] It should be noted that the first information output in the first processing stage can be structured semantic parameters, which are natural semantic level parameters of the visualization component's intent. For example, the first information may include the visualization component type / subtype, field roles, filtering and sorting intents expressed in natural language, and additional visual intents. Among them, field roles can be used to record field identifiers and names, which can be aggregated with semantic hints; additional visual intents may include whether to stack, whether to use percentages, and direction, etc.

[0139] The process of obtaining structured semantic parameters described above belongs to the upper layer, as it does not involve underlying protocol fields, has fewer constraints, and is easier to correctly generate large language models. The translation of the first language belongs to the middle layer, and the compilation of the rendering specification belongs to the lower layer. By decomposing the description of the visualization components into three layers and connecting them with controlled rule-based translation and template-based filling, the uncertainty of large language models can be constrained to stages that are easier to generate correctly. Here, the communication medium between the three layers can be task cards, message queues, and shared state, etc.

[0140] By restricting the free generation of large language models to the less constrained and more accurate level of natural semantic parameters, entrusting the translation of semantic parameters to the first language to deterministic mapping rules, and entrusting the rendering specification to the fixed mapping between visualization component type templates and visual intents, the overall failure rate of visualization generation can be significantly reduced, and subsequent failure feedback and repair can be simplified.

[0141] As an alternative approach, after generating the first visualization component, a validation operation can be performed on it to obtain a validation result. If the validation result passes, the first visualization component can be output. Here, validating the first visualization component can involve performing a structural validation operation to obtain a first validation result. This structural validation operation can be used to validate fields, aggregation compatibility, etc. Alternatively, a rendering validation operation can be performed on the first visualization component to obtain a second validation result. Based on this, a final validation result is obtained by combining the first and second validation results.

[0142] For example, when generating chart artifacts, structural validity checks can be performed on the first language and rendering specification, including checking the existence of referenced fields and data tables, and the validity of the references. These checks can be performed within the chart creation or editing interface and can include structural and rendering checks, where the rendering check can be a trial rendering check. A passing check result can be achieved by passing both the structural and rendering checks. Validity checks can be triggered uniformly after the rendering specification is compiled, or embedded checks can be used at compile time. Furthermore, trial rendering can be performed in a separate rendering service or in a browser.

[0143] The above structural verification and rendering verification can be found in [reference]. Figure 15 ,based on Figure 15 It is understood that skill loading and reasoning can be performed in the first processing stage. After passing the gating, the second processing stage can be entered. In the second processing stage, a domain-specific language (the first language) can be generated, and the rendering specification can be compiled. Based on this, a verification operation can be performed. That is, structural verification can be performed first. If the structural verification passes, trial rendering verification can be performed. If the trial rendering verification passes, the verification operation is completed.

[0144] Optionally, when structural verification or trial rendering verification fails, a repair mode can be entered. That is, the second processing stage can enter repair mode after receiving failure feedback. In repair mode, the error cause can be analyzed, the root cause located, and the first language corrected, rendering specifications modified, or the layout regenerated, followed by a re-invocation of the creation or editing interface. During the repair process, the number of retries can be tracked. If it is determined that the number of retries exceeds a preset number and still fails, a fallback can be implemented, and the error cause reported. For example, if the cumulative retries exceed three rounds, and the third round still fails, the final error cause can be reported through a task summary, along with the attempted correction solutions, thus avoiding infinite retries.

[0145] In addition, differential repair can output a natural language description of the changes, which can then be parsed by the program. Furthermore, the fallback path for repair failures can include clarification, template fallback, switching to another large language model, or switching to another visualization component type.

[0146] It should be noted that after validation, the visualization component creation or editing interface can return a success or failure validation result. In the event of a failure, the validation result can include the reason for the error. For example, the validation result can include whether it was successful or not. Additionally, upon success, it can return the visualization component entity identifier; upon failure, it can return the reason for the failure, which can be used by the large language model to locate the root cause. For instance, failures can include three categories: the first category could be a language translation error, which might be output when a field representation is missing or the aggregation method is not supported; the second category could be a rendering specification error, which might be output when field references do not match or required options are missing; and the third category could be a layout error. Furthermore, when missing field mapping information or missing chart type information is determined, field mapping clarification and chart type clarification are performed respectively.

[0147] The two-layer design of first-language translation and rendering specifications isolates uncertainties in large language models within the less information-intensive first-language translation layer. Through two-stage validity checks and a minimum DSL differential repair loop, most errors can be detected and locally repaired before rendering, eliminating the need for a complete overhaul. Furthermore, after the repair failure limit is reached, it can automatically revert to clarification, thus preventing users from encountering issues such as freezing or blank graphs.

[0148] Additionally, after the first processing stage is completed, a pre-validation operation can be performed, which can be a tool call order pre-validation. Several tools in the second processing stage have strict call order dependencies; for example, artifact generation and validation must be performed after layout generation. To avoid unnecessary errors caused by incorrect call order, the tools can be wrapped with pre-validation. During the validation process, if it is determined that the call order does not meet the pre-validation requirements, a complete missing error message can be returned to the large language model, instructing it to adjust the tool call order and retry. This avoids unnecessary interruptions to the inference execution loop.

[0149] Optionally, in editing scenarios, this article can follow the principle of minimum difference, that is, only the fields explicitly specified in the current editing scope can be modified, while the first language (data retrieval DSL) and rendering specification configuration that are not involved can be fully preserved. This ensures that even if the visualization component type changes, the user's historical custom configuration that is unrelated to the visualization component type can be preserved.

[0150] As an alternative approach, after generating the first visualization component, it can be visualized and displayed as a component of the dashboard. For example, this paper defines AI-generated charts as first-class components (first-class citizen components) in the dashboard chart system within the data model. Here, first-class components represent the complete isomorphism between AI-generated charts and manually generated charts in terms of storage and capabilities; they can share dashboard permissions, themes, editing history, etc.

[0151] In other words, the first visualization component can be integrated into the existing dashboard visualization component system as a special visualization component type. It can be distinguished from ordinary visualization components through an additional subtype identifier at the metadata layer. The two can reuse the same visualization component entity and update chain, thus enabling automatically generated visualization components and manually created visualization components to share the same set of dashboard capabilities.

[0152] For example, a snapshot of a chart automatically generated based on artificial intelligence can be saved in two parts side by side: the first part is the data retrieval definition, which can be an open DSL (first language), and the second part is the rendering specification (Spec). The first part can be used to drive data querying and linkage, while the second part can be used to drive visualization rendering.

[0153] Optionally, the automatically generated first visualization component can reuse existing dashboard capabilities, such as automatic integration with global filtering, slicer response, chart linkage, drill-down, combined layout and copying, import / export, sharing, and automated screenshotting. Furthermore, the first visualization component can automatically update its style according to the dashboard theme and color scheme. It can also generate specifications based on the theme type using the default configuration in the visualization component type definition, eliminating the need to re-trigger the large language model when switching themes.

[0154] Optionally, AI-generated visualization components can support subsequent incremental modifications, either manually or using AI. AI-generated and manual editing can both affect the same visualization component entity. Furthermore, unified artifact management can be integrated, allowing for unified processing of generation, updates, and undoing, with undoing reusing the dashboard's changeset mechanism. Additionally, AI-generated visualization components can revert to their original session and the snapshot of the data retrieval or rendering specifications at the time of generation.

[0155] Data access for AI-generated visualization components can be achieved through... Figure 16The AI-powered chart data dimension manager shown can be used to consume and manage data sources, binding raw data to visualization components and accessing the dirty data area as a dimension manager. This supports the control of filters and slicers. Additionally, the AI-powered chart data dimension manager can hold AI-powered chart block models and aggregate interfaces, such as an interface for adding new table data sources. Please see Figure 17 The Dimension Manager can be used to parse data conditions, enabling the detection of changes in snapshots within an AI chart block model. When a range definition is updated, it can be parsed and set as a query condition for the data source. Additionally, data retrieval can be performed by calling the data source's numeric function to fetch table data at appropriate times.

[0156] Optionally, the Dimension Manager can be used to manage data state: maintaining the stream of observables, broadcasting data loading status and update events. Additionally, the Dimension Manager can hold raw data, storing raw two-dimensional tabular data returned by the data source in raw table data for use by subsequent rendering converters.

[0157] As described above, after obtaining the first visualization component, it can be displayed as a dashboard component. For example, in generating... Figure 18 After the first visualization component 1801 shown, it can be displayed as a dashboard component.

[0158] As an alternative approach, this paper proposes a layered architecture for domain-level intelligent systems, reserving scalable collaborative interfaces for dashboard-level orchestration. Firstly, the architecture can be layered. The first intelligent system could be a domain-level intelligent system focused on the creation and editing of individual visual component entities. At the dashboard level, multiple visual components can be generated or edited simultaneously and orchestrated uniformly, which can be handled by a parallel dashboard intelligent system (dashboard domain intelligent system). The visual component intelligent system and the dashboard intelligent system can reside in the same layered architecture, sharing a unified intent recognition / routing layer and structured semantic parameter collaboration method. Alternatively, the visual component intelligent system and the dashboard intelligent system can also be decomposed into multiple layers.

[0159] Secondly, the products of the second intelligent system (visual component intelligent system) can be a subset of the products of the dashboard intelligent system. The product management, cancellation, and capability attachment of the second intelligent system can be aligned with the dashboard system, thus reserving a unified product structure and collaboration interface for the future access to the multi-graph arrangement capability of the dashboard intelligent system.

[0160] Here, the dashboard intelligent system can deconstruct a single high-level intent into multiple analytical perspectives, meaning it can collaboratively generate a complete set of visualization components at once and complete cross-chart coordination, avoiding the need to manually assemble visualization components one by one, thereby improving the efficiency of dashboard generation.

[0161] In this paper, the visualization component intelligent system (the second intelligent system) and the dashboard intelligent system can coexist in the same hierarchical architecture, sharing an architecture that collaborates on intent recognition, routing layer, and structured semantic parameters. The visualization component intelligent system can be used to generate individual visualization component entities, while the dashboard intelligent system can be used for multi-graph orchestration. The outputs of the visualization component intelligent system can include visualization component snapshots and dashboard change sets, which can be subsets of the dashboard intelligent system's outputs, allowing the visualization component intelligent system to align with the dashboard outputs.

[0162] As an alternative approach, an editing control can be displayed simultaneously during the output of the first visual component. Based on this editing control, the user can modify the generated first visual component according to their needs, such as... Figure 19 As shown, in generating Figure 19 When the first visual component 1901 is shown and displayed, an editing control 1902 can be displayed at a specified location.

[0163] For example, this paper can display an AI editing entry (editing control) at an adjacent position to each AI-generated visualization component, and combine it with the pre-set candidate editing attributes in the skills of that visualization component type to show users commonly used modification instructions for that type, so as to lower the threshold for users to express their editing intentions.

[0164] Here, candidate sources can include candidate editing attributes of visualization component type skills. Each visualization component type's skill unit or visualization component type definition can have a fixed number of pre-defined candidate editing attributes. Each attribute can consist of an icon and instruction text, describing a commonly used editing instruction for that visualization component type. Therefore, candidate editing attributes can be provided by the skill packages of each visualization component type, and can be maintained and registered along with the visualization component type skills.

[0165] AI-generated editing candidates can be generated entirely based on the enumeration of built-in skills, or by combining user history, common patterns, or popular actions from visual component communities. Candidate ranking can employ heuristic rules, weighted scoring, collaborative filtering, and small-sample candidates from large language models. Furthermore, candidates can be presented as a candidate list, or as floating prompts, right-click menus, or other similar formats.

[0166] Understandably, after the visualization component is successfully rendered, an editing control (AI editing entry point) can be provided on the visualization component, which can be displayed as a floating button. When the editing control is clicked, a target panel 1903 can pop up. This target panel 1903 can include a text input box and a list of candidate editing instructions from the skills of that visualization component type. When the user clicks on a candidate instruction or enters it manually, the corresponding editing query can be sent to the dialog side. At this time, an editing process can be triggered, that is, the editing scene of the first processing stage (think) and the second processing stage (execute) can be entered, and the existing visualization component can be modified based on the principle of minimum difference.

[0167] In addition, when the visualization component fails to be generated, targeted repair instructions can be provided for the same entry point. After the user clicks, the corresponding repair query can be initiated. In this way, the problem of "how to express the editing intent" can be solved by the commonly used editing instructions preset by the system according to the visualization component type. The user can trigger a minimum difference modification of the editing scene by clicking on a candidate.

[0168] This paper can be applied to natural language-driven structured configuration generation scenarios, such as natural language-driven form generation, process orchestration generation, report template generation, Kanban script generation, alarm rule generation, SQL (Structured Query Language) generation and result visualization hybrid generation.

[0169] As an example, the user's first request is "Help me check sales trends." This request reaches the intent distribution layer via an entry point. The router can pre-label the request as a newly created visualization component based on the entry point type and assign it a session identifier, then bind it to the current workbench context. The first request enters the inference phase of the first intelligent system, which determines that it belongs to a single-graph creation task. At this point, the first request can be further forwarded to the second intelligent system. Here, the lifecycle of the session identifier can be session-level, task-level, or object-level.

[0170] In the first processing stage (think stage) of the second intelligent system, the skills of line chart skill mapping, time field inference skill, and clarification skill are matched and loaded into the context. If multiple selections are found for a field candidate (e.g., sales revenue may come from multiple table columns) and the time granularity is not specified, a field mapping clarification card can be output. Users can select target information in the clarification card, such as choosing a monthly granularity. The clarification result is written back to the session snapshot.

[0171] When the first condition (inference gating condition) is met, the second intelligent system can enter the second processing stage (Execute stage). In this stage, it can call the large language model to generate the first language, and then use a deterministic compiler to compile the first language into a rendering specification. If the structural verification and trial rendering verification pass, the visualization component generation is completed. Afterwards, the visualization component entity can be written to the dashboard, and the first-class citizen component attachment is complete. Simultaneously, the AI ​​editing panel can display candidate information such as adding year-on-year curves, switching to bar charts, and adding target lines based on line chart skills.

[0172] Here, the large language model can be a general-purpose large model, a domain-specific fine-tuning model, or a combination of multiple models. For example, a large language model can be a combination of multiple models, including an intent understanding model, a DSL generation model, and a repair model. The specific type of large language model is not explicitly defined here and can be selected based on the actual situation.

[0173] When a user clicks to add a year-on-year curve, a minimum first-language difference patch can be triggered, and the process returns to the second processing stage to quickly complete an incremental edit. If an incompatibility issue between aggregation type summation and string fields is identified during the trial rendering stage, the process can enter a repair state. The large language model can output a minimum difference patch to change the aggregation method from summation to counting, recompile, and pass the validation. This process is done without the user's awareness.

[0174] Upon receiving a first request, this paper identifies the first request based on a first intelligent system. The first request is used to instruct the generation of a visualization component or the editing of a visualization component. Subsequently, if the first intelligent system determines that the first request includes a first identifier, the first request is routed to the corresponding second intelligent system so that the visualization component can be generated or modified by the second intelligent system to obtain the first visualization component. This allows different types of requests to be distributed hierarchically to specialized intelligent systems for processing, thereby reducing the generation failure problem caused by a single intelligent system carrying all knowledge and improving the accuracy of visualization component generation to a certain extent.

[0175] Figure 20 This is a schematic diagram illustrating the structure of a visualization component generation apparatus according to an exemplary embodiment. For example... Figure 20 As shown, this article provides a visualization component generation device 2000, which may include a receiving module 2010, an identification module 2020, an acquisition module 2030 and a generation module 2040.

[0176] The receiving module 2010 is used to receive a first request, the first request being used to instruct the generation of a visualization component or to instruct the editing of a visualization component; The identification module 2020 is used to identify the first request and obtain an identification result, the identification result being from the first intelligent system; The acquisition module 2030 is used to send the identification result to the second intelligent system if the identification result includes a first identifier, wherein there is an association relationship between the second intelligent system and the first identifier; The generation module 2040 is used to generate a first visualization component, which comes from the second intelligent system.

[0177] In some implementations, the generation module 2040 may include: The reasoning submodule is used to reason about the recognition result based on the first processing stage to obtain first information, the first information including component type information and field mapping information; A generation submodule is used to enter the second processing stage if the first information meets the first condition; and to generate the first visualization component according to the second processing stage.

[0178] In some implementations, the reasoning submodule is further configured to load skill information into a first registry based on the recognition result; and to reason about the skill information according to a first processing stage to obtain first information.

[0179] In some implementations, the skill information includes at least one of the following: Meta-information, which is used to match the type of visualization component; Template information, which is used to define the structural template of the rendering specification; Type information, which is used to characterize the subtypes of the visualization components; Constraint information, which is used to limit the number of dimensions and metrics, roles, and data transformation rules; Attribute information, which is used to provide candidate options for commonly used editing operations of the visualization component.

[0180] In some implementations, the component type information is used to indicate a component type related to the first request, the field mapping information is used to indicate a field mapping relationship related to the first request, and the first condition includes at least one of the following: The component type information belongs to a first range, which is the range of visual component types supported by the second intelligent system; The field mapping relationship satisfies the field mapping condition; The first request is related to the visualization component; The second intelligent system is in the execution ready state.

[0181] In some implementations, the generation submodule is further configured to generate a first language, which is generated from the first information and includes a domain-specific language; compile the first information to obtain a rendering specification; and generate the first visualization component based on the first language and the rendering specification.

[0182] In some implementations, the first information includes semantic information, and the generation submodule is further configured to translate the semantic information into the first language according to a first mapping rule. The first mapping rule is a pre-configured mapping rule in the second intelligent system, and the first mapping rule includes at least one of an inference rule, a filtering rule, and a sorting rule.

[0183] In some embodiments, the visualization component generation apparatus 2000 may further include: The clarification module is configured to output clarification information if the first information does not meet the first condition, wherein the clarification information is used to indicate the supplementation of the component type information and / or the field mapping information; and to receive a clarification result, wherein the clarification result is input based on the clarification information. The generation module 2040 is also used to generate the first visualization component based on the clarification result.

[0184] In some embodiments, the visualization component generation apparatus 2000 may further include: The verification module is used to perform a verification operation based on the first visualization component and obtain a verification result; if the verification result passes, the first visualization component is output.

[0185] In some implementations, the verification module is further configured to perform a structural verification operation to obtain a first verification result, and to perform a rendering verification operation to obtain a second verification result, wherein the structural verification operation and the rendering verification operation are implemented according to the first visualization component; and the verification result is obtained based on the first verification result and the second verification result.

[0186] In some embodiments, the visualization component generation apparatus 2000 may further include: The display module is used to display the first visualization component, which is displayed as a dashboard component.

[0187] Upon receiving a first request, this paper identifies the first request based on a first intelligent system. The first request is used to instruct the generation of a visualization component or the editing of a visualization component. Subsequently, if the first intelligent system determines that the first request includes a first identifier, the first request is routed to the corresponding second intelligent system so that the visualization component can be generated or modified by the second intelligent system to obtain the first visualization component. This allows different types of requests to be distributed hierarchically to specialized intelligent systems for processing, thereby reducing the generation failure problem caused by a single intelligent system carrying all knowledge and improving the accuracy of visualization component generation to a certain extent.

[0188] The following is for reference. Figure 21 The diagram illustrates a structural schematic of an electronic device 2100 suitable for implementing the above-described method. Terminal devices may include, but are not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Tablet Personal Computers), PMPs (Portable Media Players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and fixed terminals such as digital TVs (Televisions), desktop computers, etc. Figure 21 The electronic device shown is merely an example and should not be construed as limiting its functionality or scope of use.

[0189] like Figure 21 As shown, electronic device 2100 may include a processing unit (e.g., a central processing unit, a graphics processing unit, etc.) 2101, which can perform various appropriate actions and processes according to a program stored in read-only memory (ROM) 2102 or a program loaded from storage device 2108 into random access memory (RAM) 2103. The random access memory 2103 also stores various programs and data required for the operation of electronic device 2100. The processing unit 2101, ROM 2102, and RAM 2103 are interconnected via bus 2104. An input / output (I / O) interface 2105 is also connected to bus 2104.

[0190] Typically, the following devices can be connected to the input / output interface 2105: input devices 2106 including, for example, a touchscreen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; output devices 2107 including, for example, a liquid crystal display (LCD), speaker, vibrator, etc.; storage devices 2108 including, for example, magnetic tape, hard disk, etc.; and communication devices 2109. Communication device 2109 allows electronic device 2100 to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 21 An electronic device 2100 with various devices is shown; however, it should be understood that it is not required to implement or possess all of the devices shown. More or fewer devices may be implemented or possessed alternatively.

[0191] In particular, depending on certain circumstances, the processes described in the flowchart above can be implemented as computer software programs. For example, a computer program product is provided, comprising a computer program carried on a non-transitory computer-readable medium, the computer program containing program code for performing the methods shown in the flowchart. This computer program can be downloaded and installed from a network via communication device 2109, or installed from storage device 2108, or installed from read-only memory 2102. When the computer program is executed by processing device 2101, it performs the functions defined in the above-described methods.

[0192] It should be noted that the aforementioned computer-readable medium may be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium may be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM, or flash memory), optical fiber, portable compact disc read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In one case, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In another case, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. The transmitted data signal can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. The computer-readable signal medium can also be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to: wires, optical fibers, RF (Radio Frequency), etc., or any suitable combination thereof.

[0193] In some scenarios, clients and servers can communicate using any currently known or future-developed network protocol, such as HTTP (Hypertext Transfer Protocol), and can interconnect with digital data communication (e.g., communication networks) of any form or medium. Examples of communication networks include Local Area Networks (LANs), Wide Area Networks (WANs), the Internet (e.g., the Internet), and peer-to-peer networks (e.g., ad-hoc peer-to-peer networks), as well as any currently known or future-developed networks.

[0194] The aforementioned computer-readable medium may be included in the aforementioned electronic device; or it may exist independently and not assembled into the electronic device.

[0195] The aforementioned computer-readable medium carries one or more programs that, when executed by the electronic device, cause the electronic device to: receive a first request, the first request being used to instruct the generation of a visualization component or to instruct the editing of a visualization component; identify the first request and obtain an identification result, the identification result being from a first intelligent system; if the identification result includes a first identifier, send the identification result to a second intelligent system, the second intelligent system being associated with the first identifier; and generate a first visualization component, the first visualization component being from the second intelligent system.

[0196] Computer program code for performing the above operations can be written in one or more programming languages ​​or a combination thereof. These programming languages ​​include, but are not limited to, object-oriented programming languages, as well as conventional procedural programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a separate software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0197] The flowcharts and block diagrams in the accompanying figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products under various scenarios. Each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing the specified logical function. It should also be noted that, in some alternative cases, the functions indicated in the blocks may occur in a different order than those indicated in the figures. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0198] The modules mentioned above can be implemented in software or hardware. In some cases, the name of a module does not necessarily limit the module itself; for example, a generation module can also be described as "the module that generates the first visualization component."

[0199] The functions described above can be performed, at least in part, by one or more hardware logic components. For example, exemplary types of hardware logic components that can be used, without limitation, include: Field-Programmable Gate Arrays (FPGAs), Application-Specific Integrated Circuits (ASICs), Application-Specific Standard Parts (ASSPs), Systems on Chips (SoCs), Complex Programmable Logic Devices (CPLDs), and so on.

[0200] In this context, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0201] The above description is merely illustrative and explains the technical principles employed. Those skilled in the art should understand that the scope of this document is not limited to the specific combinations of the above-described technical features, but should also cover any combination of the above-described technical features or their equivalents without departing from the above concept.

[0202] Furthermore, while the operations are described in a specific order, this should not be construed as requiring these operations to be performed in the specific order shown or in a sequential order. Multitasking and parallel processing may be advantageous in certain environments. Similarly, while some specific implementation details are included in the above discussion, these should not be interpreted as limiting the scope of this paper. Certain features described in the context of a single example can also be implemented in combination in a single example. Conversely, various features described in the context of a single example can also be implemented individually or in any suitable sub-combination in multiple examples.

[0203] Although this document has been described using language specific to structural features and / or methodological logic, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Rather, the specific features and actions described above are merely illustrative examples of implementing the claims. Regarding the aforementioned apparatus, the specific manner in which the various modules perform their operations has already been described in detail in the section concerning the method, and will not be elaborated upon here.

Claims

1. A method for generating a visual component, comprising: Receive a first request, the first request being used to instruct the generation of a visualization component or to instruct the editing of a visualization component; The first request is identified, and an identification result is obtained, wherein the identification result comes from the first intelligent system; If the identification result includes a first identifier, the identification result is sent to the second intelligent system, and there is an association relationship between the second intelligent system and the first identifier; A first visualization component is generated, which originates from the second intelligent system.

2. The method for generating a visualization component according to claim 1, wherein the second intelligent system generates the first visualization component through a first processing stage and a second processing stage, wherein generating the first visualization component includes: Based on the identification result in the first processing stage, reasoning is performed to obtain first information, which includes component type information and field mapping information; If the first information satisfies the first condition, proceed to the second processing stage; The first visualization component is generated according to the second processing stage.

3. The method for generating a visualization component according to claim 2, wherein the second intelligent system is configured with a first registry, and the step of reasoning about the recognition result based on the first processing stage to obtain first information includes: Based on the recognition results, load the skill information into the first registry; Based on the skill information in the first processing stage, the first information is obtained.

4. The method for generating a visualization component according to claim 3, wherein the skill information includes at least one of the following: Meta-information, which is used to match the type of visualization component; Template information, which is used to define the structural template of the rendering specification; Type information, which is used to characterize the subtypes of the visualization components; Constraint information, which is used to limit the number of dimensions and metrics, roles, and data transformation rules; Attribute information, which is used to provide candidate options for commonly used editing operations of the visualization component.

5. The method for generating a visualization component according to claim 2, wherein the component type information is used to indicate the component type, the component type is related to the first request, the field mapping information is used to indicate the field mapping relationship, the field mapping relationship is related to the first request, and the first condition includes at least one of the following: The component type information belongs to a first range, which is the range of visual component types supported by the second intelligent system; The field mapping relationship satisfies the field mapping condition; The first request is related to the visualization component; The second intelligent system is in the execution ready state.

6. The method for generating a visualization component according to claim 2, wherein generating the first visualization component according to the second processing stage comprises: Generate a first language, which is generated from the first information, and the first language includes a domain-specific language; Compile the first information to obtain the rendering specification; The first visualization component is generated according to the first language and the rendering specification.

7. The method for generating a visualization component according to claim 6, wherein the first information includes semantic information, and generating the first language includes: The semantic information is translated into the first language according to the first mapping rule, wherein the first mapping rule is a pre-configured mapping rule in the second intelligent system, and the first mapping rule includes at least one of inference rule, filtering rule and sorting rule.

8. The method for generating a visualization component according to claim 2, further comprising: If the first information does not meet the first condition, clarification information is output, and the clarification information is used to indicate the supplementation of the component type information and / or the field mapping information; Receive clarification results, which are based on the clarification information input; The first visualization component is generated based on the clarification results.

9. The method for generating a visualization component according to claim 1, further comprising: The verification operation is performed based on the first visualization component to obtain the verification result; If the verification result passes, the first visualization component is output.

10. The method for generating a visualization component according to claim 9, wherein performing a verification operation based on the first visualization component to obtain a verification result includes: Perform a structural verification operation to obtain a first verification result, and perform a rendering verification operation to obtain a second verification result. The structural verification operation and the rendering verification operation are implemented based on the first visualization component. The verification result is obtained based on the first verification result and the second verification result.

11. The method for generating a visualization component according to any one of claims 1 to 10, the method further comprising: The first visualization component is displayed, and the first visualization component is displayed as a dashboard component.

12. An apparatus for generating a visualization component, comprising: A receiving module is configured to receive a first request, wherein the first request is used to instruct the generation of a visualization component or to instruct the editing of a visualization component; The identification module is used to identify the first request and obtain an identification result, wherein the identification result comes from the first intelligent system; The acquisition module is used to send the identification result to the second intelligent system if the identification result includes a first identifier, wherein there is an association between the second intelligent system and the first identifier; A generation module is used to generate a first visualization component, which comes from the second intelligent system.

13. A computer readable medium having stored thereon a computer program, wherein, When executed by a processing device, the computer program implements the method described in any one of claims 1-11.

14. An electronic device comprising: A storage device on which computer programs are stored; A processing apparatus for executing the computer program in the storage device to implement the method according to any one of claims 1-11.

15. A computer program product comprising a computer program, wherein, When executed by a processor, the computer program implements the method described in any one of claims 1-11.

Images