Course flexible construction and computing power elastic distribution method and system oriented to large education model

Abstract

The invention belongs to the technical field of artificial intelligence education application and computing resource management, and discloses a course flexible construction and computing power elastic allocation method and system oriented to an education large model. According to the method, course contents are disassembled into knowledge unit plug-ins which can be independently deployed, and lightweight consistent deployment of course instances in different terminal environments is realized based on a dependency relationship between directed acyclic graph modeling plug-ins; by taking a course target as a constraint, analyzing a knowledge unit reasoning path on the dependency graph, only reserving components with weights higher than a threshold value, and cutting non-key sub-model components and a redundant prompt chain to generate a dynamically cut course instance; distributing an independent container operation environment for the course instance, and collecting an operation resource state through kernel-level monitoring; according to the method, tasks are divided into different types of task queues in combination with calculation characteristics of resource states and teaching tasks, resource demands are predicted based on historical resource use behaviors of users, and calculation resources are dynamically allocated or recycled.

Description

Technical Field

[0001] This invention belongs to the field of artificial intelligence education application and computing resource management technology, specifically involving a method and system for flexible curriculum construction and flexible allocation of computing power for large-scale education models. Background Technology

[0002] As the application of large-scale educational models in education deepens, intelligent teaching systems based on these models are increasingly being used for scenarios such as course content generation, personalized tutoring, and assisting the teaching process. However, under current technological conditions, the deployment and operation of large-scale educational models in actual teaching systems still face numerous technical challenges.

[0003] First, existing teaching course construction methods mostly adopt a monolithic or statically encapsulated model structure, tightly coupling course content with model reasoning logic, lacking the ability to modularly decompose knowledge units within the course and model dependencies. In such technical solutions, different course objectives or teaching scenarios often require rebuilding or adjusting the course model as a whole, making it difficult to achieve flexible combination and cross-terminal reuse of course content, increasing the complexity of course construction and maintenance, and hindering the unified deployment of course instances in different computing environments.

[0004] Secondly, large-scale educational models typically involve large parameter sizes and high inference computations. When running on resource-constrained terminal devices or in edge computing environments, they are prone to issues such as high model startup latency and unstable resource usage. Existing solutions for model lightweighting often focus on parameter compression or model simplification, but they frequently fail to tailor the model to the course objectives and internal knowledge structure. This can easily lead to incomplete inference logic or inconsistent teaching content, making it difficult to ensure the stable operation of course instances while meeting terminal resource constraints.

[0005] Furthermore, in real-world teaching applications, different teaching tasks have significantly different demands for computing resources, and users' teaching behaviors exhibit marked temporal fluctuations. For example, tasks such as course content generation and complex problem-solving are typically computationally intensive, while tasks like real-time Q&A and homework submission feedback rely more heavily on input-output interaction performance. Existing computing resource allocation schemes often employ static configuration or simple threshold triggering methods, failing to predict future resource demands based on teaching task types and changes in user behavior. This can easily lead to uneven distribution or insufficient utilization of computing resources, making it difficult to support the efficient operation of large-scale educational models in dynamic teaching scenarios.

[0006] Therefore, how to achieve flexible construction and cross-terminal deployment of course content while ensuring the integrity of the reasoning logic of the large-scale educational model course, and how to elastically schedule computing resources in combination with the characteristics of teaching tasks and changes in user behavior, are technical problems that existing technologies urgently need to solve. Summary of the Invention

[0007] To address the problems in existing educational large-scale models, such as lack of modularity and composability in course construction, difficulty in adapting to different terminal computing environments, static allocation of computing resources in teaching scenarios, and insufficient resource utilization efficiency, this invention provides a method and system for flexible course construction and flexible allocation of computing power for educational large-scale models. This allows for flexible construction of course content and dynamic scheduling of computing resources while ensuring the integrity of course reasoning logic.

[0008] To achieve the above objectives, the present invention adopts the following technical solution: This invention provides a flexible course construction and computational resource allocation method for a large-scale education model. The method decomposes course content into multiple independently deployable knowledge unit plugins and constructs dependencies between these plugins based on a directed acyclic graph (DAG), thus forming a knowledge structure corresponding to each course instance. Based on this, the reasoning paths within the knowledge structure are analyzed using course objectives as constraints to identify key reasoning paths highly relevant to the course objectives, and course instances are dynamically trimmed. The trimmed course instances are deployed in independent container runtime environments, and their computational resource usage is monitored during execution. Teaching tasks are classified based on their computational characteristics, and a task execution queue is constructed. Future resource demands are predicted based on users' historical teaching behavior, thereby achieving flexible allocation and recycling of computational resources.

[0009] Specifically, the method includes the following steps: S1, the course plugin construction steps, decompose the course content into multiple independently deployable knowledge unit plugins according to the three-level granularity of "chapter-section-knowledge point". The dependency relationship between plugins is modeled based on the directed acyclic graph (DAG) to generate the knowledge unit dependency structure corresponding to the course instance, ensuring the composability and deployability of the course.

[0010] Each knowledge unit plugin contains four core modules: knowledge ontology (representing the core teaching content), teaching logic (controlling the teaching process), interaction rules (defining teacher-student interaction methods), and standardized interface protocol (ensuring communication compatibility between plugins). It is also configured with complete plugin metadata, including version identification information, dependency list, resource requirement description (such as the number of CPU cores and memory capacity threshold), security policy (interface access permissions and data encryption methods), and functional description, to ensure the independence and traceability of the plugin.

[0011] The system uses knowledge unit plugins as graph nodes, with node attributes including a unique plugin identifier, resource requirement threshold, and functional priority. Dependencies between plugins are represented as directed edges, with edge attributes including dependency type (strong / weak), data transfer volume, and interaction latency threshold. After construction, a topological sorting algorithm is used to verify acyclicity. If a cycle is detected, it is eliminated by removing weak dependency edges or adjusting the plugin deployment order. Simultaneously, the system verifies interface compatibility between plugins, ensuring consistency in data formats (e.g., JSON, Protobuf), communication protocols (e.g., gRPC), and parameter definitions, generating a compatibility verification report.

[0012] S2, the dynamic trimming step of course instances, takes the course objectives as the core constraint, and through inference path weight calculation and critical path filtering, trims non-critical sub-model components and redundant prompt chains to generate lightweight course instances adapted to terminal resources, balancing teaching integrity and resource adaptability.

[0013] Specifically, based on a directed acyclic graph, all possible reasoning paths are traversed using depth-first search or breadth-first search algorithms. Each path corresponds to a complete set of "knowledge transfer-teaching interaction" logic. A reasoning path weight calculation model is defined, taking the strength of the association between knowledge nodes and the importance of nodes relative to the course objectives as inputs, to quantify the contribution of the path to the course objectives.

[0014] The strength of association between knowledge nodes is calculated using a knowledge graph semantic similarity algorithm, specifically an improved cosine similarity algorithm. The calculation formula is as follows: in, For the first inference path The semantic relevance coefficient of each knowledge node represents the degree of semantic matching between that knowledge node and the core objectives of the course, and its value ranges from [value range missing]. , , These are two related knowledge nodes at the 1st Feature values ​​in each semantic dimension The total number of semantic dimensions. This is the similarity correction coefficient, with a value range of [value range missing]. Adjusted according to the characteristics of the subject area; The importance of each knowledge node relative to the course objectives is determined using the analytic hierarchy process (AHP). The specific steps are: ① Constructing a course objective-knowledge node importance judgment matrix; ② Calculating the largest eigenvalue and corresponding eigenvector of the judgment matrix; ③ Performing a consistency check. If the consistency ratio... Then, the normalized feature vectors become the importance weights of each knowledge node. , ; The final formula for calculating the inference path weight is: in, This represents the total number of knowledge nodes in the reasoning path. This is a path length correction factor; the longer the path length, the more... The smaller the value, the smaller the range of values. This is used to avoid excessive bias towards long paths.

[0015] Perform statistical distribution analysis on the weights of all inference paths and calculate the mean of the weights. and standard deviation The initial critical path threshold is determined based on the statistical distribution. ,in The adjustment coefficient has a range of values. The critical path threshold needs to be adaptively adjusted based on the resource profile reported by the terminal device or pre-collected in the cloud. The resource profile includes at least the processor utilization rate. Available memory Current available bandwidth and remaining storage space The adaptive adjustment formula is: in, and These represent available memory and total memory (unit: GB), respectively. and This indicates the currently available bandwidth and maximum bandwidth (unit: Mbps). Indicates CPU utilization. Indicates the CPU idle ratio; , , , For resource weight coefficients, satisfying Default value , , , It can be dynamically adjusted according to the terminal type.

[0016] S3, the course instance running and resource monitoring steps, allocates an independent container running environment to the trimmed course instances, and collects full-dimensional resource status data through a kernel-level monitoring mechanism to provide data support for subsequent task classification and resource scheduling.

[0017] Containers are built using Docker or Kubernetes, allocating independent namespaces, network stacks, and storage volumes to each course instance. CPU share, memory limits, disk I / O quotas, and network bandwidth limits are set to ensure resource isolation between different course instances and avoid mutual interference. eBPF (extended Berkeley Packet Filter) technology is used in conjunction with traditional monitoring tools (top, free, iostat, etc.) to collect multi-dimensional resource metrics. The collection frequency is dynamically adjusted according to task type: 100ms / time for computationally intensive tasks, 50ms / time for interactive tasks, and 1s / time for idle states. Collected data is compressed using LZ4, and timestamps, container identifiers, course instance identifiers, and terminal device identifiers are added before storage in a time-series database (such as InfluxDB) supporting multi-dimensional queries and traceability.

[0018] S4, Task Classification and Queue Construction Steps: Based on resource status data and teaching task characteristics, multi-dimensional task classification is carried out, and priority-driven task execution queues are constructed to ensure the priority execution of core teaching tasks.

[0019] The classification of teaching tasks adopts a multi-dimensional classification model, with specific dimensions including: ① Computational complexity: classified by the number of floating-point operations (FLOPs) required for the task, with low complexity (FLOPs < 10) as the primary factor. 8 Medium complexity (10) 8 ≤ FLOPs<10 10 High complexity (FLOPs ≥ 10) 10 ); ② Interaction characteristics: divided into synchronous interactive tasks (requiring real-time response, such as real-time Q&A and classroom interaction) and asynchronous interactive tasks (not requiring real-time response, such as homework grading and course content generation); ③ Data scale: small data volume tasks (input data < 1MB), medium data volume tasks (1MB ≤ input data < 10MB), and large data volume tasks (input data ≥ 10MB); Based on the above dimensions, teaching tasks are divided into 6 types: low-complexity synchronous interactive tasks, medium-complexity synchronous interactive tasks, high-complexity synchronous interactive tasks, low-complexity asynchronous interactive tasks, medium-complexity asynchronous interactive tasks, and high-complexity asynchronous interactive tasks; an independent task execution queue is constructed for each type of task, and tasks are assigned priorities. The priority calculation method is as follows: in The urgency level of the task (values ​​range from 1 to 5, with higher values ​​indicating greater urgency). This represents the intensity of resource demand (values ​​range from 1 to 3, with higher values ​​indicating higher resource demand). This represents the task complexity coefficient (1 for low complexity, 2 for medium complexity, and 3 for high complexity). For the weighting coefficients, satisfying Default value , , The teaching tasks in each task execution queue are sorted according to the task priority parameters. A priority scheduling algorithm (such as multi-level feedback queue scheduling) is used to control the execution order of the teaching tasks. High-priority tasks can preempt the resources of low-priority tasks, and low-priority tasks are executed in batches during idle periods.

[0020] S5, the resource demand forecasting step, constructs a resource usage state transition model based on users' historical teaching behavior data to predict future resource demand trends and provide a forward-looking basis for elastic scheduling of computing power.

[0021] The K-means clustering algorithm is used to divide user resource usage into five discrete states: extremely low demand (S1), low demand (S2), medium demand (S3), high demand (S4), and extremely high demand (S5). Clustering features include CPU utilization, memory usage, network bandwidth usage, and task concurrency. Based on a Hidden Markov Model (HMM), a set of states and an observation set are defined. The state transition probability matrix A, the observation probability matrix B, and the initial state probability vector are calculated using the maximum likelihood estimation method. The Baum-Welch algorithm is used to iteratively optimize the model parameters until convergence.

[0022] S6, the elastic scheduling step, combines task queue priorities and resource demand predictions, employing a hybrid strategy of passive and active scheduling to dynamically allocate or reclaim computing resources, achieving elastic scaling of computing power. It starts standby container instances (the standby container pool has 3-10 pre-set idle containers), dynamically adjusts container CPU / memory quotas (up to twice the initial quota), or migrates low-priority tasks to edge nodes / cloud nodes. A preheating mechanism is used when starting standby containers, preloading commonly used sub-models and cached data to shorten startup latency to within 100ms. Reclaiming is performed when all of the following reclamation conditions are met: ① Containers have been idle for more than 5-30 minutes (default 10 minutes); ② Overall computing resource utilization is ≤30% (default 25%); ③ No high-priority tasks are waiting, and the number of medium-priority tasks is ≤50% of the current container capacity. Reclaiming operations include closing idle containers, reducing the resource quota of active containers to the baseline level, and releasing idle resources on edge nodes, employing a smooth exit mechanism to ensure the normal completion of currently executing tasks. When local node resources are insufficient, tasks are distributed to edge nodes or cloud nodes through the resource scheduling center. The distribution strategy is based on a comprehensive decision considering node load rate, network latency, and resource costs. The objective function is: in, C For distribution strategy, For node network latency, For node load rate, For resource usage costs, , , For the weighting coefficients, satisfying .

[0023] This invention also provides a flexible curriculum construction and computing power allocation system for a large-scale education model. The system includes a curriculum construction unit, a pruning and processing unit, an operation and monitoring unit, a task management unit, a resource prediction unit, and an elastic scheduling unit. The curriculum construction unit is used to break down the curriculum content into multiple knowledge unit plugins and build dependencies between the plugins; the trimming unit is used to dynamically trim the curriculum instances based on the curriculum objectives; the operation and monitoring unit is used to provide a containerized runtime environment for the trimmed curriculum instances and collect resource usage status; the task management unit is used to classify teaching tasks and build task execution queues; the resource prediction unit is used to generate prediction results of future resource needs; and the elastic scheduling unit is used to control the allocation or reclamation of computing resources based on the task execution queues and resource demand prediction results.

[0024] Compared with the prior art, the present invention has at least the following beneficial effects: (1) By decomposing the course content into plug-ins and building the dependencies between knowledge units, course instances can be flexibly combined and deployed according to different course objectives and terminal computing environments, reducing the complexity of course construction and maintenance; (2) By dynamically tailoring course examples in conjunction with course objectives, the integrity of course reasoning logic can be maintained under the premise of meeting terminal resource constraints, which is conducive to the stable operation of the large education model in a resource-constrained environment. (3) Through multi-dimensional task classification, quantitative priority calculation and efficient scheduling algorithm, the teaching tasks are managed in a refined manner, ensuring that core teaching tasks with high urgency and high resource demand are executed first; at the same time, a resource demand prediction model is built based on user historical behavior data, and the dynamic allocation and recycling of computing resources are realized by combining passive and active scheduling mechanisms, avoiding uneven resource allocation or idle waste, significantly improving the utilization efficiency of computing resources and reducing operating costs.

[0025] (4) The system adopts a modular design, with each unit having independent functions and efficient collaboration. It supports containerized deployment and cross-node expansion, has good compatibility and scalability, and can be adapted to different types of terminal devices (mobile terminals, desktop terminals), edge nodes and cloud environments to meet the application needs of diverse teaching scenarios. Attached Figure Description

[0026] To more clearly illustrate the technical solutions of the present invention, the accompanying drawings used in the embodiments of the present invention are briefly described below. Obviously, the described drawings are only some embodiments of the present invention, and those skilled in the art can obtain other drawings based on these drawings without creative effort.

[0027] Figure 1 This is a schematic diagram of the overall process of the flexible course construction and flexible computing power allocation method for education big model described in the embodiment of the present invention in a collaborative environment of cloud, edge and terminal, showing the collaborative relationship between flexible course construction, dynamic pruning, operation monitoring and flexible computing power scheduling. Figure 2 This is a schematic diagram illustrating the composition structure and dependencies of knowledge unit plugins in the flexible course construction process of this invention, showing the dependencies between the entry plugin, knowledge ontology parsing plugin, teaching logic plugin, interaction rule plugin, and output plugin based on a directed acyclic graph. Figure 3 This is a schematic diagram of the dynamic trimming process for course instances in an embodiment of the present invention, illustrating the process of analyzing reasoning paths based on course objectives and knowledge structures, determining key reasoning paths, and trimming and verifying course instances. Figure 4This is a schematic diagram of the computing power monitoring, resource demand prediction, and computing power elastic scheduling process in an embodiment of the present invention, illustrating the processing relationship between resource operation monitoring, task type identification, resource demand prediction, and computing power expansion and reclamation control. Detailed Implementation

[0028] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0029] It should be noted that, unless otherwise defined, the technical or scientific terms used in the embodiments of this invention should have the ordinary meaning understood by one of ordinary skill in the art to which this invention pertains. In the embodiments of this invention, the use of terms such as "comprising" or "including" means that the element or object preceding the word encompasses the elements or objects listed following the word and their equivalents, without excluding other elements or objects. Terms such as "connected" or "linked" are not limited to physical or mechanical connections, but can include electrical connections, whether direct or indirect.

[0030] Example 1 like Figures 1-4 As shown, this invention provides a method for flexible curriculum construction and flexible allocation of computing power for a large-scale education model, including the following steps: S1, the course plugin-based construction steps, decompose the course content into multiple independently deployable knowledge unit plugins, and model the dependency relationships between the knowledge unit plugins based on a directed acyclic graph to generate the knowledge unit dependency structure corresponding to the course instance, specifically including: The knowledge unit plugin includes a knowledge ontology, teaching logic, interaction rules, and standardized interface protocols. Each knowledge unit plugin is configured with plugin metadata, which includes at least version identification information, a dependency list, resource requirement description, security policy, and function description. The method of modeling the dependency relationships between knowledge unit plugins based on a directed acyclic graph (DAG) specifically includes: using knowledge unit plugins as graph nodes, with node attributes including a unique plugin identifier, resource requirement threshold, and functional priority; using the dependency relationships between plugins as directed edges, with edge attributes including dependency type (strong dependency / weak dependency), data transmission volume, and interaction latency threshold; after constructing the DAG, a topological sorting algorithm is used to verify the acyclicity of the DAG. If a cycle structure is detected, the cycle is eliminated by removing weak dependency edges or adjusting the plugin deployment order to ensure the deployability of course instances; simultaneously, the interface compatibility between plugins is verified to ensure consistency in data format and communication protocol.

[0031] The standardized interface protocol of the knowledge unit plugin adopts the gRPC protocol, which supports both synchronous and asynchronous call modes. The interface parameters include input data format, output data format, call timeout, and error code definition. The security policy in the plugin metadata includes interface access permission control, data encryption transmission method, and plugin runtime sandbox restrictions.

[0032] The course plugin-based construction process also includes: The plugin version management mechanism supports plugin version iteration, rollback, and compatibility adaptation. When a plugin version is updated, it automatically detects the compatibility of other plugins that depend on it. If incompatibility is found, a compatibility report is generated and the user is prompted to choose to upgrade the dependent plugin or keep the old version of the plugin.

[0033] S2, the dynamic trimming step for course instances, uses the course objectives as constraints to analyze the reasoning paths in the knowledge unit dependency structure. Based on the correlation between the reasoning paths and the course objectives, key reasoning paths are determined, and the sub-model components and hint chains corresponding to these key reasoning paths are retained. Simultaneously, sub-model components and redundant hint chains corresponding to non-key reasoning paths are trimmed to generate dynamically trimmed course instances. Specifically, this includes: The determination of critical inference paths includes performing statistical distribution analysis on path weights and determining critical path thresholds based on the statistical distribution to distinguish between critical inference paths and non-critical inference paths. The critical path threshold is adaptively adjusted based on resource profiles reported by terminal devices or pre-collected in the cloud. These resource profiles include at least processor utilization, available memory capacity, and network bandwidth information. After pruning sub-model components and redundant hint chains corresponding to non-critical inference paths, the pruned course instances must undergo integrity verification. Verification includes: ① Coverage of core course knowledge points ≥ 95%; ② Coherence of teaching logic (verified through connectivity checks of the logic inference graph); ③ Interface compatibility between sub-model components. If the verification fails, some non-critical components must be retained or the critical path threshold adjusted, and pruning must be repeated.

[0034] When generating dynamically trimmed course instances, ensure that the trimmed course instances meet the resource constraints and runtime latency constraints of the terminal device.

[0035] The analysis of reasoning paths includes: based on the directed acyclic graph, obtaining all reasoning paths composed of multiple knowledge nodes through depth-first search or breadth-first search algorithms; defining a reasoning path weight calculation model, which takes the correlation strength between knowledge nodes and the importance of each knowledge node relative to the course objective as input parameters, and performs weighted calculation to obtain the corresponding reasoning path weight, wherein the reasoning path weight characterizes the degree of contribution of the reasoning path in achieving the course objective; The association strength between the knowledge nodes is calculated using a knowledge graph semantic similarity algorithm, specifically an improved cosine similarity algorithm. The calculation formula is as follows: in, For the first inference path The semantic relevance coefficient of each knowledge node represents the degree of semantic matching between that knowledge node and the core objectives of the course, and its value ranges from [value range missing]. , , These are two related knowledge nodes at the 1st Feature values ​​in each semantic dimension The total number of semantic dimensions. This is the similarity correction coefficient, with a value range of [value range missing]. Adjusted according to the characteristics of the subject area; The importance of each knowledge node relative to the course objectives is determined using the analytic hierarchy process (AHP). The specific steps are: ① Constructing a course objective-knowledge node importance judgment matrix; ② Calculating the largest eigenvalue and corresponding eigenvector of the judgment matrix; ③ Performing a consistency check. If the consistency ratio... Then, the normalized feature vectors become the importance weights of each knowledge node. , ; The final formula for calculating the inference path weight is: in, This represents the total number of knowledge nodes in the reasoning path. This is a path length correction factor; the longer the path length, the more... The smaller the value, the smaller the range of values. This is used to avoid excessive bias towards long paths; The process of determining the key inference path includes: performing a statistical distribution analysis on the weights of all inference paths and calculating the mean of the weights. and standard deviation The initial critical path threshold is determined based on the statistical distribution. ,in The adjustment coefficient has a range of values. ; The critical path threshold needs to be adaptively adjusted based on resource profiles reported by terminal devices or pre-collected in the cloud. The resource profiles include at least processor utilization. Available memory Current available bandwidth and remaining storage space The adaptive adjustment formula is: in, and These represent available memory and total memory (unit: GB), respectively. and This indicates the currently available bandwidth and maximum bandwidth (unit: Mbps). Indicates CPU utilization. Indicates the CPU idle ratio; , , , For resource weight coefficients, satisfying Default value , , , It can be dynamically adjusted according to the terminal type; When generating dynamically trimmed course instances, simulation tests are needed to verify whether the trimmed course instances meet the resource constraints of the terminal device. On one hand, they must meet the terminal device's resource constraints (processor utilization ≤ 80%, memory usage ≤ 75%, network bandwidth usage ≤ 90%) and runtime latency constraints (single inference latency ≤ 500ms, average latency for batch tasks ≤ 1s). On the other hand, runtime constraints must also be met. in, To improve the accuracy of the generated model after cropping, For the precision threshold, M This represents the volume of the model after trimming. Memory reserve factor (adaptively adjusted based on historical OOM errors and memory jitter data). T For model startup latency, Set the maximum acceptable latency for the terminal (e.g., 3s for mobile devices and 2s for computers).

[0036] If the above constraints are not met, the critical path threshold should be readjusted and the pruning repeated. To ensure the accuracy of course instance pruning, the accuracy before and after pruning should be evaluated using a validation set that covers the core knowledge points of the course. Requirements: in, To establish the baseline accuracy of the model before trimming. To ensure the actual accuracy of the model after trimming, The accuracy loss tolerance represents the maximum range of accuracy that the user or system is allowed to lose due to pruning; if the accuracy is not met, the critical path threshold is readjusted and pruning is performed again until the constraints are met.

[0037] S3, Course Instance Execution and Resource Monitoring Steps: An independent container runtime environment is allocated to the dynamically trimmed course instance. A kernel-level monitoring mechanism is used to collect the computing resource usage status generated during the container's operation, forming resource status data. Specifically, this includes: The configuration of the container runtime environment includes: building containers based on Docker or Kubernetes, allocating independent namespaces, network stacks and storage volumes for each course instance container, setting CPU shares, memory limits, disk I / O quotas and network bandwidth limits for the containers, and ensuring resource isolation between different course instances; The kernel-level monitoring mechanism is implemented using eBPF (extended Berkeley Packet Filter) technology combined with traditional monitoring tools. The monitored resource metrics include: processor metrics (CPU utilization, process scheduling latency, context switch count), memory metrics (used memory, cache memory, swap partition utilization, memory page miss rate), storage metrics (disk read / write speed, IOPS, storage latency), network metrics (number of packets sent / received, bandwidth utilization, network latency, packet loss rate), and application layer metrics (sub-model inference time, hint chain execution efficiency, interface response time). The frequency of resource data collection is dynamically adjusted according to the task type: the collection frequency is 100ms / time for computationally intensive tasks, 50ms / time for interactive tasks, and 1s / time in idle state; the collected data is compressed and stored using a data compression algorithm (such as LZ4), and timestamps, container identifiers, course instance identifiers, and terminal device identifiers are added to ensure data traceability.

[0038] S4, Task Classification and Queue Construction Steps: Based on the resource status data, combined with the computational complexity and input-output interaction characteristics of the teaching tasks, the teaching tasks are classified into types, and corresponding task execution queues are constructed. Specifically, this includes: Assigning priorities to teaching tasks includes: calculating task priority parameters based on the urgency of the teaching task and the intensity of the resource demand corresponding to the teaching task, and sorting the teaching tasks in the task execution queue according to the task priority parameters to control the execution order of the teaching tasks.

[0039] The classification of teaching tasks adopts a multi-dimensional classification model, with specific dimensions including: ① Computational complexity: classified by the number of floating-point operations (FLOPs) required for the task, with low complexity (FLOPs < 10) as the primary factor. 8 Medium complexity (10) 8 ≤ FLOPs<10 10 High complexity (FLOPs ≥ 10) 10 ); ② Interaction characteristics: divided into synchronous interactive tasks (requiring real-time response, such as real-time Q&A and classroom interaction) and asynchronous interactive tasks (not requiring real-time response, such as homework grading and course content generation); ③ Data scale: small data volume tasks (input data < 1MB), medium data volume tasks (1MB ≤ input data < 10MB), and large data volume tasks (input data ≥ 10MB); Based on the above dimensions, teaching tasks are divided into 6 types: low-complexity synchronous interactive tasks, medium-complexity synchronous interactive tasks, high-complexity synchronous interactive tasks, low-complexity asynchronous interactive tasks, medium-complexity asynchronous interactive tasks, and high-complexity asynchronous interactive tasks; an independent task execution queue is constructed for each type of task, and tasks are assigned priorities. The priority calculation method is as follows: in The urgency level of the task (values ​​range from 1 to 5, with higher values ​​indicating greater urgency). This represents the intensity of resource demand (values ​​range from 1 to 3, with higher values ​​indicating higher resource demand). This represents the task complexity coefficient (1 for low complexity, 2 for medium complexity, and 3 for high complexity). For the weighting coefficients, satisfying Default value , , The teaching tasks in each task execution queue are sorted according to the task priority parameters. A priority scheduling algorithm (such as multi-level feedback queue scheduling) is used to control the execution order of the teaching tasks. High-priority tasks can preempt the resources of low-priority tasks, and low-priority tasks are executed in batches during idle periods.

[0040] S5, Resource Demand Forecasting Step: Based on the resource usage status corresponding to the user's historical teaching behavior, construct the state transition relationship of the user's resource usage status, and generate the prediction result of future resource demand based on the current user resource usage status. Specifically, this includes: The user's resource usage during the teaching process is divided into multiple discrete resource usage states to construct a user resource usage state space; Based on the resource usage state sequence corresponding to historical user behavior, determine the state transition relationship between different resource usage states; Based on the current user resource usage status and the state transition relationship, a resource demand prediction result for future time moments is generated and used in the computing power elastic scheduling step.

[0041] The user resource usage status was divided using the K-means clustering algorithm, which categorized user resource usage during the teaching process into five discrete resource usage states: extremely low demand (S1), low demand (S2), medium demand (S3), high demand (S4), and extremely high demand (S5). Clustering features included CPU utilization, memory usage, network bandwidth usage, and task concurrency. Based on the resource usage state sequence corresponding to historical user behavior, a Hidden Markov Model (HMM) was used to construct the state transition relationship. The specific steps were: ① Determine the state set of the HMM. ① Calculate the state transition probability matrix A based on the maximum likelihood estimation method, and the observation set O (the observed values ​​are normalized values ​​of resource monitoring indicators); ② Calculate the state transition probability matrix A based on the maximum likelihood estimation method. ), observation probability matrix B ( and initial state probability vector ( ); ③ The Baum-Welch algorithm is used to iteratively optimize the model parameters until convergence; Based on the current user resource usage status And the state transition probability matrix A, using a forward algorithm to predict the future. to time( For the prediction time window, the default is... The system can configure the distribution of resource demand states (ranging from 3 to 10) and combine the resource demand thresholds corresponding to each state to generate quantitative prediction results of future resource demand, including average CPU demand, peak memory demand, minimum bandwidth demand, and upper limit of task concurrency within the prediction period.

[0042] S6, the elastic computing power scheduling step, dynamically allocates or reclaims computing resources based on the task priorities of the task execution queue and the predicted resource requirements, to achieve elastic computing power operation of the course instance. In this embodiment, the dynamic allocation refers to elastic resource management implemented through two mechanisms: computing power expansion control and computing power reclamation control.

[0043] like Figure 4 As shown, the computing power elastic scheduling system of the present invention includes six major components: resource operation monitoring, resource status modeling, task type identification, resource demand prediction, computing power expansion control, computing power reclamation control, and resource isolation and limitation module. Among them, the resource isolation and limitation module is deployed inside each container runtime environment, and implements hard limits on CPU, memory, I / O and network bandwidth based on Linux Cgroups and Namespace mechanisms, and allocates an independent resource quota sandbox for each course instance.

[0044] The resource isolation and limitation module receives instructions from the computing power expansion control module and the computing power reclamation control module, and performs resource quota adjustments in real time: When a scaling instruction is received, the container's CPU / memory quota is increased (up to twice the initial value), and burst borrowing is supported (≤1.5 times, lasting ≤5 seconds). Upon receiving a recycling instruction, the quota is smoothly reduced to the baseline level, in conjunction with the container closure operation; All adjustments are completed within 100ms to ensure timely response of high-priority tasks and prevent resource preemption.

[0045] Elastic computing power scheduling employs a hybrid scheduling strategy, combining passive and active scheduling methods: Passive scheduling trigger conditions: When the current resource utilization exceeds a preset threshold (any one of the following conditions is met: CPU utilization ≥ 85%, memory utilization ≥ 80%, network bandwidth utilization ≥ 95%), or when there is a high-priority task (priority... When there are insufficient resources and tasks are waiting to be executed, resource expansion is triggered; when the current resource utilization rate is detected to be lower than the preset threshold (CPU utilization rate ≤ 30%, memory utilization rate ≤ 25%, network bandwidth utilization rate ≤ 20% simultaneously), and there are no medium or high priority tasks waiting to be executed, resource reclamation is triggered. Active scheduling trigger condition: Based on resource demand forecast results, if the future is predicted... When resource demand status upgrades (e.g., from S3 to S4) and current resource reserves are insufficient, advance... time( = Predicted latency × 0.8, minimum 3s, maximum 30s) triggers resource expansion; if the predicted future continuous At any moment ( If the resource demand status is downgraded (e.g., from S4 to S2), resource reclamation will be triggered ahead of schedule. Resource expansion operations include: starting standby container instances (the standby container pool has 3-10 idle containers pre-set, which can be adjusted according to the cluster size), dynamically adjusting the CPU and memory quotas of containers (which can be increased to up to twice the initial quota), and migrating some low-priority tasks to edge nodes or cloud nodes; when starting standby container instances, a preheating mechanism is used to preload commonly used sub-model components and cached data, shortening the container startup latency to within 100ms; Resource recycling operations must meet preset recycling conditions, which include: ① The continuous idle time of the container instance exceeds a set threshold (the threshold can be dynamically configured according to the teaching scenario, with a value range of 5-30 minutes, and a default of 10 minutes); ② The current overall computing resource utilization rate is lower than a preset ratio (the ratio is not higher than 30%, and the default is 25%); ③ There are no high-priority tasks waiting to be executed, and the number of medium-priority tasks is ≤ 50% of the current container capacity; Resource reclamation operations include: shutting down idle container instances (prioritizing the latest started container), reducing the resource quota of active containers to the baseline level, and releasing idle resources from edge nodes to the resource pool; a smooth exit mechanism is adopted during the reclamation process to ensure that the tasks being executed are completed normally and to avoid data loss or task interruption.

[0046] In the elastic scheduling step, when the resource demand forecast indicates an increase in future resource demand, at least one standby container instance is launched to increase available computing resources. It also includes a cross-node resource scheduling mechanism, whereby tasks are distributed to edge nodes or cloud nodes through a resource scheduling center when local node resources are insufficient. The distribution strategy is based on a comprehensive decision considering node load rate, network latency, and resource costs, with the objective function being: in, C For distribution strategy, For node network latency, For node load rate, For resource usage costs, , , For the weighting coefficients, satisfying .

[0047] Example 2 Based on the same inventive concept, this embodiment provides a flexible construction and elastic computing power scheduling method for the "Data Structures - Binary Trees" course in computer science. Taking the "Binary Trees" chapter of the "Data Structures" course in computer science as the application scenario, the terminal device is a laptop computer (processor: Intel i5-1035G1, memory: 8GB, network bandwidth: 200Mbps). The specific implementation process of the method of the present invention is described in detail.

[0048] Course plug-in architecture (S1) The "Binary Tree" course is broken down into 6 knowledge unit plugins at a three-level granularity of "chapter-section-knowledge point": entry plugin (course startup and parameter initialization), knowledge ontology analysis plugin (binary tree definition, properties, and storage structure), teaching logic plugin (concept explanation - algorithm demonstration - code implementation - practice and consolidation flow control), interaction rules plugin (code submission, debugging feedback, and question submission), visualization plugin (binary tree structure visualization and dynamic demonstration of traversal algorithms), and output plugin (course report and code assignment answer generation).

[0049] Each plugin configuration includes a version identifier (V2.0), a dependency list (the entry plugin depends on the knowledge ontology parsing plugin and the teaching logic plugin, the teaching logic plugin depends on the interaction rules plugin and the visualization plugin, and the output plugin depends on the teaching logic plugin), a resource requirement description (CPU ≥ 1 core, memory ≥ 1GB), a security policy (interface access requires student identity verification, and code data transmission uses SSL encryption), and a function description.

[0050] Using 6 plugins as nodes and strong dependencies as directed edges, a directed acyclic graph is constructed. The acyclic sequence is obtained by topological sorting [Entry Plugin → Knowledge Ontology Parsing Plugin → Teaching Logic Plugin → Interaction Rule Plugin → Visualization Plugin → Output Plugin]. The interface adopts the gRPC protocol, the data format is JSON, and a compatibility report is generated after successful verification.

[0051] Course Example Dynamic Clipping (S2) The course objective is to master the definition, properties, and preorder / inorder / postorder traversal algorithms of binary trees, and to be able to implement basic traversal functions through code. Three reasoning paths are obtained through depth-first search: Path 1 (entry point → knowledge ontology (definition / properties) → teaching logic (concept explanation) → output), Path 2 (entry point → knowledge ontology (storage structure) → teaching logic (algorithm demonstration → code implementation) → interaction rules (code submission) → visualization plugin (traversal demonstration) → output), and Path 3 (entry point → knowledge ontology (extended applications) → teaching logic (algorithm optimization for complex scenarios) → interaction rules (advanced debugging) → visualization plugin (demonstration of complex structures) → output).

[0052] Calculate the association strength of knowledge nodes, where the storage structure and algorithm demonstration nodes are considered. Traversal algorithm and code implementation nodes Expanding applications and complex optimization nodes ; Calculate importance weights, which involves traversing algorithm nodes. Code implementation node Definition / Property Node Expand application nodes Path weight , , .

[0053] Initial threshold After adjusting the resource profile of laptops Paths 1 and 2 are retained, while the extended application sub-models, complex scene algorithm optimization components, and complex structure visualization functions corresponding to path 3 are pruned. Simulation tests show that the pruned course examples have CPU utilization ≤70%, memory usage ≤2.8GB, and single inference latency ≤280ms, meeting the constraints.

[0054] Course Example Execution and Resource Monitoring (S3) The container was built using Docker, allocating 1.5 CPU cores, 3GB of memory, and a 20GB storage volume. An independent namespace and network stack were configured, with CPU Shares set to 16384 and memory limit set to 3GB. eBPF technology, combined with tools like `top` and `free`, was used to collect metrics such as CPU utilization, memory usage, and network bandwidth. Interactive tasks (code submission feedback) were collected at a frequency of 50ms / time, while computationally intensive tasks (algorithm visualization demonstrations) were collected at 100ms / time. Data was compressed using LZ4 and labeled before being stored in InfluxDB.

[0055] Task classification and queue construction (S4) Tasks are categorized as follows: Algorithm concept Q&A (low complexity, synchronous interaction, small data volume), Traversal algorithm visualization (medium complexity, synchronous interaction, medium data volume), Code assignment grading (medium complexity, asynchronous interaction, large data volume), and Advanced algorithm optimization push (low complexity, asynchronous interaction, small data volume). Computation priority: Algorithm concept Q&A Visualization of traversal algorithms Code assignment correction Advanced algorithm optimization push .

[0056] Four task queues are constructed, with the algorithm visualization queue having the highest priority, followed by the algorithm concept Q&A queue. A multi-level feedback queue scheduling is adopted, with visualization tasks being executed first, and Q&A tasks being able to preempt homework grading task resources.

[0057] Resource demand forecasting (S5) Five resource usage states were obtained through K-means clustering, with the current state being S3 (medium demand: CPU 40%-60%, memory 50%-70%). A state transition model was built based on Hidden Markov Models (HMMs), which converged after 100 iterations. The predicted resource demand distribution for the next 5 minutes is S4 (38%), S3 (42%), and S2 (18%). The quantitative prediction results are an average CPU demand of 60%, a peak memory demand of 78%, and a minimum bandwidth demand of 55%.

[0058] Elastic scheduling of computing power (S6) predict The system status was upgraded to S4, indicating insufficient current resource reserves. Active scaling was triggered 12 seconds in advance. Two backup container instances (1 CPU core / 2GB memory) were started, and a preheating mechanism was used to load the core components of the visualization plugin and the traversal algorithm model. The advanced algorithm optimization push task was migrated to the edge node. After the course ended, the containers remained idle for 18 minutes, with CPU utilization at 28% and memory usage at 22%. With no medium- or high-priority tasks, resource reclamation was triggered, the two backup containers were shut down, and edge node resources were released.

[0059] Through the above implementation process, the course runs stably on laptops, with complete core teaching functions. Students can complete the learning and code implementation of the binary tree traversal algorithm normally. Resource utilization efficiency is improved by 68% compared with the existing solution, and user interaction response latency is ≤300ms, meeting the needs of teaching scenarios.

[0060] Example 3 This embodiment provides a distributed deployment scheme and operational verification results for the system. The system adopts a three-tier deployment architecture of "cloud-edge-terminal". The cloud-based deployment of course building units, resource prediction units, and elastic scheduling units utilizes Alibaba Cloud ECS servers (8 cores, 16GB memory) and runs a Kubernetes cluster to manage container resources. The time-series database uses an InfluxDB cluster, supporting massive resource data storage and analysis. At the edge, the deployment of pruning and processing units and cross-node scheduling modules utilizes edge gateway devices (4 cores, 8GB memory) to cache commonly used knowledge unit plugins and sub-models, reducing terminal access latency. Terminal deployment includes operation and monitoring units and task management units, supporting multiple operating systems such as Windows, macOS, and Linux, and adapting to different terminal types such as laptops, desktops, and tablets.

[0061] Two hundred computer science students were selected as test users. They accessed three data structure courses—"Binary Trees," "Graph Structures," and "Hash Tables"—using laptops, desktops, and tablets respectively. The test was conducted continuously for 30 days, and the results are as follows: (1) Course deployment success rate: 100%, cross-terminal deployment consistency reaches 99%; (2) Terminal performance: The average startup latency of laptops is 320ms and the memory usage is ≤3GB; the average startup latency of desktops is 210ms and the memory usage is ≤4GB; the average startup latency of tablets is 450ms and the memory usage is ≤2.5GB. (3) Resource utilization efficiency: The resource utilization rate during peak class time (9:00-11:00) is 85%, and the resource utilization rate during after class time (19:00-22:00) is 68%, with an overall average utilization rate of 76%, which is 42% higher than the existing plan; (4) User satisfaction: The completeness of teaching content was rated 4.9 / 5, the system response speed was rated 4.8 / 5, the fluency of code demonstration was rated 4.7 / 5, and the overall satisfaction was 4.8.

[0062] Verification results show that the system of the present invention can stably adapt to different terminals and data structure-based course types, and its resource utilization efficiency and user experience are significantly better than existing technologies.

[0063] Example 4 A flexible curriculum construction and computational power allocation system for a large-scale education model is provided to implement the method described in any of the preceding embodiments of the claims. The system includes: a curriculum construction unit, a pruning processing unit, an operation and monitoring unit, a task management unit, a resource prediction unit, and an elastic scheduling unit. The course construction unit is configured to decompose the course content into multiple independently deployable knowledge unit plugins, and to model the dependency relationship between the knowledge unit plugins based on a directed acyclic graph to generate the knowledge unit dependency structure corresponding to the course instance. The trimming processing unit, connected to the course construction unit, is configured to receive the knowledge unit dependency structure and course objective information, analyze the reasoning path in the knowledge unit dependency structure, and generate a dynamic trimming strategy based on the degree of correlation between the reasoning path and the course objective, thereby outputting a trimmed course instance. The operation and monitoring unit is connected to the trimming processing unit and is configured to allocate an independent container running environment to the trimmed course instance and collect corresponding computing resource usage status data during the course instance operation. The task management unit, connected to the operation and monitoring unit, is configured to classify teaching tasks by type and construct corresponding task execution queues based on the computing resource usage status data and the computing characteristics of the teaching tasks. The resource prediction unit, connected to the task management unit, is configured to generate prediction results of future resource needs based on resource usage status data corresponding to users' historical teaching behaviors. The elastic scheduling unit, connected to the resource prediction unit and the task management unit, is configured to control the allocation or reclamation of computing resources based on the prediction results of the task execution queue and the resource demand.

[0064] Example 5 Based on the same inventive concept, the present invention also provides an electronic device, including a processor and a memory, wherein the memory stores a computer program, and when the computer program is executed on the processor, it causes the processor to perform the method described in any of the foregoing embodiments, or to implement the flexible curriculum construction and flexible computing power allocation system for the educational big model described in the foregoing embodiments.

[0065] Example 6 Based on the same inventive concept, the present invention also provides a computer-readable storage medium storing a computer program, which, when executed by a processor, is used to perform the methods described in any of the foregoing embodiments.

[0066] The embodiments of this invention are intended to cover all such substitutions, modifications, and variations falling within the broad scope of the appended claims. Therefore, any omissions, modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the embodiments of this invention should be included within the protection scope of this invention.

Claims

1. A method for flexible curriculum construction and elastic allocation of computing power for a large-scale education model, characterized in that, The method includes the following steps: S1, the course plug-in construction steps, decompose the course content into multiple independently deployable knowledge unit plug-ins, and model the dependency relationship between the knowledge unit plug-ins based on a directed acyclic graph to generate the knowledge unit dependency structure corresponding to the course instance; S2, the course instance dynamic trimming step, takes the course objectives as constraints, analyzes the reasoning paths in the knowledge unit dependency structure, determines the key reasoning paths based on the degree of correlation between the reasoning paths and the course objectives, retains the sub-model components and hint chains corresponding to the key reasoning paths, and trims the sub-model components and redundant hint chains corresponding to non-key reasoning paths to generate dynamically trimmed course instances. S3, Course Instance Execution and Resource Monitoring Steps: Allocate an independent container runtime environment for the dynamically trimmed course instance, and collect the computing resource usage status generated during container execution through a kernel-level monitoring mechanism to form resource status data; S4, Task classification and queue construction steps: Based on the resource status data, combined with the computational complexity and input-output interaction characteristics of the teaching tasks, the teaching tasks are classified into types, and corresponding task execution queues are constructed. S5, Resource Demand Forecasting Step: Based on the resource usage status corresponding to the user's historical teaching behavior, construct the state transition relationship of the user's resource usage status, and generate the prediction result of future resource demand based on the current user's resource usage status and its state transition relationship. S6, the computing power elastic scheduling step, dynamically allocates or reclaims computing resources based on the task priority of the task execution queue and the prediction results of future resource needs, combined with a hybrid scheduling strategy of passive scheduling and active scheduling, so as to realize the elastic operation of computing power for course instances.

2. The method according to claim 1, characterized in that, The standardized interface protocol of the knowledge unit plugin adopts the gRPC protocol, which supports both synchronous and asynchronous call modes. The interface parameters include input data format, output data format, call timeout, and error code definition. The security policy in the plugin metadata includes interface access permission control, data encryption transmission method, and plugin runtime sandbox restrictions.

3. The method according to claim 1, characterized in that, The course plugin-based construction process also includes a plugin version management mechanism, which supports plugin version iteration, rollback, and compatibility adaptation. When a plugin version is updated, it automatically detects the compatibility of other plugins that depend on it. If there are incompatibilities, it generates a compatibility report and prompts the user to choose to upgrade the dependent plugin or keep the old version of the plugin.

4. The method according to claim 3, characterized in that, The determination of critical inference paths includes performing statistical distribution analysis on path weights and determining critical path thresholds based on the statistical distribution to distinguish between critical inference paths and non-critical inference paths. The critical path threshold is adaptively adjusted based on the resource profile reported by the terminal device or pre-collected in the cloud. The resource profile includes at least processor utilization, available memory capacity and network bandwidth information. After trimming the sub-model components and redundant hint chains corresponding to non-critical inference paths, the trimmed course instances need to be verified for completeness. The verification includes: ① Coverage of core knowledge points of the course ≥ 95%; ② Coherence of teaching logic; ③ Interface compatibility between sub-model components. If the verification fails, some non-critical components need to be retained or the critical path threshold needs to be adjusted, and the trimming process needs to be repeated. When generating dynamically trimmed course instances, ensure that the trimmed course instances meet the resource constraints and runtime latency constraints of the terminal device.

5. The method according to claim 1, characterized in that, In the task classification and queue construction steps, assigning priority to teaching tasks includes: calculating task priority parameters based on the urgency of the teaching task and the intensity of the resource demand corresponding to the teaching task, and sorting the teaching tasks in the task execution queue according to the task priority parameters to control the execution order of the teaching tasks.

6. The method according to claim 1, characterized in that, The steps involved in resource demand forecasting include: The user's resource usage during the teaching process is divided into multiple discrete resource usage states to construct a user resource usage state space; Based on the resource usage state sequence corresponding to historical user behavior, determine the state transition relationship between different resource usage states; Based on the current user resource usage status and the state transition relationship, a resource demand prediction result for future time moments is generated and used in the computing power elastic scheduling step.

7. The method according to claim 1, characterized in that, In the elastic scheduling step, when the resource demand forecast indicates an increase in future resource demand, at least one standby container instance is launched to increase available computing resources. It also includes a cross-node resource scheduling mechanism, whereby tasks are distributed to edge nodes or cloud nodes through a resource scheduling center when local node resources are insufficient. The distribution strategy is based on a comprehensive decision considering node load rate, network latency, and resource costs, with the objective function being: ； in, C For distribution strategy, For node network latency, For node load rate, For resource usage costs, , , For the weighting coefficients, satisfying .

8. A flexible curriculum construction and computational power allocation system for a large-scale education model, characterized in that, The system is used to implement the method according to any one of claims 1-7, and the system includes: a course construction unit, a pruning processing unit, an operation and monitoring unit, a task management unit, a resource prediction unit, and an elastic scheduling unit; The course construction unit is configured to decompose the course content into multiple independently deployable knowledge unit plugins, and to model the dependency relationship between the knowledge unit plugins based on a directed acyclic graph to generate the knowledge unit dependency structure corresponding to the course instance. The trimming processing unit, connected to the course construction unit, is configured to receive the knowledge unit dependency structure and course objective information, analyze the reasoning path in the knowledge unit dependency structure, and generate a dynamic trimming strategy based on the degree of correlation between the reasoning path and the course objective, thereby outputting a trimmed course instance. The operation and monitoring unit is connected to the trimming processing unit and is configured to allocate an independent container running environment to the trimmed course instance and collect corresponding computing resource usage status data during the course instance operation. The task management unit, connected to the operation and monitoring unit, is configured to classify teaching tasks by type and construct corresponding task execution queues based on the computing resource usage status data and the computing characteristics of the teaching tasks. The resource prediction unit, connected to the task management unit, is configured to generate prediction results of future resource needs based on resource usage status data corresponding to users' historical teaching behaviors. The elastic scheduling unit, connected to the resource prediction unit and the task management unit, is configured to control the allocation or reclamation of computing resources based on the prediction results of the task execution queue and the resource demand.

9. An electronic device, characterized in that, It includes a processor and a memory, wherein the memory stores a computer program, and when the computer program is executed on the processor, it causes the processor to perform the method described in any one of claims 1-7, or to implement the flexible curriculum construction and flexible computing power allocation system for a large-scale education model as described in claim 8.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program, which, when executed by a processor, performs the method described in any one of claims 1-7.

Images