Component recommendation method and device, computer equipment and storage medium

Abstract

The invention relates to a component recommendation method and device, computer equipment and a storage medium, and the method comprises the steps: obtaining a behavior sequence of a user in an operation platform, and extracting a corresponding operation intention mode from the behavior sequence; performing similarity analysis on the operation intention mode and historical interaction data based on a comparison algorithm, and determining a component demand category corresponding to the operation intention mode; if the component demand category and the layout demand information of the current operation interface meet the matching condition, screening component options corresponding to the component demand category from a component library, and generating a component recommendation list based on the component options; acquiring change data of the behavior sequence; adjusting the component recommendation list based on the change data to obtain a target component list; based on the target component list and the current operation context, determining a component combination meeting the requirement; and generating a component recommendation result based on the component combination, and outputting the component recommendation result. According to the invention, the intelligence and accuracy of component recommendation can be improved.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to component recommendation methods, apparatus, computer devices, and storage media. Background Technology

[0002] In the wave of digital transformation, front-end interface development, as a crucial bridge connecting users and technology, directly impacts the user experience and development cycle of software products. Especially in low-code or no-code development platforms, enabling developers to quickly build interfaces that meet their needs has become a key area for improving productivity. The importance of this area is self-evident; it not only concerns the ease of technical implementation but also the participation of non-professional developers and the speed of innovation for enterprises.

[0003] However, existing front-end development assistance tools have significant shortcomings. Most tools only provide static component libraries or fixed templates, lacking the ability to dynamically respond to developers' real-time operations. They struggle to meet personalized needs during the design process and cannot provide effective assistance for specific scenarios, thus limiting development efficiency. For complex interface designs, developers must spend a significant amount of time manually searching and trying various component combinations. More importantly, existing technologies struggle to accurately understand developers' operational intentions and cannot provide logically sound component recommendations. The unified static component library provided by the system results in insufficient intelligence and accuracy in component recommendations, often leading to irrelevant or useless component recommendations, impacting the development experience. Users are forced to manually search for the required components in the static component library.

[0004] In summary, dynamically recommending the most suitable components during the development process has become a key issue that urgently needs to be addressed to improve interface design efficiency and user experience. Summary of the Invention

[0005] The purpose of this application is to provide a component recommendation method, apparatus, computer device, and storage medium to solve the technical problem of insufficient intelligence and accuracy in existing component recommendations.

[0006] Firstly, a component recommendation method is provided, including: Obtain the user's behavior sequence on the operating platform, and extract the corresponding operation intent pattern from the behavior sequence; Based on a preset comparison algorithm, a similarity analysis is performed between the operation intention pattern and historical interaction data to determine the component requirement category corresponding to the operation intention pattern. If the component requirement category matches the layout requirement information of the current operation interface, then the component options corresponding to the component requirement category are selected from the preset component library, and a corresponding component recommendation list is generated based on the component options. Obtain the change data of the behavior sequence; The component recommendation list is adjusted based on the changed data to obtain the corresponding target component list; Based on the target component list and the current operation context, a combination of components that meets the requirements is determined; Based on the component combination, corresponding component recommendation results are generated, and the component recommendation results are output.

[0007] Secondly, a component recommendation device is provided, comprising: The first processing module is used to acquire the user's behavior sequence in the operating platform and extract the corresponding operation intention pattern from the behavior sequence. The analysis module is used to perform similarity analysis on the operation intention pattern and historical interaction data based on a preset comparison algorithm, and determine the component requirement category corresponding to the operation intention pattern. The second processing module is used to filter out component options corresponding to the component requirement category from the preset component library if the component requirement category matches the layout requirement information of the current operation interface, and generate a corresponding component recommendation list based on the component options. The acquisition module is used to acquire change data of the behavior sequence; The adjustment module is used to adjust the component recommendation list based on the changed data to obtain the corresponding target component list; The determination module is used to determine the combination of components that meets the requirements based on the target component list and the current operation context; The third processing module is used to generate corresponding component recommendation results based on the component combination, and to output the component recommendation results.

[0008] Thirdly, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the recommended method of the above-described components.

[0009] Fourthly, a computer-readable storage medium is provided, which stores a computer program that, when executed by a processor, implements the steps of the recommended method of the above-described components.

[0010] In the solution implemented by the above-mentioned component recommendation method, apparatus, computer equipment, and storage medium, this application first obtains the user's behavior sequence in the operating platform and extracts the corresponding operation intent pattern from the behavior sequence; then, based on a preset comparison algorithm, it performs similarity analysis on the operation intent pattern and historical interaction data to determine the component demand category corresponding to the operation intent pattern; if the component demand category matches the layout demand information of the current operating interface, it filters the component options corresponding to the component demand category from the preset component library and generates a corresponding component recommendation list based on the component options; then, it obtains the change data of the behavior sequence; subsequently, it adjusts the component recommendation list based on the change data to obtain the corresponding target component list; further, it determines the component combination that meets the requirements based on the target component list and the current operating context; finally, it generates the corresponding component recommendation result based on the component combination and outputs the component recommendation result. Based on the above automated processing flow, this application extracts operation intent patterns from user behavior sequences on the operating platform. Then, using a comparison algorithm, it performs similarity analysis between the operation intent patterns and historical interaction data to accurately determine component requirement categories. Furthermore, it filters components from the component library based on the layout requirements of the current operating interface to generate a component recommendation list. Simultaneously, it adjusts the generated component recommendation list based on behavioral sequence change data to obtain a target component list. Then, it determines suitable component combinations based on the target component list and the current operating context. Finally, it generates and outputs component recommendation results based on the obtained component combinations. Thus, unlike existing component recommendation methods that rely on static component libraries or fixed templates, this application's component recommendation method significantly improves the efficiency and user experience of complex interface design, achieving intelligent and precise component recommendation, enhancing the intelligence and accuracy of component recommendation processing, and ultimately improving the user experience. Attached Figure Description

[0011] To more clearly illustrate the solutions in this application, the accompanying drawings used in the description of the embodiments of this application will be briefly introduced below. Obviously, the accompanying drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0012] Figure 1 This is an exemplary system architecture diagram to which this application can be applied; Figure 2 This is a flowchart of one embodiment of the component recommendation method according to this application; Figure 3 This is a schematic diagram of the structure of one embodiment of the component recommendation device according to this application; Figure 4 This is a schematic diagram of the structure of one embodiment of the computer device according to this application. Detailed Implementation

[0013] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application pertains; the terminology used herein in the specification of the application is for the purpose of describing particular embodiments only and is not intended to be limiting of the application; the terms "comprising" and "having," and any variations thereof, in the specification, claims, and foregoing drawings of this application, are intended to cover non-exclusive inclusion. The terms "first," "second," etc., in the specification, claims, or foregoing drawings of this application are used to distinguish different objects, not to describe a particular order.

[0014] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of this application. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment mutually exclusive with other embodiments. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0015] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings.

[0016] like Figure 1 As shown, system architecture 100 may include terminal device 101, network 102, and server 103. Terminal device 101 may be a laptop 1011, tablet 1012, or mobile phone 1013. Network 102 is used as a medium to provide a communication link between terminal device 101 and server 103. Network 102 may include various connection types, such as wired, wireless communication links, or fiber optic cables, etc.

[0017] Users can use terminal device 101 to interact with server 103 via network 102 to receive or send messages, etc. Various communication client applications can be installed on terminal device 101, such as web browser applications, shopping applications, search applications, instant messaging tools, email clients, social media platform software, etc.

[0018] Terminal device 101 can be various electronic devices with a display screen and support web browsing. In addition to laptops 1011, tablets 1012, or mobile phones 1013, terminal device 101 can also be an e-book reader, an MP3 player (Moving Picture Experts Group Audio Layer III), an MP4 player (Moving Picture Experts Group Audio Layer IV), a laptop computer, and a desktop computer, etc.

[0019] Server 103 can be a server that provides various services, such as a backend server that provides support for the pages displayed on terminal device 101.

[0020] It should be noted that the component recommendation method provided in this application embodiment is generally executed by a server / terminal device, and correspondingly, the component recommendation device is generally set in the server / terminal device.

[0021] It should be understood that Figure 1 The number of terminal devices, networks, and servers shown is merely illustrative. Depending on implementation needs, any number of terminal devices, networks, and servers can be included.

[0022] Continue to refer to Figure 2 The flowchart illustrates an embodiment of the component recommendation method according to this application. Depending on different requirements, the order of the steps in the flowchart can be changed, and some steps can be omitted. The component recommendation method provided in this application embodiment can be applied to any scenario requiring component recommendation, and therefore can be applied to products in these scenarios. The component recommendation method includes the following steps: Step S201: Obtain the user's behavior sequence in the operation platform, and extract the corresponding operation intent pattern from the behavior sequence.

[0023] In this embodiment, the component recommendation method runs on an electronic device (e.g., Figure 1 The server / terminal device shown can acquire the user's behavior sequence on the operating platform via wired or wireless connection. It should be noted that the aforementioned wireless connection methods may include, but are not limited to, 3G / 4G / 5G connections, WiFi connections, Bluetooth connections, WiMAX connections, Zigbee connections, UWB (ultra-wideband) connections, and other currently known or future wireless connection methods. The implementing entity of this application is specifically a component recommendation system, which can be simply referred to as the system, and can be applied to low-code or no-code development platforms.

[0024] The specific implementation process of obtaining the user's behavior sequence in the operating platform and extracting the corresponding operation intention pattern from the behavior sequence will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0025] Step S202: Based on a preset comparison algorithm, perform similarity analysis on the operation intention pattern and historical interaction data to determine the component requirement category corresponding to the operation intention pattern.

[0026] In this embodiment, the above-mentioned implementation process of performing similarity analysis between the operation intention pattern and historical interaction data based on a preset comparison algorithm to determine the component requirement category corresponding to the operation intention pattern will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0027] Step S203: If the component requirement category matches the layout requirement information of the current operation interface, then the component options corresponding to the component requirement category are selected from the preset component library, and a corresponding component recommendation list is generated based on the component options.

[0028] In this embodiment, the specific implementation process of filtering component options corresponding to the component requirement category from the preset component library and generating a corresponding component recommendation list based on the component options if the component requirement category matches the layout requirement information of the current operation interface will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0029] Step S204: Obtain the change data of the behavior sequence.

[0030] In this embodiment, multi-timescale event acquisition and aggregation analysis technology is used to acquire and process the change data of the aforementioned behavior sequences. The specific implementation process includes: First, user operation events (such as component dragging, attribute configuration, and code submission) are captured in real time through front-end event tracking. A sliding window mechanism is then used to segment and aggregate the original event stream. For example, the operation events of the last 5 minutes are aggregated into a short-term behavior sequence, the events of the past hour are aggregated into a medium-term behavior sequence, and the cumulative events of the day are aggregated into a long-term behavior sequence. During the aggregation process, the events are structurally transformed. For example, the event of dragging a button component to the canvas is converted into a standardized record of {component type: 'button', operation type: 'add', timestamp: '2023-10-01T14:30:00'}. Additionally, duplicate events (such as consecutive clicks on the same component) or noisy events (such as meaningless mouse movements) are removed. Finally, the sequence data from different time periods are stored as independent time-series sets (i.e., change data), and metadata (such as window size and aggregation method) can be attached for subsequent analysis.

[0031] Step S205: Adjust the component recommendation list based on the changed data to obtain the corresponding target component list.

[0032] In this embodiment, the specific implementation process of adjusting the component recommendation list based on the changed data to obtain the corresponding target component list will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0033] Step S206: Determine the component combination that meets the requirements based on the target component list and the current operation context.

[0034] In this embodiment, the specific implementation process of determining the required component combination based on the target component list and the current operating context will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0035] Step S207: Generate corresponding component recommendation results based on the component combination, and output the component recommendation results.

[0036] In this embodiment, the specific implementation process of generating corresponding component recommendation results based on the component combination and outputting the component recommendation results will be further described in detail in subsequent specific embodiments of this application, and will not be elaborated on here.

[0037] Based on the above automated processing flow, this application extracts operation intent patterns from user behavior sequences on the operating platform. Then, using a comparison algorithm, it performs similarity analysis between the operation intent patterns and historical interaction data to accurately determine component requirement categories. Furthermore, it filters components from the component library based on the layout requirements of the current operating interface to generate a component recommendation list. Simultaneously, it adjusts the generated component recommendation list based on behavioral sequence change data to obtain a target component list. Then, it determines suitable component combinations based on the target component list and the current operating context. Finally, it generates and outputs component recommendation results based on the obtained component combinations. Thus, unlike existing component recommendation methods that rely on static component libraries or fixed templates, this application's component recommendation method significantly improves the efficiency and user experience of complex interface design, achieving intelligent and precise component recommendation, enhancing the intelligence and accuracy of component recommendation processing, and ultimately improving the user experience.

[0038] In some alternative implementations, step S201 includes the following steps: Record the user's interactive actions on the operating platform to generate a real-time behavior sequence.

[0039] In this embodiment, a multi-layered event capture mechanism is deployed at the user interface layer, event handling layer, and data transmission layer of the operating platform to record user (e.g., developer) interactions with the platform in real time. Specifically, at the user interface layer, direct user interactions with interface elements are captured by listening to mouse events (e.g., click, move, hover, drag), keyboard events (e.g., shortcut key triggers, text input), and touch events (e.g., swipe, zoom). At the event handling layer, user-triggered business logic events (e.g., component selection, parameter configuration, code submission) are recorded by intercepting system callback functions (e.g., onClick, onKeyDown) or hook mechanisms provided by the framework. At the data transmission layer, user interactions with backend services or the local environment are captured by analyzing network requests (e.g., API calls, data uploads) or local storage operations (e.g., file read / write, cache updates). All captured events are appended with a timestamp (accurate to milliseconds), event type identifier, operation object identifier (e.g., component ID, file path), and context information (e.g., current interface state, user permission level), forming structured event metadata. Subsequently, the event metadata is serialized in chronological order by an event stream processing engine (such as Apache Kafka) to generate a continuous, tamper-proof real-time behavior sequence data stream, namely the aforementioned behavior sequence, which can be stored in a distributed cache or time-series database.

[0040] In addition, the behavior sequence collection process can employ an anonymization mechanism to remove sensitive information from developers; the storage process uses encrypted storage technology to ensure data security; and the usage process can set up strict access control and operation log recording mechanisms to ensure that data access is compliant and controllable.

[0041] The behavioral sequence is analyzed based on a preset pattern recognition algorithm to obtain corresponding regular features.

[0042] In this embodiment, the above-mentioned feature analysis of the behavior sequence based on the preset pattern recognition algorithm includes feature extraction and regularity analysis. Specifically, feature extraction includes: 1) Sliding window segmentation: First, based on the temporal continuity or number of operations in the behavior sequence, define the parameters of the sliding window (such as window size and step size). For example, if the behavior sequence consists of operation events recorded by timestamps, the window can be set to a fixed duration (such as 5 minutes) or a fixed number of operations (such as 20 operations), and the step size can be 50% of the window size (i.e., half-overlapping) or completely non-overlapping. The sliding window moves gradually along the time axis, dividing the original sequence into multiple subsequences, ensuring that each subsequence contains local behavioral features. 2) Statistical Feature Extraction: For each subsequence within a window, calculate the following statistical features: Operation Frequency: Total number of operations within the window divided by the time span (e.g., times / minute); Interval Time: Mean, standard deviation, or median of the time interval between adjacent operations; Path Length: If the operation involves spatial movement (e.g., mouse trajectory), calculate the cumulative distance of cursor movement or the number of inflection points; Operation Type Distribution: Statistically calculate the proportion or entropy value of different operation types (e.g., click, drag, keyboard input) to reflect the diversity of operations. 3) Semantic Feature Extraction: Combine business logic to extract semantic features related to the operation object, such as: Object Category Association: Record the object types involved in the operation within the window (e.g., "button", "text box", "database table") and their interaction order; Resource Access Pattern: If the operation involves files or system resources, statistically analyze the resource categories accessed (e.g., "configuration file", "API interface") and permission levels (e.g., "read" "write"); Contextual Association: Extract the dependencies between operations (e.g., "select object and modify attributes").

[0043] Regularity analysis includes: 1) Data preprocessing: Converting the subsequences extracted by the sliding window into symbolic sequences (e.g., encoding "Create Component" as "A" and "Configure Parameters" as "B") to facilitate algorithm processing. 2) Frequent sequence mining: Recursively mining all frequent subsequences using the PrefixSpan algorithm: starting with a pattern of length 1 (e.g., "A"), gradually expanding to longer sequences (e.g., "A→B"), filtering patterns whose support (frequency of occurrence) exceeds a threshold; optimizing search efficiency through a projection database to avoid repeatedly scanning sequence data. 3) High-frequency pattern recognition: Statistically analyzing the frequency and confidence of the mining results, filtering out frequently occurring high-frequency operation patterns (e.g., "Create Component → Configure Parameters → Save"), and filtering out noisy patterns (e.g., isolated operations or random combinations) in conjunction with business rules, thus using the obtained high-frequency operation patterns as corresponding regularity features.

[0044] Based on the aforementioned regularity, the user's operational intentions at different stages of operation are extracted.

[0045] In this embodiment, based on the obtained regular features, a multi-level intent reasoning mechanism can be used to extract the user's operational intent at different operation stages. First, by combining a predefined intent classification system (such as component selection, parameter configuration, code debugging, and performance optimization), feature vectors are mapped to preliminary intent labels. For example, a feature vector of frequently clicking the "Component Library" button accompanied by dragging operations may be mapped to "Component Selection Intent"; a feature vector of continuously modifying parameter values ​​and triggering a preview operation may be mapped to "Parameter Configuration Intent". Second, by introducing a context-aware mechanism, the preliminary intent labels are corrected and refined by combining the current interface state (such as the menu level and the type of selected object), historical operation records (such as the types of the last 5 operations), and business rules (such as specific parameter range restrictions). For example, if the current interface is a code editor and historical operations include "Save" and "Run", then the "Parameter Modification" intent is refined to "Performance Optimization Intent". Finally, a dynamic intent tracking algorithm (such as an intent state machine based on a sliding window) is used to update the main intent and sub-intents of the current operation stage in real time. For example, in the "component selection" phase, if a drag-to-canvas event is detected, the main idea remains as component selection, and the sub-intention is updated to component placement; if a double-click event is subsequently detected, the main idea switches to component editing. Finally, all generated intentions are integrated to output a structured sequence of operation intentions, clearly labeling the intention type, confidence level, and associated operation object at each time point.

[0046] The operational intentions are categorized and organized to generate corresponding initial operational intention patterns.

[0047] In this embodiment, based on the extracted operation intent sequences, preliminary operation intent patterns can be formed through cluster analysis and pattern induction. First, a hierarchical clustering algorithm (such as AGNES) is used to perform pattern aggregation processing on the intent sequences. Pattern aggregation processing refers to clustering behavioral sequences with the same or similar intent labels into higher-level intent patterns (such as "rapid prototyping pattern"). The algorithm discovers potential structured patterns, specifically including: calculating the similarity between all pairs of behavioral sequences (such as cosine similarity) and constructing a hierarchical tree diagram; setting a similarity threshold (such as 0.8) according to business requirements and merging sequences with similarity higher than the threshold into the same cluster; each cluster corresponds to an intent pattern (such as the "high-frequency creation + configuration" pattern); and combining the core intent labels and typical operation names within the cluster (such as "rapid prototyping pattern" including "component creation + drag and drop").

[0048] Furthermore, a structured description is provided for each aggregated intent pattern, defining the triggering conditions (e.g., clicking the component library button three times consecutively), the core intent (e.g., component selection), associated operations (e.g., dragging to the canvas), and typical parameters (e.g., component type = button). Simultaneously, metadata is added to the intent patterns, including applicable scenarios (e.g., UI design phase), pattern complexity (e.g., low / medium / high), and pattern priority (e.g., sorted based on usage frequency), to obtain the structured initial operation intent patterns.

[0049] The initial operation intent mode is used as the operation intent mode.

[0050] Based on the above processing flow, this application transforms the user's ambiguous operation intentions into structured patterns through real-time behavior sequence modeling, effectively ensuring the accuracy of the generated operation intention patterns and avoiding noise interference with subsequent component recommendations.

[0051] In some optional implementations of this embodiment, step S202 includes the following steps: Retrieve pre-stored historical interaction data. This historical interaction data includes behavioral records from multiple operational scenarios.

[0052] In this embodiment, raw behavior logs can be extracted from the operation platform's log system. These logs are typically stored in unstructured text format. Historical interaction data can then be extracted from these raw behavior logs. This historical interaction data includes behavior records across multiple operation scenarios. The criteria for classifying operation scenarios may include: business function modules (e.g., form design, report generation), user roles (e.g., junior developers), and time periods (e.g., quarterly peak operations). Behavior records may include the following fields: user ID, operation timestamp, event type (e.g., component dragging, parameter modification), operation object (e.g., component ID or API name), context information (e.g., current interface layout information, project type), and result status (e.g., operation successful / failed).

[0053] The similarity between the operation intention pattern and the historical interaction data is calculated based on a preset sequence alignment algorithm.

[0054] In this embodiment, the appropriate sequence alignment algorithm can be selected by considering both pattern characteristics and data scale. First, the operation intent pattern and the behavior sequences in historical interaction data are uniformly converted into symbolic representations. For example, the intent pattern "component selection → parameter configuration → preview" is mapped to the symbolic sequence [C, P, V], and similar sequences in historical behavior records are converted according to the same rules. Then, the Dynamic Time Warping (DTW) algorithm is used to calculate sequence similarity. This algorithm solves the problem of inconsistent sequence lengths caused by differences in developer operation speed by flexibly matching non-aligned events on the timeline. Specifically, DTW constructs a distance matrix, where each element represents the edit distance (such as replacement, insertion, and deletion costs) between the intent pattern symbol and the historical sequence symbol, and finds the path with the minimum cumulative distance through dynamic programming. To optimize computational efficiency, pruning strategies (such as retaining only candidate paths within the distance threshold) and segmentation acceleration techniques (such as sliding window segmentation of long sequences) are further introduced. In addition, for high-frequency operation intent patterns, the TF-IDF algorithm is used to extract key events in the sequence (such as component dragging having a higher weight than mouse hovering), and these events are given higher weight in the similarity calculation. Finally, the normalized similarity score of each historical behavior sequence and the operation intention pattern is output, with a higher score indicating a stronger match.

[0055] Based on the similarity, historical behavior records that match the operation intent pattern are filtered from the historical interaction data.

[0056] In this embodiment, the similarity score-based filtering process combines business rules and statistical thresholds. First, a global similarity threshold (e.g., 0.85) is set, retaining only historical behavior records with scores exceeding this threshold and excluding low-relevance data to reduce noise interference. Second, a Top-K mechanism (e.g., K=10) is introduced to select the K most similar records from the remaining behavior records as candidate records, ensuring the recommendation results cover diverse scenarios. Furthermore, to avoid over-recommendation of a single scenario, candidate records are further weighted and sorted according to the distribution of operational scenarios. For example, if the current intent mode corresponds to the "form design" scenario, entries with this scenario accounting for more than 30% of the historical records are prioritized. Additionally, for new developers or cold start scenarios (insufficient historical data), heuristic rules are used to supplement candidate records, such as selecting the most frequently used behavior sequences globally as alternatives. Finally, the filtering results (historical behavior records) generated based on the Top-K mechanism are output in a structured list format, with each record containing the original behavior sequence, similarity score, and associated contextual information (e.g., user role, project type).

[0057] Extract the corresponding component usage information from the historical behavior records.

[0058] In this embodiment, the extraction of component usage information, i.e., component usage scenarios, is achieved by combining the contextual information of the behavior sequence with component metadata. First, for each filtered historical behavior record, the component operation events it contains (such as dragging component A to the canvas) are parsed and associated with the platform's component library metadata (such as component ID, category, and version). For example, component A in the behavior record needs to be mapped to a specific entry in the component library, and its attributes (such as input box, responsiveness) are recorded. Second, to address the ambiguity of the same component in different scenarios (such as a button potentially being used for submit or cancel), a context enhancement mechanism is introduced. This further refines the component's purpose by associating it with the interface state at the time the behavior occurs (such as its menu level or selected component combination). For example, if a button is frequently used in the form submission area, its purpose is marked as submission; if it is used in the "pop-up close area," it is marked as cancel. Furthermore, for composite components (such as a table + pagination combination), the complete component set is extracted through a component dependency graph (such as the parent-child relationship stored in Neo4j) to avoid missing associated components. Finally, the system outputs a list / information of component usage for each historical behavior record. Each item in the list includes the component ID, usage frequency, purpose tag, and associated context.

[0059] The usage information of the components is analyzed to generate corresponding specified component requirement categories.

[0060] In this embodiment, statistical analysis and domain knowledge can be combined to summarize the component requirement categories corresponding to the aforementioned component usage information. The specific implementation process includes: First, frequency statistics are performed on the component usage list of all historical behavior records to identify high-frequency component combinations. Then, a clustering algorithm is used to group the component usage tags. The clustering criteria include functional similarity (e.g., data display, interactive control), usage scenario (e.g., backend management), and technology dependence (e.g., React components, Vue components). For example, frequently used tables, paginators, and filters are grouped into "data display," while buttons, pop-ups, and prompts are grouped into "interactive control." In addition, expert rules are introduced to correct the clustering results. For example, if a component combination appears frequently in a specific business scenario (e.g., e-commerce payment process), it is marked as a scenario-specific category. Finally, a list of potential component requirement categories is output, i.e., the specified component requirement categories. Each category must include the following information: category name, constituent component set, typical usage scenario, and confidence score (generated based on statistical frequency and expert weights). The confidence score is used for subsequent consistency verification to ensure the interpretability of the recommendation results.

[0061] Consistency verification is performed on the specified component requirement category based on a preset consistency verification strategy.

[0062] In this embodiment, consistency verification can be achieved through multi-dimensional evaluation and dynamic adjustment. The specific implementation process includes: First, setting consistency judgment criteria, including: statistical significance of component co-occurrence rate within the category (e.g., chi-square test p-value < 0.05), cross-scenario applicability (e.g., appearing in at least 3 different business scenarios), and expert review pass rate (e.g., approval by more than 80% of domain experts). If a category meets all criteria, it is directly marked as a "credible demand category"; if it partially meets the criteria, it enters the correction process, such as: adjusting the components of the category (e.g., removing low-frequency components) or splitting it into multiple subcategories (e.g., splitting the interaction control category into form interaction category and pop-up interaction category). Then, a user feedback mechanism is introduced to collect implicit feedback (e.g., frequency of clicking recommended components) and explicit feedback (e.g., useful / useless ratings) from developers on demand categories in actual recommendation scenarios, and comparing the recommendation effects of different categories through A / B testing. If a category's click-through rate exceeds a threshold (e.g., 30%) in N consecutive recommendations (e.g., N=5), its consistency is confirmed and it passes the consistency verification; otherwise, it fails the consistency verification and is re-analyzed.

[0063] If the specified component requirement category passes the consistency verification, then the specified component requirement category will be used as the component requirement category.

[0064] Based on the above processing flow, this application uses a comparison algorithm to perform similarity analysis on the operation intent pattern and historical interaction data, and based on the analysis results, it can automatically and accurately predict the component demand categories that users have not explicitly expressed from historical interaction data.

[0065] In some alternative implementations, step S203 includes the following steps: Obtain the layout requirements information for the current user interface. This layout requirements information includes interface layout information and functional requirements information.

[0066] In this embodiment, front-end tracking technology is used to capture the layout information of the current user interface, including: DOM tree structure (such as component hierarchy and coordinate position), style attributes (such as layout type and responsive breakpoints), and user interaction events (such as mouse hover area and focused components). Data collection can be conducted using two methods: active polling (e.g., taking a snapshot of the interface every 500ms) and event-driven methods (e.g., listening for events such as component drag-and-drop completion). Furthermore, functional requirement information is inferred by analyzing the user's current operation sequence; for example, if the user continuously clicks the "Add Field" button, the functional requirement is marked as a dynamic form expansion. In addition, to improve the accuracy of contextual information, a multi-source data fusion mechanism is introduced; for example, combining backend API call logs (such as querying database table structure) with the interface state, it can be inferred that the user may be building a data visualization dashboard. Finally, the contextual information is encapsulated into a structured object containing layout descriptions, functional labels, and timestamps.

[0067] Calculate the degree of matching between the component requirement category and the layout requirement information.

[0068] In this embodiment, the component requirement categories are first matched with the functional requirements in the layout requirement information using keywords. For example, the text similarity between the category description and the functional tag is calculated using the TF-IDF algorithm. Then, for layout matching, spatial analysis technology is used to verify whether the layout constraints of the component requirement categories meet the current interface requirements. For example, if the "sidebar navigation" component in the requirement category requires a width ≥ 300px, but the current interface only has 250px of remaining space, a layout conflict is flagged. Simultaneously, a business rule base (e.g., prohibiting the use of full-screen pop-ups in form design scenarios) is introduced for hard constraint verification to avoid recommending components that violate domain knowledge. Subsequently, to improve matching accuracy, a weighted scoring mechanism is used. For example, the functional requirement matching weight is set to 0.6, and the layout matching weight is set to 0.4, ultimately outputting a comprehensive matching score (range 0~1). If the score exceeds a preset threshold (e.g., 0.7), the matching degree is determined to have reached the preset standard; otherwise, the matching degree is determined to have reached the preset standard, and the adjustment process begins.

[0069] If the matching degree reaches a preset standard, then component options related to the component requirement category are extracted from the preset component library.

[0070] In this embodiment, when the matching degree reaches a preset standard, components directly related to the aforementioned component requirement category are retrieved from a preset component library (such as an internal enterprise component repository or an open-source UI library). For example, if the requirement category is data display, components such as "table," "chart," and "card" are extracted. Furthermore, a context filtering mechanism is introduced to exclude options that do not conform to the current environment constraints. For example, if the interface layout is a mobile portrait screen, components with a width greater than 100% are filtered out. In addition, to support personalized recommendations, component options are further filtered based on user profiles. For example, similar components frequently used by the user in the past are prioritized for display. Finally, the extracted component options are output in a structured list format, with each item including component ID, name, preview image, function description, and matching score.

[0071] The functional attributes of the component options are sorted to generate a corresponding first component recommendation list.

[0072] In this embodiment, a score is assigned based on the matching degree between the functional attributes of component options (such as support for data sorting and responsive layout) and the contextual functional requirements. For example, cosine similarity is used to calculate the vector distance between the component's functional tags and the requirement tags. Then, user behavior data is introduced for weighting; for example, if a component has been frequently used by users with the same role in the past 30 days, its ranking weight is increased. Finally, the ranking results are normalized to generate priority scores (ranging from 0 to 1), and arranged in descending order of scores to form a preliminary recommendation list (i.e., the first component recommendation list). Each component in the list is accompanied by a ranking criterion (such as functional matching degree of 80% + historical usage frequency of 20%), enhancing the interpretability of the recommendations.

[0073] Based on the dynamic changes in the layout requirement information, the component options in the first component recommendation list are adjusted to obtain the corresponding second component recommendation list.

[0074] In this embodiment, the dynamic adjustment of the recommendation list relies on real-time monitoring of layout requirements and an incremental update mechanism. First, dynamic changes in layout requirements are captured through front-end event listeners (such as window size changes or component dragging initiation). For example, if a user adjusts the canvas width from 800px to 1200px, a layout re-analysis is triggered. Then, incremental calculation techniques are used to update only the affected component options. For example, only the layout adaptability of width-sensitive components (such as the sidebar) is reassessed, rather than a complete reordering. Furthermore, a sliding window mechanism (such as the last 5 operations) is introduced to analyze the evolution of user intent. For example, if a user deletes multiple "card" components consecutively, the recommendation priority of similar components is temporarily reduced. The resulting adjusted recommendation list (i.e., the second component recommendation list) is pushed to the front end only for the changed portions using a difference comparison algorithm (such as Levenshtein distance).

[0075] The second component recommendation list is adapted based on a preset adaptability verification strategy.

[0076] In this embodiment, the adaptability verification of the recommendation list can be performed by combining automated testing and manual evaluation. First, an interface layout simulator (such as a headless browser based on Puppeteer) is used to verify the rendering effect of component options within the layout requirements information. For example, it checks whether the "table" component is compatible with the current theme style and whether there are any overlapping or truncation issues. Next, a rule engine is used to verify business constraints, such as ensuring that the "payment button" does not appear in the "backend management" interface. Furthermore, an A / B testing framework is introduced, dividing the recommendation list into an experimental group and a control group, which are displayed to different user groups respectively. Effectiveness is evaluated using metrics such as click-through rate and usage time. If the experimental group's metrics are significantly better than the control group (e.g., a 20% increase in click-through rate), the recommendation list is deemed effective and passes the adaptability verification; otherwise, the recommendation list fails the adaptability verification, triggering a rollback mechanism and recording the reason for failure.

[0077] If the second component recommendation list passes the compatibility verification, then the second component recommendation list will be used as the component recommendation list.

[0078] Based on the above processing flow, when this application detects that the component requirement category matches the layout requirement information of the current operation interface, it will automatically and accurately filter out the component options corresponding to the component requirement category from the preset component library, and generate a component recommendation list that matches the current scenario based on the component options, ensuring that the obtained component recommendation list not only matches the user's operation intention, but also integrates into the current interface.

[0079] In some alternative implementations, step S205 includes the following steps: Based on a preset dynamic change model, trend analysis is performed on the changing data to obtain the corresponding trend characteristics.

[0080] In this embodiment, the construction process of the aforementioned dynamic change model includes: selecting a model suitable for the characteristics of the behavioral sequence (e.g., ARIMA for short-term trend prediction, LSTM for long-term dependency modeling), and preprocessing the input data, such as normalizing the frequency of component operations (range 0~1) and one-hot encoding the operation type (e.g., add = 100, delete = 010). Then, the model is trained using a sliding window cross-validation method, specifically using the first 80% of the data to train the ARIMA model parameters and the last 20% of the data to verify the prediction accuracy, until a well-trained model with trend extraction function is obtained, which serves as the dynamic change model.

[0081] In the trend feature extraction stage, the above-mentioned change data is analyzed by using a trained dynamic change model. The trend features output by the model include: periodic patterns (such as users adding a form component every 10 minutes), mutation point detection (such as the operation frequency suddenly increasing by 3 times), and changes in the distribution of operation types (such as switching from a button to a table).

[0082] Based on the trend characteristics, intent change information corresponding to the user's operational intent is generated.

[0083] In this embodiment, trend features are matched with predefined intent patterns to generate corresponding intent change information. For example, if a sudden change of "deleting the same type of component three times consecutively" is detected, the intent is marked as "component replacement optimization"; if "periodic addition of chart components" is found, the intent is marked as "data visualization requirement expansion". Furthermore, a context enhancement mechanism is introduced, such as combining the current project type (e.g., e-commerce backend) with historical behavior (e.g., the user has frequently optimized form layouts in the past) to weight and adjust the intent probability. In addition, to avoid misjudgment, a confidence threshold filtering is used; for example, short-term changes are only confirmed when the intent matching score exceeds 0.8. The intent judgment results are output in the form of a structured report, including intent tags, confidence scores, and supporting evidence (e.g., three input box components were deleted in the past 5 minutes), providing a basis for subsequent priority adjustments.

[0084] The priority weights of the specified component options in the component recommendation list that are related to the intent change information are adjusted to obtain the corresponding adjustment weight information.

[0085] In this embodiment, the adjustment of component priority weights can be achieved by combining intent relevance analysis and dynamic weight calculation. First, semantic matching technology (such as Word2Vec) is used to quantify the relevance between intent change information and component options in the component recommendation list. For example, if the intent is "increased form validation requirements", the similarity between the "validation rule component" and the intent keyword is calculated (e.g., 0.85). Then, the priority weights are adjusted using a dynamic weight formula to generate corresponding adjusted weight information, including: new weight = original weight × (1 + relevance × intent strength), where the intent strength is determined by the magnitude of the change (e.g., "doubled operation frequency corresponds to an intensity of 2.0"). Furthermore, to prevent excessive weight skew, normalization constraints are introduced (e.g., a single adjustment limit of 50%), and weight change logs are recorded (e.g., due to the form validation intent, the validation component weight increases from 0.3 to 0.6).

[0086] Based on the adjusted weight information, the component recommendation list is reordered according to the component options to obtain the corresponding optimized recommendation list for the specified component.

[0087] In this embodiment, the re-ranking process includes: First, the adjusted priority weights (i.e., adjusted weight information) are weighted and fused with the original ranking features (such as functional matching degree and usage frequency), including: Comprehensive Score = 0.6 × Functional Matching Degree + 0.3 × Dynamic Weight + 0.1 × Historical Preference. Then, to avoid drastic fluctuations in the ranking results, a smoothing mechanism is introduced (e.g., limiting the change in component position between two adjacent rankings to no more than 3 positions). Furthermore, diversity constraints (such as the maximum interval algorithm) are used to ensure that the list includes components from different technology stacks (e.g., "React Button" and "Vue Button" appear alternately). The re-ranking results are pushed to the front end only for the changed parts using a difference comparison algorithm (e.g., longest common subsequence), reducing rendering overhead. Finally, the optimized recommended list of specified components will also include an explanation of the ranking criteria (e.g., due to recent increases in form validation operations, recommended component A has been promoted from 5th to 2nd position), increasing user trust in the recommendation logic.

[0088] The recommended list of specified components is matched and verified based on a preset matching and verification strategy.

[0089] In this embodiment, a behavioral sequence simulator (such as a Monte Carlo simulation based on historical data) is constructed to generate an expected operation path (such as adding a form → configuring validation rules → submitting data), which is then compared with the expected usage path of the recommended component list. Then, a coverage metric is used to evaluate the matching degree. For example, if the components in the recommended component list cover 80% of the key operations in the simulated expected operation path, it is considered a high match, and the recommended component list is then verified for matching; otherwise, the recommended component list is deemed to have failed the matching verification. Additionally, implicit user feedback (such as click-through rate and dwell time) can be introduced as supplementary verification signals. For example, if the click-through rate of high-priority components in the optimized list increases by 30%, it indirectly proves the effectiveness of the matching.

[0090] If the specified component recommendation list passes the matching verification, then the specified component recommendation list will be used as the target component list.

[0091] Based on the above processing flow, this application can intelligently and accurately adjust the priority of the component recommendation list according to the changes in user operation data, which helps to solve the problem of sudden changes in developer intentions and ensures that component recommendations keep up with the user's operation rhythm.

[0092] In some optional implementations of this embodiment, step S206 includes the following steps: Obtain the component attribute information of each component included in the target component list, and obtain the current operation context.

[0093] In this embodiment, for each component in the optimized target component list, its core attributes can be extracted from a predefined component knowledge base (such as JSON Schema or database table), such as: component type (such as button, table), functional description (such as submitting form data), technical parameters (such as supporting click events, responsive layout) and dependencies (such as needing to cooperate with backend API).

[0094] In addition, the current operational context includes functional requirements and layout constraints. The process of obtaining the operational context includes: First, obtaining the static operational context by parsing the current editor state (such as canvas content, selected components). For example, if a user registration form already exists on the canvas, the functional requirement is inferred to be supplementing form validation logic or optimizing the submit button style. Then, dynamic behavior analysis is introduced, for example, by listening to user actions in the last 5 minutes (such as dragging input boxes, adjusting layout spacing) to extract temporary requirements (such as needing to arrange components horizontally) or constraints (such as the remaining canvas height being less than 200px). Furthermore, to enhance the accuracy of constraint extraction, a domain rule engine is used to generate layout constraints, including: if the current project is a mobile page, automatically adding the layout constraint "component width ≤ 100% screen width". Finally, the obtained functional requirements and layout constraints are integrated into a context description, i.e., the operational context, which includes explicit requirements (such as adding data visualization charts) and implicit constraints (such as avoiding component overlap), providing contextual input for subsequent correlation calculations.

[0095] The component attribute information and the operation context are correlated and analyzed to generate the corresponding correlation degree.

[0096] In this embodiment, component attribute information and operational context are converted into a unified semantic space. For example, a pre-trained BERT model is used to encode text descriptions (such as button functions: submit data) into a 768-dimensional vector, and numerical parameters (such as component height = 40px) are expanded into high-dimensional sparse vectors through one-hot encoding. Then, a multimodal fusion strategy (such as weighted concatenation or attention mechanism) is adopted to merge features of different dimensions. For example, the component function vector (weight 0.7) and the layout constraint vector (weight 0.3) are concatenated into a 1024-dimensional embedding vector. In addition, to capture the dynamics of the context, a time decay factor is introduced to adjust the weights. For example, the vector weight of recent operational contexts (such as spacing adjusted within 30 seconds) is increased by 30%. Finally, the correlation (range -1 to 1) is quantified by calculating the cosine similarity between the component attribute vector and the context vector. For example, a similarity of 0.85 indicates a high correlation, and -0.2 indicates a negative correlation. The correlation results are stored in matrix form to support efficient subsequent filtering.

[0097] Based on the correlation, specified components that meet the preset matching requirements with the operation context are selected from the list of target components.

[0098] In this embodiment, component selection can be performed by combining threshold filtering and diversity constraints. The specific implementation process includes: First, setting a relevance threshold (e.g., 0.6) to filter low-relevance components; for example, if a component's similarity to the operational context is 0.5, it is directly excluded. Then, to avoid homogenization of recommendation results, a Top-K diversity algorithm is used for further selection; for example, among the Top-10 relevance components, components with different functional categories are prioritized (e.g., after recommending text boxes, the priority of similar password boxes is reduced). Furthermore, context-sensitive weight adjustments are introduced; for example, if the current requirement is data display, the relevance threshold for table components is increased to 0.7. Subsequently, the selection results (i.e., the specified components) obtained after the Top-K diversity algorithm are output in an ordered list format, including component ID, relevance score, and recommendation reason (e.g., recommending a line chart component due to contextual mention of chart requirements), providing a candidate set for subsequent combination generation.

[0099] The specified components are combined to generate the corresponding initial component combination.

[0100] In this embodiment, the number of the specified components mentioned above includes multiple components. The corresponding initial component combination can be obtained by combining all the specified components.

[0101] Based on the dynamic changes in the operation context, the initial component combination is adjusted to obtain the adjusted specified component combination.

[0102] In this embodiment, by listening for changes in the operation context (such as a user deleting a table from the canvas), a partial update of the initial component combination is triggered. For example, if the table is removed, the associated pagination control is automatically removed from the combination. Furthermore, incremental layout optimization is employed, including recalculating only the positions of affected components (e.g., shifting the right component to the left to fill a gap), rather than a global reordering. Preferably, to balance response speed and accuracy, a delayed adjustment mechanism is introduced. For example, if the context changes frequently (e.g., five component adjustments within three consecutive seconds), the adjustment is paused until the operation stabilizes. The adjustment process can use a difference comparison algorithm (such as a Diff algorithm) to update only the changed parts, reducing performance overhead. Finally, the adjusted component combination maintains overall consistency based on the principle of minimal modification.

[0103] The suitability of the specified component combination is verified based on the operational context.

[0104] In this embodiment, the applicability verification of the component composition can be achieved through simulation testing. Specifically, firstly, a context simulator is constructed, for example, generating expected operation paths based on historical data (such as the user's next step might be configuring button styles), and checking whether the component composition supports this path (such as the button component exposing a style configuration interface). Furthermore, a coverage metric is used to evaluate reasonableness; for example, if the composition covers a specified threshold (such as 90%) of the functional points in the simulated path, it is determined to be highly applicable, and the component composition is deemed to have passed the applicability verification. Otherwise, the component composition is deemed to have failed the applicability verification, and the component composition rollback process can be triggered.

[0105] If the specified component combination passes the applicability verification, then the specified component combination will be used as the component combination.

[0106] Based on the above processing flow, this application analyzes the current operation context and adopts a method that takes into account both functional adaptability and layout feasibility. By utilizing the correlation between the generated component attribute information and the operation context, it can intelligently determine the component combination that meets the requirements from the target component list. Through dynamic adjustment, it can ensure that the obtained component combination can adapt to the needs and guarantee the accuracy of the obtained component combination.

[0107] In some optional implementations of this embodiment, step S207 includes the following steps: Component analysis is performed on each target component included in the component combination to obtain the functional attributes and interaction attributes of each target component.

[0108] In this embodiment, after obtaining the component combination, it is necessary to deeply analyze the various attributes of each target component, focusing on functional attributes and interaction attributes. Functional attributes refer to the specific functions that the component itself can perform. For example, a text input box component may have functional attributes such as the maximum character length limit it supports, whether special characters are allowed, and whether it has an auto-completion function. Interaction attributes focus on the interaction methods and characteristics between the component and the user or other components. Taking a button component as an example, its interaction attributes may include the feedback effect after clicking (such as color change, pop-up prompt box, etc.), whether it supports long press operation, and the linkage logic with other components (such as triggering the submission of a form or the jump to a page after clicking the button). By comprehensively and meticulously analyzing and obtaining the functional and interaction attributes of each component, we can clearly understand the core characteristics and usage of each component, laying the foundation for subsequent processing.

[0109] Key features are obtained by extracting features from the functional attributes and the interactive attributes, and a corresponding attribute set is constructed based on the key features.

[0110] In this embodiment, after extracting the functional and interactive attributes of each target component, key features are further extracted from this rich attribute information. Key features are attribute elements that represent the core characteristics of the component and have a significant impact on the overall combination. For example, for the text input box component mentioned above, the maximum character length limit and auto-completion function in its functional attributes may be key features because they directly affect the convenience of user input and the accuracy of data; the click feedback effect and the linkage logic with other components in the interactive attributes may also be key features, as they determine the user's experience of interacting with the component and the smoothness of the entire system. By summarizing and organizing these key features extracted from the functional and interactive attributes of different components, an attribute set is constructed. This attribute set is a comprehensive information base that contains information on all key characteristics of the component combination, providing comprehensive data support for subsequent evaluation of the component combination's performance.

[0111] The operational smoothness of the component combination is evaluated based on the attribute set.

[0112] In this embodiment, the operational fluency of component combinations can be comprehensively evaluated based on the constructed attribute set. Operational fluency refers to the ease with which users complete specific tasks using component combinations, and it involves multiple aspects. First, from the perspective of functional attributes, the functional synergy between various components is evaluated. For example, in a form filling scenario, can the functions of components such as text input boxes, drop-down menus, and date pickers be seamlessly integrated, and can users smoothly complete the input of various information? If the function of a component conflicts with or is incompatible with other components, it will lead to operational instability. For example, if the character limit of a text input box does not match the option settings of a drop-down menu, it may cause difficulties for users during the input process. In addition, from the perspective of interaction attributes, the interaction response speed and logical rationality between components are evaluated. For example, when a user clicks a button, can the associated components react promptly, such as popping up the corresponding form or updating the data display? Is the interactive feedback clear and unambiguous, allowing users to clearly understand whether their operation was successful and what effect it produced? If the interactive response is slow or the feedback is ambiguous, it will confuse users and reduce operational fluency.

[0113] The evaluation process involves comprehensively assessing multiple dimensions of functional and interactive attributes to determine the overall performance of the component composition in terms of operational smoothness, and to assess whether it meets the user's need for efficient and smooth task completion. If the component composition is found to meet the user's need for efficient and smooth task completion, it is considered to have passed the operational smoothness evaluation; otherwise, it is considered to have failed the evaluation.

[0114] If the component combination passes the operation fluency evaluation, the attribute set and the component combination are integrated to obtain the corresponding integrated data.

[0115] In this embodiment, the integration process includes associating the constructed attribute set with the component combination. This association is a form of information binding, ensuring that each component combination has corresponding detailed attribute information. Through this association, the specific characteristics of the component combination can be easily queried and understood during subsequent use and management. For example, when it is necessary to optimize or adjust the component combination, the aspects that need improvement can be quickly located based on the information in the attribute set; when introducing the component combination to other users or systems, a comprehensive and accurate description can also be provided based on the attribute set.

[0116] The integrated data is used as the component recommendation result, and the component recommendation result is output to the operating platform.

[0117] In this embodiment, after generating the component recommendation results, the results can be output to the operating platform using the following methods. Specifically, the recommendation results are transmitted as data to the front-end interface or back-end system of the operating platform via interface calls. On the front-end interface, the recommendation results can be displayed to the user in an intuitive way, such as presenting the component combination's name, brief description, preview image, etc., in the form of a list or card, facilitating quick browsing and selection. Simultaneously, interactive functions such as filtering, sorting, and searching can be provided, allowing users to further refine the recommendation results according to their needs. On the back-end system, the recommendation results are stored in a corresponding database so that they can be retrieved and loaded promptly when the user performs operations. For example, when a user creates a new project in a project management system, the system can automatically recommend suitable project templates and component combinations based on the recommendation results, improving the efficiency and accuracy of project creation.

[0118] Based on the above processing flow, this application analyzes each target component in the component combination, constructs an attribute set based on the obtained key features, and then uses the attribute set to evaluate the operational fluency of the component combination. Furthermore, it integrates the attribute set and the component combination to generate a final component recommendation result that optimizes operational fluency, thereby improving the accuracy and adaptability of the generated component recommendation result. Moreover, by outputting the component recommendation result to the operation platform, a close integration between the system and actual operation is achieved, providing users with a more intelligent and personalized service experience, and enhancing the overall system's usability and competitiveness.

[0119] It should be understood that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention.

[0120] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by instructing related hardware through computer-readable instructions. These computer-readable instructions can be stored in a computer-readable storage medium. When the program is executed, it can include the processes of the embodiments of the above methods. The aforementioned storage medium can be a non-volatile storage medium such as a magnetic disk, optical disk, or read-only memory (ROM), or random access memory (RAM).

[0121] It should be understood that although the steps in the flowcharts of the accompanying figures are shown sequentially as indicated by the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the accompanying figures may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times, and their execution order is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the sub-steps or stages of other steps.

[0122] Further reference Figure 3 As a response to the above Figure 2 To implement the method shown, this application provides an embodiment of a component recommendation device, which is similar to... Figure 2 Corresponding to the method embodiments shown, this device can be specifically applied to various electronic devices.

[0123] like Figure 3 As shown, the component recommendation device 300 described in this embodiment includes: a first processing module 301, an analysis module 302, a second processing module 303, an acquisition module 304, an adjustment module 305, a determination module 306, and a third processing module 307. Wherein: The first processing module 301 is used to acquire the user's behavior sequence in the operating platform and extract the corresponding operation intention pattern from the behavior sequence. Analysis module 302 is used to perform similarity analysis on the operation intention pattern and historical interaction data based on a preset comparison algorithm, and determine the component requirement category corresponding to the operation intention pattern. The second processing module 303 is used to filter out component options corresponding to the component requirement category from the preset component library if the component requirement category matches the layout requirement information of the current operation interface, and generate a corresponding component recommendation list based on the component options. Acquisition module 304 is used to acquire change data of the behavior sequence; The adjustment module 305 is used to adjust the component recommendation list based on the changed data to obtain the corresponding target component list; The determination module 306 is used to determine the required component combination based on the target component list and the current operation context; The third processing module 307 is used to generate corresponding component recommendation results based on the component combination, and to output the component recommendation results.

[0124] In some optional implementations of this embodiment, the first processing module 301 includes: The first generation submodule is used to record the user's interactive actions on the operating platform in order to generate a real-time behavior sequence; The first analysis submodule is used to perform feature analysis on the behavior sequence based on a preset pattern recognition algorithm to obtain the corresponding regularity features; The first extraction submodule is used to extract the user's operational intent at different operation stages based on the regularity features. The second generation submodule is used to classify and organize the operation intentions and generate corresponding initial operation intention patterns. The first determining submodule is used to use the initial operation intention mode as the operation intention mode.

[0125] In some optional implementations of this embodiment, the analysis module 302 includes: The first acquisition submodule is used to acquire pre-stored historical interaction data; wherein, the historical interaction data includes behavior records under multiple operation scenarios; The first calculation submodule is used to calculate the similarity between the operation intention pattern and the historical interaction data based on a preset sequence alignment algorithm. The first filtering submodule is used to filter historical behavior records that match the operation intent pattern from the historical interaction data based on the similarity. The second extraction submodule is used to extract corresponding component usage information from the historical behavior records; The second analysis submodule is used to analyze the component usage information and generate corresponding specified component requirement categories; The first verification submodule is used to perform consistency verification on the specified component requirement category based on a preset consistency verification strategy. The second determining submodule is used to determine the specified component requirement category as the component requirement category if the specified component requirement category passes the consistency verification.

[0126] In some optional implementations of this embodiment, the second processing module 303 includes: The second acquisition submodule is used to acquire the layout requirement information of the current operation interface; wherein, the layout requirement information includes interface layout information and functional requirement information. The second calculation submodule is used to calculate the degree of matching between the component requirement category and the layout requirement information; The third extraction submodule is used to extract component options related to the component requirement category from a preset component library if the matching degree reaches a preset standard. The first sorting submodule is used to sort the functional attributes of the component options and generate a corresponding first component recommendation list; The first adjustment submodule is used to adjust the component options in the first component recommendation list based on the dynamic changes of the layout requirement information, so as to obtain the corresponding second component recommendation list. The second verification submodule is used to perform adaptation verification on the recommendation list of the second component based on a preset adaptation verification strategy. The third determining submodule is used to use the second component recommendation list as the component recommendation list if the second component recommendation list passes the adaptability verification.

[0127] In some optional implementations of this embodiment, the adjustment module 305 includes: The third analysis submodule is used to perform trend analysis on the changing data based on a preset dynamic change model to obtain the corresponding trend characteristics; The third generation submodule is used to generate intent change information corresponding to the user's operation intent based on the trend features; The second adjustment submodule is used to adjust the priority weight of specified component options related to the intent change information in the component recommendation list to obtain the corresponding adjustment weight information. The second sorting submodule is used to re-sort the component recommendation list based on the adjusted weight information to obtain the corresponding optimized recommended list of the specified component. The third verification submodule is used to perform matching verification on the specified component recommendation list based on a preset matching verification strategy; The fourth determining submodule is used to use the specified component recommendation list as the target component list if the specified component recommendation list passes the matching verification.

[0128] In some optional implementations of this embodiment, the determining module 306 includes: The third acquisition submodule is used to acquire component attribute information for each component included in the target component list, and to acquire the current operation context; The fourth analysis submodule is used to perform correlation analysis on the component attribute information and the operation context to generate the corresponding correlation degree; The second filtering submodule is used to filter specified components from the target component list that meet the preset matching requirements of the operation context based on the relevance. The fourth generation submodule is used to combine the specified components to generate the corresponding initial component combination; The third adjustment submodule is used to perform component adjustment processing on the initial component combination based on the dynamic change information of the operation context, so as to obtain the adjusted specified component combination. The fourth verification submodule is used to perform applicability verification on the specified component combination based on the operation context; The fifth determining submodule is used to determine the specified component combination as the component combination if the specified component combination passes the applicability verification.

[0129] In some optional implementations of this embodiment, the third processing module 307 includes: The fifth analysis submodule is used to perform component analysis on each target component included in the component combination to obtain the functional attributes and interaction attributes of each target component; The fourth extraction submodule is used to extract key features from the functional attributes and the interaction attributes, and to construct a corresponding attribute set based on the key features; An evaluation submodule is used to evaluate the operational fluency of the component combination based on the attribute set. An integration submodule is used to integrate the attribute set and the component combination if the component combination passes the operation fluency evaluation, to obtain the corresponding integrated data. The output submodule is used to use the integrated data as the component recommendation result and output the component recommendation result to the operating platform.

[0130] To address the aforementioned technical problems, embodiments of this application also provide a computer device. Please refer to [link / reference needed]. Figure 4 , Figure 4 This is a basic structural block diagram of the computer device in this embodiment.

[0131] The computer device 4 includes a memory 41, a processor 42, and a network interface 43 that are interconnected via a system bus. It should be noted that only the computer device 4 with components 41-43 is shown in the figure; however, it should be understood that it is not required to implement all the shown components, and more or fewer components can be implemented alternatively. Those skilled in the art will understand that the computer device described here is a device capable of automatically performing numerical calculations and / or information processing according to pre-set or stored instructions, and its hardware includes, but is not limited to, microprocessors, application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), digital signal processors (DSPs), embedded devices, etc.

[0132] The computer device can be a desktop computer, laptop, handheld computer, or cloud server, etc. The computer device can interact with the user via a keyboard, mouse, remote control, touchpad, or voice control.

[0133] The memory 41 includes at least one type of readable storage medium, including flash memory, hard disk, multimedia card, card-type memory (e.g., SD or DX memory), random access memory (RAM), static random access memory (SRAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), programmable read-only memory (PROM), magnetic memory, magnetic disk, optical disk, etc. In some embodiments, the memory 41 may be an internal storage unit of the computer device 4, such as the hard disk or memory of the computer device 4. In other embodiments, the memory 41 may also be an external storage device of the computer device 4, such as a plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, etc., equipped on the computer device 4. Of course, the memory 41 may also include both the internal storage unit and its external storage device of the computer device 4. In this embodiment, the memory 41 is typically used to store the operating system and various application software installed on the computer device 4, such as computer-readable instructions for component recommendation methods, etc. In addition, the memory 41 can also be used to temporarily store various types of data that have been output or will be output.

[0134] In some embodiments, the processor 42 may be a central processing unit (CPU), a controller, a microcontroller, a microprocessor, or other data processing chip. The processor 42 is typically used to control the overall operation of the computer device 4. In this embodiment, the processor 42 is used to execute computer-readable instructions stored in the memory 41 or to process data, such as executing computer-readable instructions for the component-recommended method.

[0135] The network interface 43 may include a wireless network interface or a wired network interface, which is typically used to establish communication connections between the computer device 4 and other electronic devices.

[0136] This application also provides another embodiment, namely, providing a computer-readable storage medium storing computer-readable instructions that can be executed by at least one processor to cause the at least one processor to perform the steps of the component recommendation method as described above.

[0137] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) and includes several instructions to cause a terminal device (which may be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in the various embodiments of this application.

[0138] Obviously, the embodiments described above are only some embodiments of this application, not all embodiments. The accompanying drawings show preferred embodiments of this application, but do not limit the patent scope of this application. This application can be implemented in many different forms; rather, the purpose of providing these embodiments is to provide a more thorough and comprehensive understanding of the disclosure of this application. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing specific embodiments, or make equivalent substitutions for some of the technical features. Any equivalent structures made using the content of this application's specification and drawings, directly or indirectly applied to other related technical fields, are similarly within the scope of patent protection of this application.

Claims

1. A component recommendation method, characterized in that, Includes the following steps: Obtain the user's behavior sequence on the operating platform, and extract the corresponding operation intent pattern from the behavior sequence; Based on a preset comparison algorithm, a similarity analysis is performed between the operation intention pattern and historical interaction data to determine the component requirement category corresponding to the operation intention pattern. If the component requirement category matches the layout requirement information of the current operation interface, then the component options corresponding to the component requirement category are selected from the preset component library, and a corresponding component recommendation list is generated based on the component options. Obtain the change data of the behavior sequence; The component recommendation list is adjusted based on the changed data to obtain the corresponding target component list; Based on the target component list and the current operation context, a combination of components that meets the requirements is determined; Based on the component combination, corresponding component recommendation results are generated, and the component recommendation results are output.

2. The component recommendation method according to claim 1, characterized in that, The step of obtaining the user's behavior sequence on the operating platform and extracting the corresponding operation intent pattern from the behavior sequence specifically includes: Record the user's interactive actions on the operating platform to generate a real-time behavior sequence; The behavioral sequence is analyzed based on a preset pattern recognition algorithm to obtain corresponding regularity features; Based on the aforementioned regularity, the user's operational intentions at different stages of operation can be extracted. The operation intentions are categorized and organized to generate corresponding initial operation intention patterns; The initial operation intent mode is used as the operation intent mode.

3. The component recommendation method according to claim 1, characterized in that, The step of performing similarity analysis between the operation intent pattern and historical interaction data based on a preset comparison algorithm to determine the component requirement category corresponding to the operation intent pattern specifically includes: Obtain pre-stored historical interaction data; wherein, the historical interaction data includes behavior records under multiple operation scenarios; The similarity between the operation intention pattern and the historical interaction data is calculated based on a preset sequence alignment algorithm. Based on the similarity, historical behavior records that match the operation intent pattern are filtered from the historical interaction data; Extract the corresponding component usage information from the historical behavior records; The component usage information is analyzed to generate corresponding specified component requirement categories; Consistency verification is performed on the specified component requirement category based on a preset consistency verification strategy; If the specified component requirement category passes the consistency verification, then the specified component requirement category will be used as the component requirement category.

4. The component recommendation method according to claim 1, characterized in that, The step of selecting component options corresponding to the component requirement category from a preset component library and generating a corresponding component recommendation list based on the component options if the component requirement category matches the layout requirement information of the current operation interface specifically includes: Obtain the layout requirements information of the current operation interface; wherein, the layout requirements information includes interface layout information and functional requirements information; Calculate the degree of matching between the component requirement category and the layout requirement information; If the matching degree reaches the preset standard, then the component options related to the component requirement category are extracted from the preset component library; The functional attributes of the component options are sorted to generate a corresponding first component recommendation list; Based on the dynamic changes in the layout requirement information, the component options in the first component recommendation list are adjusted to obtain the corresponding second component recommendation list; The second component recommendation list is adapted based on a preset adaptability verification strategy. If the second component recommendation list passes the compatibility verification, then the second component recommendation list will be used as the component recommendation list.

5. The component recommendation method according to claim 1, characterized in that, The step of adjusting the component recommendation list based on the changed data to obtain the corresponding target component list specifically includes: Based on a preset dynamic change model, trend analysis is performed on the changing data to obtain the corresponding trend characteristics; Based on the trend characteristics, generate intent change information corresponding to the user's operational intent; The priority weights of the specified component options in the component recommendation list that are related to the intent change information are adjusted to obtain the corresponding adjustment weight information; Based on the adjusted weight information, the component recommendation list is reordered according to the component options to obtain the corresponding optimized recommendation list for the specified component. The recommended list of specified components is matched and verified based on a preset matching and verification strategy; If the specified component recommendation list passes the matching verification, then the specified component recommendation list will be used as the target component list.

6. The component recommendation method according to claim 1, characterized in that, The step of determining the required component combination based on the target component list and the current operation context specifically includes: Obtain the component attribute information of each component included in the target component list, and obtain the current operation context; The component attribute information and the operation context are correlated and analyzed to generate the corresponding correlation degree; Based on the relevance, select specified components from the target component list that meet the preset matching requirements of the operation context; The specified components are combined to generate a corresponding initial component combination; Based on the dynamic change information of the operation context, the initial component combination is adjusted to obtain the adjusted specified component combination. The suitability of the specified component combination is verified based on the operational context. If the specified component combination passes the applicability verification, then the specified component combination will be used as the component combination.

7. The component recommendation method according to claim 1, characterized in that, The step of generating corresponding component recommendation results based on the component combination and outputting the component recommendation results specifically includes: Perform component analysis on each target component included in the component combination to obtain the functional attributes and interaction attributes of each target component; Key features are obtained by extracting features from the functional attributes and the interactive attributes, and a corresponding attribute set is constructed based on the key features; The operational smoothness of the component combination is evaluated based on the attribute set. If the component combination passes the operation fluency evaluation, the attribute set and the component combination are integrated to obtain the corresponding integrated data; The integrated data is used as the component recommendation result, and the component recommendation result is output to the operating platform.

8. A component recommendation device, characterized in that, include: The first processing module is used to acquire the user's behavior sequence in the operating platform and extract the corresponding operation intention pattern from the behavior sequence. The analysis module is used to perform similarity analysis on the operation intention pattern and historical interaction data based on a preset comparison algorithm, and determine the component requirement category corresponding to the operation intention pattern. The second processing module is used to filter out component options corresponding to the component requirement category from the preset component library if the component requirement category matches the layout requirement information of the current operation interface, and generate a corresponding component recommendation list based on the component options. The acquisition module is used to acquire change data of the behavior sequence; The adjustment module is used to adjust the component recommendation list based on the changed data to obtain the corresponding target component list; The determination module is used to determine the combination of components that meets the requirements based on the target component list and the current operation context; The third processing module is used to generate corresponding component recommendation results based on the component combination, and to output the component recommendation results.

9. A computer device, characterized in that, The device includes a memory and a processor, wherein the memory stores computer-readable instructions, and the processor executes the computer-readable instructions to implement the steps of the component recommendation method as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-readable instructions that, when executed by a processor, implement the steps of the component recommendation method as described in any one of claims 1 to 7.

Images