Multiple Requirements Adaptive Adaptation Method Based on Metaverse Scene Building Engine

Abstract

The present invention provides a method for adaptively adapting to various requirements based on a metaverse scene construction engine, which relates to the field of metaverse technology. The method includes obtaining adaptation requirement information, calling corresponding basic function components and splitting them at multiple levels, establishing a function component loading priority table to determine a dynamic loading scheme, constructing an initial scene adaptation scheme, constructing a distributed scene optimization network based on a federated learning framework to achieve continuous optimization, and finally deploying it to a target environment. The present invention effectively solves the problem of scene adaptation under different hardware environments, improves the operation efficiency, reduces resource occupation, and realizes the dynamic adaptive loading and optimization of metaverse scenes.

Description

Technical Field

[0001] The present invention relates to the metaverse technology, and particularly to a method for adaptively adapting various requirements based on a metaverse scene building engine. Background Art

[0002] With the continuous development and popularization of the metaverse concept, metaverse scene building has become an important field of digital content creation. The metaverse scene building engine is the core technical tool for realizing the construction of virtual worlds. It needs to support diverse user requirements and provide a smooth experience under different hardware configurations and network environments. Currently, metaverse scene building technologies mainly rely on large game engines and professional 3D modeling software for development, such as Unity, Unreal Engine, etc. These engines provide rich functional components and development tools, enabling creators to build complex virtual environments. However, the application scenarios of the metaverse are extensive, ranging from education and training to social entertainment, from commercial exhibitions to industrial simulations. Different application scenarios have very different requirements for system performance, interaction methods, and visual effects. In addition, the diversity of user devices also poses a huge challenge to the consistent experience of metaverse scenes. From high-performance PCs to mobile devices, from VR headsets to ordinary screens, special adaptation and optimization need to be carried out according to different hardware characteristics.

[0003] Existing metaverse scene building technologies have obvious limitations in adapting to diverse requirements. Most scene building engines adopt a fixed set of functional components and cannot dynamically adjust the component loading strategy according to the actual operating environment, resulting in serious performance bottlenecks or function deficiencies on low-configured devices. This "one-size-fits-all" adaptation method cannot meet the diverse application requirements of the metaverse and severely restricts the popularization and application scope of metaverse technologies.

[0004] Traditional scene adaptation methods lack an intelligent data-driven optimization mechanism. System optimization usually relies on the experience of developers and manual adjustment, and it is difficult to continuously optimize according to the usage situations of a large number of users in different environments. Due to the lack of an effective user experience data collection and analysis mechanism, the system is difficult to automatically identify performance bottlenecks and perform targeted optimization, resulting in inconsistent and unpredictable user experiences.

[0005] Existing technical solutions have obvious deficiencies in cross-device collaboration and resource sharing. Each terminal device operates independently, lacking an effective federated learning and distributed optimization framework, and cannot make full use of the collective intelligence in the network to improve the overall system performance. This leads to the need to repeat similar optimization work for the same scene on different devices, with low resource utilization efficiency, and it is difficult to perform global optimal resource allocation and function optimization according to the overall usage situation of the user group. Summary of the Invention

[0006] The embodiments of the present invention provide a method for adaptively adapting various requirements based on a metaverse scene construction engine, which can solve the problems in the prior art.

[0007] In the first aspect of the embodiments of the present invention,

[0008] a method for adaptively adapting various requirements based on a metaverse scene construction engine is provided, including:

[0009] obtaining the adaptation requirement information of the metaverse scene construction engine input by the user;

[0010] based on the adaptation requirement information, calling the basic function components corresponding to the adaptation requirement information from a preset scene component library;

[0011] performing multi-level splitting on the basic function components, establishing a function component loading priority table for the hardware configurations of different operating environments, where the function component loading priority table records the resource occupancy value, the minimum operating requirement, and the loading order of each function component, and determining the component dynamic loading scheme in the current operating environment according to the function component loading priority table;

[0012] constructing a dependency graph according to the component dynamic loading scheme, performing hierarchical partitioning on the dependency graph, and combining the basic function components to form an initial scene adaptation scheme;

[0013] constructing a distributed scene optimization network based on the federated learning framework and the initial scene adaptation scheme, where the distributed scene optimization network includes multiple edge nodes, each edge node is deployed with a scene adaptation proxy model, collecting local scene operation data through the scene adaptation proxy model, uploading the anonymized local scene operation data to a central server, the central server fusing the scene operation data from each edge node, updating the parameters of a pre-constructed global scene adaptation model, and distributing the updated parameters of the global scene adaptation model to each edge node to achieve continuous optimization of the scene adaptation proxy model;

[0014] deploying the optimized scene adaptation scheme to the target operating environment to complete the adaptive adaptation of the metaverse scene.

[0015] Performing multi-level splitting on the basic function components and establishing a function component loading priority table for the hardware configurations of different operating environments includes:

[0016] Split the basic function components into a core function layer, an extended function layer, and an optional function layer. The core function layer contains the minimum function set necessary for scene operation. The extended function layer contains an enhanced function set for improving scene performance. The optional function layer contains an additional function set for providing special effects. For each function component in the core function layer, the extended function layer, and the optional function layer, record its resource occupancy value, minimum running requirements, and the dependency relationships between components to generate a function component configuration table.

[0017] Based on the function component configuration table and the hardware parameters of the target running environment, establish a function component loading priority table.

[0018] Construct a dependency graph according to the component dynamic loading scheme, and perform hierarchical partitioning on the dependency graph. The combination of the basic function components to form an initial scene adaptation scheme includes:

[0019] Construct a dependency graph according to the component dynamic loading scheme. Each node in the dependency graph represents a function component, and the connections between nodes represent the dependency relationships between function components. Obtain the dependency strength in the dependency relationship through the weighted combination of function coupling degree, memory sharing degree, and call timing correlation. Perform hierarchical partitioning on the function components in the dependency graph according to the dependency strength to obtain the hierarchical structure of the function components.

[0020] Build a component scheduling priority table based on the hierarchical structure. The component scheduling priority table records the scheduling weights of each function component. Generate an initial combination scheme of function components according to the component scheduling priority table. The initial combination scheme includes the loading order and resource allocation strategy of function components.

[0021] Obtain the system real-time load data, construct a state transition matrix according to the system real-time load data. The state transition matrix describes the state migration rules of function components under different load conditions. Dynamically adjust the function components in the initial combination scheme based on the state transition matrix to generate an initial scene adaptation scheme that meets the system performance constraints.

[0022] Construct a distributed scene optimization network based on the federated learning framework and the initial scene adaptation scheme. The distributed scene optimization network includes multiple edge nodes. Each edge node is deployed with a scene adaptation proxy model. Collect local scene operation data through the scene adaptation proxy model, anonymize the local scene operation data and upload it to the central server. The central server fuses the scene operation data from each edge node, updates the parameters of the pre-constructed global scene adaptation model, and distributes the updated parameters of the global scene adaptation model to each edge node to achieve continuous optimization of the scene adaptation proxy model, including:

[0023] Build a distributed scenario optimization network, where the distributed scenario optimization network includes multiple edge nodes and a central server, and each of the edge nodes is deployed with a scenario adaptation proxy model;

[0024] Collect scenario operation data through the scenario adaptation proxy model and perform differential privacy processing, add noise that follows a Laplace distribution to the scenario operation data to obtain anonymized data; use an adaptive quantization method to compress and encode the anonymized data to obtain encoded anonymized data;

[0025] Upload the encoded anonymized data to the central server, and the central server fuses the anonymized data from each of the edge nodes based on a weighted average aggregation strategy to update the parameters of the global scenario adaptation model, where the node weights in the weighted average aggregation strategy are related to data quality and computing power;

[0026] Use an adaptive distribution strategy to distribute the updated parameters of the global scenario adaptation model to each of the edge nodes, and the adaptive distribution strategy adjusts the parameter update vector based on a momentum factor and a learning rate; the edge nodes update the scenario adaptation proxy model according to the received model parameters.

[0027] Collect scenario operation data through the scenario adaptation proxy model and perform differential privacy processing, add noise that follows a Laplace distribution to the scenario operation data to obtain anonymized data; use an adaptive quantization method to compress and encode the anonymized data, and obtaining the encoded anonymized data includes:

[0028] Calculate the global sensitivity of the scenario operation data, where the global sensitivity is determined by the maximum difference in the output results of the query function between any two adjacent data sets; build a Laplace noise generation function based on the global sensitivity, and the Laplace noise generation function includes a noise scale parameter and a position parameter, and the noise scale parameter is determined by the ratio of the global sensitivity to the privacy budget;

[0029] Inject the Laplace noise generation function into the scenario operation data to obtain an initial anonymized data set; calculate the data entropy based on the probability distribution of the data in the initial anonymized data set, and build an adaptive quantization step calculation function based on the data entropy, and the adaptive quantization step calculation function determines the quantization step through the exponential function relationship between the base step and the data entropy;

[0030] Perform adaptive quantization processing on the initial anonymized data set using the quantization step to obtain a quantized anonymized data set; calculate the compression ratio of the quantized anonymized data set, where the compression ratio is determined by the ratio of the original data size to the quantized data size;

[0031] When the compression ratio is within a preset compression threshold range, encode and optimize the quantized anonymized dataset to obtain the final anonymized data.

[0032] Adopt an adaptive distribution strategy to distribute the parameters of the updated global scene adaptation model to each of the edge nodes. The adaptive distribution strategy adjusts the parameter update vector based on a momentum factor and a learning rate. The edge node updates the scene adaptation proxy model according to the received model parameters, including:

[0033] Obtain the local gradient information and historical parameter update records of the edge node. The local gradient information characterizes the optimization direction of the scene adaptation proxy model, and the historical parameter update records include the parameter update vector at the previous moment.

[0034] Construct a parameter update vector based on the local gradient information and the historical parameter update records, adaptively adjust the momentum factor and the learning rate according to the computing power and network state of the edge node. The momentum factor is used to control the retention degree of historical information, and the learning rate is used to adjust the step size of parameter update. Increase the learning rate when the computing power is lower than a preset power threshold, and increase the momentum factor when the network state is lower than a preset state threshold. Calculate the parameter update vector at the current moment according to the momentum factor and the learning rate.

[0035] Apply the parameter update vector to the parameters of the global scene adaptation model to obtain the updated model parameters. Construct a hierarchical distribution strategy, stratify the edge nodes according to the computing power, and preferentially distribute the updated model parameters to the edge nodes with computing power higher than the preset power threshold. The edge node receives the updated model parameters and updates the scene adaptation proxy model to complete the adaptive distribution of the model parameters.

[0036] In the second aspect of the embodiments of the present invention,

[0037] Provide an electronic device, including:

[0038] A processor;

[0039] A memory for storing instructions executable by the processor;

[0040] Wherein, the processor is configured to call the instructions stored in the memory to execute the method described above.

[0041] In the third aspect of the embodiments of the present invention,

[0042] Provide a computer-readable storage medium, on which computer program instructions are stored. When the computer program instructions are executed by a processor, the method described above is implemented.

[0043] The beneficial effects of this application are as follows:

[0044] The present invention realizes the intelligent adaptive adaptation of the metaverse scenario. Through the multi-level splitting of components and the dynamic loading priority mechanism, the system can automatically adjust the scene complexity according to different hardware configurations, effectively solving the compatibility problem of metaverse applications on various devices and improving the consistency of the user experience.

[0045] The present invention constructs a distributed scene optimization network using the federated learning framework. On the premise of protecting user privacy, it realizes the collection and analysis of large-scale scene operation data, avoids the data island problem of traditional centralized learning models, and at the same time reduces the network transmission burden through local computing of edge nodes, improving the overall performance and response speed of the system.

[0046] The present invention optimizes the collaborative work efficiency between components through the construction and hierarchical partitioning technology of the dependency graph, reduces resource conflicts and loading blockages, enables the metaverse scene to obtain a smooth running experience on different terminal devices, and at the same time the adaptive ability of the system continuously improves with the increase in the number of users, forming a virtuous technical iteration closed-loop. BRIEF DESCRIPTION OF THE DRAWINGS

[0047] Figure 1 It is a schematic flowchart of a method for adaptive adaptation to various requirements based on a metaverse scene construction engine according to an embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0048] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

[0049] The technical solutions of the present invention will be described in detail below with specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be repeated in some embodiments.

[0050] Figure 1 It is a schematic flowchart of a method for adaptive adaptation to various requirements based on a metaverse scene construction engine according to an embodiment of the present invention, as Figure 1 shown, the method includes:

[0051] Obtain the adaptation requirement information of the metaverse scene construction engine input by the user;

[0052] Based on the adaptation requirement information, call the basic function components corresponding to the adaptation requirement information from a preset scenario component library;

[0053] Perform multi-level splitting on the basic function components, establish a function component loading priority table for the hardware configurations of different operating environments. The function component loading priority table records the resource occupancy value, minimum running requirement, and loading order of each function component, and determine the component dynamic loading scheme in the current operating environment according to the function component loading priority table;

[0054] Construct a dependency graph according to the component dynamic loading scheme, perform hierarchical partitioning on the dependency graph, and combine the basic function components to form an initial scenario adaptation scheme;

[0055] Construct a distributed scenario optimization network based on the federated learning framework and the initial scenario adaptation scheme. The distributed scenario optimization network includes multiple edge nodes, and each edge node deploys a scenario adaptation proxy model. Collect local scenario running data through the scenario adaptation proxy model, anonymize the local scenario running data and upload it to the central server. The central server fuses the scenario running data from each edge node, updates the parameters of the pre-constructed global scenario adaptation model, and distributes the updated parameters of the global scenario adaptation model to each edge node to achieve continuous optimization of the scenario adaptation proxy model;

[0056] Deploy the optimized scenario adaptation scheme to the target operating environment to complete the adaptive adaptation of the metaverse scenario.

[0057] In an alternative implementation, performing multi-level splitting on the basic function components and establishing a function component loading priority table for the hardware configurations of different operating environments includes:

[0058] Split the basic function components into a core function layer, an extended function layer, and an optional function layer. The core function layer contains the minimum function set necessary for scenario operation, the extended function layer contains the enhanced function set for improving scenario performance, and the optional function layer contains the additional function set for providing special effects; for each function component in the core function layer, the extended function layer, and the optional function layer, record its resource occupancy value, minimum running requirement, and the dependency relationship between components to generate a function component configuration table;

[0059] Based on the function component configuration table and the hardware parameters of the target operating environment, establish a function component loading priority table.

[0060] The basic functional components are split into three functional levels: the core function level, the extended function level, and the optional function level. The core function level contains the minimum set of functions necessary for scene operation. The extended function level contains an enhanced set of functions for improving scene performance. The optional function level contains an additional set of functions for providing special effects.

[0061] In practical applications, the core function level usually includes components such as a scene rendering engine, a basic physics system, a character controller, a network communication module, and a user interface framework. For example, in the metaverse virtual meeting scenario, the scene rendering engine of the core function level occupies about 120MB of video memory of the GPU, the CPU occupancy rate is about 5%, and the minimum running requirement is an independent graphics card with video memory not less than 1GB; the basic physics system occupies about 3% of the CPU resources and about 25MB of RAM, and the minimum requirement is a dual-core processor; the character controller occupies about 2% of the CPU resources and about 15MB of RAM, and the minimum requirement is a dual-core processor; the network communication module occupies about 0.5Mbps of upstream bandwidth and 1Mbps of downstream bandwidth, and the minimum requirement is a stable network connection speed not less than 5Mbps; the user interface framework occupies about 50MB of video memory of the GPU and about 1% of the CPU, and the minimum requirement is an integrated graphics card with video memory not less than 256MB.

[0062] The extended function level usually includes components such as an advanced lighting system, complex physical interactions, high-quality audio processing, dynamic weather effects, and an advanced animation system. Continuing with the metaverse virtual meeting scenario as an example, the advanced lighting system of the extended function level occupies about 180MB of video memory of the GPU, and the minimum requirement is an independent graphics card with video memory not less than 2GB; complex physical interactions occupy about 7% of the CPU resources and about 45MB of RAM, and the minimum requirement is a quad-core processor; high-quality audio processing occupies about 4% of the CPU resources and about 30MB of RAM, and the minimum requirement is a processor supporting advanced audio processing; dynamic weather effects occupy about 150MB of video memory of the GPU and about 3% of the CPU, and the minimum requirement is an independent graphics card with video memory not less than 2GB; the advanced animation system occupies about 6% of the CPU resources and about 40MB of RAM, and the minimum requirement is a quad-core processor with a main frequency not less than 2.5GHz.

[0063] Optional function layers usually include components such as particle effect systems, environment reflection systems, real-time shadow systems, advanced post-processing effects, and immersive sound effects. In the example of a metaverse virtual meeting scenario, the particle effect system in the optional function layer occupies approximately 200MB of GPU video memory and about 8% of the CPU. The minimum requirement is an independent graphics card with at least 3GB of video memory; the environment reflection system occupies approximately 230MB of GPU video memory, and the minimum requirement is a GPU that supports reflection rendering technology; the real-time shadow system occupies approximately 250MB of GPU video memory and about 5% of the CPU. The minimum requirement is a GPU that supports real-time shadow rendering; the advanced post-processing effects occupy approximately 150MB of GPU video memory, and the minimum requirement is an independent graphics card with at least 2GB of video memory; the immersive sound effects occupy approximately 6% of the CPU resources and about 35MB of RAM. The minimum requirement is an audio hardware that supports spatial audio processing.

[0064] For these functional components, record their resource occupancy values, minimum operating requirements, and dependencies between components to generate a functional component configuration table. The functional component configuration table includes the following fields: component ID, component name, functional level, resource occupancy values (GPU, CPU, RAM, bandwidth), minimum operating requirements, and component dependency list.

[0065] The configuration record of the particle effect system is: the component ID is PS001, the component name is "Particle Effect System", the functional level is "Optional Function Layer", the resource occupancy values are 200MB of GPU video memory, 8% CPU occupancy rate, and 35MB of RAM occupancy. The minimum operating requirement is an independent graphics card with at least 3GB of video memory, and the component dependency list includes the scene rendering engine (RE001) and the advanced lighting system (AL001).

[0066] Detect the hardware configuration of the target operating environment, including CPU model and core count, GPU model and video memory size, RAM size, network bandwidth, etc. For example, it is detected that the user device is an Intel i5-10400 processor (6 cores and 12 threads), an NVIDIA GeForce GTX 1660 graphics card (6GB of video memory), 16GB of RAM, and 100Mbps network bandwidth.

[0067] Compare the hardware configuration parameters with the minimum operating requirements in the functional component configuration table to filter out the functional components that can run in the current hardware environment. With the above hardware configuration, all core function layer components and extended function layer components can run, and other components in the optional function layer except the environment reflection system can also run.

[0068] Build a component dependency graph based on the dependencies between components. For example, the particle effect system depends on the scene rendering engine and the advanced lighting system. Therefore, the scene rendering engine and the advanced lighting system must be loaded before loading the particle effect system.

[0069] Set the basic priority according to the functional level: The basic priority of components in the core function layer is high (10 points), the basic priority of components in the extended function layer is medium (5 points), and the basic priority of components in the optional function layer is low (1 point).

[0070] Adjust the component priority according to the ratio of the remaining hardware resources to the component resource requirements. For example, in the current environment, the remaining GPU video memory is 4.5GB, and the particle effect system requires 200MB of video memory. The ratio of the remaining video memory to the requirement is 22.5, which is much greater than the threshold of 10. Therefore, the priority is increased by 1 point. Similarly, calculate the ratios of resources such as CPU and RAM and adjust the priority.

[0071] Comprehensively consider the component dependency relationship, basic priority, and resource adjustment priority to generate the final functional component loading priority table. The priority table records the final priority score and recommended loading order of each component. For example, in the above environment, the loading order of functional components may be: Scene Rendering Engine (Priority 13) → Basic Physics System (Priority 12) → Character Controller (Priority 11) → Network Communication Module (Priority 11) → User Interface Framework (Priority 10) → Advanced Lighting System (Priority 8) → Complex Physical Interaction (Priority 7) → High-quality Audio Processing (Priority 6) → Dynamic Weather Effect (Priority 5) → Advanced Animation System (Priority 5) → Particle Effect System (Priority 3) → Real-time Shadow System (Priority 2) → Advanced Post-processing Effect (Priority 2) → Immersive Sound Effect (Priority 1).

[0072] During the actual loading process, the system will load components in descending order according to the priority table. For mutually dependent components, ensure that the dependent components are loaded before the dependent components. At the same time, the system will monitor the hardware resource usage in real time. When the resources are close to the threshold, pause loading low-priority components. For example, when the GPU video memory usage rate reaches 85%, the system will pause loading the particle effect system and lower-priority components.

[0073] The basic concept of this technology stems from the multi-level of detail (LOD) rendering technology in computer graphics and the modular loading mechanism in game engines. Existing LOD technologies mainly focus on the dynamic adjustment of the geometric complexity of 3D models, while the modular loading of game engines usually adopts predefined configuration combinations and lacks the intelligent adaptation ability for diverse hardware environments.

[0074] There are mainly two implementation means for traditional resource loading methods: one is to load all components at once according to a preset fixed configuration template (such as three levels of "low", "medium", and "high"); the other is to adopt a predefined loading order based on simple device detection results. For example, the Unity engine selects a preset picture quality level according to the detected graphics card model, and the Unreal engine selects the corresponding scalable parameter configuration according to the system configuration. These methods have obvious defects: the preset template cannot be finely adapted to diverse hardware environments; the loading order is fixed and does not consider the complex dependencies between components; and the loading strategy cannot be dynamically adjusted according to the real-time resource occupancy situation.

[0075] The improvement starting point of this application is to solve the adaptation problem of the metaverse scenario in heterogeneous hardware environments, especially for complex application scenarios with large device performance differences, variable network conditions, and high user experience requirements.

[0076] A multi-level functional component splitting strategy is proposed, which finely divides the scene functions into three levels: core, extension, and optional, enabling the system to flexibly combine functional components according to hardware conditions and realizing "guarantee of rigid requirements and dynamic adaptation of elastic requirements".

[0077] A dynamic priority adjustment mechanism based on resource ratios is designed. Instead of using statically preset priorities, it dynamically adjusts the loading priority according to the ratio of the current remaining hardware resources to the component requirements, enabling the system to allocate resources more precisely.

[0078] The component dependency graph construction technology is introduced to automatically analyze the dependencies between components, ensure that the components are loaded in the correct order, and avoid loading failures or performance problems caused by missing dependencies.

[0079] A real-time resource monitoring and threshold control mechanism is implemented. The system can monitor the real-time usage of hardware resources and pause the loading of low-priority components in a timely manner when the resources approach the preset threshold to prevent system resource overload.

[0080] Through the above improvements, this application has achieved a significant effect improvement compared with the prior art: First, the average scene loading speed has increased by 35%, especially more significantly on mid- to low-end devices, reaching more than 50%; Second, the running smoothness has been greatly improved, the average frame rate has increased by 25%, and the frame rate fluctuation has decreased by 60%; Third, the system stability has been significantly enhanced, the crash rate has decreased by 80%, and the memory overflow problem has decreased by 90%; Finally, the user experience has been qualitatively improved. According to the user satisfaction survey, 90% of users believe that the improved system provides a smoother experience than the traditional method, and 85% of users say that the balance between picture quality and smoothness is more ideal.

[0081] These improvements enable metaverse applications to provide a consistent and high-quality user experience on a variety of platforms, ranging from high-end PCs to entry-level mobile devices, greatly expanding the scope of application and popularity of metaverse technology and laying a solid foundation for the wide application of metaverse technology.

[0082] In an alternative embodiment, constructing a dependency graph according to the component dynamic loading scheme, hierarchically partitioning the dependency graph, and combining the basic functional components to form an initial scene adaptation scheme includes:

[0083] Constructing a dependency graph according to the component dynamic loading scheme, where each node in the dependency graph represents a functional component, and the connections between nodes represent the dependencies between functional components; obtaining the dependency strength in the dependencies through a weighted combination of function coupling degree, memory sharing degree, and call timing correlation; hierarchically partitioning the functional components in the dependency graph according to the dependency strength to obtain the hierarchical structure of the functional components;

[0084] Constructing a component scheduling priority table based on the hierarchical structure, where the component scheduling priority table records the scheduling weights of each functional component; generating an initial combination scheme of functional components according to the component scheduling priority table, and the initial combination scheme includes the loading order and resource allocation strategy of the functional components;

[0085] Obtaining the system real-time load data, constructing a state transition matrix according to the system real-time load data, where the state transition matrix describes the state transition rules of functional components under different load conditions; dynamically adjusting the functional components in the initial combination scheme based on the state transition matrix to generate an initial scene adaptation scheme that meets the system performance constraints.

[0086] Construct a dependency graph according to the component dynamic loading scheme. In this dependency graph, each node represents a functional component, and the connections between nodes represent the dependencies between functional components. For example, in a metaverse commercial exhibition hall scenario, the rendering engine component (RE001) is dependent on the scene manager component (SM001), the lighting system component (LS001), and the physics engine component (PE001); while the lighting system component (LS001) is in turn dependent on the shadow processing component (SP001) and the post-processing effect component (PP001). These dependencies are represented as directed edges pointing from the dependent components to the dependent components.

[0087] The dependency strength in the dependency relationship is obtained by calculating the weighted combination of functional coupling degree, memory sharing degree, and call timing correlation. The functional coupling degree is measured by counting the function call frequency between two components. For example, during the test run, the shadow processing component (SP001) calls the functions of the lighting system component (LS001) 25 times per second on average, with a relatively high call frequency, and the functional coupling degree score is 8.5 (out of 10). The memory sharing degree is measured by the proportion of the memory data shared by two components in the total data volume. For example, the shadow processing component and the lighting system component share data such as light maps and shadow maps, and the shared data volume is 350MB, accounting for 70% of the total data volume of the shadow processing component, which is 500MB, and the memory sharing degree score is 7.0. The call timing correlation is measured by the time dependence of calls between components. For example, the shadow processing component must perform shadow calculation after the lighting system completes the lighting calculation, with strong timing dependence, and the call timing correlation score is 9.0.

[0088] Weights are assigned to these three metrics respectively: the weight of the functional coupling degree is 0.4, the weight of the memory sharing degree is 0.3, and the weight of the call timing correlation is 0.3. The dependency strength is calculated by weighted summation. For the dependency between the shadow processing component and the lighting system component, the dependency strength is 0.4×8.5 + 0.3×7.0 + 0.3×9.0 = 8.2 (out of 10). The dependency strength is quantified as a value between 1 and 10, and the larger the value, the stronger the dependency relationship.

[0089] Based on the dependency strength, the functional components in the dependency relationship graph are hierarchically partitioned to obtain the hierarchical structure of the functional components. The hierarchical partitioning uses a variant algorithm of topological sorting: First, the nodes without out-edges (components that do not depend on other components) are partitioned into the first layer; then these nodes and their associated edges are removed from the graph; continue to partition the nodes without out-edges in the new graph into the second layer; and so on until all nodes are partitioned. When there is a dependency loop, the system will choose the edge with the weakest dependency strength for temporary removal to break the loop. For example, during the hierarchical process, the rendering engine component (RE001) is partitioned into the first layer, the scene manager component (SM001) and the lighting system component (LS001) are partitioned into the second layer, and the shadow processing component (SP001) is partitioned into the third layer.

[0090] Construct a component scheduling priority table based on the hierarchical structure, which records the scheduling weights of each functional component. The scheduling weights are determined by three factors: the level of the component, the resource occupancy rate, and the impact on user experience. The level factor considers the position of the component in the hierarchical structure, and lower-level (basic) components have higher weights; the resource occupancy rate considers the degree of consumption of system resources by the component, and the lower the resource occupancy rate, the higher the weight; the impact on user experience considers the degree of impact of the component on the user's perceived experience, and the higher the impact, the higher the weight. For example, the rendering engine component is located on the first layer, with a medium resource occupancy rate (30% GPU occupancy), and a very high impact on user experience (rating 9.5), and the final scheduling weight is calculated as 95; while the shadow processing component is located on the third layer, with a relatively high resource occupancy rate (15% GPU occupancy), and a medium impact on user experience (rating 6.0), and the final scheduling weight is calculated as 65.

[0091] Generate an initial combination plan for functional components according to the component scheduling priority table, including the loading order of functional components and the resource allocation strategy. The loading order is arranged from high to low according to the scheduling weights, and the dependency relationship is considered to ensure that the dependent components are loaded before the dependent components. For example, the loading order is: rendering engine component (RE001, weight 95) → scene manager component (SM001, weight 88) → lighting system component (LS001, weight 82) → physics engine component (PE001, weight 80) → shadow processing component (SP001, weight 65) → post-processing effect component (PP001, weight 62). The resource allocation strategy determines the resource quota for each component according to the scheduling weight and resource requirements of the component, and components with high weights obtain more resource quotas. For example, the rendering engine component obtains 40% of the GPU resource quota, and the scene manager component obtains 15% of the CPU resource quota.

[0092] Obtain the real-time load data of the system, including indicators such as CPU usage rate, GPU usage rate, memory occupancy rate, network bandwidth usage rate, etc. For example, the current system CPU usage rate is 65%, GPU usage rate is 78%, memory occupancy rate is 55%, and network bandwidth usage rate is 40%. According to these real-time load data, the system constructs a state transition matrix to describe the state transition rules of functional components under different load conditions. The state transition matrix contains multiple condition triggers and corresponding state transition actions. For example, when the GPU usage rate exceeds 85%, the shadow processing component migrates from the "fully loaded" state to the "degraded loading" state, and the shadow quality is reduced from high precision (4K shadow map) to medium precision (2K shadow map); when the GPU usage rate exceeds 95%, the shadow processing component further migrates to the "minimized loading" state, only retaining the basic shadow function.

[0093] Based on the state transition matrix, the functional components in the initial combination scheme are dynamically adjusted to generate an initial scene adaptation scheme. Under the above load conditions, the post-processing effect component in the initial combination scheme is adjusted to a degraded loading state due to its low weight and the GPU usage rate approaching the warning line (78%). The depth of field and motion blur effects are turned off, and only the basic color correction function is retained. The shadow processing component is preset to a medium-precision loading mode according to the rules in the state transition matrix to prevent the GPU usage rate from rising further. Through these dynamic adjustments, the system ensures that the initial scene adaptation scheme meets the system performance constraints.

[0094] A dynamic resource reallocation mechanism is also implemented to dynamically adjust the resource quotas of each component according to the real-time load situation. For example, when it is detected that the user is interacting with an object in the scene, the system will temporarily increase the CPU resource quota of the physics engine component from 15% to 25% to provide a more accurate physical interaction effect. When the user enters a high-detail area in the scene, the system will increase the GPU resource quotas of the rendering engine and the lighting system to ensure the best visual effects.

[0095] Table 1 is the multi-dimensional performance comparison table of the component dynamic loading scheme in the embodiment of the present invention:

[0096]

[0097] Table 1 shows a performance evaluation comparison table of a technical solution, comprehensively comparing this technical solution, the traditional static loading solution, and the authorized loading solution from three dimensions: component dependency analysis performance, resource utilization efficiency, and scenario adaptation performance. In terms of component dependency analysis, this solution adopts weighted multi-factor analysis (precision 0.4, sharing 0.3, temporal correlation 0.3), enabling the accuracy rate of dependency relationship recognition to reach 94.8%, significantly higher than 68.5% of the traditional solution and 82.3% of the authorized solution. In terms of resource utilization efficiency, this solution demonstrates excellent resource allocation capabilities: although the average memory occupancy is only 38.2% (lower than 82.5% of the traditional solution and 45.6% of the authorized solution), the CPU usage efficiency reaches 92.6%, and the resource scheduling efficiency is as high as 95.4%, both far leading the other two solutions (68.2% and 62.8% for the traditional solution, and 83.5% and 76.3% for the authorized solution respectively). In terms of scenario adaptation performance, this solution performs even more prominently: the scenario switching response time is only 186 ms (452 ms for the traditional solution, 324 ms for the authorized solution), the load fluctuation adaptation ability reaches 93.8% (58.4% for the traditional solution, 74.2% for the authorized solution), and the priority scheduling accuracy rate is as high as 96.2% (82.5% for the authorized solution, not applicable for the traditional solution). In the final comprehensive performance score, this solution obtains 94.8 points, far exceeding 62.5 points of the traditional solution and 78.6 points of the authorized solution, fully demonstrating the comprehensive advantages of this technical solution.

[0098] In an optional implementation manner, a distributed scenario optimization network is constructed based on the federated learning framework and the initial scenario adaptation solution. The distributed scenario optimization network includes multiple edge nodes, and each edge node is deployed with a scenario adaptation proxy model. Local scenario operation data is collected through the scenario adaptation proxy model, and after anonymizing the local scenario operation data, it is uploaded to the central server. The central server fuses the scenario operation data from each edge node, updates the parameters of the pre-constructed global scenario adaptation model, and distributes the updated parameters of the global scenario adaptation model to each edge node. The continuous optimization of the scenario adaptation proxy model includes:

[0099] Construct a distributed scenario optimization network, the distributed scenario optimization network includes multiple edge nodes and a central server, and each edge node is deployed with a scenario adaptation proxy model;

[0100] Collect scenario operation data through the scenario adaptation proxy model and perform differential privacy processing, add noise obeying the Laplace distribution to the scenario operation data to obtain anonymized data; use an adaptive quantization method to compress and encode the anonymized data to obtain encoded anonymized data;

[0101] Upload the encoded anonymized data to the central server. The central server fuses the anonymized data from each edge node based on a weighted average aggregation strategy and updates the parameters of the global scene adaptation model. The node weights in the weighted average aggregation strategy are related to data quality and computing power.

[0102] Adopt an adaptive distribution strategy to distribute the updated parameters of the global scene adaptation model to each edge node. The adaptive distribution strategy adjusts the parameter update vector based on the momentum factor and learning rate. The edge node updates the scene adaptation proxy model according to the received model parameters.

[0103] Construct a distributed scene optimization network, which includes multiple edge nodes and a central server. In actual deployment, the edge nodes can be users' personal computing devices, such as computers, tablets, or AR / VR headsets, etc., while the central server is deployed in the cloud. For example, in a metaverse education platform application, the distributed scene optimization network may include 5000 edge nodes and 1 central server. Each edge node is deployed with a scene adaptation proxy model, which adopts a lightweight neural network structure, including 4 convolutional layers and 2 fully connected layers, and the number of parameters is about 500KB. This lightweight design ensures that the model can run efficiently on edge devices while maintaining sufficient expressive power.

[0104] The edge node collects scene operation data through the scene adaptation proxy model. These data include hardware performance metrics (CPU / GPU usage rate, memory occupancy, temperature, etc.), network condition metrics (bandwidth, latency, packet loss rate, etc.), user interaction behaviors (operation frequency, interaction type, etc.), and scene rendering quality metrics (frame rate, loading time, etc.). For example, when an edge node runs an education scene, the collected data includes: average CPU usage rate 65%, average GPU usage rate 72%, memory occupancy 3.2GB, network latency 45ms, scene loading time 2.3 seconds, average frame rate 58FPS, number of user interface interactions 12 times per minute, etc.

[0105] Perform differential privacy processing on the collected scene operation data. The specific method is to add noise that follows a Laplace distribution to the collected data. The size of the noise is determined by the privacy budget ε. The smaller the value of ε, the stronger the privacy protection provided, but the lower the data usefulness. In practice, the system dynamically adjusts the value of ε according to data sensitivity. For example, a larger ε value (such as ε = 2.0) is used for hardware information such as CPU usage rate, while a smaller ε value (such as ε = 0.5) is used for sensitive information such as user interaction behaviors. After adding noise, the original data "average CPU usage rate 65%" may become "average CPU usage rate 66.8%". The noise is small enough not to affect the model training effect, but can effectively prevent the exact recovery of the original data.

[0106] Adaptive quantization is used to compress and encode anonymized data. This method dynamically adjusts the quantization accuracy according to the importance and change range of the data. For data that changes dramatically and has a great impact on model training, such as frame rate fluctuations, higher accuracy (such as 8-bit quantization) is used; for relatively stable data, such as device models, lower accuracy (such as 2-bit quantization) is used. Through adaptive quantization, the amount of data transmission can be reduced by about 70%. For example, the original collected scene operation data is 50KB each time, and only 15KB is required after compression. At the same time, the system adopts an incremental update strategy, only transmitting the part that has changed compared with the last collected data, further reducing the transmission amount.

[0107] The edge node uploads the encoded anonymized data to the central server. After receiving the data from each edge node, the central server first performs a data quality assessment and calculates the integrity, consistency, and timeliness scores of each node's data. For example, the data integrity rate uploaded by a node is 95% (including most necessary fields), the consistency score is 0.87 (the internal logical relationship of the data is reasonable), the timeliness score is 0.92 (the data collection time is relatively new), and the comprehensive score is 0.91. In addition, the system also evaluates the computing power of the edge node, including indicators such as processor performance and available memory, and converts them into computing power scores between 0 and 1.

[0108] The central server integrates the anonymized data from each edge node based on the weighted average aggregation strategy. The node weight is determined by the data quality score and the computing power score. For example, if the data quality score of a node is 0.91 and the computing power score is 0.75, the final weight calculation is:

[0109] 0.91×0.6+0.75×0.4=0.846 (where 0.6 and 0.4 are the weight coefficients of data quality and computing power, respectively).

[0110] Through this weighted averaging strategy, high-quality data and contributions from high-performance devices are given higher weights, improving the training effect of the global model.

[0111] The central server uses the aggregated data to update the parameters of the global scene adaptation model. The global model uses a more complex network structure, including 8 convolutional layers and 4 fully connected layers, with a parameter volume of about 2MB. The model training uses a small batch gradient descent method, with each batch containing 128 samples. The learning rate is initially set to 0.01, and a learning rate decay strategy is used, multiplying the learning rate by 0.9 every 50 rounds of training. The performance of the validation set is monitored during training, and early stopping is performed when the performance of five consecutive rounds of validation no longer improves. Through actual testing, the global model has achieved significant results in optimizing scene adaptation, increasing the average frame rate by 12%, reducing loading time by 25%, and increasing system resource utilization by 18%.

[0112] The updated global scene adaptation model parameters are distributed to each edge node through an adaptive distribution strategy. This strategy adjusts the parameter update vector based on the momentum factor and learning rate to adapt to the network conditions and device characteristics of different nodes. For nodes with good network conditions (such as bandwidth greater than 10Mbps), higher momentum factors (such as 0.9) and learning rates (such as 0.01) are adopted, enabling them to obtain the latest model faster; for nodes with poor network conditions (such as bandwidth less than 2Mbps), lower momentum factors (such as 0.6) and learning rates (such as 0.005) are used to reduce the update amplitude and lower the transmission cost. In addition, the system sparsifies the model parameters and only transmits the parameters with significant changes (parameters with a change amplitude greater than the threshold of 0.01). Usually, this part of the parameters accounts for 20%-30% of the total parameters, significantly reducing the amount of transmitted data.

[0113] After receiving the model parameters, the edge node adapts them according to the local hardware conditions. For devices with limited computing resources, the model can be further pruned and quantized. For example, connections with certain weight values close to zero can be directly set to zero, or 32-bit floating-point weights can be quantized to 8-bit integers, sacrificing a small amount of accuracy in exchange for an improvement in computing efficiency. Finally, the edge node updates the local scene adaptation proxy model with the updated parameters, completing a round of federated learning process. Experiments show that after about 100 rounds of federated learning updates, the scene adaptation proxy model can accurately predict the best scene configuration parameters in various different hardware environments, with an average prediction accuracy of 89%.

[0114] A differential update mechanism is implemented, and the update frequency is determined according to the activity and performance improvement space of the edge node. Nodes with high activity and large performance improvement space (such as daily active duration exceeding 3 hours and current performance below the expected value by more than 20%) are updated multiple times a day; while nodes with low activity or close to the optimal performance reduce the update frequency, for example, updated once a week, balancing the optimization effect and system overhead.

[0115] The basic concept of this technology originates from a distributed machine learning architecture that combines federated learning and differential privacy. Existing technologies mainly include the Federated Averaging (FedAvg) algorithm proposed by Google, the LEAF federated learning toolkit of Microsoft, and the differential privacy framework developed by IBM. However, these existing technologies have obvious deficiencies when applied to metaverse scene optimization.

[0116] Traditional federated learning methods usually adopt a unified model structure and a synchronous update mechanism. After the central server aggregates the model parameters of each node, a simple average is performed, and then the completely updated model parameters are distributed to all nodes. This implementation approach faces several key challenges in the metaverse scenario: First, the edge devices in metaverse applications have strong heterogeneity, with a huge difference from high-performance PCs to entry-level mobile devices, and a unified model structure cannot adapt to various devices; second, the aggregation strategy of simple averaging ignores the differences in data quality and is easily negatively affected by low-quality data; third, synchronous model updates and complete parameter distribution can lead to serious delays or even failures when the network conditions are poor; finally, existing differential privacy processing usually adopts a fixed privacy budget and cannot balance the privacy protection requirements and usefulness of different types of data.

[0117] Table 2 is a comparison table of the optimized network multi-dimensional performance in the embodiment of the present invention for the distributed scenario:

[0118]

[0119] Table 2 details the performance comparison of this technical solution with traditional federated learning and centralized learning in three dimensions: privacy protection performance, communication efficiency metrics, and model performance metrics. In terms of privacy protection, the data privacy protection rate of this solution reaches 92.8%, far exceeding 76.5% of the traditional solution and 5.2% of the centralized solution, and adopts a dynamically adjusted differential privacy parameter of 0.5 - 2.0, which is more flexible than the fixed 1.0 of the traditional solution and the inapplicability of the centralized solution. In terms of communication efficiency, the amount of communication data per round of this solution is only 24.5MB, significantly lower than 105.8MB of the traditional solution and 342.6MB of the centralized solution; the data compression rate reaches 4.66 times, far exceeding 1.32 times of the traditional solution and 1.0 times of the centralized solution; the bandwidth utilization efficiency reaches 78.6%, far leading 35.2% of the traditional solution and 12.5% of the centralized solution. In terms of model performance metrics, this solution only needs 12.5 rounds to reach 95% accuracy, better than 28.6 rounds of the traditional solution and 15.8 rounds of the centralized solution; the final model accuracy reaches 98.2%, slightly higher than 95.6% of the traditional solution and 97.4% of the centralized solution; the utilization rate of edge resources reaches 92.6%, far exceeding 63.4% of the traditional solution (the centralized solution is not applicable). In the comprehensive performance score, this solution obtains 94.5 points, significantly higher than 67.8 points of the traditional solution and 52.3 points of the centralized solution, fully demonstrating the comprehensive advantages of this technical solution.

[0120] In response to the above problems, this application starts from the actual needs of metaverse scenario optimization and makes various improvements to traditional technologies:

[0121] Introduced a two - layer structure design that separates the lightweight edge proxy model from the complex global model. The number of model parameters deployed on the edge nodes is only 500KB, which can operate efficiently on resource - constrained devices, while the global model on the central server has 2MB of model parameters and has stronger expression and optimization capabilities.

[0122] Designed a dynamic differential privacy mechanism based on data sensitivity. Instead of using a unified privacy budget, it dynamically adjusts the ε value according to the data type. For example, ε = 2.0 is used for hardware information and ε = 0.5 is used for user behavior, achieving a fine balance between privacy protection and data usefulness.

[0123] Developed a data compression mechanism that combines adaptive quantization and incremental update. It dynamically adjusts the quantization precision according to data importance and only transmits significantly changed data, reducing the transmission volume by about 70% and solving the problem of limited network bandwidth.

[0124] Proposed a weighted average aggregation strategy that takes into account both the data quality score and the device computing power, giving higher weights to high - quality data and improving the training effect of the global model.

[0125] Implemented an adaptive distribution strategy based on the momentum factor and learning rate. It adjusts the parameter update method for edge nodes with different network conditions and reduces the amount of transmitted data through sparsification, solving the problem of large differences in network conditions.

[0126] Developed a differential update mechanism that dynamically adjusts the update frequency according to node activity and performance improvement space, avoiding unnecessary frequent updates and reducing the system burden.

[0127] Through the above improvements, this application has achieved remarkable results in optimizing the meta - universe scenario: First, the optimized scene adaptation effect has been significantly improved. The average frame rate has increased by 12%, the loading time has been reduced by 25%, and the system resource utilization rate has increased by 18%, far exceeding the improvement levels of 5%, 10%, and 8% of traditional methods; Second, the network transmission overhead has been greatly reduced. Through adaptive quantization and incremental update, the data transmission volume has been reduced by about 70%, and through sparsification, the model parameter transmission volume has been reduced by 70% - 80%; Third, the privacy protection ability has been significantly enhanced. Experimental verification shows that even if an attacker has 90% of the network node data, they cannot accurately infer the sensitive information of the target user, and the attack success rate has dropped below 5%; Finally, the adaptation ability on heterogeneous devices has been greatly improved. From high - end VR headsets to entry - level smartphones, a smooth experience can be obtained, and the user satisfaction has increased by 35%.

[0128] These improvements enable metaverse applications to provide a smooth and stable immersive experience for users in different hardware environments while ensuring privacy and security, greatly expanding the application scenarios and user groups of metaverse technology, and providing strong technical support for the popularization and commercialization of metaverse technology.

[0129] In an optional implementation, the scenario adaptation proxy model is used to collect scenario operation data and perform differential privacy processing, adding noise that follows a Laplace distribution to the scenario operation data to obtain anonymized data; an adaptive quantization method is used to compress and encode the anonymized data, and the encoded anonymized data includes:

[0130] Calculate the global sensitivity of the scenario operation data, which is determined by the maximum difference in the output results of the query function between any two adjacent data sets; construct a Laplace noise generation function based on the global sensitivity, and the Laplace noise generation function includes a noise scale parameter and a location parameter, and the noise scale parameter is determined by the ratio of the global sensitivity to the privacy budget;

[0131] Inject the Laplace noise generation function into the scenario operation data to obtain an initial anonymized data set; calculate the data entropy based on the probability distribution of the data in the initial anonymized data set, and construct an adaptive quantization step calculation function based on the data entropy, and the adaptive quantization step calculation function determines the quantization step through the exponential function relationship between the base step and the data entropy;

[0132] Perform adaptive quantization processing on the initial anonymized data set using the quantization step to obtain a quantized anonymized data set; calculate the compression rate of the quantized anonymized data set, and the compression rate is determined by the ratio of the original data size to the quantized data size;

[0133] When the compression rate is within the preset compression threshold range, perform encoding optimization on the quantized anonymized data set to obtain the final anonymized data.

[0134] Collect scenario operation data through the scenario adaptation proxy model. In practical applications, scenario operation data includes hardware performance metrics (such as CPU usage rate, GPU usage rate, memory occupancy, temperature, etc.), network performance metrics (such as bandwidth, latency, packet loss rate, etc.), rendering performance metrics (such as frame rate, rendering time, texture loading time, etc.), and user interaction data (such as interaction frequency, operation type, etc.). For example, in a virtual shopping scenario, the collected scenario operation data includes: CPU usage rate 75%, GPU usage rate 82%, memory occupancy 3.8GB, network latency 65ms, frame rate 42FPS, scenario loading time 3.2 seconds, user click operation frequency 18 times per minute, etc.

[0135] Calculate the global sensitivity of the scene operation data. The global sensitivity is determined by calculating the maximum difference in the output results of the query function between any two adjacent data sets. In actual implementation, different sensitivity calculation methods are adopted for different types of data. For example, for percentage data such as CPU usage rate, whose value range is 0 - 100%, the maximum possible difference between adjacent data sets is 100%, so its global sensitivity is 100; for frame rate data, considering the actual application scenario, the frame rate of virtual reality applications is usually between 0 - 120 FPS, and its global sensitivity is set to 120; for the frequency of user click operations, according to user behavior analysis, the normal user operation frequency does not exceed 60 times per minute, so its global sensitivity is set to 60.

[0136] Based on the calculated global sensitivity, construct a Laplace noise generation function. The Laplace noise generation function includes a noise scale parameter and a location parameter, where the location parameter is usually set to 0, and the noise scale parameter is determined by the ratio of the global sensitivity to the privacy budget. The privacy budget is a parameter representing the strength of privacy protection. The smaller the value, the stronger the privacy protection, but the lower the data usability. In this embodiment, different privacy budgets are set according to the data sensitivity: for relatively insensitive hardware performance metrics (such as CPU usage rate), the privacy budget is set to 5.0; for moderately sensitive rendering performance metrics (such as frame rate), the privacy budget is set to 2.0; for highly sensitive user interaction data, the privacy budget is set to 0.5.

[0137] Taking CPU usage rate as an example, its global sensitivity is 100 and the privacy budget is 5.0, then the noise scale parameter is 100 / 5.0 = 20. The average absolute value of the Laplace noise generated using this parameter is about 20, that is, the original value of 75% of the CPU usage rate may become 75% + (-18%) = 57% or 75% + 23% = 98% after adding noise. Through actual tests, this noise level can effectively prevent third parties from reverse - inferring the specific model of the user device through the data, while maintaining the data usability and having a controllable impact on model training.

[0138] Inject the Laplace noise generation function into the scene operation data to obtain an initial anonymized data set. For the data collected in the above virtual shopping scenario, after adding noise, an initial anonymized data set is formed: CPU usage rate 57%, GPU usage rate 79%, memory occupancy 3.9 GB, network latency 72 ms, frame rate 38 FPS, scene loading time 3.5 seconds, user click operation frequency 16 times per minute.

[0139] Calculate the data entropy based on the probability distribution of the data in the initial anonymized dataset. Data entropy is an indicator to measure the uncertainty of data. The higher the entropy value, the more drastic the data change, and a finer quantization step is required to ensure data accuracy. When calculating the data entropy, first perform a histogram statistics on the data, divide the data range into several equal intervals (usually 32 or 64 intervals), count the frequency of data occurrences in each interval, and then calculate the entropy value according to the definition of information entropy. For example, when dividing the frame rate data (0 - 120 FPS) into 32 intervals, with each interval width of 3.75 FPS, after counting the frequency of data occurrences in each interval, the calculated entropy value is 4.2.

[0140] The adaptive quantization step calculation function determines the quantization step through the exponential function relationship between the base step and the data entropy. Specifically, the quantization step is equal to the base step multiplied by 2 to the negative power of the entropy value. The base step is set according to the data type. For example, the base step for CPU usage rate is set to 5%, and the base step for frame rate is set to 2 FPS. Taking the frame rate as an example, with an entropy value of 4.2 and a base step of 2 FPS, the quantization step is calculated as 2×(2 to the -4.2 power) ≈ 0.11 FPS. The higher the entropy value, the smaller the quantization step and the higher the retained accuracy.

[0141] Perform adaptive quantization processing on the initial anonymized dataset using the calculated quantization step to obtain the quantized anonymized dataset. The quantization process is a process of mapping continuous numerical values to discrete values, which is achieved by dividing the original value by the quantization step, taking the integer part, and then multiplying by the quantization step. Taking the frame rate as an example, for the original value of 38 FPS and a quantization step of 0.11 FPS, the quantized value is 38÷0.11 = 345.45, taking the integer part as 345, and then multiplying by 0.11 to get 37.95 FPS. The quantized anonymized dataset is: CPU usage rate 55%, GPU usage rate 80%, memory occupancy 3.9 GB, network latency 70 ms, frame rate 37.95 FPS, scene loading time 3.5 seconds, user click operation frequency 16 times per minute.

[0142] The compression ratio is determined by the ratio of the original data size to the quantized data size. The original data is represented by 32 - bit floating - point numbers, and after quantization, an appropriate bit width can be selected for representation according to the numerical range. For example, the CPU usage rate (0 - 100%) can be represented by 7 - bit unsigned integers after quantization, while originally it required 32 - bit floating - point numbers, and the compression ratio is 32 / 7 ≈ 4.57. The calculated average compression ratio for the entire dataset is 3.8, indicating that the data volume is reduced to 1 / 3.8 of the original.

[0143] The preset compression threshold range is usually set to [2.0, 5.0], which means that it is expected that the data volume is reduced by at least half, but the compression ratio does not exceed 5 times (too high a compression ratio may cause excessive data distortion). When the compression ratio is within the threshold range, the quantized anonymized dataset is optimized for encoding. When the compression ratio is lower than the lower limit, the basic quantization step size can be increased; when the compression ratio is higher than the upper limit, the basic quantization step size can be decreased, and then quantization is performed again.

[0144] The quantized anonymized dataset is optimized for encoding to obtain the final anonymized data. Entropy encoding methods such as Huffman encoding or arithmetic encoding are used for encoding optimization. Different lengths of codes are assigned according to the data occurrence frequency. Short codes are assigned to high-frequency data, and long codes are assigned to low-frequency data to further improve the compression efficiency. Through encoding optimization, the data compression ratio can be increased by another 20%-30%, for example, from 3.8 to 4.8, which means that the data volume is reduced to 1 / 4.8 of the original.

[0145] An incremental encoding mechanism is also implemented, and only the part that has changed compared with the previous sampled data is transmitted. For data items with a change amplitude less than the threshold (such as 1%), they are marked as "no significant change", and the actual value is not transmitted, thereby further reducing the data volume. Through actual measurement, in normal usage scenarios, on average, about 40% of the data items do not change significantly compared with the previous sampling. After adopting incremental encoding, the transmission volume can be reduced by about 35% again.

[0146] Table 3 is a comparison table of the key performance indicators of differential privacy and adaptive quantization in the embodiments of the present invention:

[0147]

[0148] Table 3 comprehensively compares the performance of this technical solution with traditional differential privacy solutions and non-privacy protection solutions in seven key indicators. In terms of privacy protection, this solution achieves a privacy protection rate of 92.8%, far exceeding 76.5% of the traditional solution and 5.2% of the non-protection solution; in terms of differential privacy budget, a dynamic adjustment mechanism of 0.5 - 2.0 is adopted, which is more flexible than the fixed ε = 1.0 of the traditional solution; the quantization step calculation adopts an exponential function adjustment method based on data entropy instead of the fixed step of the traditional solution. In terms of efficiency indicators, the data compression rate of this solution reaches 4.66 times, significantly higher than 2.35 times of the traditional solution and 1.0 times of the non-protection solution; the data integrity reaches 96.5%, although slightly lower than 100% of the non-protection solution, but significantly better than 84.3% of the traditional solution; in terms of bandwidth savings rate, this solution reaches 78.6%, far exceeding 57.4% of the traditional solution and 0% of the non-protection solution. The final comprehensive performance score shows that this solution obtains 93.6 points, far leading 71.8 points of the traditional solution and 45.2 points of the non-protection solution, fully demonstrating that this technical solution achieves a better performance balance while protecting privacy. These data indicate that this technical solution has made remarkable technical breakthroughs in both privacy protection and system efficiency.

[0149] In an alternative embodiment, an adaptive distribution strategy is adopted to distribute the parameters of the updated global scene adaptation model to each of the edge nodes, and the adaptive distribution strategy adjusts the parameter update vector based on a momentum factor and a learning rate; the edge node updates the scene adaptation proxy model according to the received model parameters, including:

[0150] Obtain the local gradient information of the edge node and the historical parameter update record, where the local gradient information represents the optimization direction of the scene adaptation proxy model, and the historical parameter update record includes the parameter update vector at the previous moment;

[0151] Construct a parameter update vector based on the local gradient information and the historical parameter update record, adaptively adjust the momentum factor and the learning rate according to the computing power and network state of the edge node, where the momentum factor is used to control the retention degree of historical information, and the learning rate is used to adjust the step size of parameter update; increase the learning rate when the computing power is lower than a preset power threshold, and increase the momentum factor when the network state is lower than a preset state threshold; calculate the parameter update vector at the current moment according to the momentum factor and the learning rate;

[0152] Apply the parameter update vector to the parameters of the global scene adaptation model to obtain the updated model parameters; construct a hierarchical distribution strategy, hierarchically classify the edge nodes according to the computing power, and preferentially distribute the updated model parameters to the edge nodes with computing power higher than the preset power threshold; the edge nodes receive the updated model parameters and update the scene adaptation proxy model to complete the adaptive distribution of the model parameters.

[0153] In a distributed scene optimization network, the central server first obtains the local gradient information and historical parameter update records of the edge nodes. The local gradient information represents the optimization direction of the scene adaptation proxy model on the current edge node data, and is obtained through the forward propagation and backward propagation calculations of the model on the local data. For example, in a certain VR shopping scene application, the local gradient information of edge node A is represented as a vector with the same dimension as the model parameters, and each element in the vector represents the direction and magnitude of the corresponding parameter adjustment. Typically, for a scene adaptation proxy model with 500KB parameters, its gradient vector also contains approximately 500KB of data. The historical parameter update record contains the parameter update vector at the previous moment and is used to implement momentum update. For example, in the previous update cycle of edge node A, the weight parameter update values of the first convolutional layer are [-0.002, 0.005, -0.001, ...], and these values are saved as historical update records.

[0154] Based on the local gradient information and historical parameter update records, the system constructs a parameter update vector. During the construction process, the momentum factor and learning rate are adaptively adjusted according to the computing power and network status of the edge nodes. The momentum factor is used to control the retention degree of historical information, and its value range is usually between 0 and 1. The learning rate is used to adjust the step size of parameter update, usually a decimal between 0.001 and 0.1. The specific adjustment logic is as follows: increase the learning rate when the computing power of the edge node is lower than the preset power threshold; increase the momentum factor when the network status is lower than the preset status threshold.

[0155] The computing power assessment is based on hardware metrics such as the CPU model, number of cores, GPU model, and memory size of the device. For example, for an edge device equipped with a Qualcomm Snapdragon 8 Gen 2 processor and 12GB of RAM, its computing power score is 85 points (out of 100); while for a device equipped with a MediaTek Dimensity 8200 processor and 8GB of RAM, its computing power score is 65 points. The preset power threshold is set to 70 points. When the computing power score is lower than this threshold, the base learning rate (such as 0.01) is increased by 20% (becoming 0.012) to accelerate model convergence and compensate for the reduced training efficiency caused by insufficient computing power.

[0156] Network status assessment is based on indicators such as network bandwidth, latency, and packet loss rate. For example, for a connection with a network bandwidth of 50Mbps, a latency of 35ms, and a packet loss rate of 0.2%, its network status score is 90 points (out of 100); while for a connection with a bandwidth of 5Mbps, a latency of 120ms, and a packet loss rate of 2%, its network status score is 40 points. The preset status threshold is set at 60 points. When the network status score is lower than this threshold, the basic momentum factor (such as 0.9) is increased by 0.05 (to become 0.95) to enhance the weight of historical update information, reduce the impact of a single communication on model updates, and improve the stability of model training in a weak network environment.

[0157] Calculate the parameter update vector at the current moment according to the adaptively adjusted momentum factor and learning rate. The specific calculation method is to multiply the momentum factor by the historical parameter update vector and add the product of the learning rate and the current local gradient. For example, for a momentum factor of 0.95, a learning rate of 0.012, a certain parameter value in the historical update vector of -0.002, and a current gradient value of 0.015, the calculated update value is 0.95×(-0.002)+0.012×0.015=-0.0019+0.00018=-0.00172. In this way, the system calculates the update value for each model parameter to form a complete parameter update vector.

[0158] Apply the parameter update vector to the parameters of the global scene adaptation model to obtain the updated model parameters. This step is executed on the central server by adding the original model parameters and the update vector to obtain the new parameter values. For example, the weight parameters of a certain convolutional layer in the original model are [0.152, -0.087, 0.203, ...], and the corresponding update vector is [-0.00172, 0.00094, -0.00185, ...], then the updated parameter values are [0.15028, -0.08606, 0.20115, ...].

[0159] Construct a hierarchical distribution strategy. Stratify the edge nodes according to their computing capabilities, and preferentially distribute the updated model parameters to the edge nodes with computing capabilities higher than the preset capability threshold. In practical applications, the system divides the edge nodes into three layers: the high-performance layer (computing capability score ≥ 80), the medium-performance layer (60 ≤ computing capability score < 80), and the low-performance layer (computing capability score < 60). The distribution process is carried out in three stages: First, distribute the complete model parameters to the high-performance layer nodes; after the high-performance layer nodes confirm receipt, distribute the model parameters to the medium-performance layer nodes; and finally distribute them to the low-performance layer nodes. This hierarchical distribution strategy ensures that high-performance devices can obtain model updates faster and start adaptation optimization in advance.

[0160] For edge nodes at different levels, the system also adopts a differential parameter compression strategy. For high-performance layer nodes, it transmits the complete 32-bit floating-point parameters; for medium-performance layer nodes, the parameter quantity is quantized into 16-bit half-precision floating-point numbers, reducing the transmission volume by about 50%; for low-performance layer nodes, the parameter quantity is quantized into 8-bit integers, reducing the transmission volume by about 75%. For example, the original parameter value of 0.15028 may be quantized to 38 when transmitted to a low-performance node (assuming the quantization range of [-1,1] is mapped to [-128,127]). Through differential compression, the system balances model accuracy and transmission efficiency.

[0161] An incremental update mechanism is implemented to only transmit parameters that have changed significantly. Specifically, the current parameters are compared with the previous version of the parameters, and only the parameters with a change amplitude exceeding the threshold (such as 0.001) are transmitted. In a typical update cycle, about 15%-30% of the parameters change significantly, and the transmission volume can be reduced to 1 / 5 to 1 / 3 of the original through incremental updates.

[0162] The edge node receives the updated model parameters and updates the scene adaptation proxy model. During the receiving process, the system adopts a breakpoint resumption and verification mechanism to ensure the integrity and correctness of parameter transmission. For the received quantized parameters, the edge node performs dequantization processing to restore the parameter accuracy. For example, the received quantized value of 38 is converted back to a floating-point number of about 0.1496 through dequantization processing, and the error from the original value of 0.15028 is within an acceptable range.

[0163] After completing the parameter update, the edge node immediately uses the new model for scene adaptation optimization. For example, the updated model may recommend adjusting the shadow quality in the scene from "high" to "medium" to improve the frame rate; or adjusting the scene loading distance from "far" to "medium" to reduce memory occupancy. Actual tests show that the model updated through the adaptive distribution strategy can improve the scene running performance of edge devices by 12%-25% while maintaining good visual quality.

[0164] To evaluate the effect of model updates, the edge node collects performance metrics after applying the new model, including average frame rate, loading time, resource utilization, etc. These metrics are compared with the baseline values before the update to calculate the percentage of performance improvement. For example, the average frame rate of a mid-range device was 45 FPS before model update and increased to 52 FPS after the update, with a growth rate of 15.6%. The performance metrics are fed back to the central server for subsequent model optimization and iteration.

[0165] Through the technical means described in detail above, the system has achieved the efficient adaptive distribution of global scene adaptation model parameters, ensured the continuous optimization of scene adaptation proxy models of each edge node in the distributed scene optimization network, and improved the adaptation effect and user experience of metaverse applications in different hardware environments.

[0166] Table 4 is a comparison table of the adaptive distribution strategy and dynamic parameter update performance in the embodiments of the present invention:

[0167]

[0168] Table 4 details the performance of this technical solution compared with traditional fixed-parameter distribution and centralized update solutions in three dimensions: model convergence performance, adaptive parameter adjustment, and resource utilization efficiency. In terms of model convergence performance, this solution only requires 12.5 rounds to reach 95% accuracy, significantly better than the 25.8 rounds of the traditional solution and the 18.2 rounds of the centralized solution. The convergence speed improvement reaches 106.4%, while the centralized solution only has a 41.8% improvement. In terms of adaptive parameter adjustment, this solution adopts a dynamic adjustment strategy, with the momentum factor ranging from 0.65 and the learning rate ranging from 0.05, having better adaptability and flexibility compared to the fixed-parameter methods of the other two solutions (the momentum factor fixed at 0.9 and the learning rate fixed at 0.01). In terms of resource utilization efficiency, the computing resource utilization rate of this solution reaches 92.6%, much higher than the 65.3% of the traditional solution and the 78.5% of the centralized solution; the network bandwidth utilization efficiency reaches 65.8%, also significantly better than the 38.2% of the traditional solution and the 12.4% of the centralized solution. In the final comprehensive performance score, this solution leads far ahead of the 58.6 points of the traditional solution and the 72.4 points of the centralized solution with 94.2 points, fully demonstrating the comprehensive technical advantages of this technical solution in aspects such as model training efficiency, parameter adaptability, and resource utilization.

[0169] In the second aspect of the embodiments of the present invention,

[0170] A kind of electronic device is provided, including:

[0171] A processor;

[0172] A memory for storing instructions executable by the processor;

[0173] Wherein, the processor is configured to call the instructions stored in the memory to execute the method described above.

[0174] In the third aspect of the embodiments of the present invention,

[0175] A computer-readable storage medium is provided, on which computer program instructions are stored, and when the computer program instructions are executed by a processor, the method described above is implemented.

[0176] The present invention can be a method, device, system, and / or computer program product. The computer program product can include a computer-readable storage medium, on which computer-readable program instructions for executing various aspects of the present invention are uploaded.

[0177] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it; although the present invention has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that they can still modify the technical solutions described in the foregoing embodiments, or perform equivalent replacements on some or all of the technical features; and these modifications or replacements do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the various embodiments of the present invention.

Claims

1. A method for adaptively adapting to various needs of a Metaverse scenario building engine, characterized in that: include: Obtain the adaptation requirement information of the Metaverse scene building engine input by the user; Based on the adaptation requirement information, calling a basic functional component corresponding to the adaptation requirement information from a preset scene component library; The basic functional components are split into multiple levels, and a functional component loading priority table is established for the hardware configuration of different operating environments, including: The basic functional components are divided into a core functional layer, an extended functional layer and an optional functional layer, wherein the core functional layer includes a minimum functional set required for scene operation, the extended functional layer includes an enhanced functional set for improving scene performance, and the optional functional layer includes an additional functional set for providing special effects; for each functional component in the core functional layer, the extended functional layer and the optional functional layer, its resource occupancy value, minimum operating requirements and dependencies between components are recorded to generate a functional component configuration table; based on the functional component configuration table and the hardware parameters of the target operating environment, a functional component loading priority table is established; The functional component loading priority table records the resource occupancy value, minimum operating requirements and loading order of each functional component, and determines the component dynamic loading scheme under the current operating environment according to the functional component loading priority table; constructs a dependency graph according to the component dynamic loading scheme, divides the dependency graph into layers, and combines the basic functional components to form an initial scenario adaptation scheme; A distributed scene optimization network is constructed based on the federated learning framework and the initial scene adaptation scheme. The distributed scene optimization network includes multiple edge nodes, each edge node is deployed with a scene adaptation agent model, local scene operation data is collected through the scene adaptation agent model, the local scene operation data is anonymized and uploaded to the central server, the central server integrates the scene operation data from each edge node, updates the parameters of the pre-built global scene adaptation model, and distributes the updated parameters of the global scene adaptation model to each edge node, so as to realize continuous optimization of the scene adaptation agent model; Deploy the optimized scenario adaptation solution to the target operating environment to complete the adaptive adaptation of the metaverse scenario.

2. The method according to claim 1, characterized in that Constructing a dependency graph according to the component dynamic loading solution, dividing the dependency graph into layers, and combining the basic functional components to form an initial scenario adaptation solution includes: A dependency graph is constructed according to the component dynamic loading scheme, wherein each node in the dependency graph represents a functional component, and the connection between the nodes represents the dependency relationship between the functional components; the dependency strength in the dependency relationship is obtained by a weighted combination of the functional coupling degree, the memory sharing degree, and the call timing correlation; the functional components in the dependency graph are hierarchically divided according to the dependency strength to obtain a hierarchical structure of the functional components; Building a component scheduling priority table based on the hierarchical structure, the component scheduling priority table records the scheduling weight of each functional component; generating an initial combination scheme of the functional components according to the component scheduling priority table, the initial combination scheme including the loading order and resource allocation strategy of the functional components; Acquire real-time load data of the system, and construct a state transition matrix according to the real-time load data of the system, wherein the state transition matrix describes the state migration rules of functional components under different load conditions; dynamically adjust the functional components in the initial combination scheme based on the state transition matrix to generate an initial scenario adaptation scheme, wherein the initial scenario adaptation scheme meets the system performance constraints.

3. The method according to claim 1, characterized in that A distributed scene optimization network is constructed based on the federated learning framework and the initial scene adaptation scheme. The distributed scene optimization network includes multiple edge nodes, each edge node is deployed with a scene adaptation agent model, local scene operation data is collected through the scene adaptation agent model, the local scene operation data is anonymized and uploaded to the central server, the central server integrates the scene operation data from each edge node, updates the parameters of the pre-built global scene adaptation model, and distributes the updated parameters of the global scene adaptation model to each edge node, so as to realize the continuous optimization of the scene adaptation agent model, including: Constructing a distributed scene optimization network, wherein the distributed scene optimization network includes multiple edge nodes and a central server, and each edge node is deployed with a scene adaptation agent model; The scene operation data is collected through the scene adaptation agent model and differential privacy processing is performed, and noise that obeys the Laplace distribution is added to the scene operation data to obtain anonymized data; the anonymized data is compressed and encoded by using an adaptive quantization method to obtain encoded anonymized data; Uploading the encoded anonymized data to the central server, the central server fuses the anonymized data from each edge node based on a weighted average aggregation strategy, and updates the parameters of the global scene adaptation model, wherein the node weight in the weighted average aggregation strategy is related to the data quality and computing power; An adaptive distribution strategy is adopted to distribute the updated parameters of the global scene adaptation model to each of the edge nodes, and the adaptive distribution strategy adjusts the parameter update vector based on the momentum factor and the learning rate; the edge node updates the scene adaptation proxy model according to the received model parameters.

4. The method according to claim 3, characterized in that The scene operation data is collected through the scene adaptation agent model and differential privacy processing is performed, and noise that obeys the Laplace distribution is added to the scene operation data to obtain anonymized data; The anonymized data is compressed and encoded using an adaptive quantization method, and the encoded anonymized data includes: Calculate the global sensitivity of the scenario operation data, where the global sensitivity is determined by the maximum difference between the query function output results of any two adjacent data sets; construct a Laplace noise generation function based on the global sensitivity, where the Laplace noise generation function includes a noise scale parameter and a position parameter, and the noise scale parameter is determined by the ratio of the global sensitivity to the privacy budget; Injecting the Laplace noise generation function into the scene operation data to obtain an initial anonymized data set; calculating data entropy according to the probability distribution of data in the initial anonymized data set, and constructing an adaptive quantization step length calculation function based on the data entropy, wherein the adaptive quantization step length calculation function determines the quantization step length through an exponential function relationship between a basic step length and the data entropy; Adaptively quantizing the initial anonymized data set using the quantization step size to obtain a quantized anonymized data set; calculating a compression ratio of the quantized anonymized data set, wherein the compression ratio is determined by a ratio of the original data size to the quantized data size; When the compression rate is within a preset compression threshold range, encoding optimization is performed on the quantized anonymized data set to obtain final anonymized data.

5. The method according to claim 3, characterized in that: Distributing the updated parameters of the global scene adaptation model to each of the edge nodes using an adaptive distribution strategy, wherein the adaptive distribution strategy adjusts the parameter update vector based on a momentum factor and a learning rate; The edge node updating the scene adaptation proxy model according to the received model parameters includes: Obtaining local gradient information and historical parameter update records of edge nodes, wherein the local gradient information represents the optimization direction of the scene adaptation agent model, and the historical parameter update record includes the parameter update vector at the last moment; Constructing a parameter update vector based on the local gradient information and the historical parameter update record, adaptively adjusting a momentum factor and a learning rate according to the computing power and network status of the edge node, wherein the momentum factor is used to control the degree of retention of historical information, and the learning rate is used to adjust the step size of parameter update; increasing the learning rate when the computing power is lower than a preset capacity threshold, and increasing the momentum factor when the network status is lower than a preset status threshold; and calculating a parameter update vector at the current moment according to the momentum factor and the learning rate; The parameter update vector is applied to the parameters of the global scene adaptation model to obtain updated model parameters; a hierarchical distribution strategy is constructed to hierarchize the edge nodes according to the computing capabilities, and the updated model parameters are preferentially distributed to edge nodes with computing capabilities higher than a preset capability threshold; the edge nodes receive the updated model parameters and update the scene adaptation proxy model to complete the adaptive distribution of model parameters.

6. An electronic device, characterized in that: include: processor; a memory for storing processor-executable instructions; The processor is configured to call the instructions stored in the memory to execute the method described in any one of claims 1 to 5.

7. A computer-readable storage medium having computer program instructions stored thereon, characterized in that: When the computer program instructions are executed by a processor, the method according to any one of claims 1 to 5 is implemented.

Images