An AI and historical page-based code page generation method and system

Abstract

The application relates to the technical field of data processing, and discloses a code page generation method and system based on AI and historical pages, which comprises the following steps: obtaining historical page configuration data stored in a code platform, analyzing the historical page configuration data based on an AI algorithm, mining business concept entities and business operation operators, identifying logical dependency relationships among various elements based on data processing, and generating a field business concept graph. Through the generated field business concept graph, a change from isolated component features to a semantic business knowledge system is realized, complex business associations among components are accurately captured, data format compatibility and transmission efficiency are ensured through a declarative data flow graph, executable application images are used, and a hot deployment mechanism is used to realize rapid delivery of platform native application packages, so that the generated code user interface has complete business functions and stable running performance.

Description

Technical Field

[0001] This invention relates to the field of data processing technology, specifically to a method and system for generating code pages based on AI and historical pages. Background Technology

[0002] Existing neural network-based code page generation typically uses historical page structured configuration data collected and processed by AI serialization as training samples. After receiving user natural language input, AI parses the basic semantics and outputs the page structure code, which is then rendered into a user interface by a visualization engine.

[0003] However, in scenarios where enterprise users quickly generate business form pages using natural language, this technical solution has a core flaw: when processing the JSON configuration data of historical pages, AI only extracts basic attributes such as component size and position and performs serialization conversion, resulting in the ability to identify isolated features of a single component, failing to capture the business relationships between components, affecting the generation of code pages, and also making it inconvenient to render and generate user interfaces later. Summary of the Invention

[0004] To address the shortcomings of existing technologies, this invention provides a method and system for generating code pages based on AI and historical pages, thus solving the aforementioned problems.

[0005] The above-mentioned technical objective of the present invention is achieved through the following technical solution:

[0006] A code page generation method based on AI and historical pages includes:

[0007] Step S1: Obtain historical page configuration data stored in the code platform, analyze the historical page configuration data based on AI algorithms, and mine business concept entities and business operation operators. At the same time, identify the logical dependencies between various elements based on data processing to generate a domain business concept map.

[0008] Step S2: Obtain the natural language requirements input by the user, perform semantic intent parsing on the natural language requirements based on AI algorithms, and map the data after processing into business concept entities and business operation operators in the domain business concept graph, generate a resource mounting list, and dynamically call atomic business components that match the target business concept and operation from the component library of the code platform according to the resource mounting list, and generate a business component assembly.

[0009] Step S3: Based on each atomic business component in the business component assembly, and combined with the logical dependencies in the domain business concept graph, perform data calculations to generate a declarative data flow graph that can connect all components.

[0010] Step S4: The business component assembly is fused with the declarative data flow diagram to generate a platform native application package that conforms to the target code platform. The platform native application package is then directly loaded into the code platform's runtime environment via a hot deployment interface to generate the code user interface.

[0011] Furthermore, based on AI algorithms, historical page configuration data is analyzed to uncover business concept entities and business operation operators. Simultaneously, based on data processing, logical dependencies between various elements are identified, generating a domain business concept map, including:

[0012] The historical page configuration data is parsed, and the configuration data of different modalities is mapped to a unified semantic vector space based on AI algorithms to generate a set of configuration semantic units;

[0013] Based on the configuration semantic unit set, by analyzing the event flow, API call chain and data binding relationship, the complete business operation sequence and decision path are dynamically traced and extracted to generate a business logic chain graph.

[0014] Based on the business logic chain graph, we mine business concept entities and business operation operators, record the symbiotic strength between them, and generate a concept-operation symbiotic matrix.

[0015] Based on the concept-operation co-occurrence matrix, a graph neural network is used to analyze the logical relationships between business concept entities and business operation operators, generating an implicit dependency network.

[0016] Furthermore, based on AI algorithms, historical page configuration data is analyzed to uncover business concept entities and business operation operators. Simultaneously, based on data processing, logical dependencies between various elements are identified, generating a domain business concept graph. This also includes:

[0017] Based on the concept-operation co-occurrence matrix and implicit dependency network, an emergent concept node set is generated through data clustering and semantic synthesis;

[0018] Data fusion is performed on the concept-operation co-occurrence matrix, implicit dependency network, and emergent concept node set, and the node layout and connection are adjusted to form a structured domain graph;

[0019] The domain graph is optimized and enhanced using AI algorithms to generate a domain business concept graph.

[0020] Furthermore, based on AI algorithms, semantic intent parsing of natural language requirements is performed, and after data processing, it is mapped to business concept entities and business operation operators in the domain business concept graph, generating a resource mounting list, including:

[0021] Based on AI algorithms, a semantic field is constructed and the intent dimension is decomposed for natural language requirements to generate a structured semantic framework;

[0022] The structured semantic framework is projected onto the semantic space of the domain business concept graph to generate a cross-modal semantic projection matrix;

[0023] Based on the cross-modal semantic projection matrix, a graph neural network is used to analyze concept nodes in the domain business concept graph and generate a concept activation field.

[0024] Furthermore, based on AI algorithms, semantic intent parsing of natural language requirements is performed, and after data processing, it is mapped to business concept entities and business operation operators in the domain business concept graph, generating a resource mounting list, which also includes:

[0025] Based on AI algorithms, the concept activation field is derived and combined to optimize the process, generating an operator combination situation diagram.

[0026] Based on the operator combination situation diagram, dynamic data matching of atomic business components is performed through AI algorithms to generate a component gravity relationship network;

[0027] Data analysis of the organization, assembly, and dependencies of component gravity relationship networks is performed to generate a self-organizing resource graph;

[0028] Data processing of resource descriptions and interface contracts is performed based on the self-organizing resource graph to generate a resource mount list.

[0029] Furthermore, based on the resource mount list, atomic business components matching the target business concept and operation are dynamically invoked from the component library of the code platform to generate a business component assembly, including:

[0030] Based on the resource mounting list, the intensity of functional interaction between components is analyzed, and a component affinity matrix is ​​generated.

[0031] Based on the component affinity matrix, the optimal assembly path is analyzed in the component library to generate a component assembly guidance sequence;

[0032] Based on the component assembly guidance sequence, the collaborative location and instantiation of components are analyzed to generate a pre-connected component cluster;

[0033] Integrity verification and interaction interface integration are performed on the pre-connected component cluster to generate a business component assembly.

[0034] Furthermore, based on the atomic business components in the business component assembly, and combined with the logical dependencies in the domain business concept graph, data computation is performed to generate a declarative data flow graph that connects all components, including:

[0035] Based on business component assemblies and domain business concept maps, data contracts are generated between components by analyzing the data formats and interactions between components.

[0036] Based on the data contract between components, a driving force field for data flow is established between components, generating a potential energy field for data flow.

[0037] Furthermore, based on the atomic business components in the business component assembly, and combined with the logical dependencies in the domain business concept graph, data computation is performed to generate a declarative data flow graph that can connect all components, which also includes:

[0038] Based on the potential energy field of the data flow, the data flow path and conversion node are derived to form a data flow routing diagram;

[0039] Analyze the data flow potential field and data flow routing graph to generate a declarative data flow graph.

[0040] Furthermore, the business component assemblies are integrated with the declarative data flow diagram to generate a platform-native application package that conforms to the target code platform's operation. This platform-native application package is then directly loaded into the code platform's runtime environment via a hot deployment interface, generating the code user interface, including:

[0041] Perform multi-dimensional alignment calculations between the component topology of the business component assembly and the data flow direction of the declarative data flow graph to generate a fused topology alignment graph.

[0042] Based on the fusion topology alignment graph, ambiguities and conflicts in data flow between components are identified and eliminated, and dependency consistency constraints are generated.

[0043] Analyze the fusion topology alignment graph and dependency consistency constraints to generate an executable application image that can be directly loaded and run;

[0044] The executable application image is loaded into the runtime environment of the code platform through the hot deployment interface, generating the code user interface.

[0045] Furthermore, a code page generation system based on AI and historical pages includes:

[0046] The logic analysis unit is used to acquire historical page configuration data stored in the code platform, analyze the historical page configuration data based on AI algorithms, mine business concept entities and business operation operators, and identify the logical dependencies between various elements based on data processing to generate a domain business concept map.

[0047] The semantic processing unit is used to obtain the natural language requirements input by the user, perform semantic intent parsing on the natural language requirements based on AI algorithms, and after data processing, map them into business concept entities and business operation operators in the domain business concept graph, generate a resource mounting list, and dynamically call atomic business components that match the target business concept and operation from the component library of the code platform according to the resource mounting list, and generate a business component assembly.

[0048] The data processing unit is used to perform data calculations based on the atomic business components in the business component assembly and the logical dependencies in the domain business concept graph, and generate a declarative data flow graph that can connect all components.

[0049] The page generation unit is used to integrate business component assemblies with declarative data flow diagrams to generate a platform native application package that conforms to the target code platform. The platform native application package is then directly loaded into the code platform's runtime environment via a hot deployment interface to generate the code user interface.

[0050] In summary, the present invention has the following main beneficial effects:

[0051] Through in-depth analysis of historical page configuration data in step S1, a complete domain business concept map was generated, realizing the transformation from raw configuration data to a semantic knowledge system. This solved the problem of isolated component features in existing technologies and can accurately capture complex business relationships between components. In step S2, through in-depth parsing of natural language requirements and resource matching, an accurate resource mounting list and optimized business component assemblies were generated, realizing precise mapping from user needs to specific component resources. This ensured a high degree of fit between component resources and business needs, while multi-dimensional optimization and evaluation ensured the reliability and performance of component combinations. In step S3, a declarative data flow graph was generated based on the business component assemblies and domain knowledge, realizing automatic optimization and visual expression of data flow paths, ensuring data format compatibility and transmission efficiency. In step S4, by integrating the generation of topology alignment graphs, dependency consistency constraints, and executable application images, a platform native application package was constructed. Multi-dimensional alignment calculations eliminated inconsistencies between component topology and data flow, and a hot deployment mechanism enabled rapid delivery, improving the efficiency and quality of page generation and ensuring that the generated code user interface has complete interactive functions and stable running performance. Attached Figure Description

[0052] Figure 1 This is a flowchart of the code page generation method based on AI and historical pages of the present invention;

[0053] Figure 2 This is a schematic diagram of the AI-based code page generation system based on historical pages according to the present invention. Detailed Implementation

[0054] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0055] refer to Figure 1 and Figure 2 A code page generation method based on AI and historical pages, including:

[0056] Step S1: Obtain historical page configuration data stored in the code platform, analyze the historical page configuration data based on AI algorithms, and mine business concept entities and business operation operators. At the same time, identify the logical dependencies between various elements based on data processing to generate a domain business concept map.

[0057] Historical page configuration data includes: component tree, attributes, layout, events, actions, routes, data binding, API configuration, etc.

[0058] Step S2: Obtain the natural language requirements input by the user, perform semantic intent parsing on the natural language requirements based on AI algorithms, and map the data after processing into business concept entities and business operation operators in the domain business concept graph, generate a resource mounting list, and dynamically call atomic business components that match the target business concept and operation from the component library of the code platform according to the resource mounting list, and generate a business component assembly.

[0059] Step S3: Based on each atomic business component in the business component assembly, and combined with the logical dependencies in the domain business concept graph, perform data calculations to generate a declarative data flow graph that can connect all components.

[0060] Step S4: The business component assembly is fused with the declarative data flow diagram to generate a platform native application package that conforms to the target code platform. The platform native application package is then directly loaded into the code platform's runtime environment via a hot deployment interface to generate the code user interface.

[0061] By performing multimodal symbolic feature extraction on historical page configuration data, node types and hierarchical paths are extracted from the component tree as structural fingerprints, key-value pairs are extracted from attributes as attribute feature tuples, and names and parameter sequences are extracted from event and application programming interface configurations as behavioral interaction signatures. Then, through cross-modal semantic alignment, the above symbolic features are semantically matched with business concepts in the pre-built domain knowledge base to form semantic association pairs and construct an initial semantic network.

[0062] By iteratively strengthening connection weights through dependency penetration computation, a highly cohesive and loosely coupled semantic subnet is ultimately delineated as the configuration semantic unit. Then, this solution dynamically traces and extracts complete business operation sequences and decision paths by analyzing event flows, application programming interface call chains, and data binding relationships, generating a business logic chain graph. This allows for the mining of business concept entities and business operation operators, constructing a concept-operation symbiotic matrix that deeply reflects business logic. Finally, implicit dependencies are analyzed using graph neural networks to generate a structurally complete domain business concept graph. Through multi-level, deep semantic parsing methods, complex business logic relationships between components can be accurately captured, forming a complete business semantic network. This improves the fit between the generated page and the real business scenario, while ensuring the integrity and accuracy of the business logic, thus solving the core defects of isolated components and weak business relationships in existing technologies.

[0063] In one embodiment, historical page configuration data is analyzed using AI algorithms to mine business concept entities and business operation operators. Simultaneously, logical dependencies between elements are identified based on data processing to generate a domain business concept graph, including:

[0064] The historical page configuration data is parsed, and AI algorithms are used to map configuration data from different modalities to a unified semantic vector space, generating a configuration semantic unit set. Specifically, this includes: in the data parsing stage, symbolic feature extraction is performed on the historical page configuration data: node types and hierarchical paths are extracted from the component tree as structural fingerprints, key-value pairs are extracted from attributes as attribute feature tuples, and names and parameter sequences are extracted from events and API configurations as behavioral interaction signatures; then cross-modal semantic alignment is performed: based on a pre-built domain knowledge base, the above symbolic features are matched with business concepts for semantic similarity. For example, the user_list component and user query are linked by the relevance of their names in the knowledge base, forming a semantic association pair; all semantic association pairs constitute an initial semantic network; dependency penetration calculation is performed on the initial semantic network, that is, the connection weights are iteratively strengthened according to the direction of data flow between nodes (e.g., the output of one component is the input of another API), and the strengthened semantic network is divided into multiple highly cohesive and loosely coupled semantic subnets. Each semantic subnet is a configuration semantic unit, and the set of all configuration semantic units constitutes the configuration semantic unit set.

[0065] Based on the configuration semantic unit set, by analyzing the event flow, API call chain, and data binding relationship, the system dynamically traces and extracts the complete business operation sequence and decision path, generating a business logic chain graph. Specifically, this includes: using the configuration semantic unit set as input nodes, establishing a logical moment identifier for the state change of each configuration semantic unit in the event flow, API call chain, and data binding relationship; the tracing process starts from the initial logical moment corresponding to any user interaction event, deduces the subsequent API call sequence that the event may trigger, and traces the data binding state changes that it depends on; when a complete causal chain of event-state change-API call-data update is identified, it is encapsulated as a logical step unit; and based on historical configuration data, redundant paths that have not been actually executed are filtered out from all logical step units. Finally, the logical step units are automatically connected according to their timestamps and dependencies to form a complete business logic chain graph containing branch decision nodes.

[0066] Based on the business logic chain graph, business concept entities and business operation operators are mined, and the symbiotic strength between them is recorded to generate a concept-operation symbiotic matrix. Specifically, this involves: automatically identifying noun phrases as business concept entities (e.g., inventory) and verb phrases as business operation operators (e.g., inventory count) from the business logic chain graph through semantic role labeling; then traversing each logical step unit, when a business concept entity and an operation operator appear in the same unit, calculating the proportion of that operation operator in all operation operator sequences related to this business concept entity, multiplying the proportion by the number of times that operation operator appears in other business concept entity sequences to obtain the symbiotic strength; and filling the symbiotic strength of all concept entities and operation operators into a two-dimensional matrix to generate a concept-operation symbiotic matrix that deeply reflects the business logic.

[0067] Based on the concept-operation co-occurrence matrix, a graph neural network is used to analyze the logical relationships between business concept entities and business operation operators, generating an implicit dependency network. Specifically, this includes: converting the concept-operation co-occurrence matrix into a weighted bipartite graph, where business concept entities and business operation operators are two types of nodes, and co-occurrence strength is used as edge weights; and assigning an initial numerical feature vector to each node in the graph.

[0068] For each node, examine all its directly connected neighboring nodes. For each neighboring node, perform a dot product operation (i.e., multiply the corresponding numbers and sum them) on its numerical feature vector and the numerical feature vector of the neighboring node to obtain a score representing the original similarity between the two. Multiply the score by the edge weight to obtain the comprehensive weight. Normalize the comprehensive weight of all neighbors to the 0-1 interval so that the sum of the weights of all neighbors is 1. Multiply the numerical feature vector of all neighbors by the normalized comprehensive weight and sum them to obtain the new feature vector of the node.

[0069] Calculate the cosine similarity between any two new feature vectors of nodes, use the mean cosine similarity of all nodes as a threshold, filter out all node pairs whose cosine similarity exceeds the threshold, and establish a new connection between these two nodes. This connection represents a kind of implicit dependency relationship. All implicit dependencies together constitute an implicit dependency network.

[0070] In one embodiment, the analysis of historical page configuration data based on AI algorithms, the mining of business concept entities and business operation operators, and the identification of logical dependencies between various elements based on data processing to generate a domain business concept graph, further includes:

[0071] Based on the concept-operation co-occurrence matrix and implicit dependency network, an emergent concept node set is generated through data clustering and semantic synthesis. Specifically, it includes: fusing the features of two nodes in the implicit dependency network to generate a unified enhanced feature vector for each node. This vector is composed of the node's own attributes, the strength weight in all co-occurrence relationships, and the implicit dependencies.

[0072] Clustering is performed on all nodes, and clustering must simultaneously meet three conditions: The first condition is: calculate the cosine similarity between all pairs of nodes, and only nodes with similarity higher than the mean similarity of all node pairs will be assigned to a cluster; the second condition is: the mean co-occurrence strength between all pairs of nodes within a cluster must be higher than the top 30% quantile of all co-occurrence strengths in the entire concept-operation co-occurrence matrix; the third condition is: divide the actual number of connections within a cluster by the total number of connections within the group to obtain the density value, and the density value must exceed the global network average connection density + 0.5 times the standard deviation.

[0073] After the above clustering, the names of all nodes in each cluster are extracted, such as inventory, stocktaking, and early warning. The most important keywords are extracted from these names using the TF-IDF algorithm. These keywords are then combined with business syntax to generate a new, higher-level business concept name, such as "intelligent inventory monitoring". By combining all the generated business concept names, the emergent concept node set can be obtained.

[0074] Data fusion is performed on the concept-operation co-occurrence matrix, implicit dependency network, and emergent concept node set, and the node layout and connections are adjusted to form a structured domain graph. Specifically, basic business concept entities and business operation operators are used as leaf nodes, and nodes of the emergent concept node set are used as composite nodes. Edges introduced from the concept-operation co-occurrence matrix are co-occurrence relationships with weights equal to co-occurrence strength; edges introduced from the implicit dependency network are implicit dependencies with weights equal to cosine similarity.

[0075] Different forces are applied to different types of relationships: the edges of the concept-operation co-occurrence matrix generate attraction proportional to the co-occurrence strength; the edges of implicit dependencies generate weaker attraction; hierarchical constraints are established between each composite node and all its subordinate leaf nodes, which force these leaf nodes to be located in a specific annular region centered on the composite node during layout, while maintaining their relative positional relationship with each other. The equilibrium position of all nodes under these mixed forces is calculated through multiple rounds of iteration.

[0076] Multiple edges connecting the same node are merged into a single summary edge. The weights of all edges connecting the same pair of nodes, after being normalized to the 0-1 interval, are summed to obtain a total weight value. The minimum width is set to 1 pixel and the maximum width to 8 pixels. The total weight value is proportionally mapped to this width range according to its position in the linear interval, thus achieving its thickness. Finally, a hierarchical and structured domain business concept graph is generated. The innermost layer of the domain business concept graph is the core layer, which consists of composite nodes; the middle layer is the business layer, which contains leaf nodes directly related to the core concepts; and the outermost layer is the extension layer, which arranges the remaining leaf nodes.

[0077] The domain graph is optimized and enhanced based on AI algorithms to generate a domain business concept graph. Specifically, this includes: finding the paths between all connected nodes in the domain graph, calculating the average weight of all edges on each path, and dividing this average by the number of nodes in the path to obtain the path cohesion score; and removing low-quality connections whose scores are lower than the average cohesion score of all paths in the domain graph.

[0078] For each composite node, the average semantic similarity of all its leaf nodes is calculated. When the average similarity of the leaf nodes is less than 0.8, the leaf nodes are reassigned to other composite nodes. Based on the number of connecting line intersections, the accuracy of the node hierarchy distribution, and the uniformity of the node distribution on the canvas, a domain business concept map with a clear structure and rigorous logic can be presented.

[0079] By extracting symbolic features from historical page configuration data, node types and hierarchical paths are extracted from the component tree as structural fingerprints, key-value pairs are extracted from attributes as attribute feature tuples, and names and parameter sequences are extracted from event and application programming interface (API) configurations as behavioral interaction signatures. Then, cross-modal semantic alignment maps these multimodal features to a unified semantic space, forming an initial semantic network. Subsequently, dependency permeation calculation iteratively strengthens the connection weights between nodes, ultimately generating a highly cohesive and loosely coupled set of configuration semantic units. Based on this, further analysis of event flows, API call chains, and data binding relationships constructs a complete semantic network. The business logic chain graph of the causal chain, based on semantic role labeling, mines business concept entities and business operation operators to generate a concept-operation co-occurrence matrix that deeply reflects the business logic; it uses graph neural networks to analyze implicit logical associations and constructs an implicit dependency network; finally, through rigorous multi-condition clustering and semantic synthesis, it generates an emergent concept node set and integrates various relation edges to construct a hierarchical domain business concept graph. This not only accurately captures the complex business logic associations between components but also mines potential semantic dependencies, forming a complete business concept system. This improves the fit between the generated page and the real business scenario while ensuring the integrity and accuracy of the business logic.

[0080] In one embodiment, the semantic intent of natural language requirements is parsed based on AI algorithms, and after data processing, it is mapped to business concept entities and business operation operators in a domain business concept graph, generating a resource mounting list, including:

[0081] Based on AI algorithms, semantic fields are constructed and intent dimensions are decomposed for natural language requirements to generate a structured semantic framework. Specifically, this includes: using semantic role labeling technology to analyze the input requirement text, identifying the core actions in the sentence (such as querying, statistics, etc.) and the subjects, objects, time, and places related to the actions, forming a preliminary semantic relationship network; and using a multi-head self-attention mechanism to deeply analyze the semantic associations between words: after converting each word into a numerical vector, the dot product score of each word's numerical vector and the numerical vectors of all other words is calculated. These scores are converted into weights between 0 and 1 using a softmax function. Based on the weights, all words are weighted and combined to generate enhanced semantics containing contextual information.

[0082] The syntactic tree structure is constructed by analyzing the grammatical relationships between words in a sentence, such as subject-verb-object. Specifically, this involves analyzing the modification relationships and grammatical roles between words in a sentence, establishing grammatical connections such as subject-verb relationships (e.g., system-query), verb-object relationships (e.g., query-order), and modifier-head relationships (e.g., recent-order). The agent, patient, etc., identified by semantic role annotations are aligned and verified based on their position and grammatical function in the syntactic tree. For example, the agent role is mapped to the subject node in the syntactic tree, the patient role is mapped to the object node, and the spatiotemporal condition is mapped to the corresponding adverbial node, thus obtaining the syntactic tree structure.

[0083] The verbs, nouns, and other elements obtained after the above processing are matched with nodes in the domain business concept graph: their cosine similarity in the vector space is calculated, the business concept entity and operation operator with the highest cosine similarity are selected, and the output is a structured semantic framework consisting of three dimensions: operation action, target object, and execution condition.

[0084] Projecting the structured semantic framework onto the semantic space of the domain business concept graph generates a cross-modal semantic projection matrix. Specifically, this involves performing multi-head attention calculations on the semantic vectors of the three dimensions of the structured semantic framework (operation action, target object, and execution condition) and the semantic vectors of all nodes in the domain business concept graph. Using the semantic vectors of the structured semantic framework as query vectors and the node vectors of the domain business concept graph as key and value vectors, attention scores are calculated through dot product operations. Then, the attention scores are normalized using the softmax function to obtain the attention weight corresponding to each node in the domain business concept graph.

[0085] Based on attention weights, the node vectors in the domain business concept graph are weighted and summed to generate projection vectors of the frame elements in the domain semantic space. The residual value between each projection vector and the original frame semantic vector is calculated, and all residual values ​​are combined into a residual vector. The residual vector is concatenated with the projection vector to form enhanced cross-modal semantics. The cross-modal semantics of all frame elements are expanded by dimension to construct a two-dimensional matrix in which rows represent frame elements and columns represent semantic features, i.e., the cross-modal semantic projection matrix.

[0086] Based on the cross-modal semantic projection matrix, a graph neural network is used to analyze concept nodes in the domain business concept graph and generate concept activation fields. Specifically, each semantic feature dimension of the cross-modal semantic projection matrix is ​​regarded as an independent energy source, and its energy influence value on each node in the domain business concept graph is calculated. Specifically, for all the values ​​in a row of the projection matrix, matrix multiplication is performed with the corresponding row values ​​of the node features in the domain business concept graph to obtain the energy value of each node in that semantic dimension.

[0087] Each node distributes its energy value to its neighboring nodes according to the connection strength ratio, while also receiving energy from its neighboring nodes. This diffusion process is repeated several times until the energy distribution across the entire network is uniform.

[0088] Then, the energy values ​​of each node under all semantic dimensions are weighted and summed. The weight is the magnitude of the column vector corresponding to that semantic dimension in the cross-modal semantic projection matrix. The magnitude is the square root of the sum of the squares of all values ​​in that column.

[0089] In the business concept map of the computing domain, the average value and standard deviation of the node energy values ​​are used to mark nodes with energy values ​​higher than the average value + 0.5 times the standard deviation as active. These active nodes and their connections together constitute the concept activation field.

[0090] In one embodiment, the semantic intent of natural language requirements is parsed based on AI algorithms, and after data processing, it is mapped to business concept entities and business operation operators in a domain business concept graph to generate a resource mounting list. The method also includes:

[0091] Based on AI algorithms, the concept activation field is deduced and optimized to generate an operator combination situation map. Specifically, in the concept activation field, starting from each activation node, a depth-first search is performed along its connecting edges to find all operator execution paths; for each path, its path weight is calculated, which is obtained by multiplying the connection strength of each edge on the path by the energy value of the corresponding node and then summing them up.

[0092] Extract key performance metrics from historical page configuration data: Divide the number of successful calls for each API interface in the API call chain by the total number of calls to obtain the historical execution success rate; calculate the average time spent on the same API interface in historical calls to obtain the estimated response time;

[0093] For each operation path derived from the concept activation field, its three indicators—path weight, historical execution success rate, and estimated response time—are normalized to the range of 0 to 1, and a dynamic weight is assigned to each indicator, with the path weight having a weight of 0.5, the historical execution success rate having a weight of 0.3, and the estimated response time having a weight of 0.2. The three normalized indicators are then summed according to their weights to obtain the comprehensive quality score of the path.

[0094] Among them, path weight represents the degree of matching between the operation path and the structured semantic framework parsed from the user's natural language requirements. The primary goal of this solution is to accurately implement the business functions described by the user, that is, a page that highly matches the user's intent. Even if a certain API call is slightly slower or the historical success rate is not 100%, its business value is far higher than a fast but functionally incorrect page. Therefore, it is given a high weight of 0.5 to ensure the correctness of the generated solution in terms of business logic and the degree of intent matching. The historical execution success rate is used to reflect the reliability of related business operations in past practice. Because this solution will prioritize those APIs and operation links that have been verified historically and are stable and reliable to assemble pages, thereby reducing the operational risk of newly generated pages and improving the quality of the final application, it is given a weight of 0.3. The estimated response time represents the delay that the user operation may face. After ensuring the correctness and stability of the function, the user experience becomes an important optimization goal. The response time directly affects the user's experience, so it is given a weight of 0.2.

[0095] Then calculate the mean of the overall quality scores of all paths to obtain the mean score. Keep the paths with an overall quality score higher than the mean score. If the node sequence of path B completely contains the node sequence of path A, it is considered redundant and the path with the lowest overall quality score is removed.

[0096] The optimized path and its overall quality score, along with the activation status of each node, are integrated to construct a directed weighted graph, namely the operator combination situation graph.

[0097] Based on the operator combination situation diagram, dynamic data matching of atomic business components is performed using AI algorithms to generate a component gravity relationship network. Specifically, this includes: mapping each operation operator in the operator combination situation diagram to the corresponding atomic business component in the component library; comparing the output data type of the preceding component with the input data type of the following component in the atomic business component. For example, if the preceding component outputs a user list and the following component requires a user identifier, then check whether the data structure of the user list contains a user identifier field, and divide the number of matching fields by the total number of fields to obtain the data flow matching degree; then traversing the historical page configuration data to count the number of times the two components co-occur in the same event-action chain, and dividing this number of co-occurrences by the maximum number of times either component appears to obtain the state dependency strength; in the operator combination situation diagram, finding the path connecting the corresponding operation operators of the two components, and using the comprehensive quality score of the path as the situation diagram transfer weight connecting the two components;

[0098] Normalize the data flow matching degree, state dependency strength, and situation map propagation weight to the 0-1 range. Then multiply the normalized data flow matching degree, state dependency strength, and situation map propagation weight to obtain the gravity value between the two components. Calculate the mean of all gravity values. Retain the connections of all components with gravity values ​​higher than the mean. The resulting network is the component gravity relationship network.

[0099] Data analysis of the organization, assembly, and dependencies of the component gravitational relationship network is performed to generate a self-organizing resource graph. Specifically, this includes: dividing the components in the gravitational relationship network into multiple highly cohesive component groups; subtracting the sum of the gravitational values ​​within the group under random connection conditions from the sum of the gravitational values ​​within the component group to obtain the modularity value; and continuously adjusting the grouping of the components through iterative calculation until the modularity value reaches its maximum, at which point the component grouping is optimal.

[0100] The gravitational values ​​of all edges connecting different component groups are added together to obtain the total cross-group gravitational force. Then, the gravitational values ​​of all edges in the component gravitational relationship network are added together to obtain the total gravitational force of the entire network. The cross-group gravitational force sum is divided by the total gravitational force of the entire network to obtain the interface coupling degree.

[0101] Component groups with an interface coupling degree > 0.6 are identified as the core group and placed at the bottom layer; component groups with an interface coupling degree between 0.3 and 0.6 are identified as the support group and placed in the middle layer; component groups with an interface coupling degree < 0.3 are identified as the extension group and placed at the top layer.

[0102] Within each component group, components are arranged into an assembly sequence according to the flow of data, forming a self-organizing resource graph with a clear hierarchical structure and assembly relationships.

[0103] Data processing based on self-organizing resource graphs for resource descriptions and interface contracts generates a resource mounting list. Specifically, this includes traversing all cross-component group connections in the self-organizing resource graph, identifying component output ports (data suppliers) and component input ports (data consumers), forming a complete interface dependency graph, and generating interface specifications based on this graph.

[0104] Data format specifications: Extract the complete data structure definition of the data supplier's output port, including field names, data types, and nested structures;

[0105] Call protocol specification: Analyze the calling methods of similar interfaces in historical configuration data to determine whether to use a protocol such as RESTful, GraphQL or RPC;

[0106] Transmission constraint specifications: Statistical analysis of historical load data from interface calls to determine the data volume threshold and concurrent processing capacity for a single transmission;

[0107] Divide the number of versions in which the interface has been called in the last 10 versions by the total number of versions that have been called to obtain the version stability coefficient. Obtain the frequency of changes to the interface parameter structure in history and use it as the structure stability coefficient. Multiply the version stability coefficient by the structure stability coefficient to obtain the stability value.

[0108] Following the hierarchical order of core group, support group, and extension group, an interface list containing component identifier, version number, resource path, dependency relationship, and corresponding stability value is generated for each component. All these descriptive items are then combined in an orderly manner to form a resource mounting list.

[0109] A structured semantic framework is constructed by semantic role labeling and multi-head self-attention mechanism. User needs are parsed into three dimensions: operation actions, target objects, and execution conditions. Then, the parsing results are mapped to the domain business concept map through a cross-modal semantic projection matrix, generating a concept activation field. Based on multi-dimensional indicators such as path weight, historical execution success rate, and estimated response time, operator combination optimization is performed to generate an optimal operator combination situation diagram. In the component matching stage, a component gravity relationship network is constructed by calculating data flow matching degree, state dependency strength, and situation diagram transmission weight. Based on interface coupling degree, the component group is divided into core group, support group, and extension group, forming a hierarchical self-organizing resource graph. Finally, through complete interface specification description and stability evaluation, a resource mounting list containing data format specifications, calling protocol specifications, and transmission constraint specifications is generated. This end-to-end semantic parsing and resource matching mechanism ensures a high degree of fit between the generated page and the user's intent.

[0110] In one embodiment, based on the resource mount list, atomic business components matching the target business concept and operation are dynamically invoked from the component library of the code platform to generate a business component assembly, including:

[0111] Based on the resource mount list, the functional interaction strength between components is analyzed to generate a component affinity matrix. Specifically, this includes: extracting the interface dependency relationships of each component in the resource mount list and establishing a component interaction network; dividing the number of times that connected components in the component interaction network are called simultaneously in historical business processes by the total number of calls to obtain the functional call frequency.

[0112] Divide the number of matching fields of connected components in the component interaction network by the total number of fields to obtain the data compatibility value; analyze the collaborative coverage of components in the business scenario in the component interaction network, calculate the proportion of the number of business functions they jointly implement to the total number of functions in the scenario, and obtain the functional complementarity value.

[0113] After normalizing the function call frequency, data compatibility value, and function complementarity value to the 0-1 range, they are weighted and summed according to weights of 0.4, 0.35, and 0.25 to obtain the functional interaction strength value between components. The interaction strength values ​​of all components are filled into a two-dimensional matrix to generate the component affinity matrix.

[0114] Among them, the function call frequency represents the actual co-occurrence record of the component in the deployed pages in the historical page configuration data, which represents the objective collaboration stability. This solution needs to ensure that the assembled page is stable and reliable at runtime. The combination method of the two components that frequently work together in a large number of historical pages has been fully verified, and the risk of compatibility issues is the lowest. Therefore, it is given a high weight of 0.4. The data compatibility value mainly represents the degree of structural matching of data transmission between components. Data compatibility directly determines whether the functional link can be opened up. Therefore, it is given a weight of 0.35. The functional complementarity value is used to evaluate the collaborative coverage capability of the components at the business level. Therefore, it is given a weight of 0.25.

[0115] Based on the component affinity matrix, the optimal assembly path is analyzed in the component library to generate a component assembly guidance sequence. Specifically, this includes: constructing a directed graph of components based on the interface dependencies in the resource mount list, where nodes represent atomic business components and edges represent data flow directions; converting the functional interaction strength values ​​in the component affinity matrix into edge weights; using Dijkstra's algorithm to find the optimal path: starting from the starting component (e.g., the data source component) determined by the business logic and ending at the ending component (e.g., the data output component), calculating the sum of the weights of all paths, prioritizing the traversal of edges with lower weight values, and gradually constructing the shortest path from the starting point to the ending point; for the component nodes in the shortest path, arranging them in traversal order to generate a component assembly guidance sequence.

[0116] Based on the component assembly guide sequence, the collaborative positioning and instantiation of components are analyzed to generate a pre-connected component cluster. Specifically, this includes: counting the number of times two components transmit data in the historical page from the historical page configuration data to obtain the data flow transmission frequency; calculating the average time of historical call records to obtain the interface response time; and multiplying the interface response time by the data flow transmission frequency to obtain the collaborative positioning weight value of each component pair.

[0117] Each component is treated as a physical particle, and two forces are set: attractive forces are generated between components with data dependencies, and the magnitude of the force is equal to the co-location weight value divided by the distance between the components; repulsive forces are generated between components with similar functions, and the magnitude of the force is 0.5 multiplied by the functional overlap, where the functional overlap is the ratio of the number of intersections to the number of unions of the functional label sets of two components.

[0118] By iteratively calculating the resultant force (attractive and repulsive forces) on each component, the positions of the components are continuously adjusted until the positions of all components tend to be stable. In each iteration, the resultant force value of all forces on each component is calculated, which is the sum of attractive and repulsive forces. The resultant force value is used as the movement distance, and the components are moved according to the movement distance. When the average movement distance of all components in three consecutive iterations is less than 0.1 pixels, or the sum of the squares of the movement distances of each component drops to less than 1% of the total displacement trend, the layout of the components is considered stable. The total displacement trend is the sum of the movement distances of all components in the first iteration.

[0119] Based on stable layout components, pre-built data channels are established for components with collaborative positioning weight values ​​higher than 0.7 to form a pre-connected component cluster.

[0120] The integrity verification and interaction interface integration of the pre-connected component cluster are performed to generate a business component assembly. Specifically, this includes: constructing a complete data flow graph based on the component assembly guidance sequence and the data channels already established in the pre-connected component cluster; verifying the existence of a reachable path from the starting component to the ending component by traversing the data flow graph; and establishing missing data connections for data endpoints that cannot be connected based on the functional interaction strength value of the corresponding component in the component affinity matrix, with higher functional interaction strength values ​​being prioritized for connection establishment.

[0121] For each data connection, examine the data structures of the ending and starting components, divide the number of identical fields by the total number of fields to obtain the data format matching degree; find its interface specifications in the resource mount list, including the three specifications of data format, calling protocol and transmission constraints. If they are consistent, the calling protocol compatibility value is 1, and if they are inconsistent, the calling protocol compatibility value is 0; divide the amount of data transmitted in a single transaction by the total amount of data transmitted to obtain the transmission constraint satisfaction degree.

[0122] The data format matching degree, calling protocol compatibility value and transmission constraint satisfaction degree are added together and normalized to the 0-1 range to obtain the interface matching degree. When the interface matching degree is lower than 0.8, a data conversion adapter is generated and inserted based on the successful mapping cases of similar interfaces in the historical page configuration data.

[0123] Verify that each user interaction event has a complete event-action-response chain, ensuring that all events can trigger the corresponding business operations, thereby generating a business component assembly.

[0124] By constructing a component affinity matrix, the strength of functional interactions between components is understood. Then, Dijkstra's algorithm is used to find the optimal assembly path in the directed component graph, generating a component assembly guidance sequence for further optimization of component layout. Based on the co-location weight value, attraction and repulsion are calculated, and stable component positioning is achieved through multiple iterations. Data channels are pre-built to form a pre-connected component cluster. Then, through integrity verification and interface fusion, data flow connectivity is verified and interface matching degree is calculated. When the interface matching degree is lower than 0.8, a data conversion adapter is automatically inserted to ensure that all user interaction events have a complete event-action-response chain. The process optimization from component interaction analysis to assembly improves the stability and reliability of business component assemblies, ensuring the integrity of business logic and runtime performance of generated pages.

[0125] In one embodiment, based on the atomic business components in the business component assembly, and combined with the logical dependencies in the domain business concept graph, data calculation is performed to generate a declarative data flow graph that can connect all components, including:

[0126] Based on business component assemblies and domain business concept graphs, data contracts are generated by analyzing the data formats and interactions between components. Specifically, this includes: extracting the interface specifications of each component in the resource mount list, including three specifications: data structure, calling protocol, and transmission constraints; verifying the data compatibility of each component connection based on the interface matching degree in the business component assembly; and establishing data mapping relationships for component pairs with data interactions based on the logical dependencies in the domain business concept graph: matching the data structure fields of the output component with the requirement fields of the input component one by one to generate a field mapping table.

[0127] By combining interface matching degree and field mapping table, a data contract between components is generated for each component pair, which includes data format and transmission rules.

[0128] Based on the data contract between components, a driving force field for data flow is established between components to generate a data flow potential energy field. Specifically, this includes: calculating the basic potential energy value for each component in the data contract between components; normalizing the average response time of the component in historical configurations to the 0-1 range to obtain the processing efficiency coefficient; using the ratio of the number of input fields to the number of output fields of the component as the data throughput coefficient; and weighting and summing these two coefficients with weights of 0.6 and 0.4 to obtain the basic potential energy value.

[0129] Calculate the potential energy difference between components in the data contract between components: For each pair of components with a data contract, multiply the interface matching degree by the completeness of the field mapping table (the proportion of mapped fields to the total number of fields), and then multiply by the basic potential energy value to obtain the potential energy difference; construct a directed weighted network of all components and their potential energy differences, which is the data flow potential energy field.

[0130] In one embodiment, based on the atomic business components in the business component assembly, and combined with the logical dependencies in the domain business concept graph, data calculation is performed to generate a declarative data flow graph that can connect all components, and the method further includes:

[0131] Based on the data flow potential energy field, the data flow path and transformation node are derived to form a data flow routing map. Specifically, it includes: starting from the data source component, the gradient descent algorithm is used to explore the data flow path in the data flow potential energy field: starting from the current component, the component with the lowest basic potential energy value among all its adjacent components is selected as the next node of the data flow, and the process is carried out step by step until the data output component is reached, thereby determining a complete data flow path.

[0132] For each data flow path, the sum of the potential energy differences between each pair of adjacent components on the path is divided by the total number of nodes on the path to obtain the path credibility score. The path credibility score reflects the average driving force intensity of data flow on the path.

[0133] When the interface matching degree between adjacent components on the path is less than 0.8, a data conversion node is inserted at the connection point to integrate all verified data flow paths with the data conversion node and build a complete data flow routing graph.

[0134] Analyze the data flow potential field and data flow routing graph to generate a declarative data flow graph. Specifically, this involves: using a path optimization algorithm to filter all paths in the data flow routing graph, retaining high-quality paths with a confidence score higher than the average confidence score of all paths; labeling each retained path with a data flow direction arrow based on the potential energy difference in the data flow potential field, with the arrow always pointing from a component with high potential energy to a component with low potential energy; finally, integrating all paths, direction arrows, and transformation nodes according to the business execution order, and using YAML format for structured description to generate a declarative data flow graph containing complete data flow direction, transformation relationships, and execution logic.

[0135] By generating a basic potential energy value, and combining it with the interface matching degree and the completeness of the field mapping table, the potential energy difference between components is calculated, and a data flow potential energy field is constructed. Then, the gradient descent algorithm is used to derive the optimal data flow path, calculate the path credibility score, and automatically insert data transformation nodes when the interface matching degree is lower than 0.8, forming a complete data flow routing diagram. Then, high-quality paths are selected, and the data flow direction is marked based on the potential energy difference. All paths, direction arrows, and transformation nodes are integrated according to the business execution order, and a structured declarative data flow diagram is generated using YAML format. This not only ensures the compatibility of data formats and transmission efficiency, but also enhances the maintainability of the system by visualizing the data flow and improves the automation of data processing during page generation.

[0136] In one embodiment, the business component assembly is fused with a declarative data flow graph to generate a platform-native application package that conforms to the target code platform. This platform-native application package is then directly loaded into the code platform's runtime environment via a hot deployment interface to generate a code user interface, including:

[0137] The component topology of the business component assembly is aligned with the data flow of the declarative data flow graph in a multidimensional alignment calculation to generate a fused topology alignment graph. Specifically, this includes: for each component's functional semantic vector (such as component type and interface description) in the topology of the business component assembly and its data role vector (such as data source component) in the data flow graph, the cosine similarity algorithm is used to calculate the similarity between the two vectors, and nodes with similarity higher than the average of all similarity are considered to be aligned.

[0138] For the connecting edges in the topology and the data flow edges in the data flow graph, compare whether the directions of the edges are consistent, and use the Pearson correlation coefficient algorithm to calculate the correlation of the edge weights. Edges with a correlation higher than the average of all correlations are considered to be aligned.

[0139] The alignment nodes are merged into one node while retaining all attributes. The alignment edges are merged into one edge. For nodes and edges that fail the alignment check, they are introduced as independent elements into the fused topology alignment graph to generate the fused topology alignment graph.

[0140] Based on the fused topology alignment graph, ambiguities and conflicts in data flow between components are identified and eliminated, and dependency consistency constraints are generated. Specifically, for each component pair, the data format matching degree is calculated: the number of identical fields in the data structures of the output component and the input component is divided by the total number of fields, which is the data format matching degree. If the matching degree is less than 0.8, it is marked as a data format conflict. A topology sorting algorithm is used to detect cyclic dependencies in the data flow. If a cyclic path is found, it is marked as a flow conflict.

[0141] For data format conflicts, a data conversion adapter is automatically inserted based on historical configuration data; for flow conflicts, the loop is broken by adjusting the execution order of components; based on the adjusted data, a set of dependency consistency constraints is generated, including data format alignment requirements, flow acyclicity, and interface call order constraints, to ensure the consistency of data flow and the correctness of business logic.

[0142] The process involves analyzing the fused topology alignment graph and dependency consistency constraints to generate an executable application image that can be directly loaded and run. Specifically, this includes: processing the fused topology alignment graph using a topology sorting algorithm to generate a linear component execution sequence based on the data dependencies between nodes, thereby ensuring that the order satisfies the acyclic requirement in the dependency consistency constraints; and using a template rendering algorithm to instantiate each component into target platform code based on the component execution sequence and declarative data flow graph: extracting the component's attributes, event bindings, and data flow mapping relationships, filling them into a preset platform component template, and generating the corresponding source code snippets.

[0143] By analyzing historical page configuration data, we can statistically analyze the average memory consumption and API call frequency of similar components to optimize runtime resource allocation. We can then use platform-specific build tools (such as Webpack or Docker) to package all generated source code files, optimized resource configuration files, and necessary third-party dependency libraries into a standardized application package that can be directly loaded and executed by the target platform, which is the executable application image.

[0144] The executable application image is loaded into the runtime environment of the code platform via a hot deployment interface, generating a code-based user interface. Specifically, this involves: verifying the integrity of the executable application image using an incremental verification algorithm; calculating the digital fingerprint of the image file (a unique string obtained by performing a specific hash operation on the file content); comparing the fingerprint with a pre-stored baseline value on the server to ensure error-free transmission; and injecting components from the image into the platform runtime via a dynamic loader: instantiating component objects one by one according to the component execution sequence within the image, while binding data streams to the corresponding component input / output ports based on dependency consistency constraints; then calling the platform's UI rendering engine to traverse the instantiated component tree structure, converting each virtual DOM node into a real DOM element, and mounting it into a specified container to generate a complete, interactive user interface based on the code.

[0145] By integrating the topology alignment graph, the component topology and data flow are aligned in multiple dimensions to ensure consistency between structure and data flow. Then, data format conflicts and flow conflicts are eliminated through dependency consistency constraints, establishing a complete data flow guarantee mechanism. Based on topology sorting and template rendering, optimized component execution sequences and source code are generated. Combined with historical resource configuration data, optimal allocation of runtime resources is achieved. Finally, the integrity verification and dynamic loading of the executable application image are realized through the hot deployment interface. The platform's UI rendering engine is used to transform virtual DOM nodes into real user interfaces. Through end-to-end automated processing mechanisms, the structural integrity, data consistency, and operational stability of the generated pages are ensured, improving the efficiency and quality of code page generation.

[0146] In one embodiment, an AI-based code page generation system, applied to the aforementioned AI-based code page generation method, includes:

[0147] The logic analysis unit is used to acquire historical page configuration data stored in the code platform, analyze the historical page configuration data based on AI algorithms, mine business concept entities and business operation operators, and identify the logical dependencies between various elements based on data processing to generate a domain business concept map.

[0148] The semantic processing unit is used to obtain the natural language requirements input by the user, perform semantic intent parsing on the natural language requirements based on AI algorithms, and after data processing, map them into business concept entities and business operation operators in the domain business concept graph, generate a resource mounting list, and dynamically call atomic business components that match the target business concept and operation from the component library of the code platform according to the resource mounting list, and generate a business component assembly.

[0149] The data processing unit is used to perform data calculations based on the atomic business components in the business component assembly and the logical dependencies in the domain business concept graph, and generate a declarative data flow graph that can connect all components.

[0150] The page generation unit is used to integrate business component assemblies with declarative data flow diagrams to generate a platform native application package that conforms to the target code platform. The platform native application package is then directly loaded into the code platform's runtime environment via a hot deployment interface to generate the code user interface.

[0151] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. An AI and history page-based code page generation method, characterized by, Comprise: Step S1, obtain the historical page configuration data stored in the code platform, analyze the historical page configuration data based on AI algorithm, and mine business concept entities and business operation operators, and identify the logical dependency relationship between each element based on data processing, generate a domain business concept graph; Step S2, obtain the natural language requirement input by the user, perform semantic intent analysis on the natural language requirement based on AI algorithm, and map the business concept entities and business operation operators in the domain business concept graph after data processing, generate a resource mounting list, including: Based on AI algorithm, the semantic field of natural language requirement is constructed and intent dimension is decomposed, and a structured semantic framework is generated; Project the structured semantic framework to the semantic space of the domain business concept graph to generate a cross-modal semantic projection matrix; Based on the cross-modal semantic projection matrix, analyze the concept nodes in the domain business concept graph through the graph neural network to generate a concept activation field; Based on AI algorithm, the concept activation field is deduced and combined to generate an operator combination situation map; Based on the operator combination situation map, the dynamic data matching of atomic business components is performed through AI algorithm to generate a component gravitational relationship network; Organize and assemble the component gravitational relationship network and analyze the data dependency relationship to generate a self-organizing resource graph; Based on the self-organizing resource graph, the resource description and interface contract data processing are performed to generate a resource mounting list; According to the resource mounting list, dynamically call the atomic business components matched with the target business concept and operation from the component library of the code platform to generate a business component assembly body, including: Based on the resource mounting list, analyze the functional interaction intensity between components to generate a component affinity matrix; According to the component affinity matrix, analyze the optimal assembly path in the component library to generate a component assembly guide sequence; Based on the component assembly guide sequence, analyze the cooperative positioning and instantiation of components to generate a pre-connected component cluster; Perform integrity verification and interactive interface fusion on the pre-connected component cluster to generate a business component assembly body; Step S3, based on each atomic business component in the business component assembly body, combined with the logical dependency relationship in the domain business concept graph, data calculation is performed to generate a declarative data flow graph that can connect all components; Step S4, fuse the business component assembly body and the declarative data flow graph to generate a platform native application package that meets the target code platform running, load the platform native application package to the running environment of the code platform through the hot deployment interface, and generate a code user interface. 2.The AI-based code page generation method with a history page according to claim 1, wherein, Based on AI algorithm, analyze the historical page configuration data, and mine business concept entities and business operation operators, and identify the logical dependency relationship between each element based on data processing, generate a domain business concept graph, including: Data analysis is performed on the historical page configuration data, and different modal configuration data is mapped to a unified semantic vector space based on AI algorithm to generate a configuration semantic unit set; Based on the configuration semantic unit set, by analyzing the event stream, API call chain and data binding relationship, the complete business operation sequence and decision path are dynamically traced and extracted, and a business logic chain graph is generated. Based on the business logic chain atlas, business concept entities and business operation operators are mined, and the symbiotic strength between them is recorded to generate a concept-operation symbiosis matrix; Based on the concept-operation symbiosis matrix, the logical association between business concept entities and business operation operators is analyzed by graph neural network to generate an implicit dependency relationship network. 3.The AI-based code page generation method with a history page according to claim 2, wherein, Based on AI algorithms, historical page configuration data is analyzed, and business concept entities and business operation operators are mined. At the same time, based on data processing, the logical dependency relationship between elements is identified to generate a domain business concept atlas, which also includes: Based on the concept-operation symbiosis matrix and the implicit dependency relationship network, through data clustering and semantic synthesis, an emerging concept node set is generated; Data fusion is performed on the concept-operation symbiosis matrix, the implicit dependency relationship network, and the emerging concept node set, and the node layout and connection are adjusted to form a structured domain atlas; Based on AI algorithms, the domain atlas is optimized and strengthened to generate a domain business concept atlas. 4.The AI-based code page generation method with a history page according to claim 1, wherein, Based on the atomic business components in the business component assembly and the logical dependency relationship in the domain business concept atlas, a declarative data flow graph that can connect all components is generated, including: Based on the business component assembly and the domain business concept atlas, the data format and interaction between components are analyzed through data contract to generate the data contract between components; Based on the data contract between components, a driving force field for data flow between components is established to generate a data flow potential field. 5.The AI-based code page generation method with a history page according to claim 4, wherein, Based on the atomic business components in the business component assembly and the logical dependency relationship in the domain business concept atlas, a declarative data flow graph that can connect all components is generated, which also includes: Based on the data flow potential field, the data flow path and conversion nodes are derived to form a data flow routing graph; Analyze the data flow potential field and the data flow routing graph to generate a declarative data flow graph. 6.The AI-based code page generation method with a history page according to claim 5, wherein, Fuse the business component assembly and the declarative data flow graph to generate a platform native application package that meets the target code platform running requirements. Through the hot deployment interface, the platform native application package is directly loaded into the running environment of the code platform to generate a code user interface, including: Perform multi-dimensional alignment calculation on the component topology structure of the business component assembly and the data flow direction of the declarative data flow graph to generate a fusion topology alignment graph; Based on the fusion topology alignment graph, identify and eliminate the ambiguity and conflict of data flow between components to generate dependency consistency constraints; Analyze the fusion topology alignment graph and the dependency consistency constraints to generate an executable application image that can be directly loaded and run; Through the hot deployment interface, the executable application image is loaded into the running environment of the code platform to generate a code user interface.

7. An AI and historical page-based code page generation system applied to the AI and historical page-based code page generation method of any one of claims 1-6, characterized in that, It includes: A logic analysis unit is used to obtain historical page configuration data stored in a code platform, analyze the historical page configuration data based on AI algorithms, and mine business concept entities and business operation operators. At the same time, based on data processing, the logical dependency relationship between elements is identified to generate a domain business concept atlas; The semantic processing unit is configured to acquire a natural language requirement input by a user, perform semantic intention analysis on the natural language requirement based on an AI algorithm, map business concept entities and business operation operators in a domain business concept graph to resource mounting lists after data processing, dynamically call atomic business components matching target business concepts and operations from a component library of a code platform according to the resource mounting lists, and generate a business component assembly; The data processing unit is configured to perform data calculation based on each atomic business component in the business component assembly and in combination with a logical dependency relationship in the domain business concept graph, and generate a declarative data flow graph connectable to all components; The page generation unit is configured to perform fusion processing on the business component assembly and the declarative data flow graph, generate a platform native application package conforming to the operation of a target code platform, directly load the platform native application package to a running environment of the code platform through a hot deployment interface, and generate a code user interface.

Images