Cross-device real-time dynamic grouping adjustment system

Abstract

The invention provides a cross-device real-time dynamic adjustment grouping system which comprises an identity authentication module, a distributed synchronization module, a rule engine module, a trigger engine module and an algorithm engine module, and all the modules are coupled and interacted through standardized data interfaces. Unified management and authentication of user identities in a multi-device environment are realized by establishing a user-device-grouping ternary association relationship, static distribution and dynamic adjustment of user permissions are realized by adopting a dynamic adjustment strategy, a multi-dimensional grouping rule is formulated to screen out users meeting conditions as the same group, and grouping is dynamically adjusted by adopting a multi-dimensional triggering strategy. Based on a K-means clustering algorithm in combination with a greedy strategy, intelligent calculation and optimization of dynamic grouping are performed, data synchronization among devices is realized based on a distributed architecture, and real-time dynamic adjustment and efficient cooperation of grouping in a cross-device environment are realized.

Description

Technical Field

[0001] The present invention relates to the field of cross-device group adjustment, and in particular to a system for real-time dynamic group adjustment across devices. Background Art

[0002] Existing cross-device group data synchronization technologies often utilize a "single central server + terminal device" hardware architecture. The central server is typically deployed as a single machine or in a simple cluster, and the terminal devices rely on HTTP / HTTPS protocols to interact with the central server. Synchronization typically involves a terminal device initiating a group adjustment request, which the central server receives and processes, then broadcasts to the relevant devices.

[0003] However, this model has numerous problems: First, the central server can easily become a performance bottleneck. When faced with a large number of concurrent device requests, data processing and distribution efficiency plummets, leading to significant synchronization delays. Second, the HTTP protocol's request-response model lacks real-time performance, making it difficult to meet the demand for instant updates of grouped data. Third, it lacks an effective conflict resolution mechanism. When multiple devices simultaneously adjust the same group, data conflicts can easily arise, resulting in inconsistent grouped data. Furthermore, this architecture is highly dependent on the network, and synchronization can be easily interrupted when the network is unstable.

[0004] Based on this, the technical problem to be solved by this application is: how to synchronize dynamically adjusted cross-device grouping data in real time. Summary of the Invention

[0005] To solve the above problems, the present invention provides a system for real-time dynamic adjustment of grouping across devices. A central node is constructed through a distributed cluster, and edge nodes are combined to realize local data processing and storage, which greatly improves the system throughput and response speed. Multi-dimensional grouping rules are formulated to screen qualified users into the same group, and a multi-dimensional trigger strategy is used to dynamically adjust the grouping. Based on the K-means clustering algorithm combined with the greedy strategy, intelligent calculation and optimization of dynamic grouping are performed to realize real-time update of dynamic adjustment of group data across devices.

[0006] To achieve the above object, the technical solution adopted by the present invention is: The present invention provides a system for real-time dynamic grouping adjustment across devices, comprising a distributed synchronization module, wherein the distributed synchronization module is respectively connected to an identity authentication module, a rule engine module, a trigger engine module, and an algorithm engine module; Identity Authentication Module: This module is used for unified management and authentication of user identities in a multi-device environment, and builds cross-device identity mapping relationships. Through the ternary relationship of user, device, and group, corresponding permissions are assigned according to user roles. Distributed synchronization module: used to build a distributed synchronization network, with the LAN server or cloud server as the central node for storing global group data, and each device as the edge node for caching local group copies, and performing real-time synchronization and update of cross-device group data; Rule engine module: used to formulate multi-dimensional grouping rules, filter users authenticated by the identity authentication module based on the grouping rules, group qualified users, and synchronize group data through the distributed synchronization module; Trigger engine module: used to monitor system status in real time, trigger dynamic grouping according to preset conditions based on multi-dimensional trigger strategies, and synchronize group data through distributed synchronization modules; Algorithm engine module: Based on the K-means clustering algorithm combined with the greedy strategy, it dynamically adjusts and optimizes the grouping and synchronizes the group data through the distributed synchronization module.

[0007] Furthermore, the identity authentication module includes an identity authentication unit, an identity association unit and an authority control unit; The identity authentication unit supports multiple identity authentication methods, adopts standard protocols, integrates multi-factor authentication methods, and is compatible with different authentication sources through adapter mode; The identity association unit binds the user identity by establishing a ternary association relationship of user-device-group; The permission control unit performs fine-grained permission management based on the RBAC model, supports group-level permission configuration, and realizes dynamic permission control in combination with attribute-based access control strategy.

[0008] Furthermore, in the identity association unit, establishing a ternary association relationship of user-device-group includes the following steps: Establishing associations between users and devices: Collecting hardware and software environment information, formulating multi-device binding strategies, and evaluating binding trust levels; Establish associations between devices and groups: divide grouped devices into whitelists, formulate device group caching strategies, and process device switching events through the identity association unit to achieve device switching synchronization; Establish associations between users and groups: Analyze and group device usage patterns, detect abnormal device behavior, and trigger group adjustments; Abnormal correlation detection: The associated data is encrypted and stored, and abnormal correlation patterns are identified based on the isolation forest algorithm and alarms are issued.

[0009] Preferably, when evaluating the trust level, evaluation indicators include device usage time, geographic location consistency, operating habit matching, and multi-factor authentication.

[0010] Further, in the authority control unit, a mixed authority model combining the RBAC core framework and the ABAC dynamic strategy is adopted, and the static allocation and dynamic adjustment of the authority are realized through a strategy engine, including the following steps: A role system is constructed, and the roles and corresponding authorities are designed in layers. Static role allocation and dynamic role authority inheritance are performed. The set authorities are cached and verified. User attributes are divided and collected, and an attribute system is constructed. The priority of the strategy is set, and the priority of the ABAC dynamic strategy is higher than that of the RBAC static authority. When a strategy conflict occurs, the strategy that takes effect most recently is given priority. An attribute triggering mechanism is set, and dynamic authority evaluation is performed. Roles and authorities are bound, and the group authorities are dynamically adjusted. A conflict detection mechanism is designed, and a conflict resolution strategy is adopted according to the detected conflict. An audit authority log record is set, and an authority backtracking mechanism is set. Abnormal authority access is monitored and alarmed.

[0011] Further, in the distributed synchronization module, a three-level conflict processing mechanism is designed, including: Optimistic lock prevention: each group data carries a version number, and the current version needs to be attached when the device end submits a modification. If the center node finds that the versions are inconsistent, it will reject the request. Automatic arbitration: for non-critical conflicts, the last write wins strategy is adopted, and the operation with the latest timestamp of the center node is used as the reference. Manual intervention: for critical conflicts, a conflict resolution interface is triggered, and the administrator can view the operation log and select the retained version. The system automatically generates a conflict resolution solution.

[0012] Further, the rule engine module, the execution process includes the following steps: Rule definition: a multi-dimensional grouping rule system is formulated, including static attribute grouping rules, dynamic behavior grouping rules, and task scene adaptive grouping rules. A graphical rule editor is used to generate a graphical rule configuration interface. Administrators can combine condition expressions through drag-and-drop methods. The rules are stored in DRL format. Rule analysis: DRL rules are parsed by ANTLR4 syntax parser to generate abstract syntax trees, which are converted into executable Java bytecode. Rule validators are used to detect condition conflicts / coverage. Rule indexers are used to build fast matching indexes. Rule execution: efficient pattern matching is performed through the Rete algorithm, which supports weight factors and constraint conditions. A parallel rule matching engine is built based on the Fork / Join framework, and the execution results are cached.

[0013] Furthermore, the execution process of the trigger engine module includes the following steps: The trigger engine collects monitoring data in real time through probes deployed on various devices and service nodes; Multi-layer processing of collected data, including real-time indicator calculation, status normalization, and anomaly detection; Visualize and store monitoring data; Design multiple trigger strategies for dynamic grouping adjustments, including time trigger strategies, event trigger strategies, and indicator trigger strategies; Determine trigger conditions, filter them, and prioritize them; Get the trigger context and execute the trigger operation to dynamically adjust the grouping.

[0014] Furthermore, the execution process of the algorithm engine module includes the following steps: Extract multidimensional features from user attributes and perform normalization processing. The multidimensional features include static features and dynamic features. Different features are assigned dynamic weights according to the grouping scenario to construct a multidimensional feature space. K-means++ algorithm is used for clustering, and grouping rule constraints are embedded in the initialization stage; During the iterative calculation process, the weighted Euclidean distance between the user and each cluster center is calculated, and the user is assigned to the cluster with the closest distance. After the iteration is completed, the grouping that does not meet the hard constraints is forcibly corrected; Define multiple soft constraint evaluation indicators, evaluate the soft constraint indicators of each group in turn, and start the greedy exchange strategy if they do not meet the standards: Perform local search and refinement adjustments on each group. After all local adjustments are completed, sort the groups by their fitness and re-execute the greedy exchange strategy on the groups whose fitness scores are lower than the threshold. When user characteristics change, the impact of the change is evaluated and local re-clustering is initiated for the affected groups. Receive the grouping request sent by the trigger engine and extract the set of users participating in the grouping; Generate multiple grouping schemes in parallel based on different K values, and perform triple verification on the feasibility of the schemes; A multi-objective decision-making method is used to rank multiple sets of plans, comprehensively considering the hard constraint satisfaction, soft constraint score, and historical effect reference, and selecting the plan with the highest comprehensive score as the final grouping result. Administrators are allowed to manually fine-tune the automatically generated plan and output the generated grouping plan.

[0015] The beneficial effects of the present invention are: The present invention provides a system for real-time dynamic adjustment of groups across devices, comprising an identity authentication module, a distributed synchronization module, a rule engine module, a trigger engine module and an algorithm engine module, wherein the modules are coupled and interacted with each other through standardized data interfaces; by establishing a ternary association relationship of user, device and group, unified management and authentication of user identities in a multi-device environment are achieved, a dynamic adjustment strategy is adopted to achieve static allocation and dynamic adjustment of user rights, multi-dimensional grouping rules are formulated to screen qualified users into the same group, a multi-dimensional trigger strategy is adopted to dynamically adjust the groups, intelligent calculation and optimization of dynamic groups are performed based on an improved K-means clustering algorithm combined with a greedy strategy, data synchronization between devices is achieved based on a distributed architecture, and real-time dynamic adjustment and efficient collaboration of groups in a cross-device environment are achieved. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1 This is a system block diagram of the present invention for dynamically adjusting grouping across devices in real time. DETAILED DESCRIPTION

[0017] See also Figure 1 As shown, the present invention relates to a system for real-time dynamic adjustment of groups across devices, comprising a distributed synchronization module, wherein the distributed synchronization module is respectively connected to an identity authentication module, a rule engine module, a trigger engine module, and an algorithm engine module; Identity Authentication Module: This module is used for unified management and authentication of user identities in a multi-device environment, and builds cross-device identity mapping relationships. Through the ternary relationship of user, device, and group, corresponding permissions are assigned according to user roles. The identity authentication module includes an identity authentication unit, an identity association unit and an authority control unit; The identity authentication unit supports multiple identity authentication methods, adopts standard protocols such as OAuth2.0, SAML2.0, JWT, integrates multi-factor authentication methods such as biometrics (fingerprint / facial recognition) and hardware tokens (U2F), and is compatible with different authentication sources (such as campus unified identity authentication, enterprise AD domain) through adapter mode. The adapter mode refers to adapting one type of interface to the interface type expected by the user, so that different devices can be compatible.

[0018] The identity association unit binds user identities by establishing a ternary association relationship of user, device, and group, realizes cross-device identity binding through device fingerprint technology (hardware serial number + software environment hash value), and supports dynamic evaluation of device trust levels (new devices require secondary verification, and commonly used devices can log in without a password). For example, device trust management is divided into three layers, including trusted devices (first authentication + secondary verification), suspicious devices (requires multi-factor authentication, i.e., MFA), and unknown devices (isolated access).

[0019] The establishment of a ternary association relationship of user, device, and group includes the following steps: Establishing associations between users and devices: Collecting hardware and software environment information, formulating multi-device binding strategies, and evaluating binding trust levels; When accessing for the first time, the client obtains the device hardware identification (such as CPU serial number, motherboard serial number, MAC address) through the underlying API and collects software environment information (operating system version, browser fingerprint, installed application hash value).

[0020] Develop a multi-device binding strategy. Multiple devices include primary devices, secondary devices, and temporary devices. For example, a user can designate one commonly used device as the primary device (such as an office computer), which has the highest trust level. The user can bind up to five secondary devices (such as mobile phones and tablets), and the binding must be confirmed through the primary device. When accessing an unbound device, secondary verification (scanning a QR code or SMS verification code) is required through the primary device.

[0021] Trust ratings can be assessed based on four evaluation criteria: device usage time, geographic location consistency, user experience match, and multi-factor authentication. For example, consider setting device usage time to 30 points, geographic location consistency to 20 points, user experience match to 30 points, and multi-factor authentication to 20 points. The four scores are then added together to create a total score, which is then used to determine the device's trust level.

[0022] Establish associations between devices and groups: divide grouped devices into whitelists, formulate device group caching strategies, and process device switching events through the identity association unit to achieve device switching synchronization; Administrators can set the types of devices that groups are allowed to access (e.g., only office computers are allowed to access project groups). Research groups can set device location restrictions (e.g., only devices within the campus network are allowed to access).

[0023] Develop a device group caching strategy. For example, the primary device caches the complete data of all participating groups (valid for 7 days), the secondary device caches the basic information of the group and user-related data (valid for 48 hours), and the temporary device does not cache the group data and pulls it from the central node for each access.

[0024] When the device switches synchronously, the old device sends a device switching event to the identity association unit, and the new device requests packet data synchronization from the identity association unit. The identity association unit generates a device difference package and pushes the packet data to the new device, while marking the packet data of the old device as invalid.

[0025] Establish associations between users and groups: Analyze and group device usage patterns, detect abnormal device behavior, and trigger group adjustments; Identified mobile device users (frequent users of mobile phones / tablets) are automatically divided into discussion groups (suitable for short-term interactions), identified desktop device users (frequent users of computers) are divided into programming groups (suitable for long-term focused tasks), and active users across multiple devices are divided into collaboration groups (requiring multiple devices to collaborate to complete tasks).

[0026] Detect whether there are any abnormalities in the device and analyze the type of abnormality. If it is a cross-region login abnormality, it will be classified into a temporary isolation group. If it is an unknown device access abnormality, it will be classified into a risk monitoring group. If it is a high-frequency device switching abnormality, it will be classified into an adaptability test group. The groups classified into the temporary isolation group, risk monitoring group and adaptability test group will be subject to secondary verification and can be restored after passing the verification.

[0027] Abnormal correlation detection: The associated data is encrypted and stored, and abnormal correlation patterns are identified based on the isolation forest algorithm and alarms are issued.

[0028] For unusual association patterns, for example, if the same device is associated with more than 20 groups, it could be an account sharing anomaly; if a user accesses the same group from three different devices within an hour, it could be an account theft anomaly; and if a device belongs to more than 10 different types of groups at the same time, it could be a permission abuse anomaly. We use the Isolation Forest algorithm to identify unusual association patterns and set alarm thresholds. For example, when the triplet anomaly score exceeds 0.8, a security alarm is triggered, high-risk associations are temporarily frozen, and the user is required to reauthenticate.

[0029] The permission control unit implements fine-grained permission management based on the RBAC model, supports group-level permission configuration (such as only allowing the group leader to adjust members), and combines the attribute-based access control strategy (ABAC) to implement dynamic permission control (such as temporarily improving collaboration permissions based on user activity).

[0030] In the permission control unit, a hybrid permission model combining the RBAC core framework with the ABAC dynamic policy is adopted. The static allocation and dynamic adjustment of permissions are achieved through the policy engine. The following steps are included: Build a role system and design roles and corresponding permissions in layers; For example, system-level roles include Super Administrator and General Administrator, group-level roles include Group Leader, Deputy Group Leader, and General Member, and temporary roles include Visitor and Observer (read-only). Set permissions for each role. For example, Group Leader permissions include: modifying group information, adding members, removing members, assigning tasks, and deleting groups (requires secondary verification).

[0031] Static role assignment and dynamic role permission inheritance; Static role assignment: The user applies to the administrator to join a group. The administrator assigns the corresponding role and verifies the role permissions through the permission control unit. After successful verification, the user is notified of the role assignment result.

[0032] Dynamic role inheritance: The deputy group leader automatically inherits all permissions of ordinary members, the group leader automatically inherits all permissions of the deputy group leader + management permissions, and the temporary role (guest) has only read-only permissions and no inheritance relationship.

[0033] Cache and verify the set permissions; Cache the set permissions. You can cache user roles and permission information to the client through local caching. Use distributed caching to cache Redis storage role-permission mapping (TTL=15 minutes). If the cache expires, push an invalidation notification via WebSocket when the role changes.

[0034] When verifying user permissions, the user role is extracted through the user's operation request, and the role permissions are queried. If the permissions exist, the operation is allowed. If the permissions do not exist, the operation is denied and recorded in the operation log.

[0035] Divide and collect user attributes to build an attribute system; These attributes include static attributes such as profession, skill level, and registration time; dynamic attributes such as activity (e.g., number of posts in the past seven days), task completion rate, and collaboration score; and environmental attributes such as device type, network location, and access time. The client obtains user attribute data and constructs an attribute system.

[0036] Set policy priority. ABAC dynamic policy takes precedence over RBAC static permissions. When a policy conflict occurs, the most recently effective policy takes precedence. Set attribute trigger mechanism to perform dynamic permission evaluation; Among them, the attribute trigger mechanism includes timed triggering, scanning all user attributes every 30 minutes to trigger policy matching; event triggering, immediate evaluation when user attributes change, such as activity updates; operation triggering, real-time evaluation of dynamic permissions before performing sensitive operations.

[0037] Bind roles and permissions, and dynamically adjust group permissions; Create groups, set default role permissions, add custom policies, assign initial member roles, generate permission configurations, and synchronize permissions to member devices. For group permissions, an inheritance system is implemented, meaning that child groups automatically inherit the basic permissions of the parent group.

[0038] For example, based on the increase in activity, when the activity is greater than or equal to 90 points, you will temporarily obtain the permission to pin the discussion to the top (valid for 24 hours). When the activity is greater than or equal to 80 points for three consecutive days, you will temporarily obtain the permission to upload and review files. When the activity is less than 30 points, some collaboration permissions will be revoked (only viewing permissions will be retained).

[0039] Design a permission conflict detection mechanism and adopt conflict resolution strategies based on detected conflicts; Static collision detection: Role permission overlap detection: Identify mutually exclusive permissions within the same role (e.g., having both "add" and "delete" permissions but no audit permissions); Policy condition overlap detection: Identifying policies with conflicting effects under the same conditions (e.g., allowing and denying the same action at the same time); Group permission inheritance conflicts: Identify situations where a child group overrides the core permissions of the parent group.

[0040] Dynamic conflict detection: Conflict detection during operation: Check whether RBAC and ABAC permissions conflict before performing an operation; Scheduled conflict scanning: Scan all user permissions at dawn every day and generate a conflict report; Permission change conflict detection: Detect potential conflicts in real time when modifying permission configuration.

[0041] The conflict resolution policy priority rules are set as follows: ABAC dynamic permissions > RBAC static permissions, group-level permissions > global permissions, and the most recently effective policy > historical policies. When a permissions conflict is detected, the conflict type is analyzed and corresponding measures are formulated. These measures require administrator approval. If the administrator approves, the measures are executed. If the administrator rejects, the conflict log is recorded.

[0042] Audit permission log records and set up permission backtracking mechanism; Through permission log records, you can understand permission change records (who modified whose permissions and when), permission usage records (who used what permissions to perform operations and when), and permission denial records (who was denied permissions and when and for what reasons).

[0043] The permission rollback mechanism allows users to understand permission change rollback (supports rollback to any historical version of permission configuration), operation permission rollback (query the specific permission status when an operation is performed), and permission conflict rollback (analyze the causes and resolution processes of historical permission conflicts).

[0044] Monitor and issue alerts for abnormal permission access.

[0045] Abnormal permissions include high-frequency permission operations (performing sensitive permission operations more than five times per minute), cross-region permissions (the same account performing permission operations in different regions within a short period of time), and abnormal permission escalation (a regular user suddenly obtaining high-level permissions, such as group leader permissions). When abnormal permissions are detected, an alarm event is generated and handled in a tiered manner, such as automatic permission freezing at level one, manual review at level two, and logging at level three. The alarm event is then notified to the administrator.

[0046] Distributed synchronization module: used to build a distributed synchronization network, with the LAN server or cloud server as the central node for storing global group data, and each device as the edge node for caching local group copies, and performing real-time synchronization and update of cross-device group data; A distributed synchronization network consisting of "central nodes + edge nodes" is constructed. The central node (LAN server or cloud server) stores global group data, while the edge nodes (each device) cache local copies of the group data. A full-duplex communication channel is established using the WebSocket protocol, enabling real-time data exchange between the central node and each device. When a group adjustment operation (such as adding or removing group members or modifying the group name) is performed on a device, the operation command is first sent to the central node. After the central node updates the global data, it pushes the update to the edge nodes of other relevant devices in real time via a WebSocket persistent connection or a message queue (such as RabbitMQ). Upon receiving the update command, the edge nodes simultaneously update their locally cached group data, thus achieving real-time synchronization of group information across devices.

[0047] The central node cluster is deployed in a Kubernetes cluster and adopts the Spring Cloud Alibaba microservice architecture, including the Nacos service registration center (supporting group data service discovery), RocketMQ message middleware (processing 50,000 synchronous messages per second), and the Redis Cluster cache layer (storing group data version numbers, TTL = 10 minutes).

[0048] The edge node component is embedded in each device client, including a WebSocket long connection module (maintaining real-time communication with the central node, a heartbeat packet interval of 20 seconds, and an exponential backoff algorithm for disconnection and reconnection), a SQLite local database (storing grouped data copies, setting a three-layer cache strategy: memory LRU cache, disk SQLite, and device storage backup), and a conflict resolution engine (handling concurrent modification conflicts on multiple devices).

[0049] Synchronize identity information of multiple devices based on the distributed synchronization network: Device access phase: When a new device logs in for the first time, the client sends an authentication request to the identity authentication module through a TLS1.3 encrypted channel, carrying an authentication token in JWT format, including userId and device fingerprint information.

[0050] Identity association stage: The identity authentication module queries the historical device list of the userId. If it is a new device, it is added to the deviceList and a device association token is generated (valid for 24 hours).

[0051] Real-time synchronization mechanism: When a user modifies personal information (such as avatar, permission role) on device A, the change event is pushed to all associated devices through Apache Kafka message queue, and each device pulls the latest identity data through the gRPC interface and updates the local cache (using LevelDB database, TTL strategy sets the cache validity period to 1 hour).

[0052] Design a three-level conflict processing mechanism: Optimistic lock prevention: Each group data carries a version number (initially 1), and the device end needs to attach the current version when submitting modifications. The center node rejects the request if the versions are inconsistent.

[0053] Automatic arbitration: For non-critical conflicts (such as simultaneously modifying group name and members), use the last write wins (LWW) strategy, and the operation with the latest timestamp on the center node is used as the reference.

[0054] Manual intervention: For critical conflicts (such as simultaneously deleting a group and adding members), trigger the conflict resolution interface, and administrators can view the operation log and select the version to keep, and the system automatically generates a conflict resolution solution.

[0055] Rule engine module: used to formulate multi-dimensional grouping rules, based on the grouping rules to filter the users authenticated by the identity authentication module, and group the users that meet the conditions, and synchronize the grouping data through the distributed synchronization module; Use Drools rule engine as the core component to build the complete process of rule definition-parsing-execution: Rule definition: formulate a multi-dimensional grouping rule system, including static attribute grouping rules, dynamic behavior grouping rules, and task scenario adaptive grouping rules, use a graphical rule editor to generate a graphical rule configuration interface, administrators can combine condition expressions through drag-and-drop, and rules are stored in DRL format; For static attribute grouping rules, the system supports administrators or teachers to customize user attribute tags such as discipline, professional, skill level, and learning progress. The system will automatically filter users that meet the conditions and generate new groups based on pre-set attribute matching conditions. At the same time, user attributes can be dynamically updated, and the system can automatically trigger grouping adjustments based on new attributes. Static attribute grouping rules include the following: Discipline and professional rules: support grouping by multi-level discipline classification (such as "Engineering > Computer Science > Software Engineering"), and match professional names through regular expressions.

[0056] Ability level rules: quantize skill level to 1-5 levels, support interval matching (such as 2-4 levels for intermediate) and discrete value matching (only 4 levels for advanced).

[0057] Time attribute rule: Grouping can be done by registration time (e.g., users registered in the past 30 days) and active time (e.g., users active in the past 7 days).

[0058] For dynamic behavior grouping rules, user behavior evaluation models are established by collecting user operation behavior data in the system (e.g., speech frequency, task completion quality, collaboration participation, etc.). When it is found that a group member has very low participation or frequent conflicts within the group, the system will automatically trigger a grouping adjustment mechanism to reassign the member to a more suitable group. The following dimensions of data are collected: Interaction behavior: Number of speeches (active daily ≥ 5 times), file upload volume (weekly ≥ 3); Task performance: Task completion rate (≥ 80%), completion time (≤ 120% of average time); Collaboration data: @ other times, @ times, group score (≥ 4 points).

[0059] Rule example: "Group users with speech frequency ≥ 10 times in the past 7 days and task completion rate ≥ 90% into the active learning group."

[0060] For task scenario adaptive rules, task-oriented grouping rules are set for different task scenarios in remote or multi-terminal teaching. The system analyzes the user's skill tags (e.g., programming, design, document writing, etc.), calculates the skill complementarity between members through intelligent algorithms, and automatically assigns users to the group with the strongest complementarity to ensure that each group has comparable ability levels and promotes group collaboration efficiency.

[0061] For example: Discussion scenario: Rule is "4-6 people per group, professional complementarity within the group ≥ 70%, active user proportion ≥ 50%"; Programming practice: Rule is "3-5 people per group, programming ability standard deviation ≤ 1.5, group leader ability level ≥ 4 levels"; Presentation: Rule is "5-7 people per group, at least one member with design / speech / document writing ability".

[0062] Rule analysis: DRL rules are parsed by ANTLR4 syntax parser to generate abstract syntax trees, converted into executable Java bytecode, and detected for condition conflicts / coverage using rule validators, and a fast matching index is built using rule indexers; Rule execution: Efficient pattern matching is performed through the Rete algorithm, supporting weight factors and constraint conditions, a parallel rule matching engine is built based on the Fork / Join framework, supporting 100,000-level user rule matching per second, and the execution results are cached to avoid repeated calculations.

[0063] After grouping rules are established, to avoid conflicts, the priority of these rules is designed from highest to lowest: manual grouping rules (specified by the teacher) > task scenario rules > dynamic behavior rules > static attribute rules. If rules of the same priority conflict, the execution order is determined by rule creation time (newer rules take precedence) or weight (configurable from 0 to 100). A rule conflict detection tool is provided, displaying overlapping rule areas through a visual chart to assist administrators in adjusting rule conditions.

[0064] Trigger engine module: used to monitor system status in real time, trigger dynamic grouping according to preset conditions based on multi-dimensional trigger strategies, and synchronize group data through distributed synchronization modules; The execution process of the trigger module includes the following steps: The trigger engine collects monitoring data in real time through probes deployed on various devices and service nodes; The monitoring data includes group status data (regularly scanning the number of people in a group, member activity, task completion rate and other indicators), user behavior data (capturing user operations across devices through embedding points to form a user behavior trajectory map), and system performance data (collecting performance indicators such as the synchronization delay between the central node and the edge node, the execution time of the grouping algorithm, etc., to determine whether the system is in a state suitable for adjustment).

[0065] Multi-layer processing of collected data, including real-time indicator calculation, status normalization, and anomaly detection; Dynamic metrics are calculated using a sliding window algorithm. Metrics of different dimensions (such as headcount and activity scores) are normalized and mapped to the [0, 1] range for unified evaluation. A moving average algorithm is used to identify sudden changes in metrics. For example, if the number of people in a group decreases by more than 50% within 5 minutes, it is marked as an abnormal state.

[0066] Visualize and store monitoring data; Key metrics are visualized and stored, with different colors used to indicate group status. For example, red indicates activity levels < 0.3. Monitoring data from the past period (e.g., 30 days) is stored in a database for analysis of trigger patterns. When a metric exceeds a threshold, an alert is pushed through a message queue, triggering preliminary troubleshooting.

[0067] Design multiple trigger strategies for dynamic grouping adjustments, including time trigger strategies, event trigger strategies, and indicator trigger strategies; Time-triggered strategy: Periodically triggers tasks based on preset Cron expressions. For example, group adjustments are scheduled to start at 8:00 AM on weekdays. Before triggering, the system load is checked. If CPU utilization exceeds 80%, execution is automatically delayed by 30 minutes. For time-consuming group adjustment tasks, execution is restricted to off-peak hours to avoid disrupting normal usage. The trigger time is automatically adjusted based on the user's time zone.

[0068] Event triggering strategies: These include user behavior events, which trigger grouping adjustments when users perform specific operations. For example, if a user exits the same group three times in a row, the system automatically marks them as "not suitable for this group" and triggers regrouping. System status events are triggered when key events are detected, such as the large-scale access of new devices (for example, 30 devices logging in simultaneously in a classroom scenario), which automatically triggers temporary grouping to accommodate sudden demands. Business process events are triggered in conjunction with business progress. For example, when an online course enters the experimental phase, the theoretical learning group is automatically reorganized into an experimental collaboration group, prioritizing device compatibility (for example, if the programming environment has been installed).

[0069] Indicator triggering strategy: including group health indicators, such as activity indicators and balance indicators; user attribute indicators, such as skill mutations and device usage patterns; system performance indicators, such as algorithm execution time and data synchronization pressure.

[0070] Determine trigger conditions, filter them, and prioritize them; First, hard conditions are verified. For example, group adjustments must meet "currently online member count ≥ 3"; otherwise, the trigger is skipped. Soft conditions are weighted and the total score is calculated. For example, adjustments are triggered only if insufficient activity (weight 0.4) + skill imbalance (weight 0.3) + device incompatibility (weight 0.3) score > 0.7. Priority levels are: P0 (system failure leading to inconsistent group data triggers immediate forced reorganization), P1 (abnormal group size, such as < 2 or > 8 members, triggers reorganization within 10 minutes), P2 (persistently low activity, triggers reorganization within the day), and P3 (regular scheduled trigger, executed when system resources are idle). Parallel triggers are queued in order of trigger time. Triggers with intervals of < 5 minutes are combined into a single execution. High-priority triggers can interrupt low-priority tasks. A maximum of two adjustments can be triggered for the same group within 48 hours to avoid frequent reorganizations that impact user experience. Rules with poor performance after triggering (e.g., a decrease in activity after adjustment) will automatically enter a 7-day cool-down period, during which they will no longer trigger.

[0071] Get the trigger context and execute the trigger operation to dynamically adjust the grouping.

[0072] Obtain the trigger type (time / event / metric), specific conditions (e.g., activity level 0.25), target group list, current member characteristics, and system resource status. Select grouping algorithm parameters based on the context. For example, for an emergency trigger (P1 level), reduce the number of K-means iterations from 10 to 5 to prioritize speed. For a regular trigger (P2 level), enable full greedy optimization to prioritize grouping quality.

[0073] The adjustment instruction is pushed to the related device through the distributed synchronization module, the edge node receives the transactional update in the local SQLite first, and then synchronizes to the center node. The synchronization state (success / failure / timeout) of each device is collected after the execution is completed. The failed node is automatically retried for 3 times. If it still fails, the log is recorded and manual intervention is triggered.

[0074] The algorithm engine module: based on the K-means clustering algorithm combined with the greedy strategy, the grouping is dynamically adjusted and optimized, and the grouping data is synchronized through the distributed synchronization module.

[0075] The K-means clustering algorithm combined with the greedy strategy is adopted to realize dynamic grouping. First, the clustering features (such as user attributes, skill level, behavior data, etc.) are determined according to the grouping rules, and the users are mapped to a multi-dimensional feature space. Then, the K-means algorithm is used to preliminarily cluster the users to determine the initial grouping. Then, the greedy strategy is used to optimize the grouping result, and check whether each group meets the rule constraints (such as the number of people limit, skill complementarity, etc.). The members of the grouping that do not meet the conditions are adjusted until all groupings meet the preset rules.

[0076] The execution process of the algorithm engine module includes the following steps: Multi-dimensional features are extracted from user attributes and standardized, including static features and dynamic features. Different features are given dynamic weights according to the grouping scene, and a multi-dimensional feature space is constructed. Static features, such as professional category, skill level score, dynamic features, such as active degree in the past 7 days, task completion rate. All feature values are standardized by Z-Score to convert them into standard feature vectors with a mean of 0 and a standard deviation of 1, ensuring that different dimensional features are comparable. Different features are given dynamic weights according to the grouping scene, for example, in a teaching discussion scene, set the active degree weight to 0.4, the professional complementarity weight to 0.3, and the collaboration score weight to 0.3. The weights can be optimized by historical grouping effect data, such as by genetic algorithm to maximize the skill complementarity within the group.

[0077] K-means++ algorithm is used for clustering, and grouping rule constraints are embedded in the initialization stage; Abandoning the random initialization method, first randomly select a user as the first clustering center, calculate the distance from other users to the center, then select the user farthest from the center as the second center, repeat this process until K initial centers are selected. In the initialization stage, the grouping rule constraints are embedded. For example, if there are at least 3 people in each group, if K=5 and the total number of users is 20, the initialization will preferentially select centers that can meet the subsequent grouping number constraints; if there is a rule that "at least one senior skill member is required in each group", the initialization center will be forced to include such users to ensure that the initial grouping meets the basic constraint conditions.

[0078] During the iterative calculation process, the weighted Euclidean distance between the user and each cluster center is calculated, and the user is assigned to the cluster with the closest distance. After the iteration is completed, the grouping that does not meet the hard constraints is forcibly corrected; The weighted Euclidean distance from each user to each cluster center is calculated, and cluster centers are recalculated after each assignment until the change in cluster center position is less than a preset threshold (e.g., 0.01) or the maximum number of iterations (default 10) is reached. After the iterations are complete, groupings that do not meet hard constraints are forcibly corrected. For example, if a group consists of only two people, users with the closest proximity and the most complementary characteristics are selected from adjacent clusters for migration. If a group lacks a specific role (e.g., a programming group lacks testers), users with that role are selected from other clusters and whose migration would have the least impact on the original grouping. This ensures that all groups meet the hard requirements for number of people, roles, and so on.

[0079] Define multiple soft constraint evaluation indicators, evaluate the soft constraint indicators of each group in turn, and start the greedy exchange strategy if they do not meet the standards: Define multiple soft constraint evaluation metrics, such as skill complementarity (calculated using the cosine similarity of group member feature vectors; smaller values ​​indicate greater complementarity, target ≥ 0.7), activity balance (standard deviation of group member activity, target ≤ 0.2), and device compatibility (percentage of devices supporting the same collaboration tools, target ≥ 80%). Each group is evaluated for these soft constraint metrics. If these metrics are not met, a greedy swap is initiated. This involves selecting one member from another group to migrate into the current group. The resulting fitness gain is calculated. At the same time, one member is selected from the current group to migrate out, and the combined fitness change of the two groups is calculated. The swap combination that maximizes the overall fitness gain is selected and executed. If no positive returns are achieved, the swap is terminated.

[0080] Perform local search and refinement adjustments on each group. After all local adjustments are completed, sort the groups by their fitness and re-execute the greedy exchange strategy on the groups whose fitness scores are lower than the threshold. Five local searches are performed on each group. One or two members are randomly selected and exchanged with members from other groups. If the exchange improves the group's fitness, the new combination is retained. For example, in a programming group, two members with similar skills are exchanged to improve skill complementarity within the group. Global Fitness Sorting: After all local adjustments are made, the group is sorted by fitness. A greedy exchange strategy is re-implemented for groups with fitness scores below a threshold to ensure balanced global group quality. Fitness calculations incorporate both hard and soft constraints. For example, a score of 30 is awarded for meeting the headcount threshold, 40 for meeting the skill complementarity threshold, and 30 for achieving balanced activity. Groups with a total score below 60 trigger a secondary optimization.

[0081] When user characteristics change, the impact of the change is evaluated and local re-clustering is initiated for the affected groups. Using an incremental update optimization mechanism, when a user's characteristics change (e.g., skill score increase, activity decrease), the magnitude of the change is first calculated. Different response strategies are then implemented based on the calculated magnitude of the change. If the characteristic value changes by more than 10%, the fitness change of the user's group and adjacent groups is evaluated. If the change is smaller (<10%), only the user's group is locally adjusted. Local re-clustering is initiated for the affected groups, retaining the grouping of unchanged users and reallocating only the user with the changed characteristics and their adjacent users to avoid global recalculation.

[0082] Receive the grouping request sent by the trigger engine and extract the set of users participating in the grouping; The trigger source receives grouping requests from the trigger engine, including timed triggers (e.g., daily regrouping at 8:00 AM), event triggers (e.g., task release), and indicator triggers (e.g., group activity < 0.3). It also obtains the trigger context (e.g., task type, group size limit). It extracts the set of users participating in the grouping, filters out abnormal users (e.g., those who have been inactive for seven consecutive days), and supplements the user's latest feature data (obtaining the last three days of behavioral data from the real-time data center), ensuring the timeliness and validity of the input data.

[0083] Generate multiple grouping schemes in parallel based on different K values, and perform triple verification on the feasibility of the schemes; For example, in discussion scenarios, the default K=5 (4-6 people per group) is used, while alternative plans with K=4 and K=6 are generated simultaneously, providing more options for subsequent optimization. Each plan undergoes a triple validation process, including hard constraint verification (checking whether all hard requirements such as number of people and roles are met), soft constraint evaluation (calculating indicators such as skill complementarity and activity balance), and performance evaluation (estimating the impact of the grouping plan on subsequent collaboration efficiency, such as predicting task completion rates based on historical data).

[0084] A multi-objective decision-making method is used to rank multiple sets of plans, comprehensively considering the hard constraint satisfaction, soft constraint score, and historical effect reference, and selecting the plan with the highest comprehensive score as the final grouping result. Administrators are allowed to manually fine-tune the automatically generated plan and output the generated grouping plan.

[0085] Through human-machine collaborative optimization, administrators are allowed to manually fine-tune the automatically generated plan. When dragging members to different groups, the system calculates the fitness changes after the adjustment in real time and gives prompts such as "suggested adjustment" or "possible reduction in group quality" to assist administrators in making decisions. It generates and outputs a grouping plan with a JSON structure that includes group details, member list, and grouping basis.

[0086] The above embodiments are merely descriptions of preferred embodiments of the present invention and are not intended to limit the scope of the present invention. Without departing from the design spirit of the present invention, various modifications and improvements made to the technical solutions of the present invention by ordinary engineering technicians in this field should fall within the scope of protection determined by the claims of the present invention.

Claims

1. A system for real-time dynamic grouping across devices, characterized in that: It includes a distributed synchronization module, which is connected to the identity authentication module, the rule engine module, the trigger engine module, and the algorithm engine module respectively; Identity Authentication Module: This module is used for unified management and authentication of user identities in a multi-device environment, and builds cross-device identity mapping relationships. Through the ternary association relationship of user, device, and group, corresponding permissions are assigned according to user roles. Distributed synchronization module: used to build a distributed synchronization network, with the LAN server or cloud server as the central node for storing global group data, and each device as the edge node for caching local group copies, and performing real-time synchronization and update of cross-device group data; Rule engine module: used to formulate multi-dimensional grouping rules, filter users authenticated by the identity authentication module based on the grouping rules, group qualified users, and synchronize group data through the distributed synchronization module; Trigger engine module: used to monitor system status in real time, trigger dynamic grouping according to preset conditions based on multi-dimensional trigger strategies, and synchronize group data through distributed synchronization modules; Algorithm engine module: Based on the K-means clustering algorithm combined with the greedy strategy, it dynamically adjusts and optimizes the grouping and synchronizes the group data through the distributed synchronization module.

2. The system for dynamically adjusting grouping across devices in real time according to claim 1, characterized in that: The identity authentication module includes an identity authentication unit, an identity association unit and an authority control unit; The identity authentication unit supports multiple identity authentication methods, adopts standard protocols, integrates multi-factor authentication methods, and is compatible with different authentication sources through adapter mode; The identity association unit binds the user identity by establishing a ternary association relationship of user-device-group; The permission control unit performs fine-grained permission management based on the RBAC model, supports group-level permission configuration, and realizes dynamic permission control in combination with attribute-based access control strategy.

3. The system for dynamically adjusting grouping across devices in real time according to claim 2, characterized in that: In the identity association unit, establishing a ternary association relationship of user-device-group includes the following steps: Establishing associations between users and devices: Collecting hardware and software environment information, formulating multi-device binding strategies, and evaluating binding trust levels; Establish associations between devices and groups: divide grouped devices into whitelists, formulate device group caching strategies, and process device switching events through the identity association unit to achieve device switching synchronization; Establish associations between users and groups: Analyze and group device usage patterns, detect abnormal device behavior, and trigger group adjustments; Abnormal correlation detection: The associated data is encrypted and stored, and abnormal correlation patterns are identified based on the isolation forest algorithm and alarms are issued.

4. The system for dynamically adjusting grouping across devices in real time according to claim 3, characterized in that: When evaluating trust levels, evaluation indicators include device usage time, geographic location consistency, operating habit matching, and multi-factor authentication.

5. The system for dynamically adjusting grouping across devices in real time according to claim 2, characterized in that: In the permission control unit, a hybrid permission model combining the RBAC core framework with the ABAC dynamic policy is adopted. The static allocation and dynamic adjustment of permissions are achieved through the policy engine. The following steps are included: Build a role system and design roles and corresponding permissions in layers; Static role assignment and dynamic role permission inheritance; Cache and verify the set permissions; Divide and collect user attributes to build an attribute system; Set policy priority. ABAC dynamic policy takes precedence over RBAC static permissions. When a policy conflict occurs, the most recently effective policy takes precedence. Set attribute trigger mechanism to perform dynamic permission evaluation; Bind roles and permissions, and dynamically adjust group permissions; Design a permission conflict detection mechanism and adopt conflict resolution strategies based on detected conflicts; Audit permission log records and set up permission backtracking mechanism; Monitor and issue alerts for abnormal permission access.

6. The system for dynamically adjusting grouping across devices in real time according to claim 1, characterized in that: In the distributed synchronization module, a three-level conflict handling mechanism is designed, including: Optimistic locking prevention: Each packet of data carries a version number. When the device submits a modification, it must include the current version. If the central node finds a version inconsistency, it will reject the request. Automatic arbitration: For non-critical conflicts, the last write wins strategy is adopted, and the operation with the latest timestamp on the central node prevails. Manual intervention: For critical conflicts, the conflict resolution interface is triggered. The administrator can view the operation log and choose to retain the version. The system automatically generates a conflict resolution solution.

7. The system for dynamically adjusting grouping across devices in real time according to claim 1, characterized in that: The execution process of the rule engine module includes the following steps: Rule definition: Develop a multi-dimensional grouping rule system, including static attribute grouping rules, dynamic behavior grouping rules, and task scenario adaptive grouping rules. Use a graphical rule editor to generate a graphical rule configuration interface. Administrators can combine conditional expressions by dragging and dropping, and the rules are stored in DRL format. Rule parsing: Parse DRL rules using the ANTLR4 parser, generate an abstract syntax tree, convert it into executable Java bytecode, use the rule checker to detect condition conflicts / coverages, and use the rule indexer to build a fast matching index; Rule execution: Efficient pattern matching is performed through the Rete algorithm, supporting weight factors and constraints, building a parallel rule matching engine based on the Fork / Join framework, and caching execution results.

8. The system for real-time dynamic grouping adjustment across devices according to claim 1, characterized in that: The execution process of the trigger engine module includes the following steps: The trigger engine collects monitoring data in real time through probes deployed on various devices and service nodes; Multi-layer processing of collected data, including real-time indicator calculation, status normalization, and anomaly detection; Visualize and store monitoring data; Design multiple trigger strategies for dynamic grouping adjustments, including time trigger strategies, event trigger strategies, and indicator trigger strategies; Determine trigger conditions, filter them, and prioritize them; Get the trigger context and execute the trigger operation to dynamically adjust the grouping.

9. The system for dynamically adjusting grouping across devices in real time according to claim 1, characterized in that: The execution process of the algorithm engine module includes the following steps: Extract multidimensional features from user attributes and perform normalization processing. The multidimensional features include static features and dynamic features. Different features are assigned dynamic weights according to the grouping scenario to construct a multidimensional feature space. K-means++ algorithm is used for clustering, and grouping rule constraints are embedded in the initialization stage; During the iterative calculation process, the weighted Euclidean distance between the user and each cluster center is calculated, and the user is assigned to the cluster with the closest distance. After the iteration is completed, the grouping that does not meet the hard constraints is forcibly corrected; Define multiple soft constraint evaluation indicators, evaluate the soft constraint indicators of each group in turn, and start the greedy exchange strategy if they do not meet the standards: Perform local search and refinement adjustments on each group. After all local adjustments are completed, sort the groups by their fitness and re-execute the greedy exchange strategy on the groups whose fitness scores are lower than the threshold. When user characteristics change, the impact of the change is evaluated and local re-clustering is initiated for the affected groups. Receive the grouping request sent by the trigger engine and extract the set of users participating in the grouping; Generate multiple grouping schemes in parallel based on different K values, and perform triple verification on the feasibility of the schemes; A multi-objective decision-making method is used to rank multiple sets of plans, comprehensively considering the hard constraint satisfaction, soft constraint score, and historical effect reference, and selecting the plan with the highest comprehensive score as the final grouping result. Administrators are allowed to manually fine-tune the automatically generated plan and output the generated grouping plan.

Images