Multi-demand self-adaptive adaptation method based on element universe scene building engine

Abstract

The invention provides a multi-demand adaptive adaptation method based on a meta-universe scene building engine, and relates to the technical field of meta-universe, and the method comprises the steps: obtaining adaptation demand information, calling a corresponding basic function component, carrying out the multi-level splitting, building a function component loading priority table, determining a dynamic loading scheme, and constructing an initial scene adaptation scheme. And constructing a distributed scene optimization network based on a federated learning framework to realize continuous optimization, and finally deploying to a target environment. According to the method, the scene adaptation problem in different hardware environments is effectively solved, the operation efficiency is improved, the resource occupation is reduced, and the dynamic adaptive loading and optimization of the meta-universe scene are realized.

Description

Technical Field

[0001] The present invention relates to metaverse technology, and in particular to a method for adaptively adapting to multiple demands based on a metaverse scenario building engine. Background Art

[0002] With the continuous development and popularization of the concept of the metaverse, the construction of metaverse scenes has become an important field of digital content creation. The metaverse scene construction engine is the core technical tool for realizing the construction of the virtual world. It needs to support diverse user needs and provide a smooth experience under different hardware configurations and network environments. At present, the metaverse scene construction technology mainly relies on large-scale 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 wide-ranging, from education and training to social entertainment, from commercial display to industrial simulation, and different application scenarios have very different requirements for system performance, interaction methods and visual effects. In addition, the diversity of user devices also brings huge challenges to the consistent experience of the metaverse scene. From high-performance PCs to mobile devices, from VR headsets to ordinary screens, special adaptation and optimization are required for different hardware characteristics.

[0003] Existing Metaverse scene building technologies have obvious limitations in adapting to diverse needs. Most scene building engines use a fixed set of functional components and cannot dynamically adjust component loading strategies according to the actual operating environment, resulting in serious performance bottlenecks or functional deficiencies on low-configuration devices. This "one-size-fits-all" adaptation method cannot meet the diverse application needs of the Metaverse, and severely limits the popularity and application scope of Metaverse technology.

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

[0005] Existing technical solutions have obvious deficiencies in cross-device collaboration and resource sharing. Each terminal device operates independently of each other, lacks an effective federated learning and distributed optimization framework, and cannot fully utilize the collective intelligence in the network to improve the overall system performance. This results in the need to repeat similar optimization work on different devices for the same scenario, resulting in low resource utilization efficiency and difficulty in making global optimal resource allocation and function optimization based on the overall usage of the user group. Summary of the invention

[0006] The embodiment of the present invention provides a method for adaptively adapting to multiple requirements based on a metaverse scene building engine, which can solve the problems in the prior art.

[0007] According to a first aspect of the embodiments of the present invention, Provides a variety of demand-based adaptive adaptation methods for building engines based on the Metaverse scenario, including: 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. The functional component loading priority table records the resource occupancy value, minimum operating requirements and loading order of each functional component, and the component dynamic loading scheme under the current operating environment is determined according to the functional component loading priority table; Construct a dependency graph according to the component dynamic loading solution, divide the dependency graph into layers, and combine the basic functional components to form an initial scene adaptation solution; 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.

[0008] 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.

[0009] 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.

[0010] 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.

[0011] 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, 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.

[0012] The updated parameters of the global scene adaptation model are distributed to each edge node using an adaptive distribution strategy, wherein the adaptive distribution strategy adjusts the parameter update vector based on a momentum factor and a learning rate; and the edge node updates the scene adaptation proxy model according to the received model parameters, including: 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.

[0013] According to a second aspect of the embodiments of the present invention, An electronic device is provided, comprising: processor; a memory for storing processor-executable instructions; The processor is configured to call the instructions stored in the memory to execute the aforementioned method.

[0014] According to a third aspect of the embodiments of the present invention, A computer-readable storage medium is provided, on which computer program instructions are stored. When the computer program instructions are executed by a processor, the aforementioned method is implemented.

[0015] The beneficial effects of this application are as follows: The present invention realizes the intelligent adaptive adaptation of Metaverse scenes. Through the multi-level splitting of components and the dynamic loading priority mechanism, the system can automatically adjust the complexity of the scene according to different hardware configurations, effectively solving the compatibility issues of Metaverse applications on multiple devices and improving the consistency of user experience.

[0016] The present invention adopts a federated learning framework to build a distributed scenario optimization network. Under the premise of protecting user privacy, it realizes the collection and analysis of large-scale scenario operation data, avoids the data island problem of traditional centralized learning models, and reduces the network transmission burden through local computing of edge nodes, thereby improving the overall performance and response speed of the system.

[0017] The present invention optimizes the collaborative working efficiency between components and reduces resource conflicts and loading blockages through the construction and hierarchical division technology of dependency graphs, so that the metaverse scene can obtain a smooth operation experience on different terminal devices. At the same time, the system's adaptive ability continues to improve with the increase in the number of users, forming a benign technology iteration closed loop. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] Figure 1 This is a flow chart of a method for adaptively adapting to multiple requirements of an engine based on a metaverse scenario according to an embodiment of the present invention. DETAILED DESCRIPTION

[0019] In order to make the purpose, technical solution and advantages of the embodiments of the present invention clearer, the technical solution in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0020] The technical solution of the present invention is described in detail with specific embodiments below. The following specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described in detail in some embodiments.

[0021] Figure 1 Schematic diagram of a process of adaptively adapting a method for building an engine for multiple requirements based on a metaverse scenario according to an embodiment of the present invention. Figure 1 As shown, the method includes: 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. The functional component loading priority table records the resource occupancy value, minimum operating requirements and loading order of each functional component, and the component dynamic loading scheme under the current operating environment is determined according to the functional component loading priority table; Construct a dependency graph according to the component dynamic loading solution, divide the dependency graph into layers, and combine the basic functional components to form an initial scene adaptation solution; 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.

[0022] In an optional implementation, the basic functional components are split into multiple levels, and a functional component loading priority table is established for hardware configurations 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.

[0023] The basic functional components are divided into three functional levels: core functional layer, extended functional layer and optional functional layer. The core functional layer contains the minimum functional set required for scene operation, the extended functional layer contains the enhanced functional set to improve scene performance, and the optional functional layer contains the additional functional set to provide special effects.

[0024] In actual applications, the core functional layer usually includes components such as scene rendering engine, basic physics system, character controller, network communication module and user interface framework. For example, in the virtual conference scene of the Metaverse, the scene rendering engine of the core functional layer occupies about 120MB of GPU resources and about 5% of CPU occupancy rate, and the minimum operating requirement is an independent graphics card and the video memory is not less than 1GB; the basic physics system occupies about 3% of CPU resources and about 25MB of RAM, and the minimum requirement is a dual-core processor; the character controller occupies about 2% of CPU resources and about 15MB of RAM, and the minimum requirement is a dual-core processor; the network communication module occupies bandwidth resources of about 0.5Mbps uplink and 1Mbps downlink, and the minimum requirement is a stable network connection speed of not less than 5Mbps; the user interface framework occupies about 50MB of GPU resources and about 1% of CPU, and the minimum requirement is an integrated graphics card and the video memory is not less than 256MB.

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

[0026] The optional function layer usually includes components such as particle special effects system, environment reflection system, real-time shadow system, advanced post-processing effects and immersive sound effects. In the example of the Metaverse virtual meeting scene, the particle special effects system of the optional function layer occupies about 200MB of GPU resources and about 8% of CPU, and the minimum requirement is an independent graphics card with a memory of no less than 3GB; the environment reflection system occupies about 230MB of GPU resources and the minimum requirement is a GPU that supports reflection rendering technology; the real-time shadow system occupies about 250MB of GPU resources and about 5% of CPU, and the minimum requirement is a GPU that supports real-time shadow rendering; advanced post-processing effects occupy about 150MB of GPU resources and the minimum requirement is an independent graphics card with a memory of no less than 2GB; immersive sound effects occupy about 6% of CPU resources and about 35MB of RAM, and the minimum requirement is audio hardware that supports spatial audio processing.

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

[0028] The configuration record of the particle effects system is: component ID is PS001, component name is "particle effects system", function level is "optional function layer", resource usage values ​​are GPU video memory 200MB, CPU usage 8%, RAM usage 35MB, the minimum operating requirement is an independent graphics card with video memory of no less than 3GB, and the component dependency list includes scene rendering engine (RE001) and advanced lighting system (AL001).

[0029] Detect the hardware configuration of the target operating environment, including CPU model and core number, GPU model and 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), NVIDIA GeForce GTX 1660 graphics card (6GB memory), 16GB RAM, and 100Mbps network bandwidth.

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

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

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

[0033] Adjust the component priority based on the ratio of remaining hardware resources to component resource requirements. For example, the GPU memory of the current environment has 4.5GB remaining, and the particle effects system requires 200MB of memory. The remaining memory to demand ratio is 22.5, which is much larger than the threshold of 10, so the priority is increased by 1 point. Similarly, calculate the ratio of CPU, RAM and other resources and adjust the priority.

[0034] The final functional component loading priority table is generated by comprehensively considering component dependencies, basic priorities, and resource adjustment priorities. 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 effects (priority 5) → advanced animation system (priority 5) → particle special effects system (priority 3) → real-time shadow system (priority 2) → advanced post-processing effects (priority 2) → immersive sound effects (priority 1).

[0035] During the actual loading process, the system will load components in order from high to low according to the priority table. For interdependent components, ensure that the dependent components are loaded before the dependent components. At the same time, the system will monitor the usage of hardware resources in real time, and when the resources are close to the threshold, the loading of low-priority components will be suspended. For example, when the GPU memory usage reaches 85%, the system will suspend loading the particle effects system and lower priority components.

[0036] The basic concept of this technology originates from the multi-level of detail (LOD) rendering technology in computer graphics and the modular loading mechanism in game engines. Existing LOD technology mainly focuses 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 ability to intelligently adapt to diverse hardware environments.

[0037] There are two main implementation methods for traditional resource loading methods: one is to load all components at once according to a preset fixed configuration template (such as "low", "medium", and "high"); the other is to use a predefined loading order based on simple device detection results. For example, the Unity engine selects a preset image quality level based on the detected graphics card model, and the Unreal engine selects the corresponding scalable parameter configuration based on the system configuration. These methods have obvious defects: the preset template cannot be finely adapted to the diverse hardware environment; 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 usage.

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

[0039] A multi-level functional component splitting strategy is proposed, which divides the scenario functions into three levels: core, extension, and optional. This enables the system to flexibly combine functional components according to hardware conditions and achieve "rigid demand guarantee and dynamic adaptation of elastic demand".

[0040] A dynamic priority adjustment mechanism based on resource ratios has been designed. Instead of using static preset priorities, the loading priority is dynamically adjusted according to the ratio of current hardware resource margin to component requirements, enabling the system to allocate resources more accurately.

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

[0042] A real-time resource monitoring and threshold control mechanism is implemented. The system can monitor the real-time usage of hardware resources and suspend the loading of low-priority components in time when resources are close to the preset threshold to prevent system resource overload.

[0043] Through the above improvements, the present application has achieved significant improvements compared with the prior art: first, the scene loading speed is increased by 35% on average, especially on mid- and low-end devices, the improvement is more obvious, reaching more than 50%; second, the running fluency is greatly improved, the average frame rate is increased by 25%, and the frame rate fluctuation is reduced by 60%; third, the system stability is significantly enhanced, the crash rate is reduced by 80%, and the memory overflow problem is reduced by 90%; finally, the user experience is 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 fluency is more ideal.

[0044] These improvements enable Metaverse applications to provide consistent and high-quality user experience on multiple platforms, 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 its widespread application.

[0045] In an optional implementation, 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 scene 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.

[0046] A dependency graph is constructed based on the component dynamic loading scheme. In the 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 scene, the rendering engine component (RE001) is dependent on the scene manager component (SM001), the lighting system component (LS001), and the physics engine component (PE001); and the lighting system component (LS001) is dependent on the shadow processing component (SP001) and the post-processing effect component (PP001). These dependencies are represented as directed edges from the dependent component to the dependent component.

[0047] The dependency strength in the dependency relationship is obtained by calculating the weighted combination of functional coupling, memory sharing, and call timing correlation. Functional coupling is measured by counting the frequency of function calls between two components. For example, during the test run, the shadow processing component (SP001) calls the function of the lighting system component (LS001) an average of 25 times per second, with a high call frequency and a functional coupling score of 8.5 (out of 10); Memory sharing is measured by the proportion of the amount of memory data shared by the two components to the total amount of data. For example, the shadow processing component shares lightmaps, shadow mapping and other data with the lighting system component. The shared data volume is 350MB, accounting for 70% of the total data volume of the shadow processing component of 500MB, and the memory sharing score is 7.0; Call timing correlation is measured by the time dependency of calls between components. For example, the shadow processing component must perform shadow calculations only after the lighting system completes the lighting calculations. The timing dependency is strong and the call timing correlation score is 9.0.

[0048] The three indicators are weighted respectively: functional coupling weight 0.4, memory sharing weight 0.3, call timing correlation weight 0.3, and the dependency strength is calculated by weighted sum. 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 (full score 10). The dependency strength is quantified as a value between 1-10, and the larger the value, the stronger the dependency.

[0049] The functional components in the dependency graph are divided into layers according to the dependency strength to obtain the hierarchical structure of the functional components. The hierarchical division adopts a variant algorithm of topological sorting: first, nodes without outgoing edges (components that do not depend on other components) are divided into the first layer; then these nodes and their associated edges are removed from the graph; nodes without outgoing edges in the new graph are continued to be divided into the second layer; and so on, until all nodes are divided. When there is a dependency loop, the system will select the edge with the weakest dependency strength for temporary removal to break the loop. For example, in the layering process, the rendering engine component (RE001) is divided into the first layer, the scene manager component (SM001) and the lighting system component (LS001) are divided into the second layer, and the shadow processing component (SP001) is divided into the third layer.

[0050] A component scheduling priority table is built based on the hierarchical structure, which records the scheduling weight of each functional component. The scheduling weight is determined by three factors: the component's hierarchy, resource occupancy, and user experience impact. The hierarchy factor considers the position of the component in the hierarchy, and low-level (basic) components have higher weights; resource occupancy considers the degree of component consumption of system resources, and the lower the resource occupancy, the higher the weight; user experience impact 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 in the first layer, with a medium resource occupancy (GPU occupancy 30%), and a very high user experience impact (score 9.5), and the final scheduling weight is calculated to be 95; while the shadow processing component is located in the third layer, with a high resource occupancy (GPU occupancy 15%), a medium user experience impact (score 6.0), and the final scheduling weight is calculated to be 65.

[0051] Generate an initial combination plan of functional components according to the component scheduling priority table, including the loading order of functional components and resource allocation strategy. The loading order is arranged from high to low according to the scheduling weight, and the dependency relationship is considered to ensure that the dependent component is loaded before the dependent component. 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 of each component according to the scheduling weight and resource demand of the component, and the high-weight component obtains more resource quota. 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.

[0052] Get the real-time load data of the system, including CPU usage, GPU usage, memory occupancy, network bandwidth usage and other indicators. For example, the current system CPU usage is 65%, GPU usage is 78%, memory usage is 55%, and network bandwidth usage is 40%. Based on these real-time load data, the system builds a state transition matrix to describe the state migration rules of functional components under different load conditions. The state transition matrix contains multiple condition triggers and corresponding state migration actions. For example, when the GPU usage exceeds 85%, the shadow processing component migrates from the "full loading" 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 exceeds 95%, the shadow processing component further migrates to the "minimized loading" state, retaining only basic shadow functions.

[0053] Based on the state transition matrix, the functional components in the initial combination scheme are dynamically adjusted to generate the 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 GPU usage close to the warning line (78%), turning off the depth of field and motion blur effects and retaining only the basic color correction function; the shadow processing component is pre-set to medium-precision loading mode according to the rules in the state transition matrix to prevent the GPU usage from further increasing. Through these dynamic adjustments, the system ensures that the initial scene adaptation scheme meets the system performance constraints.

[0054] A dynamic resource reallocation mechanism is also implemented to dynamically adjust the resource quota 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 more accurate physical interaction effects; when the user enters a high-detail area in the scene, the system will increase the GPU resource quota of the rendering engine and lighting system to ensure the best visual effect.

[0055] Table 1 is a multi-dimensional performance comparison table of the dynamic loading solution of components in an embodiment of the present invention:

[0056] Table 1 shows a performance evaluation comparison table of technical solutions, which comprehensively compares this technical solution, traditional static loading solution and 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 (accuracy 0.4, sharing 0.3, and timing correlation 0.3), so that the dependency recognition accuracy rate reaches 94.8%, which is significantly higher than the 68.5% of the traditional solution and 82.3% of the authorized solution. In terms of resource utilization efficiency, this solution shows excellent resource allocation capabilities: although the average memory usage is only 38.2% (lower than the 82.5% of the traditional solution and 45.6% of the authorized solution), the CPU utilization efficiency reaches 92.6%, and the resource scheduling efficiency is as high as 95.4%, which are significantly ahead of the other two solutions (the traditional solution is 68.2% and 62.8%, respectively, and the authorized solution is 83.5% and 76.3%, respectively). In terms of scene adaptation performance, this solution performs better: the scene switching response time is only 186ms (traditional solution 452ms, authorized solution 324ms), the load fluctuation adaptability is 93.8% (traditional solution 58.4%, authorized solution 74.2%), and the priority scheduling accuracy is as high as 96.2% (authorized solution 82.5%, traditional solution is not applicable). In the final comprehensive performance score, this solution scored 94.8 points, far exceeding the 62.5 points of the traditional solution and the 78.6 points of the authorized solution, which fully demonstrated the comprehensive advantages of this technical solution.

[0057] In an optional implementation, a distributed scene optimization network is constructed based on a 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 a central server, the central server fuses the scene operation data from each edge node, updates the parameters of a pre-built global scene adaptation model, and distributes the updated parameters of the global scene adaptation model to each edge node, and realizes 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.

[0058] Build a distributed scene optimization network, which includes multiple edge nodes and a central server. In actual deployment, the edge node can be a user's personal computing device, such as a computer, tablet, or AR / VR helmet, while the central server is deployed in the cloud. For example, in a metaverse education platform application, the distributed scene optimization network may include 5,000 edge nodes and 1 central server. Each edge node is deployed with a scene adaptation agent model, which adopts a lightweight neural network structure, including 4 convolutional layers and 2 fully connected layers, with a parameter volume of approximately 500KB. This lightweight design ensures that the model can run efficiently on edge devices while maintaining sufficient expressiveness.

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

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

[0061] 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.

[0062] 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.

[0063] 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: 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).

[0064] 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.

[0065] 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%.

[0066] 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), a higher momentum factor (such as 0.9) and learning rate (such as 0.01) are used to enable them to obtain the latest model faster; for nodes with poor network conditions (such as bandwidth less than 2Mbps), a lower momentum factor (such as 0.6) and learning rate (such as 0.005) are used to reduce the update amplitude and reduce transmission costs. In addition, the system will sparsely process the model parameters and only transmit parameters with significant changes (parameters with a change amplitude greater than the threshold of 0.01). Usually, these parameters account for 20%-30% of the total parameters, greatly reducing the amount of transmitted data.

[0067] 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, some connections with 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 precision in exchange for improved computing efficiency. Finally, the edge node uses the updated parameters to update the local scene adaptation agent model, completing a round of federated learning. Experiments show that after about 100 rounds of federated learning updates, the scene adaptation agent model can accurately predict the optimal scene configuration parameters in various hardware environments, with an average prediction accuracy of 89%.

[0068] A differentiated update mechanism is implemented, and the update frequency is determined based on the activity and performance improvement space of edge nodes. Nodes with high activity and large performance improvement space (such as nodes with daily active time exceeding 3 hours and current performance lower than expected by more than 20%) are updated multiple times a day; while nodes with low activity or close to optimal performance are updated less frequently, for example, once a week, balancing the optimization effect and system overhead.

[0069] The basic concept of this technology comes from the distributed machine learning architecture that combines federated learning with differential privacy. Existing technologies mainly include the FedAvg algorithm proposed by Google, Microsoft's federated learning toolkit LEAF, and the differential privacy framework developed by IBM. However, these existing technologies have obvious shortcomings when applied to the optimization of metaverse scenarios.

[0070] Traditional federated learning methods usually adopt a unified model structure and synchronous update mechanism. After the central server aggregates the model parameters of each node, it performs a simple average and then distributes the fully updated model parameters to all nodes. This implementation method faces several key challenges in the metaverse scenario: First, the edge devices in metaverse applications are highly heterogeneous, ranging from high-performance PCs to entry-level mobile devices. The unified model structure cannot adapt to various devices; second, the simple average aggregation strategy ignores the difference in data quality and is easily negatively affected by low-quality data; third, synchronous model updates and complete parameter distribution will cause serious delays or even failures when network conditions are poor; finally, existing differential privacy processing usually adopts a fixed privacy budget, which cannot balance the privacy protection needs and usefulness of different types of data.

[0071] Table 2 is a comparison table of multi-dimensional performance of distributed scenario optimization network according to an embodiment of the present invention:

[0072] Table 2 compares the performance of this technical solution with traditional federated learning and centralized learning in terms of privacy protection performance, communication efficiency index and model performance index. In terms of privacy protection, the data privacy protection rate of this solution reaches 92.8%, far exceeding the 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, which is significantly lower than the 105.8MB of the traditional solution and 342.6MB of the centralized solution; the data compression rate reaches 4.66 times, far exceeding the 1.32 times of the traditional solution and 1.0 times of the centralized solution; the bandwidth utilization efficiency reaches 78.6%, which is significantly ahead of the 35.2% of the traditional solution and 12.5% ​​of the centralized solution. In terms of model performance indicators, this solution only needs 12.5 rounds to achieve 95% accuracy, which is better than the 28.6 rounds of the traditional solution and the 15.8 rounds of the centralized solution; the final model accuracy reaches 98.2%, slightly higher than the 95.6% of the traditional solution and the 97.4% of the centralized solution; the edge resource utilization rate reaches 92.6%, far exceeding the 63.4% of the traditional solution (centralized solution is not applicable). In the comprehensive performance score, this solution scored 94.5 points, significantly higher than the 67.8 points of the traditional solution and the 52.3 points of the centralized solution, fully demonstrating the comprehensive advantages of this technical solution.

[0073] In response to the above problems, this application has made many improvements to traditional technologies based on the actual needs of Metaverse scenario optimization: A two-layer structure design is introduced to separate the lightweight edge proxy model from the complex global model. The model parameters deployed on the edge node are only 500KB, which can run efficiently on resource-constrained devices. The global model parameters on the central server are 2MB, which has stronger expression and optimization capabilities.

[0074] A dynamic differential privacy mechanism based on data sensitivity was designed. Instead of using a unified privacy budget, the ε value is dynamically adjusted 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.

[0075] A data compression mechanism combining adaptive quantization and incremental update has been developed to dynamically adjust the quantization accuracy according to the importance of the data. At the same time, only the data with significant changes is transmitted, reducing the transmission volume by about 70% and solving the problem of limited network bandwidth.

[0076] A weighted average aggregation strategy is proposed, which takes into account both the data quality score and the device computing power, so that high-quality data is given a higher weight, thus improving the training effect of the global model.

[0077] An adaptive distribution strategy based on momentum factor and learning rate is implemented, the parameter update method is adjusted for edge nodes with different network conditions, and the amount of transmitted data is reduced through sparse processing, solving the problem of large differences in network conditions.

[0078] A differentiated update mechanism has been developed to dynamically adjust the update frequency based on node activity and performance improvement space, avoiding unnecessary frequent updates and reducing system burden.

[0079] Through the above improvements, this application has achieved remarkable results in metaverse scene optimization: first, the adaptation effect of the optimized scene is significantly improved, the average frame rate is increased by 12%, the loading time is reduced by 25%, and the system resource utilization rate is increased by 18%, which is far higher than the 5%, 10% and 8% improvement levels of traditional methods; secondly, the network transmission overhead is greatly reduced. Through adaptive quantization and incremental update, the data transmission volume is reduced by about 70%, and through sparse processing, the model parameter transmission volume is reduced by 70%-80%; thirdly, the privacy protection capability is significantly enhanced. Experiments have verified that even if the attacker has 90% of the network node data, it is impossible to accurately infer the sensitive information of the target user, and the attack success rate is reduced to less than 5%; finally, the adaptation capability on heterogeneous devices is greatly improved, and a smooth experience can be obtained from high-end VR helmets to entry-level smartphones, and user satisfaction has increased by 35%.

[0080] These improvements enable metaverse applications to provide users with smooth and stable immersive experiences 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.

[0081] In an optional implementation, the scene operation data is collected through the scene adaptation agent model and differential privacy processing is performed, 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.

[0082] The scene operation data is collected through the scene adaptation agent model. In actual applications, the scene operation data includes hardware performance indicators (such as CPU utilization, GPU utilization, memory occupancy, temperature, etc.), network performance indicators (such as bandwidth, latency, packet loss rate, etc.), rendering performance indicators (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 scene, the collected scene operation data include: CPU utilization 75%, GPU utilization 82%, memory occupancy 3.8GB, network latency 65ms, frame rate 42FPS, scene loading time 3.2 seconds, user click operation frequency 18 times per minute, etc.

[0083] Calculate the global sensitivity of the scene operation data. The global sensitivity is determined by calculating the maximum difference in the query function output results between any two adjacent data sets. In actual implementation, different sensitivity calculation methods are used for different types of data. For example, for percentage data such as CPU usage, the value range is 0-100%, and the maximum possible difference between adjacent data sets is 100%, so its global sensitivity is 100; for frame rate data, considering the actual application scenarios, the frame rate of virtual reality applications is usually between 0-120FPS, and its global sensitivity is set to 120; for user click operation frequency, 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.

[0084] Based on the calculated global sensitivity, a Laplace noise generation function is constructed. The Laplace noise generation function contains a noise scale parameter and a position parameter, where the position 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 that represents the strength of privacy protection. The smaller the value, the stronger the privacy protection, but the lower the data usefulness. In this embodiment, different privacy budgets are set according to the sensitivity of the data: for relatively insensitive hardware performance indicators (such as CPU usage), the privacy budget is set to 5.0; for moderately sensitive rendering performance indicators (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.

[0085] Taking CPU usage 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 by this parameter is about 20, that is, the original value of CPU usage of 75% may become 75%+(-18%)=57% or 75%+23%=98% after adding noise. Through actual testing, this noise level can effectively prevent third parties from inferring the specific model of user devices through data, while maintaining the availability of data and controlling the impact on model training.

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

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

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

[0089] The calculated quantization step size is used to perform adaptive quantization processing on the initial anonymized data set to obtain the quantized anonymized data set. The quantization process is the process of mapping continuous values ​​to discrete values. It is achieved by dividing the original value by the quantization step size, rounding it up, and then multiplying it by the quantization step size. Taking the frame rate as an example, the original value is 38FPS, the quantization step size is 0.11FPS, and the quantized value is 38÷0.11=345.45, which is rounded to 345 and then multiplied by 0.11 to get 37.95FPS. The quantized anonymized data set is: CPU utilization rate 55%, GPU utilization rate 80%, memory usage 3.9GB, network delay 70ms, frame rate 37.95FPS, scene loading time 3.5 seconds, and user click operation frequency 16 times per minute.

[0090] 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, the appropriate bit width can be selected according to the value range. For example, the CPU usage (0-100%) can be represented by a 7-bit unsigned integer after quantization, while the original 32-bit floating point number is required, and the compression ratio is 32 / 7≈4.57. The average compression ratio calculated for the entire data set is 3.8, which means that the amount of data is reduced to 1 / 3.8 of the original amount.

[0091] The preset compression threshold range is usually set to [2.0, 5.0], indicating that the amount of data is expected to be reduced by at least half, but the compression rate is not more than 5 times (too high a compression rate may cause excessive data distortion). When the compression rate is within the threshold range, the encoding of the quantized anonymized data set is optimized. When the compression rate is lower than the lower limit, the basic quantization step size can be increased; when the compression rate is higher than the upper limit, the basic quantization step size can be reduced and then re-quantized.

[0092] The quantized anonymized data set is coded and optimized to obtain the final anonymized data. Coding optimization uses entropy coding methods such as Huffman coding or arithmetic coding to assign codes of different lengths according to the frequency of data occurrence, with short codes assigned to high-frequency data and long codes assigned to low-frequency data, further improving compression efficiency. Through coding optimization, the data compression rate can be further increased by 20%-30%, for example, from 3.8 to 4.8, which means that the amount of data is reduced to 1 / 4.8 of the original.

[0093] An incremental encoding mechanism is also implemented to transmit only the data that has changed compared to the previous sampling. For data items whose change is less than a threshold (such as 1%), they are marked as "no significant change" and the actual value is not transmitted, thereby further reducing the amount of data. Through actual measurements, in normal usage scenarios, an average of about 40% of the data items have no significant changes compared to the previous sampling. After using incremental encoding, the transmission amount can be reduced by about 35%.

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

[0095] 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 the 76.5% of the traditional solution and 5.2% of the non-protected solution; in terms of differential privacy budget, a dynamic adjustment mechanism of 0.5-2.0 is adopted, which is more flexible than the traditional solution of fixed ε=1.0; the quantization step size calculation adopts an exponential function adjustment method based on data entropy, rather than the fixed step size of the traditional solution. In terms of efficiency indicators, the data compression rate of this solution reaches 4.66 times, significantly higher than the 2.35 times of the traditional solution and 1.0 times of the non-protected solution; the data integrity reaches 96.5%, which is slightly lower than the 100% of the non-protected solution, but significantly better than the 84.3% of the traditional solution; in terms of bandwidth saving rate, this solution reaches 78.6%, far exceeding the 57.4% of the traditional solution and 0% of the non-protected solution. The final comprehensive performance score shows that this solution scored 93.6 points, far ahead of the 71.8 points of the traditional solution and the 45.2 points of the unprotected solution, which fully proves that this technical solution achieves a better performance balance while protecting privacy. These data show that this technical solution has achieved a significant technical breakthrough in balancing privacy protection and system efficiency.

[0096] In an optional implementation, an adaptive distribution strategy is used to distribute the updated parameters of the global scene adaptation model to each edge node, 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, including: 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.

[0097] In a distributed scene optimization network, the central server first obtains the local gradient information and historical parameter update records of the edge node. The local gradient information represents the optimization direction of the scene adaptation agent model on the current edge node data, and is obtained by forward propagation and back propagation calculations of the model on local data. For example, in a VR shopping scene application, the local gradient information of edge node A is represented as a vector with the same dimension as the model parameter, and each element in the vector represents the direction and magnitude of the corresponding parameter to be adjusted. Typically, for a scene adaptation agent model containing 500KB parameters, its gradient vector also contains about 500KB of data. The historical parameter update record contains the parameter update vector at the last moment, which is used to implement momentum update. For example, in the last update cycle of edge node A, the weight parameter update value of the first convolution layer is [-0.002, 0.005, -0.001, ...], and these values ​​are saved as historical update records.

[0098] Based on 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 of the edge node and the network status. The momentum factor is used to control the degree of retention of historical information, and the value range is usually between 0 and 1. The learning rate is used to adjust the step size of the parameter update, which is usually a decimal between 0.001 and 0.1. The specific adjustment logic is as follows: when the computing power of the edge node is lower than the preset capacity threshold, the learning rate is increased; when the network status is lower than the preset status threshold, the momentum factor is increased.

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

[0100] The network status evaluation 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%, the 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%, the network status score is 40 points. The preset status threshold is set to 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 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.

[0101] The parameter update vector at the current moment is calculated based on the adaptively adjusted momentum factor and learning rate. The specific calculation method is to add the product of the momentum factor and the historical parameter update vector, plus the product of the learning rate and the current local gradient. For example, for a momentum factor of 0.95 and a learning rate of 0.012, a parameter value in the historical update vector is -0.002, and the current gradient value is 0.015, then 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.

[0102] Apply the parameter update vector to the parameters of the global scene adaptation model to obtain the updated model parameters. This step is performed on the central server, and the new parameter values ​​are obtained by adding the original model parameters to the update vector. For example, the weight parameters of a 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, ...].

[0103] Construct a hierarchical distribution strategy, stratify edge nodes according to computing power, and prioritize the distribution of updated model parameters to edge nodes with computing power higher than the preset capacity threshold. In actual applications, the system divides edge nodes into three layers: high-performance layer (computing power score ≥ 80), medium-performance layer (60≤computing power score <80), and low-performance layer (computing power score <60). The distribution process is divided into three stages: first, the complete model parameters are distributed to the high-performance layer nodes; after the high-performance layer nodes confirm receipt, the model parameters are distributed to the medium-performance layer nodes; and finally, they are distributed 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.

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

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

[0106] The edge node receives the updated model parameters and updates the scene adaptation proxy model. During the reception process, the system uses breakpoint resuming and verification mechanisms to ensure the integrity and correctness of parameter transmission. For the received quantized parameters, the edge node performs dequantization to restore the parameter accuracy. For example, the received quantized value 38 is converted back to a floating point number of approximately 0.1496 after dequantization, which is within an acceptable range compared to the original value of 0.15028.

[0107] After completing the parameter update, the edge node immediately uses the new model to optimize the scene adaptation. 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 usage. Actual tests show that the model updated through the adaptive distribution strategy can improve the scene operation performance of edge devices by 12%-25% while maintaining good visual quality.

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

[0109] Through the technical means described in detail above, the system realizes the efficient adaptive distribution of global scene adaptation model parameters, ensures the continuous optimization of the scene adaptation agent model of each edge node in the distributed scene optimization network, and improves the adaptation effect and user experience of Metaverse applications in different hardware environments.

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

[0111] Table 4 compares the performance of this technical solution with the 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 needs 12.5 rounds to achieve 95% accuracy, which is significantly better than the 25.8 rounds of the traditional solution and the 18.2 rounds of the centralized solution. The convergence speed is improved by 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 a momentum factor range of 0.65 and a learning rate range of 0.05. Compared with the fixed parameter methods of the other two solutions (momentum factor fixed at 0.9 and learning rate fixed at 0.01), it has better adaptability and flexibility. In terms of resource utilization efficiency, the computing resource utilization rate of this solution reaches 92.6%, which is much higher than the 65.3% of the traditional solution and 78.5% of the centralized solution; the network bandwidth utilization efficiency reaches 65.8%, which is also significantly better than the 38.2% of the traditional solution and 12.4% of the centralized solution. In the final comprehensive performance score, this solution scored 94.2 points, far ahead of the traditional solution's 58.6 points and the centralized solution's 72.4 points, fully demonstrating that this technical solution has comprehensive technical advantages in terms of model training efficiency, parameter adaptability, and resource utilization.

[0112] According to a second aspect of the embodiments of the present invention, An electronic device is provided, comprising: processor; a memory for storing processor-executable instructions; The processor is configured to call the instructions stored in the memory to execute the aforementioned method.

[0113] According to a third aspect of the embodiments of the present invention, A computer-readable storage medium is provided, on which computer program instructions are stored. When the computer program instructions are executed by a processor, the aforementioned method is implemented.

[0114] The present invention may be a method, an apparatus, a system and / or a computer program product. The computer program product may include a computer-readable storage medium carrying computer-readable program instructions for executing various aspects of the present invention.

[0115] 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 aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or replace some or all of the technical features therein with equivalents. However, 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 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. The functional component loading priority table records the resource occupancy value, minimum operating requirements and loading order of each functional component, and the component dynamic loading scheme under the current operating environment is determined according to the functional component loading priority table; Construct a dependency graph according to the component dynamic loading solution, divide the dependency graph into layers, and combine the basic functional components to form an initial scene adaptation solution; 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 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.

3. 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.

4. 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.

5. The method according to claim 4, 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.

6. The method according to claim 4, 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.

7. 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 according to any one of claims 1 to 6.

8. 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 6 is implemented.

Images