User interface preference adaptation system and method

Abstract

The application discloses a user interface preference self-adaptive system and method, and the system comprises a preference atom definition module, a layered weight calculation engine, a sparse storage manager, a context preloader and a conflict resolution processor.The preference atom definition module atomizes UI configuration items; the layered weight calculation engine quantifies explicit operations, implicit behaviors and role inheritance into comprehensive weights; the sparse storage manager screens significant preferences with a significance threshold θ, forms a sparse vector, and adopts a baseline snapshot and a delta snapshot chain to persist, so that storage grows with the number of habits instead of the total number of configuration items, and supports second-level historical rollback; the context preloader screens candidate configurations in constant time by using a page-level Bloom filter; and the conflict resolution processor smoothes the transition of users, roles and global default configurations by using a double threshold. The method significantly reduces storage and rendering delay when the number of users and the number of configuration items both reach the order of ten thousand, and solves the problems of storage explosion, performance bottleneck, historical backtracking and smooth transition in the scenario of a large number of users and a large number of configurations.

Description

Technical Field

[0001] This invention relates to the field of computer software technology, and specifically to a user interface preference adaptive system and method based on hierarchical weight compression and incremental snapshots. Background Technology

[0002] In existing UI personalization systems, a "full key-value pair" approach is typically used—saving a complete N-dimensional configuration vector (page size, field visibility, theme color, shortcuts, etc.) for each user. With the development of ToB SaaS, cloud consoles, and multi-tenant platforms, the number of configurable items N has exceeded 10,000, and the number of users M is approaching tens of millions, resulting in a linear explosion in storage complexity O(M×N). Simultaneously, each user modification is an "overwrite," making it impossible to trace back history and creating bottlenecks for reading and writing large objects. When a user logs in, hundreds or thousands of preference records must be loaded one by one, and then conflicts with global and role default values ​​must be resolved, resulting in initial screen rendering times often exceeding hundreds of milliseconds, failing to meet the business goal of "millisecond-level personalization."

[0003] To address this, invention patent CN114491291A provides a user preference prediction method, terminal, and storage medium. The method includes: constructing an explicit rating matrix and an implicit rating matrix based on historical interaction data of m users and n items. The explicit rating matrix represents the explicit ratings of the m users for the n items, and the implicit rating matrix represents the implicit ratings of the m users for the n items. Both the explicit and implicit rating matrices are m x n matrices. The explicit and implicit rating matrices are then input into a pre-set matrix factorization and deep neural network joint prediction model to obtain prediction results. For each of the m users, the prediction result includes the user's preference level for each item among the n items. The core idea of ​​this invention patent is to construct an m×n explicit and implicit rating matrix, feed the two matrices into a "matrix factorization + deep neural network" joint model to predict the user's preference level for the n items, and store the prediction results in a dense m×n matrix for subsequent recommendation. The technical solution of this invention patent can alleviate the cold start problem in the "recommendation system" scenario, but in practical applications, directly transplanting it to the field of UI personalization has the following drawbacks: 1. The storage model is still dense: the m×n matrix of the prediction output needs to be fully stored in the database, and the space complexity is still O(M×N), which cannot solve the storage disaster caused by "configuration item explosion"; 2. No historical version capability: The prediction results are updated in the "overwrite" method. Every time the user makes a minor adjustment to the UI (such as pagination 10 → 30), the entire record is rewritten. It is impossible to trace back any historical state, and it does not support gray-scale rollback. 3. Lack of role inheritance and conflict resolution: The model only outputs "preference degree value" and does not provide a mechanism to integrate with multi-level weights such as "global default value" and "role default value", which means that users with different roles under the same enterprise need to save their complete vectors, which doubles the redundancy. 4. Heavy online rendering process: The prediction matrix is ​​often resident on disk or in a remote cache. When a user logs in, the entire row vector (thousands of dimensions of floating points) needs to be loaded, resulting in high network and CPU overhead, which often causes the first screen to take more than 200ms. 5. UI atomic sparsity is not considered: In a real console, the configuration that the user explicitly modifies is less than 5% of the total items, but this invention still saves floating-point weights for all items, resulting in a large amount of invalid storage and calculation. Summary of the Invention

[0004] A brief overview of embodiments of the invention is provided below to provide a basic understanding of certain aspects of the invention. It should be understood that this overview is not an exhaustive summary of the invention. It is not intended to identify key or essential parts of the invention, nor is it intended to limit the scope of the invention. Its purpose is merely to present certain concepts in a simplified form as a prelude to the more detailed description that follows.

[0005] This invention addresses the aforementioned shortcomings, specifically targeting "massive users + massive configurations (tens of thousands of UI configurations) (N>10)". 4 To address challenges such as storage explosion, performance bottlenecks, historical backtracking, and smooth transitions in scenarios like “hierarchical weighted compression + incremental snapshot (sparse vector + incremental chain) + page-level Bloom filter”, a new architecture is proposed to achieve second-level undo and version comparison at any time.

[0006] According to one aspect of this application, a user interface preference adaptive system is provided, comprising: a) Preference atom definition module, used to divide user interface configuration items into preference atoms of the smallest granularity and establish a global preference atom set U; b) A hierarchical weight calculation engine is used to quantify the comprehensive weight of a user's preference atom into a linear combination of explicit weights, implicit weights, and inherited weights: W u (i)=α·W explicit (u,i)+β·W implicit (u,i)+γ·W inherit (r,i); Wherein, and α+β+γ=1; W u (i) represents the comprehensive weight W of user u to atom i. u (i), W explicit (u,i) represents the explicit weights, obtained from the user's explicit operations; W implicit(u,i) represents the implicit weights, obtained from the user's implicit behavior; W inherit (r,i) represents the inheritance weight obtained from the user's role inheritance information, where r is the role of user u. c) A sparse storage manager for storing each user's personalized configuration only in the form of a salient preference set S. u Obtained by filtering with a significance threshold θ, only storing results satisfying |W u (i)-W global_default (i) Preferred atoms of |>θ, and persistent data using a combination of baseline snapshots and incremental snapshot chains; W global_default (i) represents the global default weight; d) Context preloader, used to maintain page-level Bloom filters (BF). P When a user visits page P, a Bloom filter (BF) is used. P For the significant preference set S u Perform fast filtering within constant time to obtain the candidate preference set Cand u ; e) Conflict resolution processor, used for resolving conflicts in the candidate preference set Cand u The preference settings in the UI execute conflict resolution logic to determine the final UI configuration value.

[0007] Furthermore, the hierarchical weight calculation engine further includes: Explicit Weight Update Unit: When a user sets an atom i for the first time, it is assigned an initial explicit weight W. explicit (u,i) is 0.7; if the same setting is repeated, the weight is increased by 0.1, up to a maximum of 1.0; if the operation is reversed, the current weight is multiplied by 0.5 to simulate the fuzziness of human memory and avoid permanent changes caused by a single accidental touch.

[0008] Implicit weight derivation unit: The implicit weight W implicit (u,i) is derived from the user's implicit behavior frequency F and intensity coefficient S using the formula W. implicit (u,i) = log2(1+F)×S is calculated to capture unspoken but persistent operational habits; where F is the number of times the configuration item is triggered per unit time, and S is the weighting coefficient for interaction depth or dwell time. The inheritance weight W inherit (r,i) is assigned once by the user's role, serving as the default starting point for new users or in scenarios with weak preferences, and is related to the global default weight W. global_default (i) Independent storage to support the parallel existence of multiple roles.

[0009] Furthermore, the sparse storage manager employs the following strategy: Incremental Snapshot Chain: Each change in user preference generates an incremental snapshot Δ, which includes a timestamp, user identifier, and operation list. The operation list records the operation type, target atom identifier, and its weight change. The operation list is used to record the "micro-operation log" of the user interface preference state evolution process. It stores the weight change with the smallest data granularity (e.g., Add / Update / Remove) rather than directly storing the final state value. State Reconstruction: The system periodically generates full baseline snapshots. u (t base The Merge() function reconstructs the complete preference state State(u,t) of the user at any historical time t in constant time, i.e., State(u,t) = Merge(Base). u (t base ),{Δ|t base <Δ.timestamp≤t}).

[0010] Furthermore, in the incremental snapshot chain, the weight change amount weight_delta is defined as a differential operator, and its calculation formula is weight_delta = W new -W old , used to record the non-linear superposition of weights. W new The new weight is the instantaneous weight value in the instant after the change. It represents the preference field strength calculated by the system based on the user's latest operation (explicit / implicit / inherited) at the current timestamp t. old The old weight is the baseline weight value in the instant before the change. It is the "original charge" recorded in the most recent baseline snapshot or the previous incremental chain node before the system executes a new operation. It is the stable state of the system before the new calculation is performed.

[0011] Furthermore, the context preloader works in conjunction with the conflict resolution processor, specifically including: The context preloader is configured to utilize BF P Filtering S in constant time u Obtain the candidate preference set Cand u Specifically, an inverted index is built, and a Bloom filter (BF) is maintained for each page P. P This is used to determine whether atom i belongs to the page context within a constant time. The Bloom filter (BF) is... P Its insertion phase only writes preference atom IDs that may be effective on that page, and the query phase completes Cand within constant time. u The filtering process significantly reduces the amount of data that needs to be resolved for conflict resolution.

[0012] The conflict resolution processor uses a three-stage decision-making process: For atom i in the candidate set, if W... u (i)≥θ high Directly use user preference values; if W u (i)≤θ low Use either the role-specific or global default value; otherwise, use a weighted average of the two to achieve a smooth transition. The role-specific or global default value is the final value for the configuration item. The role-specific default value is a pre-set configuration value for the role, while the global default value is a configuration value uniformly assigned by the system to all users. high With θ low The system dynamically generates a conflict resolution threshold based on weight drift analysis. It periodically scans user behavior and calculates the percentage of positive and negative values ​​for each atom's weight change. The average weight of the top 5% of positively drifting atoms is analyzed and set as θ. high (Activation threshold); θ is set by analyzing the average weight of the bottom 5% negative drift atoms. low (Regression threshold).

[0013] Furthermore, the Bloom filter BF P Only inserts satisfying W u (i)≥θ hot High-weighted atoms, θ hot For the dynamic thermal threshold, θ hot >θ high The system periodically removes cooled atoms from BF P Remove from the middle to form a dynamic hot configuration set.

[0014] Furthermore, based on the weight drift direction of the incremental snapshot chain statistics, the significance threshold θ is adjusted inversely to make the significant preference set S u It automatically expands or contracts throughout the user's lifecycle. The direction of weight shift can be directly calculated from the weight_delta (weight change) recorded in the incremental snapshot chain. The specific steps are as follows: Each incremental snapshot Δ stores (atom_id, weight_delta) in its operation_list. Positive numbers indicate that the user strengthens the preference, while negative numbers indicate that the preference weakens it.

[0015] Calculate the algebraic sum of all weights_delta for the same atom_id within a period (e.g., 1 hour): drift(atom_id)=Σweight_delta; If drift > 0, the overall weights will drift upwards (users are developing this habit). If drift < 0, the overall weights will drift downwards (users are abandoning this habit). If drift≈0 → weight oscillation or not touched, it can be classified as "cold configuration"; Use the drift direction to drive two types of subsequent actions: Dynamic Bloom filter: Only filters with drift > 0 and the latest W value. u (i)≥θ hot Atom insertion BF P Remove cold configurations promptly.

[0016] Adaptive threshold θ: When the proportion of system-level "drifting up" atoms exceeds the set ratio, θ is automatically reduced to allow more atoms to enter the salient set; conversely, θ is increased to prevent storage bloat.

[0017] Furthermore, when the storage space reaches a threshold, the baseline-incremental snapshot retains only the latest baseline and subsequent increment chains, discarding earlier baselines and their corresponding increments, achieving cyclic compression while still ensuring that any historical state can be reconstructed. In the incremental snapshot chain, the latest baseline snapshot and all incremental snapshots are retained; older baseline snapshots are deleted; when it is necessary to backtrack to a historical state, the operations in the operation_list are executed in reverse using the retained incremental chain, achieving lossless backtracking throughout the entire historical cycle.

[0018] Furthermore, the significance threshold θ, the mixing coefficients α, β, γ, and the threshold θ high ,θ low All configuration files are hot-loaded, allowing for online adjustments without requiring a service restart.

[0019] This application adopts the above-mentioned scheme, which performs sparse compression by introducing a significance threshold θ in the sparse storage manager, stores only significant preferences, and uses Delta Chain to record changes. The storage overhead varies with the size S of the significant preference set. u Instead of increasing the total configuration item N, it achieves order-of-magnitude compression, resulting in a storage compression rate of >90%. The operation_list of the incremental snapshot Δ adopts "weight transfer" semantics, that is, it records the same reverse weight change amount weight_delta for the old and new values ​​of the same preference atom, recording only the change. This not only avoids redundant full storage, but also achieves reversible backtracking and garbage collection. At the same time, the Merge() function is used to achieve second-level undo and version comparison, solving the problem of massive UI configurations that traditional technologies cannot handle.

[0020] Furthermore, the incremental snapshot chain utilizes timestamps and a state machine to achieve reconstruction within constant time. The timestamp index is strictly ordered in ascending order. State machine optimization involves maintaining a global "state pointer" pointing to the current baseline snapshot. The merge algorithm directly jumps to the corresponding baseline snapshot and applies the incremental snapshot when requesting historical states, eliminating the need for linear traversal. Therefore, this application not only provides backups but also implements second-level undo and arbitrary time-to-date rollback capabilities.

[0021] According to a second aspect of this application, a user interface preference adaptation method is provided, applied to the aforementioned user interface preference adaptation system, comprising the following steps: S1. Model the user's preferences for N configuration items as a weighted sparse vector; S2. Introduce a significance threshold θ, and only persist atomic terms whose weights deviate from the global default value by more than θ; S3. When a user interaction is detected that causes a change in preference, the original record is not overwritten. Instead, an incremental snapshot Δ is generated, where Δ contains (timestamp, atom_id, weight_delta). S4. Using a Bloom filter (BF) P The user's significant preference set is quickly filtered to remove configuration items irrelevant to the current page; S5. For the selected candidate preferences, based on W u (i)≥θ high Use user preferences, or otherwise use role or global default values ​​to complete UI rendering.

[0022] According to a third aspect of this application, a computer-readable storage medium is provided having a computer program stored thereon, the program being executed by a processor to perform all the steps of the above-described method.

[0023] According to a fourth aspect of this application, an electronic 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 program to implement all the steps of the above-described method.

[0024] Existing technologies have not proposed solutions to the storage bottleneck under massive UI configuration items. This invention aims to solve the problem of N>10. 4 Designed to address the storage explosion problem in the past, this application has the following advantages compared to existing technologies: 1. Existing technologies only perform prediction and data storage. This application further segments the prediction results into significant / non-significant categories using an information entropy threshold (significance threshold θ), and then continuously records weight drift using an incremental snapshot chain, thereby achieving: storage volume increases with the "habitual number" rather than the "configuration item" (O(S u )vsO(N)); The weight history can be rolled back to any second (database / virtual machine incremental snapshots have no "weight drift" semantics).

[0025] 2. Existing Bloom filters only perform existence checks in crawlers / caches; this application moves it to the first hop of the HTTP request, forming a millisecond-level decision pipeline together with the role-global default dual threshold rule: the candidate set is reduced from thousands of dimensions to single digits, significantly shrinking the candidate set size; the weight range [θ] low ,θ high This allows for a smooth transition curve in the three-level configuration of "user-role-system" for the first time, avoiding the interface jumps caused by the traditional "hard overlay" and improving user experience metrics.

[0026] 3. Existing Bloom filters are static dictionaries; this application utilizes weighted hot zones to statistically and periodically insert only high-weight atoms into the Bloom filter. P This allows the bit array to shrink dynamically as cold configurations exit, maintaining a constant false positive rate; and enables adaptive BF with dynamic loading of "hot configurations" and automatic exit of cold configurations. Attached Figure Description

[0027] The present invention can be better understood by referring to the description given below in conjunction with the accompanying drawings, in which the same or similar reference numerals are used throughout the drawings to denote the same or similar parts. These drawings, together with the following detailed description, are incorporated in and form part of this specification, and are used to further illustrate preferred embodiments of the invention and explain the principles and advantages of the invention. In the drawings: Figure 1 This is a schematic diagram illustrating the principle of the user interface preference adaptive system of the present invention. Detailed Implementation

[0028] Embodiments of the present invention will now be described with reference to the accompanying drawings. Elements and features described in one drawing or embodiment of the invention may be combined with elements and features shown in one or more other drawings or embodiments. It should be noted that, for clarity, representations and descriptions of components and processes unrelated to the present invention and known to those skilled in the art have been omitted from the drawings and description.

[0029] The core problem solved by this invention is: how to handle a massive number of users and massive configuration items (N>10) 4Against the backdrop of storage explosion, this approach aims to efficiently and accurately record and apply each user's personalized UI habits while avoiding storage explosion and performance bottlenecks.

[0030] To address this, this invention provides a user interface preference adaptive system and method, which introduces a hierarchical weighted compression model and an incremental snapshot mechanism. The hierarchical weighted compression model models user preferences as a multi-layered, weighted sparse matrix. Through "configuration item-weight" separation storage and weight quantization based on information entropy, storage space is compressed by over 90%. Incremental snapshots and version merging: each time a user adjusts their preferences, the system does not overwrite the original record but generates a very small incremental snapshot. Through a multi-version merging algorithm, the system restores the user's complete preference state at any point in time, while simultaneously achieving historical backtracking and garbage collection. Furthermore, preference preloading and conflict resolution based on Bloom filters: when a user logs in, the system uses a Bloom filter to quickly predict the preferences the user might need and intelligently resolves conflicts with global default values ​​and role default values, achieving millisecond-level personalized rendering.

[0031] See Figure 1 The user interface preference adaptive system of the present invention includes a preference event collector, a hierarchical weight calculation engine, an incremental snapshot generator, a preference state reconstructor, a preference conflict resolver, and a personalized configuration assembler. The following describes the solution of the embodiments of the present invention in detail: 1. Hierarchical weighted compression model Definition (Preference Atom): The smallest, indivisible unit of UI configuration. For example: page_size:30, tag_show: relay status, default_auto_login:on. The system has N preference atoms, forming the universal set U.

[0032] Traditional problem: Store an N-dimensional vector for each user (even if it is mostly the default value), with a storage cost of O(M*N) (where M is the number of users).

[0033] The solution of this invention: Hierarchical weight representation: The degree of preference of user u for preference atom i is represented as a three-layer weight scalar W. u (i), rather than simply 0 / 1.

[0034] W u (i)=α·W explicit (u,i)+β·W implicit (u,i)+γ·W inherit (r,i); Where α + β + γ = 1; α, β, γ are adjustable mixing coefficients. W u (i) represents the combined weight of user u on preference atom i.

[0035] W explicit (u,i)(explicit weights): The strength set manually by the user.

[0036] Quantification rules: Initial settings: Weight = 0.7; Repeat the same settings: weight = min(1.0, previous weight + 0.1) (reinforcing habits); Reverse setting (e.g., turning it on and then off): Weight = previous weight * 0.5 (weakening habit).

[0037] W implicit (u,i) (implicit weights): The strength derived from behavioral analysis.

[0038] Calculation example: W implicit (u,i)=log2(1+F)×S, where F is the frequency of the behavior and S is the weight of the behavior. For example, if you manually switch to tag A every time you visit, the implicit weight of "show tag A" will continue to increase.

[0039] W inherit (r,i)(Inherited Weight): The default strength inherited from the user's role / group. This is a fixed baseline value.

[0040] Sparse storage based on information entropy: The complete preference vector of a user is extremely sparse (most atoms remain at their default values). This application stores only the salient preference set S for each user u. u : S u ={i||W u (i)-W global_default (i)|>θ} where θ is the significance threshold (e.g., 0.3).

[0041] For i∈S u This application stores (i, W) u (i)); for i S u Then its weight is considered to be equal to the global default weight W. global_default (i).

[0042] The storage overhead is reduced from O(N) to O(|Su|), while |S u |<<N.

[0043] Based on incremental snapshots and versioned merging: User preferences evolve over time, and traditional overlay storage cannot trace back, and each update requires reading and writing the entire vector. Therefore, this invention employs an operation-based incremental snapshot chaining scheme.

[0044] Snapshot definition: Each time a user triggers a preference change (manual or implicit reinforcement), an incremental snapshot Δ is generated.

[0045] The data structure for Δ is: Δ = (timestamp, user_id, operation_list).

[0046] operation_list is a set of operations, each of which is (atom_id, weight_delta).

[0047] Example: If a user changes the pagination from 10 to 30, then Δ=(t1,u1,[(page_size_30,+0.7),(page_size_10,-0.7)]) is generated. Note that this is a "weight transfer" operation, and the total weight is conserved.

[0048] Multi-version merging and state restructuring: To obtain the preference state (State(u,t) of user u at any time t, the system does not need to traverse all historical snapshots.

[0049] Baseline + Incremental Method: The system periodically (e.g., daily) generates a full baseline snapshot. u (t base ), including S u All significant preference atoms and their weights.

[0050] State reconstruction function: State(u,t)=Merge(Base) u (t base ),{Δ|t base <Δ.timestamp<=t}).

[0051] The Merge function efficiently calculates the weights at time t by sequentially applying the increment operation's weight_delta. The weight change, weight_delta, is defined as a differential operator, and its formula is weight_delta = W new -W old , used to record the non-linear superposition of weights. W new The new weight is the instantaneous weight value in the instant after the change. It represents the preference field strength calculated by the system based on the user's latest operation (explicit / implicit / inherited) at the current timestamp t. old The old weight is the baseline weight value in the instant before the change. It is the "original charge" recorded in the most recent baseline snapshot or the previous incremental chain node before the system executes a new operation. It is the stable state of the system before the new calculation is performed.

[0052] Historical backtracking and garbage collection: Old baselines can be cleaned up, only the latest baseline and subsequent incremental chains need to be retained, realizing the recycling of storage space while retaining the full historical change capability.

[0053] The significance threshold θ abstracts "user habits" into measurable information gain, thus transforming the "preference storage" problem into an "entropy compression" problem for the first time; the incremental snapshot chain adopts "weight transfer" semantics (+Δ, Δ appears in pairs, ensuring the conservation of total weight and enabling the system to have reversible rollback capability, while database / VM snapshots only record "state differences" and have no conservation constraints.

[0054] 3. Preference preloading and conflict resolution based on Bloom filters When a user requests a page, it is necessary to quickly retrieve all the preferences associated with that page.

[0055] Page - Preference Index and Bloom Filter: Build an inverted index: Maintain a Bloom filter BF_P for each page (or context) P. This filter contains all the preference atom IDs that may appear on that page.

[0056] Preloading and resolution: a. When a user visits page P, the server obtains the user's salient preference set S. u .

[0057] b. Using BF P For S u Filtering is performed to quickly obtain the candidate preference set Cand u ={i|i∈S u AND BF P .contains(i)}. Bloom filters can complete the filtering in constant time, greatly reducing the amount of data that needs further processing.

[0058] c. Conflict resolution: For each atom i in Candu, calculate the final effective value: If W u (i)≥θ high If so, then the user preference value will be used; If W u (i)≤θ low If so, the role / global default value will be used; Otherwise, use W u (i) Weighted average with the default value (smooth transition).

[0059] Where θ high and θ low This is the decision threshold for conflict resolution. The specific method for obtaining it is as follows: Step 1: Collect micro-behavior: The system periodically (e.g., hourly) traverses the user's incremental snapshot chain. For each atom i, calculate its weight drift direction: drift(i) = Σ(Δ weight ); Step 2: Statistical Distribution: Sort the drift(i) values ​​of all atoms to form an energy spectrum distribution. In this distribution: Top 5%: Corresponding to high-energy states, users continuously strengthen their preference. Bottom 5%: Corresponding to low-energy states, users continuously weaken their preference.

[0060] Step 3: Set the macroscopic threshold: Based on the above distribution, calculate the average of the two ends: θ high Take the average of the top 5% atomic drifts. θ low Take the average of bottom 5% atomic drift.

[0061] via θ high and θ low The Top / Bottom 5% statistical method allows the system to adaptively adjust based on actual usage. Using fixed values ​​(e.g., directly setting them to 0.8 / 0.2) cannot handle the differences in business operations. Furthermore, in high-activity environments, where most users are modifying configurations, the Top 5% value will automatically increase, θ. high Improve this to prevent the system from being over-activated. During periods of low activity, if users make almost no changes to their configurations, the Top 5% value decreases, and θ... high When the threshold is lowered, the system is more likely to accept subtle changes in preferences.

[0062] Compared with existing technologies, this application significantly optimizes storage efficiency: through sparse storage of "significant preference sets" and "incremental snapshot chains," the storage overhead for each user's preferences is reduced from being proportional to the total number of configuration items (N) to being only proportional to the number of their unique habits (|S). u The improvement is proportional to the speed of data, usually by 1-2 orders of magnitude, and supports complete historical tracking.

[0063] A qualitative leap in response speed: By utilizing Bloom filters for page-level preference pre-screening, the amount of preference data processed for each request is minimized. Combined with "baseline + incremental" state reconstruction, it can respond to user preference queries in constant time, achieving true millisecond-level personalized rendering.

[0064] The scientific rigor and flexibility of preference modeling: By introducing a hierarchical weight model, explicit actions, implicit habits, and role inheritance are uniformly quantified into computable weights, making "user habits" measurable and calculable. The weight model allows for smooth transitions and intelligent conflict resolution, avoiding abrupt, either-or switching.

[0065] Robust and elegant system architecture: This invention deeply integrates information theory (sparseness), data structures (Bloom filters, incremental logs), and version control theory to build a high-concurrency, highly available user preference service. It is not just a feature, but a comprehensive enterprise-level solution capable of handling massive numbers of users and complex configurations.

[0066] The parameters in the above formula are explained in detail below: 1. Preference Atom Parameters: Preference atoms are the most basic and indivisible UI configuration units in the system.

[0067] i (Preference Atomic Identifier): Preference atomic identifier. Uniquely identifies a specific, smallest-grained user interface configuration item. Data type: String or integer ID. Values ​​and examples: page_size_30: Indicates that the page size is set to 30. tag_show_call_quality: Indicates that the "Call Quality" label is displayed. default_auto_login_on: Indicates that passwordless login is enabled by default when creating resources. Function: The basic unit constituting all preference operations and calculations.

[0068] U (Global Preference Atom Set): The global preference atom set. The set of all preference atoms supported by the system. Data type: Set {i1,i2,i3,...,iN}, where N is the total number of atoms. Values: For example, U={page_size_10,page_size_30,page_size_50,tag_show_a,tag_show_b,...,default_auto_login_on,default_auto_login_off}. Purpose: Defines the theoretical boundary of the system's personalization capabilities.

[0069] 2. User and context parameters, used to identify the subject of the action and the context in which it occurs.

[0070] u(User Identifier): User Identifier. Uniquely identifies a system user (e.g., HostingUser, Reseller). Data type: String (e.g., username, UUID) or integer ID. Purpose: Owner and associated entity of all preference data.

[0071] P (Page / Context Identifier): Page or context identifier. Identifies a specific user interface view or operation scenario. Data type: String (e.g., route address). Values ​​and examples: pbx_list_view, pbx_detail_view, resource_creation_modal. Function: Used to associate and filter preference atoms that may be effective in this scenario.

[0072] `role(u)` (or `r`, user role function): User role function. Returns the role or user group to which user `u` belongs. Return value: Role identifier, such as `hostinguser`, `reseller`, `admin`. Purpose: Used to determine the weights of default preferences that a user can inherit.

[0073] W u (i) (User Overall Weight): The overall preference weight of user u for preference atom i. It is a continuous value between 0 and 1, with a larger value indicating a stronger tendency to adopt the configuration corresponding to that atom. It is the core basis for the system to determine the user's final preference.

[0074] W explicit (u,i) (Explicit Weights): The weights resulting from user u's explicit operation on atom i. Directly reflects the user's active settings. Used to accurately record the user's active choices.

[0075] W implicit (u,i) (Implicit Weights): The weights derived from user u's implicit behavior toward atom i. Reflects the user's usage habits.

[0076] F (Behavior Frequency): The number of times a behavior indicating preference i occurs within a statistical period. For example, manually clicking to expand the "Advanced Tabs" area every time you visit a PBX list page will increase the F value of the tabs in that area.

[0077] S (Behavior Intensity Coefficient): A coefficient assigned to the value of different behaviors. For example, the coefficient for "stay time exceeding the threshold" is 0.1, and the coefficient for "high-frequency clicks" is 0.3. Purpose: To capture users' unspoken but actual preferences.

[0078] W inherit (r,i)(Inherited Weight): The default weight of role r relative to atom i. Data type: A default constant (between 0 and 1). Values ​​and examples: For role reseller, W inherit (reseller, page_size_30) = 0.6; for default_auto_login_on, W inherit (reseller,...)=0.2. Purpose: To provide a reasonable starting point for new users or users with unclear preferences.

[0079] α, β, γ (Weight Mixing Coefficients): Hierarchical weight mixing coefficients. They represent the proportions of explicit weights, implicit weights, and inherited weights in the calculation of the comprehensive weight Wu(i), respectively. Constraint: α + β + γ = 1. Example values: α = 0.6, β = 0.3, γ = 0.1. This indicates that the system trusts the user's direct operations more, while also considering their behavioral habits, with minimal influence from pre-defined roles. Function: Controls the degree of trust in different sources of evidence by the system; it is an adjustable hyperparameter.

[0080] W global_default (i) (Global Default Weight): The global system default weight for atom i. This weight is used when a user's preference does not meet the "significant" criterion. Value: Usually set to a baseline inherited weight, or a neutral value such as 0.5. Purpose: Serves as a benchmark for measuring whether a user's preference is "significant".

[0081] θ (Significance threshold: The significance threshold is used to determine whether a user's preference is unique enough to require separate storage. Example value: θ = 0.3. If the absolute value of the difference between a user's weight for a certain atom and the global default weight is greater than 0.3, it is considered a significant preference of that user. Function: Key to achieving sparse storage, filtering out a large number of irrelevant default preferences.)

[0082] S u (Set of Significant User Preferences): The set of significant preferences for user u. It only includes preference atoms whose weights significantly deviate from the system default values. Data structure: Set {i1, i2, ..., i...} K}, where K=|S u | and K << N. Stored content: For S u For each atom i in the array, store a tuple (i, W) u (i)). Effect: Reduces storage overhead from O(N) to O(|S). u |) enables massive data compression.

[0083] Δ (Incremental Snapshot): Records one or a group of events that cause a change in the weight of a user's preference. Data Structure: Tuple (timestamp, user_id, operation_list). Purpose: Replaces full overwrite, recording history incrementally, saving storage and supporting backtracking.

[0084] Operation (Weighted Operation): The basic unit constituting the `operation_list`, describing changes to the weight of a single atom. Data Structure: Tuple (atom_id, weight_delta). Example Values: (page_size_30, +0.7), (page_size_10, -0.7). This indicates that the weight was transferred by 0.7 from page_size_10 to page_size_30. Purpose: To accurately describe the micro-level weight changes caused by a single user interaction.

[0085] Base u (t base (User Baseline Snapshot): A full baseline snapshot of user u at time t_base. It represents the complete state of u at a given point in time. Data Structure: Set {(i,W u (i))|i∈S u at time t base Function: As the starting point for incremental merging, it avoids replaying all Δ values ​​from the very beginning of history.

[0086] State(u,t) (User Preference State): The complete preference state of user u at a specific time t. Purpose: The system can reconstruct the user's precise preferences in the past or present at any time using this function.

[0087] BF P (Page Bloom Filter): A Bloom filter for page P. A probabilistic data structure used to quickly determine whether a preference atom i is likely to be used on page P. Method: BF P `.contains(i)` returns true or false (there may be a small probability of false positives). Its function is to filter the user's `Su` (Su's) set of candidate preferences (`Cand`) relevant to the current page within milliseconds. u This greatly improves query performance.

[0088] Cand u (Candidate Preference Set): Within the current page context P, a potentially relevant subset of user u's salient preferences. Purpose: The range of data requiring further conflict resolution.

[0089] θ high (High confidence threshold): High confidence threshold. When W u (i)≥θ high At this time, the system completely trusts the user's personal preferences and directly adopts the corresponding configuration. Example value: θ high =0.8. Function: Threshold parameter used for decision-making.

[0090] θ low(Low confidence threshold): Low confidence threshold. When W u (i)≤θ low At this point, the system deems the user's preference too subtle and switches to using a role or a global default value. Example value: θ low =0.3. Function: A threshold parameter used for decision-making, which, together with θ_high, defines three decision intervals.

[0091] In existing technologies, storage methods typically employ full storage or simple key-value pairs, which are insufficient to handle tens of thousands of configuration items. Update mechanisms rely on overwrite, resulting in the loss of historical versions and making backtracking impossible. Query logic involves directly traversing all configurations or using a simple LRU cache, lacking intelligent filtering. This invention adopts the above-mentioned solutions and offers the following improvements: 1. Storage method: Sparse storage of significant preference set is adopted, and non-significant preferences are filtered based on information entropy compression (significance threshold θ). Only a small number of items that deviate from the default value are saved for each user. The storage overhead increases with the number of unique habits rather than the total number of configuration items. 2. Complete historical backtracking: The incremental snapshot chain Δ retains all weight change events, can reconstruct the preference state at any time, supports millisecond-level historical backtracking, and supports auditing and canary rollback; 3. Query logic: Bloom filters predict page relevance, enabling "on-demand loading" instead of "full scan" and achieving millisecond-level rendering: After page-level Bloom filters pre-filter, the candidate set is greatly reduced, and querying and conflict resolution can be completed in constant time; 4. Smooth role inheritance: The weights of explicit, implicit, and inheritance are linearly integrated to avoid hard switching of "either / or". Changes in roles within the same enterprise do not require rewriting user vectors. 5. Lightweight write operations: Each user UI tweak generates only a tiny increment Δ, significantly reducing write amplification; 6. Versatile across scenarios: Not only applicable to "recommended items", but also applicable to any fine-grained UI atom, achieving true "full interface personalization".

[0092] In summary, this invention surpasses existing technologies in all aspects, including storage efficiency, historical traceability, online rendering performance, role inheritance mechanism, and write amplification suppression, filling the gap in UI personalization technology for scenarios with "massive users + massive configuration items".

[0093] Although the invention has been disclosed above through the description of specific embodiments, it should be understood that all the embodiments and examples described above are exemplary and not restrictive. Those skilled in the art can design various modifications, improvements, or equivalents to the invention within the spirit and scope of the appended claims. These modifications, improvements, or equivalents should also be considered to be included within the protection scope of the invention.

Claims

1. A user interface preference adaptive system, characterized in that, include: a) Preference atom definition module, used to divide user interface configuration items into preference atoms of the smallest granularity and establish a global preference atom set U; b) A hierarchical weight calculation engine is used to quantify the comprehensive weight of a user's preference atom into a linear combination of explicit weights, implicit weights, and inherited weights: IN u (i)=α·W explicit (u,i)+β·W implicit (u,i)+γ·W inherit (r,i); Where α+β+γ=1; W u (i) represents the combined weight of user u on preference atom i, W explicit (u,i) are explicit weights, W inherit (r,i) represents the inheritance weight, and r represents the role of user u; W implicit (u,i) represents the implicit weights, which are derived from the user's implicit behavior frequency F and intensity coefficient S using the formula W. implicit (u,i) = log2(1+F)×S is calculated; c) A sparse storage manager for storing user u's personalized configuration only as a set of salient preferences, S. u Obtained by filtering with a significance threshold θ, only storing results satisfying |W u (i)-W global_default (i) Preferred atoms of |>θ, and persistent data using a combination of baseline snapshots and incremental snapshot chains; W global_default (i) represents the global default weight; d) Context preloader, used to maintain page-level Bloom filters (BF). P When a user visits page P, a Bloom filter (BF) is used. P For the significant preference set S u Perform quick filtering to obtain the candidate preference set Cand u ;as well as e) Conflict resolution processor, used for resolving conflicts in the candidate preference set Cand u The preferences in the settings execute conflict resolution logic to determine the final UI configuration value that takes effect.

2. The system as described in claim 1, characterized in that, The hierarchical weight calculation engine includes an explicit weight update unit, which is configured as follows: When a user first sets up atom i, it is assigned an initial explicit weight W. explicit (u,i) is 0.7; If a user repeats the same settings, the current explicit weight W will be changed. explicit (u,i) increases by 0.1, with a maximum value of 1.0; If the user performs the reverse operation, then the current explicit weight W will be changed. explicit (u,i) multiplied by 0.

5.

3. The system as described in claim 1, characterized in that, The sparse storage manager is further configured as follows: When a change in user preference is detected, an incremental snapshot Δ is generated. The incremental snapshot Δ includes a timestamp, a user identifier, and an operation list. The operation list records the operation type, the target atom identifier, and its weight change. as well as The system periodically generates full baseline snapshots. u (t base ), and use the Merge function to transfer the Base u (t base ) and t base Subsequent incremental snapshots are merged to reconstruct the user's complete preference state State(u,t) at any historical time t.

4. The system as described in claim 3, characterized in that, The sparse storage manager is further configured to: retain the latest baseline snapshot and all incremental snapshots after generating a new limit snapshot; delete the old baseline snapshot; and when it is necessary to backtrack to a historical state, use the retained incremental chain to reverse the operations in the operation list to achieve lossless backtracking of the entire historical cycle.

5. The system as described in claim 3, characterized in that, The context preloader works in conjunction with the conflict resolution processor, specifically including: The context preloader is configured to utilize BF P Filtering S in constant time u Obtain the candidate preference set Cand u ; The conflict resolution processor is configured such that, for atom i in the candidate set, if W u (i)≥θ high If W, then the user preference value is used directly; u (i)≤θ low If the value is positive, the role or global default value is used; otherwise, the weighted average value is used; θ high With θ low The system dynamically generates a conflict resolution threshold based on weight drift analysis. The system periodically scans user behavior and calculates the percentage of positive and negative values ​​for each atomic weight change. high θ represents the average weight of the top 5% of positively drifting atoms. low The average weight of the last 5% of negatively drifting atoms.

6. The system as described in claim 5, characterized in that, The BF Bloom filter P Only inserts satisfying W u (i)≥θ hot High-weighted atoms, θ hot For the dynamic thermal threshold, θ hot >θ high The system periodically removes cooled atoms from BF P Remove from the middle to form a dynamic hot configuration set.

7. A user interface preference adaptive method based on hierarchical weighted compression and incremental snapshots, applied to the system described in any one of claims 1-6, characterized in that, Includes the following steps: S1. Model the user's preferences for N configuration items as a weighted sparse vector; S2. Introduce a significance threshold θ, and only persist atomic terms whose weights deviate from the global default value by more than θ; S3. When a user interaction is detected that causes a change in preference, the original record is not overwritten, and an incremental snapshot Δ is generated. The incremental snapshot Δ includes a timestamp, an atom identifier, and a weight change amount. S4. Utilize a page-level Bloom filter (BF) P The user's significant preference set is quickly filtered to remove configuration items irrelevant to the current page, resulting in the candidate preference set Cand. u ; S5. For the filtered candidate preference set Cand u According to W u (i)≥θ high Use user preferences, or otherwise use role or global default values ​​to complete UI rendering.

8. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the program is executed by the processor, it implements the method as described in claim 7.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the program, it implements the method as described in claim 7.

Images