Teaching data management method and system based on artificial intelligence

Abstract

The invention discloses a teaching data management method and system based on artificial intelligence, and the method comprises the steps: obtaining a standardized time series data stream according to a heterogeneous data stream generated by a multi-source teaching platform in real time; based on the standardized time sequence data stream, performing classified encryption on the teaching data through a dynamic hierarchical storage strategy based on attribute-based encryption to obtain a security hierarchical storage topological structure; according to a user query request and a teaching scene label, extracting a target data set from the security hierarchical storage topological structure to obtain an enhanced multi-modal teaching data set; based on the enhanced multi-modal teaching data set, generating an interpretable teaching mode graph through a dynamic sub-graph evolution algorithm; and according to the teaching mode map and the real-time teaching feedback data, generating a personalized teaching recommendation strategy through a course-learner dual-channel adaptive recommendation model. According to the embodiment of the invention, the utilization efficiency of teaching resources can be improved, and personalized and intelligent teaching recommendation and decision can be realized.

Description

Technical Field

[0001] The present invention belongs to the field of smart teaching technology, and in particular to a teaching data management method and system based on artificial intelligence. Background Art

[0002] With the rapid development of information technology, the field of education is undergoing profound changes. The widespread use of the internet and multi-source teaching platforms is continuously generating massive amounts of teaching data—including video courses, text materials, behavioral logs, test scores, and more—providing valuable foundational resources for personalized and intelligent education. However, faced with heterogeneous, massive, and dynamically changing educational data, how to efficiently, securely, and intelligently manage and utilize it has become a key technical challenge that urgently needs to be addressed.

[0003] Currently, many teaching data management systems only support single or local data processing methods, making it difficult to achieve deep cross-platform and cross-modal integration. The diverse formats of heterogeneous data pose additional challenges to data security and privacy. Data diversity and inconsistency lead to a surge in processing complexity. Furthermore, the lack of intelligent analytical models limits the value of data extraction, making it difficult to meet the needs of personalized teaching and precise recommendations. Summary of the Invention

[0004] The purpose of the present invention is to provide an artificial intelligence-based teaching data management method and system to address the deficiencies in the existing technology, improve the utilization efficiency of teaching resources, and realize personalized and intelligent teaching recommendations and decisions.

[0005] One embodiment of the present application provides an artificial intelligence-based teaching data management method, the method comprising: According to the heterogeneous data streams generated in real time by the multi-source teaching platform, the heterogeneous data streams are dynamically parsed and normalized, and the data format characteristics are identified by combining the bidirectional long short-term memory network and a dynamic interface adapter is constructed to obtain a standardized time series data stream; Based on the standardized time series data stream, the teaching data is classified and encrypted through a dynamic hierarchical storage strategy based on attribute-based encryption, and the knowledge distillation algorithm is used to compress the unstructured data and generate a unique data fingerprint to obtain a secure hierarchical storage topology structure; Based on user query requests and teaching scenario labels, the target dataset is extracted from the secure hierarchical storage topology. The text, video, and behavior log data are jointly embedded and represented using a multimodal feature fusion network. The missing features are supplemented using a generative adversarial network to obtain an enhanced multimodal teaching dataset. Based on the enhanced multimodal teaching dataset, a cross-institutional federated knowledge graph is constructed. A differentially private graph attention mechanism is used to mine potential teaching associations, and an interpretable teaching model graph is generated through a dynamic subgraph evolution algorithm. According to the teaching mode map and real-time teaching feedback data, a personalized teaching recommendation strategy is generated through a course-learner dual-channel adaptive recommendation model, wherein the course-learner dual-channel adaptive recommendation model dynamically adjusts the recommendation weight by integrating temporal reinforcement learning and meta-path reasoning algorithm.

[0006] Optionally, the method includes dynamically parsing and normalizing the heterogeneous data streams generated in real time by the multi-source teaching platform, identifying data format features in combination with a bidirectional long short-term memory network, and constructing a dynamic interface adapter to obtain a standardized time series data stream, including: Receive raw data streams from teaching platforms, learning management systems, and online course platforms, extract the temporal features of the raw data streams through a bidirectional long short-term memory network, identify the implicit patterns of the data format, and obtain multi-source data format feature vectors; Based on the multi-source data format feature vectors, a density peak clustering algorithm is used to generate a dynamic interface template library, and the optimal interface template is dynamically matched according to the real-time data flow characteristics to obtain the interface adapter initialization parameters; Based on the interface adapter initialization parameters, a lightweight data conversion rule engine is constructed to convert heterogeneous data including SCORM, xAPI, and IMS-QTI into a unified JSON-LD format to obtain an intermediate standardized data block; The intermediate standardized data blocks are time-aligned, a sliding window mechanism is used to eliminate cross-platform timestamp deviations, and a continuous, conflict-free, standardized time-series data stream is output through an event-driven pipeline.

[0007] Optionally, based on the standardized time series data stream, the teaching data is classified and encrypted through a dynamic hierarchical storage strategy based on attribute-based encryption, and a knowledge distillation algorithm is used to compress unstructured data and generate a unique data fingerprint to obtain a secure hierarchical storage topology structure, including: According to the metadata attributes of the standardized time series data stream, the data sensitivity level label is extracted through the attribute-based encryption algorithm, and the access control tree is defined using the CP-ABE strategy to generate a dynamic hierarchical encryption strategy; Based on the dynamic hierarchical encryption strategy, the teaching video data and text log data are classified and encrypted to generate hierarchical ciphertext data blocks; A knowledge distillation algorithm is used for unstructured video data. Key teaching features are extracted through a teacher model, and a lightweight student model is trained to generate compressed feature vectors, which are then output as a lightweight video feature package that retains semantic meaning. ‌The hierarchical ciphertext data blocks and lightweight video feature packages are integrated into a hash chain, a unique data fingerprint is generated based on the content characteristics of the hierarchical ciphertext data blocks, and a secure hierarchical storage topology with access control tags is constructed.

[0008] Optionally, according to the user query request and the teaching scenario label, the target dataset is extracted from the secure hierarchical storage topology structure, the text, video, and behavior log data are jointly embedded and represented through a multimodal feature fusion network, and the missing features are supplemented by a generative adversarial network to obtain an enhanced multimodal teaching dataset, including: Based on the keyword vectors and teaching scenario labels in the user query request, the target data is retrieved in the secure hierarchical storage topology structure through a semantic similarity algorithm to generate a candidate data set index table; Based on the candidate dataset index table, a multi-head attention mechanism is used to align text TF-IDF features, video optical flow features, and behavior log temporal features to generate a multimodal joint embedding matrix; The multimodal joint embedding matrix is ​​input into the adversarial generative network. The discriminator identifies the missing feature locations, and the generator reconstructs the missing video key frames and text semantic segments, outputting the completed feature tensor. ‌Adversarial training optimization is performed on the completed feature tensor, and a gradient penalty strategy is used to stabilize the training process to generate an intermediate multimodal dataset with enhanced robustness; ‌A feature decoupling algorithm is used to separate the modality-specific and common information in the intermediate multimodal dataset, and finally an enhanced multimodal teaching dataset with cross-modal association labels is output.

[0009] Optionally, the method constructs a cross-institutional federated knowledge graph based on the enhanced multimodal teaching dataset, uses a differentially private graph attention mechanism to mine potential teaching associations, and generates an interpretable teaching mode graph through a dynamic subgraph evolution algorithm, including: Based on the entity-relationship triples in the enhanced multimodal teaching dataset, we aggregate cross-institutional data through a federated learning framework, use homomorphic encryption technology to protect institutional privacy, and generate an initial federated knowledge graph. Based on the initial federated knowledge graph, a differentially private graph attention mechanism is designed. Laplace noise injection is used to perturb the attention weights between nodes to generate a privacy-safe relationship strength matrix. Based on the relationship strength matrix, a temporal graph convolutional network is used to capture the evolution of teaching patterns. A dynamic community discovery algorithm is used to identify potential teaching association clusters and generate a set of subgraph evolution paths. Perform causal reasoning analysis on the subgraph evolution path, calculate the interpretability score of the teaching model by combining the Bayesian network, and generate an intermediate teaching model map with confidence labels; ‌The graph neural network distillation technology is used to compress the graph size of the intermediate teaching model graph, and finally output an interpretable teaching model graph that supports real-time reasoning.

[0010] Optionally, the personalized teaching recommendation strategy is generated by a course-learner dual-channel adaptive recommendation model based on the teaching mode map and real-time teaching feedback data, wherein the course-learner dual-channel adaptive recommendation model dynamically adjusts the recommendation weight by integrating temporal reinforcement learning and meta-path reasoning algorithm, including: Based on the knowledge point dependency relationships in the teaching model map and real-time learner feedback data, we extract the node weights in the course knowledge topology and the temporal characteristics of the learner behavior trajectory, and construct the topological feature map of the course channel and the behavioral evolution sequence of the learner channel. In the course channel, a temporal reinforcement learning algorithm is used to dynamically plan paths on the topological feature graph. A sliding window mechanism is used to capture historical teaching effect data and generate candidate recommendation sequences based on the correlation strength of knowledge points. In the learner channel, a meta-path inference algorithm based on the knowledge graph analyzes the knowledge transition pattern in the learner's behavior evolution sequence and generates a personalized path candidate set that integrates the ability growth curve; The candidate recommendation sequence of the course channel and the personalized path candidate set of the learner channel are input into the multi-strategy fusion module. The cross-channel weight distribution matrix is ​​calculated through the dynamic attention mechanism to generate a personalized teaching comprehensive recommendation strategy with priority sorting.

[0011] Optionally, extracting data sensitivity level labels using an attribute-based encryption algorithm based on metadata attributes of the standardized time-series data stream, defining an access control tree using a CP-ABE strategy, and generating a dynamic hierarchical encryption strategy include: Based on the metadata attributes of standardized time-series data streams, a multi-dimensional sensitive feature extraction network is used to analyze the privacy relevance of data fields. A hierarchical clustering algorithm is combined with an autoencoder architecture to map student status information, academic records, and classroom behavior logs to different sensitivity levels, outputting a three-dimensional feature vector of data sensitivity. Based on the three-dimensional feature vector of data sensitivity, a dynamic attenuation decision tree is used to generate a fine-grained access strategy. In this strategy, access rights for course video data are divided according to resolution and content sensitivity, and decryption conditions for test data are defined according to the score distribution range. The initial access control rule set with a timestamp is output. Based on the contextual information of real-time teaching scenarios, the initial access control rule set is dynamically modified through the policy evolution engine. When a cross-campus data sharing request is detected, regional constraint attributes are automatically added and two-factor authentication conditions are introduced to generate a time-space-aware enhanced access control tree. The enhanced access control tree is coupled and optimized with the three-dimensional feature vector of data sensitivity. The policy node weights are calculated using an asymmetric bilinear pairing algorithm. The policy public key matrix is ​​generated through elliptic curve encryption technology. Finally, a CP-ABE hierarchical encryption strategy with dynamic attenuation factors and spatiotemporal constraints is output.

[0012] Another embodiment of the present application provides an artificial intelligence-based teaching data management system, the system comprising: The processing module is used to dynamically parse and normalize the heterogeneous data streams generated in real time by the multi-source teaching platform, identify the data format characteristics by combining the bidirectional long short-term memory network and build a dynamic interface adapter to obtain a standardized time series data stream; An encryption module is used to classify and encrypt teaching data based on the standardized time series data stream through a dynamic hierarchical storage strategy based on attribute-based encryption, compress unstructured data using a knowledge distillation algorithm and generate a unique data fingerprint to obtain a secure hierarchical storage topology structure; An extraction module is used to extract the target dataset from the secure hierarchical storage topology structure based on user query requests and teaching scenario labels, jointly embed the text, video, and behavior log data through a multimodal feature fusion network, and use a generative adversarial network to complete the missing features to obtain an enhanced multimodal teaching dataset; A mining module is used to construct a cross-institutional federated knowledge graph based on the enhanced multimodal teaching dataset, mine potential teaching associations using a differentially private graph attention mechanism, and generate an interpretable teaching mode graph through a dynamic subgraph evolution algorithm; A generation module is used to generate a personalized teaching recommendation strategy based on the teaching mode map and real-time teaching feedback data through a course-learner dual-channel adaptive recommendation model, wherein the course-learner dual-channel adaptive recommendation model dynamically adjusts the recommendation weight by integrating temporal reinforcement learning and meta-path reasoning algorithm.

[0013] Yet another embodiment of the present application provides a storage medium, wherein the storage medium stores a computer program, wherein the computer program is configured to execute any of the above methods when run.

[0014] Yet another embodiment of the present application provides an electronic device, comprising a memory and a processor, wherein the memory stores a computer program, and the processor is configured to run the computer program to execute any of the above methods.

[0015] Compared with the existing technology, the present invention provides an artificial intelligence-based teaching data management method, which obtains a standardized time series data stream based on the heterogeneous data stream generated in real time by a multi-source teaching platform; based on the standardized time series data stream, the teaching data is classified and encrypted through a dynamic hierarchical storage strategy based on attribute-based encryption to obtain a secure hierarchical storage topology structure; according to user query requests and teaching scenario labels, the target data set is extracted from the secure hierarchical storage topology structure to obtain an enhanced multimodal teaching data set; based on the enhanced multimodal teaching data set, an interpretable teaching mode map is generated through a dynamic subgraph evolution algorithm; according to the teaching mode map and real-time teaching feedback data, a personalized teaching recommendation strategy is generated through a course-learner dual-channel adaptive recommendation model, thereby improving the utilization efficiency of teaching resources and realizing personalized and intelligent teaching recommendations and decisions. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1 A hardware structure block diagram of a computer terminal for an artificial intelligence-based teaching data management method provided in an embodiment of the present invention; Figure 2 A flowchart of an artificial intelligence-based teaching data management method provided by an embodiment of the present invention; Figure 3 A structural diagram of an artificial intelligence-based teaching data management system provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0017] The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present invention, and are not to be construed as limiting the present invention.

[0018] The embodiment of the present invention first provides a teaching data management method based on artificial intelligence, which can be applied to electronic devices such as computer terminals, specifically ordinary computers.

[0019] The following describes it in detail by taking running on a computer terminal as an example. Figure 1 The hardware structure block diagram of a computer terminal for a teaching data management method based on artificial intelligence provided by an embodiment of the present invention. Figure 1 As shown, the computer device includes a processor, a memory, and a network interface connected via a system bus, wherein the memory may include a non-volatile storage medium and an internal memory.

[0020] The non-volatile storage medium can store an operating system and a computer program. The computer program includes program instructions, which, when executed, can cause a processor to execute any one of the teaching data management methods based on artificial intelligence.

[0021] The processor is used to provide computing and control capabilities and support the operation of the entire computer equipment.

[0022] The internal memory provides an environment for the operation of the computer program in the non-volatile storage medium. When the computer program is executed by the processor, the processor can execute any teaching data management method based on artificial intelligence.

[0023] The network interface is used for network communication, such as sending assigned tasks, etc. Those skilled in the art will understand that Figure 1 The structure shown in the figure is only a block diagram of a part of the structure related to the solution of the present application, and does not constitute a limitation on the computer device to which the solution of the present application is applied. The specific computer device may include more or fewer components than shown in the figure, or combine certain components, or have a different component arrangement.

[0024] It should be understood that the processor may be a central processing unit (CPU), other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA), other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor may be a microprocessor or any conventional processor, etc.

[0025] See also Figure 2 , an embodiment of the present invention provides a teaching data management method based on artificial intelligence, which may include the following steps: S201, based on the heterogeneous data streams generated in real time by the multi-source teaching platform, dynamically parse and normalize the heterogeneous data streams, identify data format features using a bidirectional long short-term memory network, and construct a dynamic interface adapter to obtain a standardized time series data stream. Specifically, this may include: S2011 receives raw data streams from teaching platforms, learning management systems, and online course platforms. It extracts temporal features of the raw data streams through a bidirectional long short-term memory network, identifies implicit patterns in the data format, and obtains multi-source data format feature vectors. Multi-source data access and preprocessing Data source definition and protocol analysis: The raw data streams of teaching platforms (such as Moodle), learning management systems (such as Canvas), and online course platforms (such as Coursera) are accessed in real time through API interfaces (RESTful or WebSocket). For example, the Moodle platform provides learning behavior logs in SCORM format (such as activity_001.xml), Canvas outputs xAPI statements (such as {"actor":"user123","verb":"completed","object":"quiz_456"}), and Coursera transmits test data through the IMS-QTI standard (such as <qti-assessment-item identifier="math_quiz">).

[0026] Data Caching and Sharding: Kafka message queues are used to cache raw data streams in shards, with each shard size set to 128MB to prevent memory overflow. For example, xAPI statements are batched by time window (e.g., 5-minute windows) and assigned to different partitions (e.g., partition_1 to partition_8) for parallel processing.

[0027] Noise filtering and anomaly detection: This function eliminates invalid data (such as "ERROR: invalid session" in the log) through regular expression matching and identifies anomalous data points (such as records with a single-day learning duration exceeding 24 hours) using the Isolation Forest algorithm. For example, setting the anomaly score threshold to 0.65 will filter out 0.3% of anomalous data.

[0028] Bidirectional LSTM (Bi-LSTM) Time Series Feature Extraction Network Architecture Design: A bidirectional LSTM network was constructed with an input layer dimension of [batch_size=64, time_steps=30, features=50], where time_steps represents the time window length (30 consecutive data points) and features contains data format attributes (such as the number of fields, encoding type, and nesting level). The hidden layer has 128 neurons, and the forward and backward LSTMs capture historical and future dependencies, respectively.

[0029] ‌Implicit Pattern Recognition‌: Extract global temporal features through the output of the last layer of Bi-LSTM. For example, <sequencing>The label nested structure is encoded and the feature vector is output (e.g., [0.23, 0.87, -0.15] represents the complexity of the label level, the frequency of occurrence, and the temporal volatility).

[0030] Dynamic feature mapping: Adaptive weighting is used to address the data characteristics of different platforms. For example, the verb-object combination of an xAPI statement (such as answered-question) is mapped to a high-dimensional sparse vector (dimension = 300), compressed to a 50-dimensional dense vector through the embedding layer, and then input into the Bi-LSTM.

[0031] ‌Feature vector generation for multiple source data formats‌ Feature fusion and dimensionality reduction: The temporal features (dimension = 256) output by the Bi-LSTM are concatenated with static metadata (such as file format and encoding standard) and then reduced to a 128-dimensional multi-source data format feature vector using a fully connected layer (Dense Layer).

[0032] Incremental update mechanism: When a new data format is detected (such as newly added H5P interactive content), the online learning mode is started, and the Bi-LSTM weights are fine-tuned through stochastic gradient descent (SGD) (learning rate = 0.001) to update the feature vector space.

[0033] S2012: Based on the multi-source data format feature vectors, a density peak clustering algorithm is used to generate a dynamic interface template library, and the optimal interface template is dynamically matched according to the real-time data stream characteristics to obtain interface adapter initialization parameters; Density peak clustering (DPC) template generation‌ ‌Local Density and Distance Calculation‌: Calculates the local density ρ and minimum distance δ for feature vectors in multi-source data formats (e.g., 1000 samples). For example, ρ_i represents the number of samples within a radius r = 0.5 (Euclidean distance) around feature vector i, and δ_i is the distance from i to the nearest sample with a higher density than it.

[0034] Cluster Center Selection: Draw a decision diagram (ρ-δ diagram) and manually annotate samples with density and distance above a threshold as cluster centers. For example, select five cluster centers with ρ > 8 and δ > 1.2, corresponding to mainstream data formats such as SCORM 1.2, xAPI 1.0.1, and IMS-QTI 2.1.

[0035] Dynamic template library construction: Each cluster generates an interface template, including field mapping rules (such as SCORM <adlcp:location>Mapped to context.location), type conversion table (such as string "90%" → floating point number 0.9), exception handling strategy (such as missing fields are filled with null by default).

[0036] ‌Real-time template matching and parameter initialization‌ Similarity Measurement and Matching: Extract the format feature vector (dimension = 128) from the real-time data stream and calculate the cosine similarity between it and all cluster centers in the template library. For example, if the similarity between xAPI data and the xAPI 1.0.1 template is 0.93, and the similarity with the IMS-QTI 2.1 template is 0.21, then the optimal matching template is xAPI 1.0.1.

[0037] Adaptive Threshold Adjustment: If the highest similarity falls below the dynamic threshold (initial value = 0.85), a new template generation process is triggered. For example, if a new data format with a similarity of 0.78 (such as xAPI 2.0 Beta) is detected, a temporary template is automatically created and added to the template library.

[0038] Interface adapter parameter generation: Initializes field mapping rules, data validation regular expressions (such as ^[A-Za-z0-9_]+$), and encoding converters (such as UTF-8→ASCII) based on matching results. For example, the xAPI template parameters include verb_mapping: {"completed":"finish", "answered":"respond"} and timestamp_format: "YYYY-MM-DDTHH:mm:ssZ".

[0039] Template library online optimization Cluster Drift Detection: Periodically (e.g., hourly) recalculates the ρ and δ values ​​of cluster centers. If the original center density drops by more than 20%, the cluster is merged or split. For example, if the ρ value of a SCORM 1.2 template drops from 15 to 9, the template is split into two sub-categories: SCORM 1.2_A and SCORM 1.2_B.

[0040] Template Weight Decay: Set a popularity value for each template (initial value = 100). Each successful match adds 5 points, and if there is no match, the value decays by 10% daily. When the popularity value falls below 30, the template is marked as a template to be eliminated, requiring manual confirmation to retain it.

[0041] S2013: Building a lightweight data conversion rule engine based on the interface adapter initialization parameters to convert heterogeneous data including SCORM, xAPI, and IMS-QTI into a unified JSON-LD format to obtain an intermediate standardized data block; ‌Rule Engine Architecture Design‌ ‌Modular processing pipeline‌: Build a three-stage pipeline including field extractor (Extractor), type converter (Transformer), and semantic validator (Validator). For example, Extractor parses from SCORM XML <adlcp:score>The Transformer converts the field into a floating point number, and the Validator checks whether the value range is between 0 and 1.

[0042] Parallel execution optimization: Use multiple thread pools (e.g., 8 threads) to process different data shards in parallel. For example, xAPI statements can be grouped by actor, with each group assigned a separate thread to process, increasing throughput to 1,000 statements per second.

[0043] Memory Management Strategy: Set the JVM heap memory limit to 4GB and use zero-copy technology to reduce serialization overhead. For example, use Protocol Buffers to directly map JSON-LD structures, avoiding intermediate format conversion.

[0044] Heterogeneous data format conversion SCORM → JSON-LD conversion: Field Mapping: <adlcp:location>The mapping is {"@context": "http: / / schema.org", "location": {"@type": "Place", "name": "Chapter3"}}.

[0045] Flattening nested structures: <sequencing> <controlmode choice="false" / > Converts to "sequencing.controlMode.choice": false.

[0046] ‌xAPI → JSON-LD conversion‌: Verb standardization: shorten verb: "http: / / adlnet.gov / expapi / verbs / completed" to "verb": "completed" and add @context link to the xAPI official vocabulary.

[0047] Timestamp formatting: Change "timestamp": "2023-10-01T12:34:56.789Z" to the ISO 8601 extended format.

[0048] ‌IMS-QTI → JSON-LD conversion‌: Topic materialization: <qti-assessment-item identifier="math_quiz">Converts to {"@type": "AssessmentItem", "identifier": "math_quiz", "question": "..."}.

[0049] Response processing: <responsedeclaration identifier="RESPONSE">Mapped to "response": {"identifier": "RESPONSE", "correctValue": "A"}.

[0050] ‌Intermediate Normalized Data Block Generation‌ Data consistency check: Verify that the converted data complies with the JSON Schema specification. For example, check whether the required field @context exists and whether the timestamp is a valid date.

[0051] Lightweight compression: Uses the GZIP compression algorithm (compression level = 6) to reduce storage overhead, reducing the average data size from 1MB per 1,000 records to 200KB per 1,000 records.

[0052] Batch packaging and indexing: Every 1,000 JSON-LD data items are packaged into an intermediate data block (file name format: block_20231001_001.ndjson), and an index file is generated (recording the start timestamp, platform type, and data volume).

[0053] In S2014, the intermediate standardized data blocks are time-aligned, a sliding window mechanism is used to eliminate cross-platform timestamp deviations, and a continuous, conflict-free, standardized time-series data stream is output through an event-driven pipeline.

[0054] Timestamp Drift Detection and Correction Global Clock Synchronization: calibrates the clocks on all platforms using the NTP protocol, with a maximum tolerance of ±500ms. For records exceeding this threshold (e.g., Canvas timestamps are 2 seconds behind Moodle), a timestamp_offset: +2000ms offset is added.

[0055] Sliding Window Alignment: Set the window size to 5 seconds and the sliding step size to 2 seconds. For example, all events (such as video playback and quiz submission) within the window 12:00:00-12:00:05 are sorted by their actual occurrence time to generate an ordered sequence of events.

[0056] Causality Repair: Corrects timing conflicts through event dependency analysis. For example, if a student submits a quiz at 12:00:03, but the video playback record shows completion at 12:00:04, the video end time will be automatically adjusted to 12:00:02 to maintain causality.

[0057] Event-driven pipeline design ‌State Management Engine‌: Maintains the session state machine for each learner (e.g., state = learning, paused, completed). When a pause_video event is received, the state is updated and subsequent event processing is suspended until a resume_video event is received.

[0058] Conflict Detection and Resolution: A vector clock algorithm is used to mark event concurrency. For example, if two platforms report the same student's start_quiz event simultaneously (with vector clocks [Moodle:2, Canvas:1] and [Moodle:1, Canvas:2]), they are sorted by platform priority (Moodle > Canvas).

[0059] Watermark Generation: This function advances global progress based on event time, with a permissible delay of 10 seconds. For example, when processing an event with a timestamp of 12:00:10, it is assumed that all events with a timestamp ≤ 12:00:00 have arrived, triggering window computation.

[0060] ‌Normalized time series data stream output‌ Data serialization and distribution: Convert the time-aligned data into Avro format (Schema includes timestamp, user_id, event_type, and payload) and distribute it to downstream systems through the Kafka topic standardized_events.

[0061] End-to-end latency monitoring: We insert tracking points at each stage of the pipeline (receiving, transforming, and aligning), and ensure that the 95th percentile latency does not exceed 800ms. If this limit is exceeded, we dynamically scale up the number of processing nodes (for example, from 8 to 12).

[0062] Data quality closed-loop feedback: Indicators such as timing conflict rate (e.g., 0.07%) and field fill rate (e.g., 99.3%) are fed back to the interface adapter, triggering rule engine parameter adjustments (e.g., relaxing the timestamp deviation threshold to ±1 second).

[0063] ‌Application Scenario Examples‌ Scenario description: A cross-platform online course uses Moodle (SCORM), Canvas (xAPI), and a self-developed testing system (IMS-QTI). Real-time data integration is required to analyze learning behavior.

[0064] Data access: Kafka receives activity_001.xml (SCORM 1.2) from Moodle, xapi_20231001.json (xAPI 1.0.1) from Canvas, and qti_math.ndjson (IMS-QTI 2.1) from the self-developed system.

[0065] Feature Extraction: Bi-LSTM recognizes features in SCORM data <sequencing>The nested pattern of labels outputs the feature vector [0.92, 0.45, ...].

[0066] Template Matching: Density peak clustering is matched to the SCORM 1.2 template (similarity = 0.95), and field mapping rules are initialized.

[0067] ‌Rule Conversion‌: Convert <adlcp:score> 0.9< / adlcp:score> Translates to {"score": 0.9, "@context": "http: / / schema.org"}.

[0068] ‌Timing Alignment‌: Corrected Canvas timestamp deviation (+1.2 seconds) and sorted the event stream by the sliding window 12:00:00-12:00:05.

[0069] Output: A standardized data stream in Avro format is sent to the recommendation system, triggering the calculation of personalized learning paths.

[0070] This step receives raw data (e.g., SCORM, xAPI, and IMS-QTI formats) from various sources, including teaching platforms, learning management systems (LMS), and online course platforms. It then uses a bidirectional long short-term memory (Bi-LSTM) network to extract temporal features from the data stream (e.g., timestamp continuity and field arrangement patterns) and identify implicit formatting patterns (e.g., the nested relationship between course video metadata and log behavior data). A dynamic interface adapter (based on a template library generated by density peak clustering) converts multi-source data into a unified JSON-LD format. A sliding window is used to align timestamps, eliminating cross-platform time skew. This ultimately generates a standardized time-series data stream, achieving semantic consistency and temporal synchronization for heterogeneous data. This addresses the issues of mixed formats and time misalignment in multi-source teaching data. The dynamic interface adapter also enables automated data integration, providing a unified input for subsequent encrypted storage and feature fusion, avoiding inefficiencies and compatibility conflicts caused by manual intervention.

[0071] S202: Based on the standardized time series data stream, the teaching data is classified and encrypted using a dynamic hierarchical storage strategy based on attribute-based encryption, and a knowledge distillation algorithm is used to compress the unstructured data and generate a unique data fingerprint to obtain a secure hierarchical storage topology. Specifically, this may include: S2021, based on the metadata attributes of the standardized time series data stream, extract the data sensitivity level label through the attribute-based encryption algorithm, use the CP-ABE strategy to define the access control tree, and generate a dynamic hierarchical encryption strategy; ‌‌Metadata sensitive feature extraction and label generation‌ Metadata Parsing and Feature Extraction: Metadata from standardized time-series data streams includes field type (e.g., user_id, course_id), data source (e.g., platform type, institution code), and content category (e.g., video, log, quiz results). The privacy relevance of these fields is analyzed using a Multi-Dimension Sensitivity Network (MDSN). For example, MDSN utilizes a three-layer fully connected network (input layer dimension = 64, hidden layer dimension = 32, output layer dimension = 3). Input features include field type (numeric encoding), access frequency (log statistics), and associated entities (e.g., whether student status is associated).

[0072] Sensitivity Stratification: Hierarchical clustering is used to classify data into three levels of sensitivity labels: Highly sensitive (L3): student information (such as ID number, home address), and original grade data (such as test answers).

[0073] Medium-sensitive (L2): Classroom behavior logs (such as login time, video viewing time), test statistics (such as average score, pass rate).

[0074] Low sensitivity (L1): Open course videos (no copyright restrictions), syllabus text.

[0075] For example, for the student data of user_id=student_001, MDSN outputs the sensitive vector [0.92, 0.15, 0.03], indicating that the L3 weight is the highest.

[0076] Dynamic label update: The autoencoder reconstructs the input data and calculates the mean square error (MSE) as a sensitivity correction factor. For example, if a video is frequently accessed (abnormally high access frequency) and the autoencoder reconstruction error exceeds a threshold (e.g., 0.1), its sensitivity label is upgraded from L1 to L2.

[0077] CP-ABE Access Control Tree Construction Policy Definition and Attribute Binding: Ciphertext-Policy Attribute-Based Encryption (CP-ABE) defines the access tree structure. For example, for highly sensitive data (L3), the access policy can be set to (role=teacher AND department=math) OR (role=admin AND time<2024-12-31). This means that only teachers in the mathematics department or administrators before the end of 2024 can decrypt the data.

[0078] Dynamic decay factor design: Add decay weights to time attributes in access policies (e.g., time < 2024-12-31). For example, use an exponential decay function weight = exp(-λ*(current_time - grant_time)), where λ = 0.001 controls the decay rate. When the weight falls below 0.5, access rights are automatically revoked.

[0079] Policy Public Key Generation: Elliptic Curve Cryptography (ECC) is used to generate the policy public key matrix. For example, the secp256k1 curve is used to generate the public key PK = (x=0x3B9ACA07, y=0x76B5821D) and the private key SK = 0x1A2B3C4D. Bilinear pairing is then used to verify that the attributes match the policy.

[0080] Dynamic hierarchical encryption policy generation Policy Optimization and Coupling: Optimize the coupling between the access control tree and sensitivity labels. For example, add a regional constraint (such as location=China) to the access tree for medium-sensitive data (L2) and bind it to the second dimension of the sensitivity vector (medium-sensitive weight).

[0081] Spatiotemporal Constraint Injection: When a cross-campus data request is detected, the policy evolution engine automatically adds two-factor authentication conditions (such as SMS verification code + fingerprint). For example, if a user accesses from an overseas IP address, the trigger policy is updated to (role=teacher AND location=China) + OTP.

[0082] Key distribution and synchronization: Based on a distributed key management system (such as HashiCorp Vault), a unique key shard is generated for each policy node and synchronized to each storage node via the Gossip protocol, ensuring that at least three shards must be merged for decryption (threshold = 3).

[0083] S2022, based on the dynamic hierarchical encryption strategy, classify and encrypt the teaching video data and text log data to generate hierarchical ciphertext data blocks; ‌Teaching video data encryption‌ Video Segmentation and Feature Extraction: Cut the video into 10-second segments (e.g., video_001_segment_0001.mp4) based on keyframes. Use OpenCV to extract optical flow features (dimension = 512) and color histograms (dimension = 256), and generate feature vectors as auxiliary information for encryption.

[0084] Selective Encryption and Compression: For highly sensitive videos (such as paid courses), full-frame encryption (AES-256-CBC mode, key length = 256 bits) is used, while for low-sensitivity videos (such as public courses), only the I-frames (key frames) are encrypted, and the P / B frames are left unencrypted to save computing resources. After encryption, H.265 encoding is used for compression, with a 40% increase in compression ratio.

[0085] Dynamic Key Binding: Bind the video shard key (such as key=0x5E6F7A8B) to the access control tree attributes. For example, if the access policy is role=student AND course_enrolled=true, the key is only visible to students who have enrolled in the course.

[0086] Text Log Data Encryption Structured Log Encryption: Perform field-level encryption on JSON-formatted logs (such as {"user_id": "student_xxx", "action": "start_video", "timestamp": 1630454400}): Highly sensitive fields (such as user_id): Use CP-ABE encryption, and the ciphertext format is {"encrypted_user_id":"0xA1B2C3D4...", "policy": "(role=admin)"}.

[0087] Low-sensitivity fields (such as action): Use lightweight encryption algorithms (such as ChaCha20-Poly1305, key length = 128 bits).

[0088] Unstructured Log Processing: For free-text logs (such as teacher comments), use a named entity recognition (NER) model (such as BERT-Base) to automatically identify sensitive entities (such as student names), and only encrypt the entity part (such as "Zhang San" → "0xE5F6G7H8").

[0089] Log Index Optimization: Build an inverted index for encrypted logs. The index fields (such as timestamp, action_type) are kept in plaintext to support fast retrieval, but the index keys are signed by HMAC-SHA256 to prevent tampering.

[0090] Hierarchical Ciphertext Data Block Generation Data Block Encapsulation: Package the encrypted video shards and log records into data blocks (Blocks) according to a time window (such as 5 minutes). Each block contains: Header information: block ID (such as block_20231001_001), encryption algorithm list (such as ["AES-256", "CP-ABE"]), timestamp range (start=1630454400, end=1630454700).

[0091] Data body: encrypted video segments and log records.

[0092] Tail checksum: CRC32 checksum (such as 0x78ABCDEF) and digital signature (RSA-2048).

[0093] ‌Tiered Storage Tagging‌: Label data blocks according to sensitivity labels: L3 data block: marked in red, stored on a local encrypted hard drive (read and write speed ≤ 200 MB / s).

[0094] L2 data block: marked in yellow, stored in a distributed file system (such as Ceph, with a replica count of 3).

[0095] L1 data blocks: marked in green, stored in object storage (such as Amazon S3, compressed storage).

[0096] ‌S2023, uses a knowledge distillation algorithm for unstructured video data, extracts key teaching features through a teacher model, and trains a lightweight student model to generate compressed feature vectors, outputting a lightweight video feature package that preserves semantics; Teacher model design and feature extraction ‌Multimodal Teacher Model Architecture‌: The teacher model adopts a hybrid structure of ResNet-101 (image branch) + Transformer (time series branch): Image branch: Input video key frames (resolution = 224x224) and extract spatial features (dimension = 2048) through ResNet-101.

[0097] Temporal branch: Input optical flow sequence (length = 30 frames) and extract temporal features (dimension = 512) through Transformer encoder (number of layers = 6, number of heads = 8).

[0098] Feature fusion: The spatial and temporal features are concatenated (total dimension = 2560) and output through a fully connected layer (dimension = 1024) to generate teaching semantic features (such as the relevance of knowledge points and student attention hotspots).

[0099] Key Feature Distillation: Gradient Backpropagation Saliency Map (Grad-CAM) is used to identify the feature regions that have the greatest impact on teaching effectiveness. For example, the key frame region where the teacher writes on the blackboard in the video (coordinates x=100-200, y=50-150) is given a higher weight.

[0100] Student model training and compression Lightweight student model design: The student model uses MobileNetV3 (image branch) + TemporalConvolutional Network (time series branch): Image branch: MobileNetV3 inverted residual structure (parameters = 2.5M), output feature dimension = 512.

[0101] Temporal branch: TCN dilated convolution (number of layers = 4, dilation factor = 2), output feature dimension = 256.

[0102] Feature fusion: The channel attention mechanism (SENet Block) dynamically weights the fusion features, and the final output dimension is 768.

[0103] ‌Distillation loss function‌: Define the joint loss of mean squared error (MSE) and cosine similarity: MSE loss: constrains the feature distance between the student model output and the teacher model (such as MSE=0.05).

[0104] Cosine loss: ensure feature direction consistency (e.g. cosθ=0.92).

[0105] Training optimization strategy: Adam optimizer (learning rate = 0.001, β1 = 0.9, β2 = 0.999), mixed precision training (FP16), batch size = 128.

[0106] Lightweight feature pack generation Feature Compression and Encoding: The 768-dimensional feature vector output by the student model is reduced to 128 dimensions through PCA. Scalar Quantization is then used to convert floating-point numbers into 8-bit integers (e.g., 0.75 → 192), increasing the compression rate by 6 times.

[0107] Semantic integrity verification: Randomly sample video clips, manually annotate the knowledge point coverage (e.g., 0-5 points), and verify the semantic consistency between the compressed features and the original video (e.g., average score difference <0.2).

[0108] Feature Packaging: Packs compressed features, timestamps, and video IDs into Protobuf format (e.g., feature_pkg_001.bin) and appends an HMAC signature (key = 0x9A8B7C6D) to prevent tampering.

[0109] In S2024, the hierarchical ciphertext data blocks and the lightweight video feature packages are hash chained together, a unique data fingerprint is generated based on the content features of the hierarchical ciphertext data blocks, and a secure hierarchical storage topology with access control tags is constructed.

[0110] ‌Hash chain construction and data association‌ ‌Data Block Hash Generation‌: Calculate the SHA-256 hash value for each hierarchical ciphertext data block (e.g., hash_block_001 = 0x1A2B3C4D...), and embed the hash value of the previous block into the current block header to form an unalterable hash chain. For example, the header of block_002 contains prev_hash = 0x1A2B3C4D.

[0111] Feature package association: Write the hash value of the lightweight video feature package (such as hash_feature_pkg_001=0x5E6F7A8B) into the metadata field of the corresponding data block to establish a bidirectional index between the video content and the encrypted data.

[0112] Cross-block verification: If a data block is modified (such as tampering with log records), the change in its hash value will cause the prev_hash verification of all subsequent blocks to fail, triggering an audit alarm.

[0113] ‌Unique data fingerprint generation‌ Content feature extraction of hierarchical ciphertext data blocks: Extract key teaching features (such as knowledge point density = 0.8 and peak attention time = 120s) from the lightweight feature package and convert them into hexadecimal strings (such as "0x8F" for knowledge point density).

[0114] Fingerprint synthesis algorithm: Merkle Tree structure is used to aggregate multi-dimensional features: Leaf node: a single feature hash (e.g., hash(knowledge_density)=0xA1B2).

[0115] Intermediate node: The hashes of adjacent leaf nodes are concatenated and then hashed (e.g., hash(0xA1B2+0xC3D4)=0xE5F6).

[0116] Root node: final data fingerprint (such as root_hash=0x9A8B).

[0117] Fingerprint Binding and Query: Write data fingerprints to a blockchain (such as Hyperledger Fabric) and support reverse retrieval of original data blocks and feature packages through fingerprints.

[0118] ‌Secure hierarchical storage topology construction‌ Storage tier division: Hot storage layer (memory cache): stores low-sensitivity data (L1) and frequently accessed feature packets, with a response time of ≤10ms.

[0119] Warm storage layer (SSD array): stores sensitive data (L2) and associated hash chain indexes, with a response time of ≤100ms.

[0120] Cold storage layer (tape library): stores highly sensitive data (L3) and full backups, with a response time of ≥10s.

[0121] Access control label embedding: Label each storage node (e.g., label = {sensitivity:L2,location:Beijing-Campus-3}) and automatically enforce policies (e.g., prohibiting cross-region access to L3 data) through smart contracts.

[0122] Dynamic topology optimization: Based on access pattern analysis (such as the Q-Learning algorithm), data blocks are dynamically migrated to balance the load. For example, L2 data blocks with more than 1,000 accesses in a week are migrated from warm storage to hot storage.

[0123] ‌Application Scenario Examples‌ Scenario description: A university needs to securely store mathematics course videos (L2 sensitive) and student exam logs (L3 sensitive).

[0124] ‌Encryption and Compression‌: Video fragment encryption: Use AES-256 to encrypt key frames (I frames), reducing the size from 1GB to 600MB after compression.

[0125] Log field encryption: Student ID is encrypted using CP-ABE with the policy (role=teacher AND course=math101).

[0126] ‌Knowledge Distillation‌: The teacher model extracts the key segment of "Calculus Formula Derivation" in the video (feature vector = 0.82).

[0127] The student model compresses features to 128 dimensions and generates the feature package math101_segment_0001.fpkg.

[0128] ‌Storage topology construction‌: Videos are stored in warm storage (SSD arrays), and logs are stored in cold storage (tape libraries).

[0129] The data fingerprint 0x9A8B is written into the blockchain for the Academic Affairs Office to verify the data integrity.

[0130] Additionally, based on the metadata attributes of the standardized time-series data stream, the data sensitivity level label is extracted through the attribute-based encryption algorithm, and the access control tree is defined using the CP-ABE strategy to generate a dynamic hierarchical encryption strategy, which may include: Based on the metadata attributes of standardized time-series data streams, a multi-dimensional sensitive feature extraction network is used to analyze the privacy relevance of data fields. A hierarchical clustering algorithm is combined with an autoencoder architecture to map student status information, academic records, and classroom behavior logs to different sensitivity levels, outputting a three-dimensional feature vector of data sensitivity. Multi-dimensional sensitive feature extraction network design Input Data Definition: Metadata attributes for standardized time-series data streams include field type (e.g., ID number and name in student status information), data source (e.g., LMS system, exam platform), and update frequency (e.g., monthly student status updates, real-time classroom behavior log updates). For example, the student status information field includes the field name student_id, field type PII (Personally Identifiable Information), and data source the educational administration system.

[0131] Privacy Relevance Calculation: The privacy relevance of each field is calculated using a sensitive feature extraction network (network structure: 256-dimensional input layer → 128-dimensional fully connected layer → ReLU → 3-dimensional output layer). Supervised learning is used for network training, and the labeled data includes three types of sensitive labels: high sensitivity (such as ID number); medium sensitivity (such as grades); and low sensitivity (such as the number of classroom interactions). Training parameters: batch_size = 256 (processing 256 fields per batch), epochs = 100 (training for 100 rounds), and cross-entropy as the loss function.

[0132] Hierarchical clustering and autoencoder fusion: Hierarchical clustering: Cluster the privacy relevance vector (3D) of each field, setting the number of clusters k to 3 (corresponding to high, medium, and low sensitivity levels). The Ward variance minimization algorithm is used to calculate the inter-cluster distance. For example, the student information field is clustered into the high-sensitivity cluster (cluster center [0.92, 0.85, 0.78]), and the academic performance field is clustered into the medium-sensitivity cluster (cluster center [0.65, 0.72, 0.61]).

[0133] Autoencoder: Design an encoder (3D input → 2D hidden layer → 3D output) and a decoder (symmetric structure). Use unsupervised learning to reconstruct the privacy relevance vector and extract potentially sensitive features. Training parameters: learning rate lr = 0.001, Adam optimizer.

[0134] ‌Three-dimensional feature vector generation‌: Concatenate the cluster labels (e.g., high sensitivity = 2, medium sensitivity = 1, low sensitivity = 0) with the autoencoder latent features (2D) to output a three-dimensional vector (e.g., the student information field vector is [2, 0.87, -0.43]).

[0135] Sensitivity Level Mapping and Verification Sensitive level division rules: The sensitive level is defined based on the first dimension value (cluster label) of the three-dimensional feature vector: Highly sensitive layer (Level 3): Contains student information, ID number, and home address. Access requires two-factor authentication.

[0136] Medium-sensitivity level (Level 2): ​​Contains grades, test answers, and coursework. Access requires role-based authorization (such as teacher or student).

[0137] ‌Low-sensitivity layer (Level 1): Contains classroom behavior logs, number of interactions, resource click rates, and allows anonymous statistical access.

[0138] Data Verification and Correction: Manual review modules (such as the Academic Administrator interface) are used to correct automatic classification results. For example, if the system mistakenly classifies "class attendance" as medium-sensitive, administrators can manually adjust it to low-sensitive and feed it back into the training dataset to optimize the model.

[0139] Based on the three-dimensional feature vector of data sensitivity, a dynamic attenuation decision tree is used to generate a fine-grained access strategy. In this strategy, access rights for course video data are divided according to resolution and content sensitivity, and decryption conditions for test data are defined according to the score distribution range. The initial access control rule set with a timestamp is output. Dynamic decay decision tree construction Decision tree node definition: Design decision conditions based on the three-dimensional feature vector of data sensitivity: Root node: Determines the data sensitivity level (Level 1 / 2 / 3).

[0140] Branch nodes: Refine conditions for different data types. For example, for course video data, branch conditions include resolution (such as 1080P, 720P) and content sensitivity (such as videos containing student portraits = high sensitivity, teaching animations = low sensitivity).

[0141] Leaf nodes: Define access permissions (such as readable, editable, and denied) and decryption conditions (such as role = teacher and IP belongs to the school network).

[0142] Dynamic decay mechanism: Each access rule is assigned a time decay factor (initial weight = 1.0, daily decay rate = 0.05). Once a threshold is exceeded (e.g., weight < 0.3), the rule automatically expires. For example, an access rule for a final exam is initially valid for 30 days. After 30 days, the weight decays to 0.25, triggering automatic revocation.

[0143] ‌Fine-grained access policy generation‌ ‌Course video data authority division‌: Resolution conditions: 1080P videos are accessible only to teachers and authorized students (permission tags r:teacher, s:authorized), while 720P videos are accessible to all students (tag r:student).

[0144] Content sensitivity condition: Videos containing student portraits must include a privacy agreement signing status check (for example, the field consent_status=True).

[0145] ‌Test data decryption conditions‌: ‌Score Range Strategy‌: Students with scores ≥90 can view their rankings (decryption condition score≥90), and students with scores <60 can only view wrong question explanations (condition score<60&role=student).

[0146] ‌Time window restriction‌: Test data can only be decrypted 24 hours after the end of the exam (timestamp condition timestamp ≥ exam_end + 24h).

[0147] Rule set storage and indexing: Use Redis to store timestamped access control rules. The key is the data ID (e.g., video_001) and the value is the JSON formatted rule (e.g., {"resolution": "1080P", "access_roles": ["teacher"], "expire_weight": 0.95}). Supports real-time updates and queries (response time <10ms).

[0148] Based on the contextual information of real-time teaching scenarios, the initial access control rule set is dynamically modified through the policy evolution engine. When a cross-campus data sharing request is detected, regional constraint attributes are automatically added and two-factor authentication conditions are introduced to generate a time-space-aware enhanced access control tree. Strategy Evolution Engine Workflow Contextual Information Collection: Real-time collection of spatiotemporal information about the teaching scenario (such as the geographic location of the request source IP address and the current time period), user behavior (such as frequent access to unusual data), and device status (e.g., mobile / PC). For example, if a request is detected from a branch campus (IP address in Shanghai, main campus in Beijing), it is marked as a cross-campus access.

[0149] Dynamic rule modification mechanism: ‌Adding regional constraints‌: When the request source is not within the scope of the campus to which the data belongs, the geographic location attribute (such as region: Shanghai) is automatically added and the access method is restricted (only VPN access is allowed).

[0150] Two-factor authentication trigger: For cross-campus access to highly sensitive data (such as student status information), a text message verification code (field 2fa_code) or biometric identification (such as fingerprint) is mandatory.

[0151] ‌Time-space aware rule generation‌: Merge the revised rules into the access control tree, for example, adding a new branch condition: IF Data Sensitivity Level = Level 3 AND Request Source = Cross-campus THEN Require two-factor authentication AND restrict access time (9:00-18:00).

[0152] Enhanced Access Control Tree Optimization Conflict Detection and Resolution: Use a rule conflict detection algorithm (such as the RETE algorithm) to check for inconsistencies between new rules and existing ones. For example, if the existing rule allows teachers all-day access, but the new rule restricts cross-campus access to 9:00 AM - 6:00 PM, an exception rule is generated: Role = teacher AND Source = cross-campus → Allow all-day access.

[0153] Spatiotemporal constraint encoding: Maps geographic locations to GeoHash codes (e.g., Beijing Main Campus = wx4g), and encodes time periods to minute-level granularity (e.g., 9:00 = 540 minutes). In the access control tree, spatiotemporal constraints are used as joint decision nodes (e.g., GeoHash IN [wx4g, wx4e] AND time BETWEEN 540 AND 1080).

[0154] The enhanced access control tree is coupled and optimized with the three-dimensional feature vector of data sensitivity. The policy node weights are calculated using an asymmetric bilinear pairing algorithm. The policy public key matrix is ​​generated through elliptic curve encryption technology. Finally, a CP-ABE hierarchical encryption strategy with dynamic attenuation factors and spatiotemporal constraints is output.

[0155] Strategy Coupling and Weight Calculation Node Weight Definition: Each decision node in the access control tree (e.g., "resolution = 1080P") is associated with a weight, calculated using the second dimension (latent feature 1 of the autoencoder) of the three-dimensional data sensitivity feature vector and an asymmetric bilinear pairing algorithm. For example, using a bilinear mapping function (e: G1×G2→GT, where G1 / G2 represents the elliptic curve group), the node weight is calculated as: Weight = e(H(node ​​condition), data sensitivity vector). H is a hash function that maps node conditions to points on the elliptic curve.

[0156] Dynamic decay factor fusion: Multiply the time decay factor (e.g., 0.95) by the node weight to obtain the final weight (e.g., 0.95 × 0.87 = 0.8265). When the weight falls below the threshold (0.3), the node condition automatically becomes invalid.

[0157] CP-ABE Strategy Generation Elliptic Curve Parameter Selection: Using the national secret SM2 curve parameters (elliptic curve equation y² = x³ + ax + b, where a=0, b=7, and the prime field p=FFFFFFFE...), we generate a public / private key pair (public key PK=(G, g^α), master private key MSK=α). G is the base point in the public parameters, used to construct the encryption algorithm; g is the generator (which may be in the same group or across groups) used to construct the public key; α is the master private key, the core secret of the system, which is combined with G and g to generate the public key g^α.

[0158] Policy Public Key Matrix Construction: Map each leaf node of the access control tree (e.g., "Allow Teacher Access") to a row in the public key matrix. For example, for the rule "role = teacher AND resolution = 1080P," the generated public key component is: PK_row = g^{α * H(role||resolution)}.

[0159] Policy Release and Storage: The final CP-ABE policy contains a dynamic attenuation factor table (stored in MySQL), spatiotemporal constraints (encoded as JSON rules), and a public key matrix (stored as a binary file). The attribute private key is distributed to authorized users through the Key Distribution Center (KDC).

[0160] ‌Application Scenario Examples‌ Scenario description: A university needs to encrypt course videos shared across campuses.

[0161] ‌Sensitivity Level Tags‌: In the video metadata, the resolution is 1080P and contains a student portrait. The sensitivity three-dimensional vector is [2, 0.91, -0.37], which is classified as a high sensitivity level.

[0162] ‌Access Policy Generation‌: Initial rule: Allow teachers of this school to access (no two-factor authentication required), valid for 30 days (initial decay factor = 1.0).

[0163] Cross-campus access triggers policy revisions: An access request from the Shanghai branch is detected → a region constraint (region=Shanghai) and two-factor authentication conditions are automatically added.

[0164] CP-ABE Strategy Release: Teacher A's attribute private key includes role = teacher and region = Beijing, and can decrypt videos of the Beijing main campus. Teacher B's attribute private key includes role = teacher and region = Shanghai, and requires two-factor authentication to decrypt.

[0165] For sensitive information in standardized data streams (such as student status and test scores), an access control tree (e.g., "only the homeroom teacher can decrypt the score field") is defined based on attribute-based encryption (CP-ABE) policies. Encryption policies are dynamically generated based on the data's sensitivity level (e.g., high-sensitivity videos, low-sensitivity logs). For unstructured video data, a knowledge distillation algorithm is used to compress key features extracted by the teacher model (complex network) (e.g., teaching action recognition and knowledge point annotation) into a lightweight student model, generating a semantically preserved compressed feature package. A hash chain is then used to combine the encrypted data and compressed features to generate a unique data fingerprint (e.g., a SHA-3 hash value). A hierarchical storage topology with access rights labels is constructed to balance data security and storage efficiency. This approach optimizes storage resource usage while ensuring data privacy. Dynamic hierarchical encryption and feature compression reduce storage costs. Furthermore, a unique fingerprint is used to ensure data traceability and tamper-proofing, meeting educational data compliance requirements.

[0166] S203, based on the user query request and the teaching scenario label, extracting the target dataset from the secure hierarchical storage topology structure, jointly embedding the text, video, and behavior log data using a multimodal feature fusion network, and supplementing the missing features using a generative adversarial network to obtain an enhanced multimodal teaching dataset. Specifically, this may include: S2031, based on the keyword vectors and teaching scenario labels in the user query request, the target data is retrieved in the secure hierarchical storage topology structure using a semantic similarity algorithm to generate a candidate data set index table; Keyword vectorization and teaching scenario label analysis Keyword vector generation: Keywords in user query requests (such as "calculus tutorial video") are converted into 768-dimensional semantic vectors using the pre-trained multilingual BERT model (bert-base-uncased, 110M parameters). For example, "calculus" is encoded as the vector [0.23, -0.45, ..., 0.89], which is then weighted and fused with the context (such as "tutorial video") to generate the query vector query_vector.

[0167] Teaching Scenario Label Matching: Teaching scenario labels (e.g., "High School Math Review Class") are mapped into 32-dimensional vectors via a label encoder. This encoder uses a fully connected network (64 input layers, 32 hidden layers) and takes as input the label's TF-IDF weight (e.g., "Review Class" weight = 0.8) and the scenario type code (e.g., "Classroom" = 1, "Experiment" = 2).

[0168] Joint Similarity Calculation: The query vector (query_vector) and the scene label vector (scene_vector) are concatenated into an 800-dimensional joint vector. This vector is then matched against the metadata description of the data block in the secure hierarchical storage topology using the cosine similarity algorithm (threshold = 0.7). For example, the metadata vector (metadata_vector) matched to video_block_001 has a similarity of 0.82, making it a candidate data item.

[0169] ‌Efficient retrieval in secure hierarchical storage‌ Distributed inverted index construction: Build an inverted index for each data block in the secure hierarchical storage topology. The index keys include: Content keywords (such as "calculus" and "derivative") are extracted using NLP word segmentation tools (such as Jieba).

[0170] Sensitivity labels (such as L1 / L2 / L3) are used to quickly filter unauthorized data.

[0171] The time range (e.g. timestamp_start=1630454400) is divided into sliding windows (window size=1 hour).

[0172] Accelerated semantic similarity retrieval: Use the Faiss library (Facebook AI Similarity Search) to perform approximate nearest neighbor (ANN) searches on high-dimensional vectors. For example, configure the HNSW32 (Hierarchical Navigable Small World) index, partition the search space into 32 layers, achieve a recall rate >95%, and a response time <50ms.

[0173] ‌Generate the candidate dataset index table‌: The search results are sorted in descending order of similarity, and the generated index table structure is shown in Table 1 below: Table 1 Data block ID Similarity Sensitive Labels Storage Location video_block_001 0.92 L2 SSD_Node_3 log_block_045 0.85 L3 Tape_Archive_7 The index table uses a Bloom filter (false positive rate = 0.1%) to quickly filter out invalid data blocks.

[0174] Dynamic permission verification and result filtering Access control policy matching: Based on the user role (such as "student" or "teacher") and query context (such as IP address and time), the attribute-based encryption (ABE) policy engine is invoked to verify permissions. For example, a student role can only access data with scene_label = "Open Class" and sensitivity ≤ L2.

[0175] Data fingerprint integrity check: Calculate the SHA-256 hash value (e.g., hash=0x1A2B3C...) for the candidate data block, compare it with the fingerprint stored in the blockchain, and eliminate tampered or damaged data blocks (e.g., hash inconsistency rate > 0.01%).

[0176] Index table optimization and caching: Frequently accessed index table fragments (such as "Basic Mathematics Course") are stored in the Redis cache (TTL = 1 hour). The Least Recently Used (LRU) strategy is used to eliminate infrequently accessed data, increasing the cache hit rate by 40%.

[0177] S2032, based on the candidate dataset index table, uses a multi-head attention mechanism to align text TF-IDF features, video optical flow features, and behavior log temporal features to generate a multimodal joint embedding matrix; Multimodal feature extraction and normalization Text TF-IDF feature extraction: Calculate the TF-IDF (Term Frequency-Inverse Document Frequency) weight for teaching text (such as courseware and test questions) using the NLTK library (Python) to generate a 300-dimensional sparse vector. For example, the word "function" has a TF-IDF of 0.65 in math lessons and 0.02 in Chinese lessons.

[0178] Video Optical Flow Feature Extraction: We use OpenCV's Farneback algorithm to calculate the optical flow of consecutive video frames, generating a 512-dimensional dense vector. For example, the optical flow feature of video_segment_001 represents the intensity of writing on the blackboard (peak value = 120px / s).

[0179] Behavior Log Time Series Encoding: Student behavior logs (such as "clicking a video" and "submitting an assignment") are sorted by timestamp and extracted using an LSTM network (with 64 hidden layers), outputting a 128-dimensional vector. For example, the behavior of a student repeatedly pausing a video within 10 minutes is encoded as [0.34, -0.56, ..., 0.78].

[0180] Feature alignment of multi-head attention mechanism Feature dimension unification and projection: The text (300 dimensions), video (512 dimensions), and log (128 dimensions) features are projected to a unified dimension of 512 through a fully connected layer (parameter matrices W_text, W_video, W_log) to generate text_proj, video_proj, and log_proj.

[0181] ‌Multi-head attention calculation‌: Using the 8-head attention mechanism of the Transformer architecture (Head=8, each head dimension=64): Query: The text feature text_proj is used as the query, focusing on the related information in the video and log.

[0182] Key-Value: The video feature video_proj and the log feature log_proj are used as the key and value.

[0183] ‌Attention score‌: Calculate Query × Key^T / sqrt(64), Softmax normalization and weighted aggregation Value.

[0184] For example, the keyword "derivative" in the text and the optical flow feature of the blackboard derivation formula in the video have an attention weight of 0.91 in the top 3.

[0185] Cross-modal feature fusion: The outputs of the eight heads are concatenated into a 512×8=4096-dimensional vector, which is then reduced to 512 dimensions through a fully connected layer to generate a joint embedding matrix joint_embedding.

[0186] Optimization strategies for feature alignment Adversarial Alignment Loss: This introduces Domain Adversarial Training (DoT) and uses a gradient reversal layer to force features from different modalities to be distributed consistently in the embedding space. For example, the MMD (Maximum Mean Discrepancy) loss for text and video features is reduced from 0.5 to 0.2.

[0187] Dynamic Weight Adjustment: Automatically adjusts attention head weights based on feature quality (e.g., video feature signal-to-noise ratio > 30dB). For example, the attention weight for low-light videos is reduced by 50%, while the weight for text is increased by 30%.

[0188] Memory Optimization and Parallel Computing: Using the NVIDIA A100 GPU's Tensor Core to accelerate matrix multiplication (FP16 precision), with a batch size of 256, the training speed is increased by 3 times.

[0189] In step S2033, the multimodal joint embedding matrix is ​​input into the generative adversarial network. The discriminator identifies the missing feature locations, and the generator reconstructs the missing video key frames and text semantic segments, outputting the completed feature tensor. ‌Generative Adversarial Network Architecture Design‌ Generator structure: It uses the U-Net architecture (encoder-decoder), takes a 512-dimensional joint embedding matrix as input, and outputs the completed multimodal feature tensor: Encoder: 4 convolutional layers (Kernel=3×3, Stride=2), with the number of channels doubled in each layer (512→1024→2048→4096), extracting high-level semantic features.

[0190] Decoder: 4 layers of deconvolution (Kernel=4×4, Stride=2), halving the number of channels in each layer (4096→2048→1024→512), restoring the original resolution.

[0191] ‌ Skip Connection‌ : The output of each layer of the encoder is concatenated with the corresponding layer of the decoder to preserve detailed information (such as video edges and text punctuation).

[0192] Discriminator architecture: It uses PatchGAN design, takes as input a real or generated 512-dimensional feature tensor, and outputs the authenticity probability of each local region (Patch): Convolutional layer: 5 convolution layers (Kernel=3×3, Stride=2), with the number of channels increasing from 64 to 512.

[0193] Fully connected layer: Outputs a 16×16 true / false probability matrix, with each patch corresponding to a confidence level of 0 to 1.

[0194] Missing feature identification and reconstruction Missing Location Detection: The discriminator uses self-attention to locate abnormal regions in the feature tensor (such as missing video keyframes or blank text paragraphs). For example, if the activation value of the video feature segment video_feat[120:150] is lower than the threshold of 0.1, it is considered missing.

[0195] ‌Generator refactoring logic‌: ‌Video keyframe completion‌: Based on optical flow features and the content of neighboring frames, the generator predicts the pixels of missing frames (e.g., filling blurred areas with bilinear interpolation).

[0196] ‌Text Semantic Recovery‌: Based on the TF-IDF context, a small GPT-2 model (124M parameters) is used to generate coherent text (e.g., to fill in the missing "limit definition" description).

[0197] Adversarial training strategy: The generator and discriminator are trained alternately, and the loss function includes: Adversarial Loss: Cross-Entropy Loss between the discriminator output and the true label.

[0198] ‌Reconstruction loss‌: L1 distance between generated features and true features (weight = 0.7).

[0199] Perceptual loss: similarity of features extracted by the VGG-16 network (weight = 0.3).

[0200] Verification and optimization of completion effects Manual evaluation: 10% of the completed data is randomly sampled and annotated by education experts for semantic coherence (e.g., 1-5 points), with an average score of ≥ 4.0.

[0201] ‌Automated Testing‌: Video PSNR (Peak Signal-to-Noise Ratio): The PSNR of the completed video and the original video is greater than 30dB.

[0202] ‌Text BLEU score‌: The BLEU-4 score of the generated text and the reference answer is > 0.65.

[0203] Dynamic mask training: Randomly mask 20%–50% of input features (simulating different missing rates) to enhance model robustness.

[0204] ‌S2034, performs adversarial training optimization on the completed feature tensor, uses a gradient penalty strategy to stabilize the training process, and generates an intermediate multimodal dataset with enhanced robustness; ‌Gradient Penalty Strategy Implementation‌ Wasserstein GAN optimization: Using the WGAN-GP (Wasserstein GAN with GradientPenalty) framework, the discriminator output is a continuous value (Critic Score), and the loss function is: Loss = E[D(real)] -E[D(fake)] + λ * GP.

[0205] Among them, the gradient penalty term GP = (||∇D(interpolated)||_2 - 1)^2, the interpolated sample interpolated = ε * real + (1-ε) * fake, ε~Uniform(0,1), λ=10.

[0206] Gradient clipping and normalization: Gradient clipping (Clip=0.01) is applied after the discriminator weights are updated to prevent gradient explosion; the generator uses spectral normalization to constrain the L2 norm of the weight matrix.

[0207] Improved stability in adversarial training Two-Time-Step Update (TTUR): The discriminator is updated five times as frequently as the generator (e.g., the discriminator is updated five times per batch and the generator is updated once), balancing the training cadence.

[0208] Dynamic learning rate adjustment: The initial learning rate is set to 2e-4, using the cosine annealing strategy with epochs = 1000 steps and minimum learning rate = 1e-6.

[0209] ‌Historical Data Replay‌: retain the most recent 1000 batches of generated samples and replace new samples in the current batch with a 10% probability to mitigate mode collapse.

[0210] Intermediate dataset generation and enhancement Post-processing of the feature tensor: The completed 512-dimensional feature tensor is normalized (mean = 0, variance = 1) and PCA dimension reduction is performed (retaining 95% variance and reducing the dimension to 256) to reduce redundant information.

[0211] ‌Data Augmentation Techniques‌: ‌Jittering‌: Add Gaussian noise (μ=0, σ=0.1) to the behavior log time series features.

[0212] Elastic Distortion: This method simulates the camera shake effect on the video optical flow features (α=50, σ=5).

[0213] Quality filtering and cleaning: Remove low-quality samples with reconstruction loss > 0.3 or discriminator confidence < 0.5 to ensure the purity of the dataset.

[0214] ‌S2035, separate the modality-specific and common information in the intermediate multimodal dataset through the feature decoupling algorithm, and finally output an enhanced multimodal teaching dataset with cross-modal association labels.

[0215] Modal feature decoupling network design Decoupler Architecture: It uses a variational autoencoder (VAE) structure, takes 256-dimensional intermediate features as input, and outputs decoupled specific and common features: ‌Encoder‌: 3 fully connected layers (256→128→64→32), outputting mean μ and variance σ.

[0216] ‌Sampling layer‌: Samples a latent vector z = μ + ε * σ from N(μ, σ^2), ε ~ N(0,1).

[0217] Decoder: 3 fully connected layers (32 → 64 → 128 → 256), reconstructing input features.

[0218] ‌Decoupled loss function‌: ‌Reconstruction loss‌: L2 distance between input and decoded output (weight = 0.6).

[0219] Minimizing mutual information: The mutual information (MI) between specific and common features is reduced to 0.05 through adversarial learning.

[0220] Orthogonality constraint: The covariance matrix of the specific feature matrix is ​​approximately diagonal (off-diagonal elements < 0.01).

[0221] ‌Cross-modal association label generation‌ ‌Correlation Calculation‌: Calculate cross-modal cosine similarity for common features (e.g., video-text correlation = 0.75) to generate a correlation matrix. The example matrix includes the following information: Table 2 Modal Pair Correlation Video-Text 0.82 Text-Log 0.68 Label assignment rules: Strong correlation (>0.8): marked as cross_modal_strong, as shown in the formula derivation in the video and the definition in the text.

[0222] Moderate correlation (0.5-0.8): Marked as cross_modal_medium, such as the answering time and video views in the log.

[0223] Weak correlation (<0.5): marked as cross_modal_weak, such as chapter titles in text and video background music.

[0224] Label propagation optimization: Use the label propagation algorithm to correct abnormal labels, with the number of iterations = 100 and the similarity threshold = 0.7.

[0225] Enhanced dataset packaging and validation ‌Dataset structure‌: Each data sample can contain: specific feature specific_feature, common feature common_feature, cross-modal association label cross_modal_label, metadata metadata, etc.

[0226] Cross-modal consistency test: 1000 samples were randomly sampled and manually verified to have a label accuracy of >85%.

[0227] ‌Downstream task adaptation‌: Provides PyTorch and TensorFlow data loading interfaces (such as the Dataset class), supporting batch loading (Batch Size = 128) and distributed training.

[0228] Based on user queries (e.g., "Analysis of interactive effects in a math class in a certain class") and scenario labels (e.g., "online teaching"), the target data is retrieved from encrypted storage. A multi-head attention mechanism is used to align the TF-IDF features (keyword weights) of the text, the optical flow features (teacher gesture dynamics) of the video, and the temporal features (student click frequency) of the behavior log to generate a multimodal joint embedding matrix. A generator using a generative adversarial network (GAN) is used to reconstruct missing features (e.g., complete the blackboard content in key frames of a video). The discriminator identifies anomalous data distributions, and gradient penalties are used to optimize generation quality. The final output is an enhanced dataset containing cross-modal association labels. This addresses data fragmentation and missing data, improves the integrity and relevance of multimodal data, and enhances analysis reliability by supplementing missing information through adversarial generation. This provides high-quality input for knowledge graph construction and supports in-depth exploration of cross-modal teaching scenarios.

[0229] S204: Based on the enhanced multimodal teaching dataset, construct a cross-institutional federated knowledge graph, use a differentially private graph attention mechanism to mine potential teaching associations, and generate an interpretable teaching model graph through a dynamic subgraph evolution algorithm. Specifically, this may include: S2041, based on the entity-relationship triples in the enhanced multimodal teaching dataset, aggregates cross-institutional data through a federated learning framework, uses homomorphic encryption technology to protect institutional privacy, and generates an initial federated knowledge graph; Entity-relationship triple extraction and federated data alignment Cross-Institutional Entity Recognition: We extract entities (e.g., "Knowledge Point: Derivative," "Teacher: Mr. Zhang," "Course: Advanced Mathematics") from cross-modal association labels in the Enhanced Multimodal Teaching Dataset. We use the pre-trained RoBERTa model (roberta-base, 125M parameters) to semantically normalize the entity names. For example, "derivative" and "differential basis" are mapped to the same entity ID, entity_001.

[0230] Federated Data Alignment Protocol: Participating institutions (e.g., school A and education platform B) exchange entity ID hashes (SHA-256) using the Secure Multi-Party Computation (SMPC) protocol. This protocol retains shared entities (e.g., shared knowledge points like "limits") and excludes non-shared data (e.g., "machine learning courses" unique to institution B). After alignment, a global entity map (global_entity_map.csv) is generated.

[0231] Homomorphically Encrypted Data Aggregation: Using the Paillier homomorphic encryption algorithm (key length = 2048 bits), organizations locally train a knowledge graph subgraph (for example, organization A's subgraph contains "derivatives → calculus → Newton's theorem") and upload the gradient parameters of a relationship triple (head entity, relationship, tail entity) in encrypted form. The federated server aggregates the encrypted gradients, decrypts them, and updates the global graph, ensuring that the original data remains locally. For example, the weight of the relationship "predecessor knowledge point" is updated from 0.65 to 0.72.

[0232] Initial federated knowledge graph construction ‌Knowledge graph schema definition‌: Defines the schema of the teaching model graph, including entity types (knowledge points, teachers, courses), relationship types (prerequisite knowledge points, teaching styles, course dependencies), and constraint rules (such as "teacher → lecture → course" must satisfy "teacher ID ∈ list of in-service teachers").

[0233] Graph Database Storage Optimization: We use the Neo4j graph database (version 4.4) to store triples. Node attributes include the knowledge point difficulty coefficient (difficulty = 0-1) and the teacher's years of teaching experience (experience = 5 years). Edge attributes include relationship strength (strength = 0.8) and confidence (confidence = 0.95). To speed up queries, we construct a combined index: entity ID + relationship type.

[0234] Federated Model Validation and Tuning: Graph quality is assessed through cross-validation (50% fold), and relationship prediction accuracy and F1 scores are calculated. If the F1 score for "knowledge point association" predictions for institution A is less than 0.7, a federated retraining mechanism is triggered: the aggregation weight is adjusted (institution A's weight is reduced from 0.5 to 0.3), and the uploaded gradient is re-encrypted.

[0235] S2042, based on the initial federated knowledge graph, designs a differentially private graph attention mechanism. It perturbs the attention weights between nodes through Laplace noise injection to generate a privacy-safe relationship strength matrix. ‌‌Design of Graph Attention Mechanism with Differential Privacy Protection‌ Graph Attention Network (GAT) Modification: Based on the standard GAT (Graph Attention Network), differential privacy protection is added to the calculation of attention weights between nodes. The weight calculation formula for each attention head (Head=4) is modified to: Attention_Weight = Softmax((Q·K^T) / sqrt(d) + Laplace(0, β)). Where Q and K are the query and key vectors (dimension=64), d=64 is the scaling factor, and Laplace(0, β) is the Laplace noise (β=0.1, privacy budget ε=0.5).

[0236] Noise Injection Strategy: Dynamically adjusts the noise intensity based on the sensitivity level of the relationship. For example, edges involving student grades (sensitive label = High) are injected with a noise of β = 0.2, while general knowledge point relationships (sensitive label = Low) are injected with β = 0.05. The noise distribution is generated through inverse transform sampling to ensure compliance with the strict definition of differential privacy ((ε, δ)-DP, δ = 1e-5).

[0237] Privacy Budget Allocation: The total privacy budget ε_total = 2.0, allocated based on the number of network layers (3) and training rounds (10): ε = 0.3 per layer, ε = 0.06 per round. Adaptive Budget Allocation is used. If a layer is detected to have a gradient leakage risk (e.g., weight variance > 0.1), the ε for that layer is temporarily increased by 0.1.

[0238] Relationship Strength Matrix Generation and Privacy Verification Multi-hop relation propagation: Node features (such as knowledge point difficulty and teacher ratings) are aggregated through a three-layer GAT to generate node embeddings (dimension = 128). The relation strength matrix R (size = N × N, where N = the number of nodes) is calculated from the cosine similarity of the embedding vectors and truncated to the range [0, 1]. For example, the strength of "derivative" and "integral" is R[i, j] = 0.88.

[0239] Privacy Attack Simulation Test: We used a membership inference attack to evaluate the effectiveness of privacy protection. The attacker attempts to infer the existence of a specific edge (e.g., "Student A → Elective → Course B") by observing the R matrix. Test results show that the attack success rate drops from 32% for non-privacy protection to 8% (when β = 0.1).

[0240] Matrix Sparse Compression: To reduce storage overhead, we perform Top-K sparsification (K=10) on the R matrix, retaining only the 10 strongest edges per node. For example, for the "Calculus" node, we retain edges such as "Prerequisite Knowledge Points → Derivatives (0.92)" and "Related Courses → Physics (0.85)."

[0241] S2043, based on the relationship strength matrix, uses a temporal graph convolutional network to capture the evolution of teaching patterns, identifies potential teaching association clusters through a dynamic community discovery algorithm, and generates a set of subgraph evolution paths; Temporal Graph Convolutional Network (T-GCN) Modeling Time Slicing: Divide the teaching data into time windows (window size = 6 months, sliding step size = 1 month) by semester. Each window corresponds to a relationship strength matrix R_t (t = 1, 2, ...T). For example, R_1 for the spring semester of 2023 includes the newly added knowledge point "Deep Learning Basics."

[0242] ‌T-GCN Architecture‌: The network consists of a temporal module and a graph module: ‌Time Series Module‌: Uses a gated recurrent unit (GRU, hidden layer = 64) to capture temporal dependencies. Input is the flattened vector (dimension = N × N) of the history R_t matrix, and outputs temporal features h_t (dimension = 64).

[0243] Graph Module: Uses a graph convolutional network (GCN, 2 layers) to aggregate neighbor information. The formula for each layer is: H^{(l+1)} = ReLU(D^{-1 / 2} R_t D^{-1 / 2} H^{(l)} W^{(l)}). Where D is the degree matrix and W is a trainable parameter (size = 64×64). The final output node embedding is Z_t (dimension = 64).

[0244] Joint training strategy: The time series module and the graph module are fused via cross-attention. The loss function includes the relationship prediction loss (cross entropy) and the temporal smoothing loss (the L2 distance between adjacent Z_t). Learning rate = 0.001, batch size = 32.

[0245] Dynamic community discovery and evolutionary path generation Incremental Community Detection: This algorithm uses a dynamic Louvain algorithm (based on modularity optimization) to detect community structures in each time window t. A modularity threshold Q > 0.3 is considered a valid community. For example, in the spring of 2023, Community 1 (the mathematics course cluster) and Community 2 (the programming course cluster) were detected.

[0246] ‌Evolutionary Path Modeling‌: Defining community evolution events: Split: Community A splits into B and C at t+1 (Jaccard similarity < 0.4).

[0247] ‌Merge‌: Communities B and C merge into D at t+1 (overlapping nodes > 60%).

[0248] Drift: The core node change rate of community A at t+1 is >30%.

[0249] For example, Community 1 split into two sub-communities, "Calculus" and "Linear Algebra", in the summer semester of 2023.

[0250] ‌Evolution path storage‌: Use a graph database to store community evolution chains (such as Community_1 → Split →Community_2&Community_3). Edge attributes include timestamp, evolution type, and confidence (for example, split confidence = 0.88).

[0251] S2044: Perform causal reasoning analysis on the subgraph evolution path, calculate the interpretability score of the teaching model using a Bayesian network, and generate an intermediate teaching model map with confidence labels; Causal Inference and Bayesian Network Modeling‌ Causal graph construction: Based on events in the subgraph's evolutionary path (e.g., "community merger" or "new knowledge point"), causal variables are defined (e.g., X = teacher turnover rate, Y = course update frequency). The causal structure is learned using the Peter-Clark PC algorithm. For example, the causal relationship "Increase in teacher turnover rate → Increase in course update frequency" is found (causal strength = 0.75).

[0252] Bayesian network parameter learning: Maximum likelihood estimation (MLE) is used to calculate the conditional probability table (CPT). For example: P(Course Update Frequency = High | Teacher Turnover = High) = 0.82; P(knowledge point association strength↑ | course update frequency=High) = 0.67.

[0253] The network structure contains three layers of latent variables (such as "teaching resource investment" and "student feedback trend"), and the total number of nodes is 15.

[0254] Explainability score calculation: Define the scoring rule: Score = 0.6 * causal strength + 0.3 * confidence + 0.1 * evolutionary stability. For example, the causal strength of the path "community merger → course association enhancement" is 0.8, confidence = 0.91, stability = 0.75, and the final score is 0.6 0.8 + 0.3 0.91 + 0.1*0.75 = 0.828.

[0255] Intermediate graph generation and verification Knowledge Fusion with Confidence: Attach the causal probability of an event (e.g., "teacher training → knowledge point update, P=0.78") output by the Bayesian network as an attribute to the graph edge. Also, add a stability label (e.g., "Stable=0.9") to each community evolution path.

[0256] Expert Verification: 10 education experts were invited to annotate 100 high-scoring pathways (on a scale of 1-5), with an average score of 4.0 or higher. For example, the pathway "Increase lab classes → Improve student performance" would score 4.3.

[0257] Logical consistency check: Verify the logical consistency of the graph using an OWL reasoning engine (such as HermiT). For example, if there are "Course A → Prerequisites → Course B" and "Course B → Prerequisites → Course A", a conflict alert will be triggered and manual correction will be required.

[0258] ‌S2045, compresses the graph scale of the intermediate teaching model graph through graph neural network distillation technology, and finally outputs an interpretable teaching model graph that supports real-time reasoning.

[0259] ‌GNN Distillation‌ ‌Teacher-Student Model Architecture‌: Teacher model: 3-layer GAT (hidden layers = 256, heads = 8), trained on the full graph, accuracy = 92%.

[0260] Student model: 2-layer GCN (hidden layers = 128), aiming to approach the teacher performance on a compressed graph (50% fewer nodes).

[0261] Distillation loss function: Loss = 0.7 * KL divergence (teacher output || student output) + 0.3 * student cross entropy loss. KL divergence measures the difference in output distribution, and the temperature parameter T = 2.0 is used to smooth the probability distribution.

[0262] ‌Progressive Pruning Strategy‌: Iterative pruning is used, removing 10% of redundant edges (weight < 0.1) in each round of pruning. For example, if the initial number of edges is 100,000, after 5 rounds of pruning, the remaining number of edges is 59,000, and the accuracy loss is less than 3%.

[0263] Real-time inference optimization and deployment Lightweight Graph Storage: Converts compressed graphs to CSR (Compressed Sparse Row) format, reducing storage usage by 60%. For example, the original Neo4j storage size is 120GB, while the compressed size is 48GB.

[0264] Real-time Inference Engine: Deploys student models based on TensorRT, processing 1,000 queries per second (e.g., "Recommend a teaching model suitable for Teacher A"). Engine response time is <50ms, and GPU utilization is >90%.

[0265] Explainable API: Generates a visual report for each inference result, including key causal paths (e.g., "community merger → performance improvement") and confidence heatmaps (rendered using D3.js). Users can click on nodes to view detailed Bayesian network inference.

[0266] ‌Application Scenario Examples‌ Scenario description: An education alliance needs to analyze the evolution of teaching models across campuses and recommend course optimization strategies in real time.

[0267] ‌Federated Knowledge Graph Construction‌: Aggregate the "Calculus Course Group" of School A and the "AI Experimental Class" of School B to generate an interdisciplinary correlation edge (strength = 0.79).

[0268] Privacy-preserving relationship mining: The causal path of "teacher mobility → course update" was detected (Score=0.85), and the attack success rate dropped to 7% after noise injection.

[0269] Real-time reasoning and recommendation: When we enter the query "How to improve the effectiveness of programming courses," the inference engine returns "Increase project practice (confidence = 0.91)" and "Associate mathematical foundations (confidence = 0.87)."

[0270] Based on the entity relationships in the enhanced dataset (e.g., "knowledge point A → prerequisite knowledge point B" or "teacher X's commonly used teaching tool Y"), a federated learning framework aggregates multi-institutional data (e.g., curriculum designs from different schools) and employs homomorphic encryption to protect privacy, constructing an initial federated knowledge graph. A differentially private graph attention mechanism (with Laplace noise injection) is used to calculate the strength of inter-node associations (e.g., the probability of knowledge point co-occurrence). A dynamic community discovery algorithm is used to identify the evolutionary paths of teaching models (e.g., "group discussion → improved grades"). A Bayesian network is then used to calculate the interpretability score (e.g., confidence level ≥ 90%) for causal reasoning. Ultimately, a teaching model graph that supports real-time updates is generated, revealing the underlying patterns between teaching strategies and learning outcomes. This enables secure cross-institutional data sharing and knowledge fusion. Privacy-preserving techniques are used to uncover interpretable associations between teaching models, providing a basis for educational decision-making and avoiding data silos and privacy breaches.

[0271] S205: Generate a personalized teaching recommendation strategy based on the teaching model map and real-time teaching feedback data through a course-learner dual-channel adaptive recommendation model. The course-learner dual-channel adaptive recommendation model dynamically adjusts the recommendation weight by integrating temporal reinforcement learning and meta-path reasoning algorithm. Specifically, it may include: S2051: Based on the knowledge point dependency relationships in the teaching model map and the learner's real-time feedback data, the node weights in the course knowledge topology structure and the temporal characteristics of the learner's behavior trajectory are extracted to construct the topological feature map of the course channel and the behavioral evolution sequence of the learner channel; ‌Course Knowledge Topology Modeling‌ Node Weight Calculation: Extract knowledge point entities (e.g., "derivative" and "integral") and their dependencies from the teaching model graph (e.g., the edge weight of "derivative→integral" is 0.85). Calculate the global importance score of each knowledge point using the PageRank algorithm (damping coefficient = 0.85, number of iterations = 50) to serve as the node weight. For example, the PageRank score for "derivative" is 0.92, and for "integral" is 0.88.

[0272] Topological feature graph construction: Combine knowledge point node weights with edge weights (relationship strength) to construct a directed weighted graph. The graph structure is stored using the NetworkX library (Python). Node attributes include the knowledge point ID, weight, and course label (e.g., "Advanced Mathematics"). Edge attributes include dependency type (predetermined, parallel) and strength (0-1). For example, the edge "Derivative → Integral" has a strength of 0.85 and a type of predetermined dependency.

[0273] Time Series Feature Extraction: We extract behavioral sequences from real-time learner feedback data (such as learning time, test accuracy, and interaction frequency) and divide them into time windows (window size = 7 days, step size = 1 day). We use an LSTM network (with 64 hidden layers and 30 time steps) to extract a time series feature vector (dimension = 64) for each window. For example, the behavioral features of a learner's "Calculus" learning in week t are [0.72, 0.65, ..., 0.88].

[0274] ‌Constructing the learner behavior evolution sequence‌ Behavior Trajectory Coding: Learners' interactive behaviors in the video, such as clicking, pausing, and rewinding, as well as textual behaviors such as submitting quizzes and posting in discussion forums, are encoded as multimodal event sequences. For example, the event "video pause" is encoded as type code 101, timestamp 2023-08-15 14:30:00, and associated knowledge point derivatives.

[0275] Knowledge Transition Pattern Recognition: Based on the knowledge point switching records in the event sequence (e.g., "derivatives → integration → differential equations"), a hidden Markov model (HMM, number of states = 5) is used to model the learner's knowledge state transition probability. For example, the transition probability from "derivatives" to "integrations" is 0.78, and to "differential equations" is 0.45.

[0276] Evolutionary Sequence Storage: Use MongoDB to store the learner's behavior evolution sequence. The document structure includes the learner ID, timestamp sequence, knowledge point path, and behavior feature vector. For example, the document learner_001 contains the path ["derivative", "integral", "differential equation"] and the feature vectors [[0.72, ...], [0.68, ...], ...].

[0277] ‌S2052, in the course channel, uses a temporal reinforcement learning algorithm to perform dynamic path planning on the topological feature graph, captures historical teaching effect data through a sliding window mechanism, and generates a candidate recommendation sequence based on the correlation strength of knowledge points; ‌Temporal Reinforcement Learning Model Design‌ State Space Definition: Map the node weights and edge strengths of the course topology feature graph into a state space. The state S_t includes the current knowledge point (e.g., "derivative"), a set of adjacent knowledge points (e.g., ["limit," "integral"]), and historical teaching effectiveness indicators (e.g., the average correct rate of learners for this knowledge point = 75%).

[0278] Action space definition: Action A_t is the next knowledge point that can be jumped from the current knowledge point (for example, selecting "Integral" or "Limit" from "Derivative"). The action candidate set is filtered based on edge strength (only edges with strength > 0.6 are retained).

[0279] Reward Function Design: The reward R is dynamically calculated based on teaching effectiveness data. It includes short-term rewards (e.g., a Δ=5% increase in the learner's test accuracy after selecting an action) and long-term rewards (e.g., a path completeness score of 0.8). For example, if "Points" is selected, the reward R = 0.3*Δ + 0.7*path score = 0.3*5 + 0.7*0.8 = 2.31.

[0280] Dynamic Path Planning and Candidate Sequence Generation Sliding Window Mechanism: Load historical teaching data (e.g., path records of 1,000 learners) in time windows (window size = 30 days, step size = 7 days) and train the reinforcement learning model using the Deep Q-Network (DQN) algorithm. The input state S_t (dimension = 64) is used to output Q values ​​(the expected reward of each action). The network structure consists of fully connected layers (256→128→64), with a learning rate lr = 0.001 and a discount factor γ = 0.9.

[0281] Path Generation Strategy: An ε-greedy strategy (ε = 0.1) is used to balance exploration and exploitation. For example, the model chooses the action with the highest Q-value ("integrate") with 90% probability and randomly chooses another action ("limit") with 10% probability. N candidate paths (N = 50) are generated through iterative planning. Each path consists of a sequence of knowledge points and their cumulative reward (e.g., path derivative → integral → differential equation, total reward = 18.5).

[0282] Candidate sequence optimization: Rank candidate paths based on path association strength (mean edge strength) and teaching effectiveness (mean historical rewards), retaining the top 10 paths. For example, a path with a derivative → integral association strength of 0.85 and a teaching effectiveness of 8.7 ranks first.

[0283] S2053: In the learner channel, a meta-path inference algorithm based on the knowledge graph analyzes the knowledge transition pattern in the learner's behavior evolution sequence and generates a personalized path candidate set for the fusion capability growth curve. ‌Meta-path reasoning algorithm implementation‌ Meta-path definition: Predefine teaching association patterns in the knowledge graph, for example: Knowledge point → Prerequisite → Knowledge point (dependency path) Learner → Learning → Knowledge Point → Belongs to → Course (cross-entity path) The length of each meta-path is limited to 3 hops (e.g., learner → test → knowledge point → dependency → knowledge point).

[0284] Path Instance Mining: Extract instances that match the meta-path from learner behavior sequences. For example, learner A’s path derivative → learning → integration → testing → differential equation matches the meta-path learner → learning → knowledge point → testing → knowledge point.

[0285] Path weight calculation: The PathSim algorithm is used to calculate the semantic similarity of meta-paths. For example, the path derivative → integral → differential equation has a weight of 0.82, and the path derivative → limit → integral has a weight of 0.75.

[0286] ‌Personalized Path Generation‌ Capacity Growth Curve Modeling: Fit a growth curve based on a learner's historical test scores (e.g., weekly quiz scores). Use cubic spline interpolation to generate a continuous curve and extract key metrics: slope (learning rate), curvature (acceleration / deceleration phases), and peak (peak performance). For example, a learner's slope is 0.15 (slow improvement) and curvature is -0.02 (entering a plateau).

[0287] ‌Path Personalization Adaptation‌: Combine meta-path instances with capability curves and match them through the rule engine: ‌High-speed growth stage‌: Long paths (such as 3-jump knowledge points) and challenging content (such as "Differential Equations → Partial Differential Equations") are recommended.

[0288] Bottleneck stage: Recommended review paths (such as "derivatives → integrals") and auxiliary resources (such as "exercise explanation videos").

[0289] For example, a path of integral → exercise reinforcement → differential equation is generated for learners who are in a bottleneck period. The related resources include 5 intensive lecture videos and 3 sets of simulation questions.

[0290] Candidate set storage and indexing: Elasticsearch is used to build a personalized path index. Fields include learner ID, meta-path type, fitness score (e.g., 0.92), and recommendation priority (1-5). Real-time queries are supported, with response times less than 100ms.

[0291] In S2054, the candidate recommendation sequence of the course channel and the candidate set of the personalized path of the learner channel are input into the multi-strategy fusion module, and the cross-channel weight distribution matrix is ​​calculated through the dynamic attention mechanism to generate a personalized teaching comprehensive recommendation strategy with priority sorting.

[0292] Multi-strategy fusion module design Feature alignment and embedding: Map the candidate paths (knowledge point sequences) of a course channel and the personalized paths (meta-path instances) of a learner channel into the same vector space. Use the BERT model (bert-base, 768 dimensions) to encode the path description text (e.g., "derivative → integral → differential equation") and generate semantic vectors (e.g., [0.34, -0.56, ..., 0.78]).

[0293] Dynamic Attention Mechanism: A cross-channel attention layer is designed to calculate the relevance weight between the course path and the learner path. The number of attention heads is 4, and the key / query vector dimension is 64. For example, the attention weight of the course path "derivative → integral" and the learner path "derivative → exercise → integral" is 0.91.

[0294] Weight assignment matrix generation: Softmax normalizes the attention weights to generate an M×N matrix (M = number of course candidates, N = number of learner candidates). For example, the weight of course path 1 and learner path 3 is 0.85, and the weight of course path 1 and learner path 5 is 0.72.

[0295] ‌Comprehensive recommendation strategy generation‌ ‌Multi-objective optimization ranking‌: Define the ranking objective function: Score = 0.6*course path strength + 0.3*learner fitness + 0.1*attention weight.

[0296] For example, if the course intensity of a certain path is 0.88, the learner fit is 0.95, and the attention weight is 0.91, then the score is 0.6*0.88 + 0.3*0.95 + 0.1*0.91 = 0.90.

[0297] Real-time priority scheduling: Sort the top 100 candidate paths based on score and dynamically adjust them according to the teaching scenario: ‌New course introduction phase‌: Prioritize high-intensity paths in the course channel (the course weight in the Score is increased to 0.7).

[0298] ‌Review and consolidation stage‌: Prioritize the recommendation of highly adaptable paths for learner channels (the learner weight ratio is increased to 0.5).

[0299] The final output is a prioritized recommendation list, for example: 1. Derivative → Integral (Score = 0.95); 2. Integral → Differential Equation (Score = 0.89).

[0300] Strategy Visualization and Feedback: Provides a dashboard for teachers, showcasing the relevant knowledge points for recommended paths, historical performance comparisons (e.g., a class's average score increased by 12%), and learner fit heat maps. It also supports manual weighting adjustments (e.g., manually prioritizing a path to the top).

[0301] ‌Application Scenario Examples‌ Scenario description: An online education platform needs to recommend an Advanced Mathematics learning path for learners.

[0302] ‌Course channel generation candidates‌: A path from derivative to integral to differential equation was mapped out through reinforcement learning (course intensity = 0.92, historical improvement effect = 15%).

[0303] Learner channel adaptation: It was detected that the learner was in a bottleneck period (growth curve slope = 0.05), and a personalized path derivative → exercise class → integration was generated (fitness = 0.89).

[0304] Multi-strategy fusion output: Dynamic attention calculation weight matrix, after comprehensive scoring, recommended derivatives → exercise classes → integration → differential equations (Score=0.93), inserted 3 intensive lecture videos and 2 stage tests.

[0305] Based on the topology of knowledge points in the teaching model map (e.g., dependencies, difficulty gradients) and real-time learner feedback (e.g., correct answer rate, interaction duration), we use sequential reinforcement learning (e.g., the DQN algorithm) within the course channel to dynamically plan teaching paths (e.g., prioritizing the recommendation of foundational knowledge points). In the learner channel, we use meta-path reasoning (e.g., "Learning Path A → Competency Improvement B") to analyze the evolution of individual behavior. A dynamic attention mechanism is used to fuse the results of both channels (e.g., 60% course weighting, 40% learner weighting) to generate personalized recommendation strategies (e.g., "Recommend introductory calculus videos for student A"). This allows for real-time adjustment of recommendation priorities to accommodate changes in learning progress, enabling precise and dynamic teaching recommendations. This dual-channel model balances the requirements of the curriculum with the individual needs of learners, improving teaching effectiveness and learning efficiency while avoiding the rigidity and overgeneralization of traditional recommendation systems.

[0306] It can be seen that according to the heterogeneous data streams generated in real time by the multi-source teaching platform, a standardized time series data stream is obtained; based on the standardized time series data stream, the teaching data is classified and encrypted through a dynamic hierarchical storage strategy based on attribute-based encryption to obtain a secure hierarchical storage topology structure; according to user query requests and teaching scenario labels, the target data set is extracted from the secure hierarchical storage topology structure to obtain an enhanced multimodal teaching data set; based on the enhanced multimodal teaching data set, an interpretable teaching mode map is generated through the dynamic subgraph evolution algorithm; according to the teaching mode map and real-time teaching feedback data, a personalized teaching recommendation strategy is generated through the course-learner dual-channel adaptive recommendation model, which can improve the utilization efficiency of teaching resources and realize personalized and intelligent teaching recommendations and decisions.

[0307] Another embodiment of the present invention provides a teaching data management system based on artificial intelligence, see Figure 3 , the system may include: Processing module 301 is used to dynamically parse and normalize heterogeneous data streams generated in real time by the multi-source teaching platform, identify data format features using a bidirectional long short-term memory network, and construct a dynamic interface adapter to obtain a standardized time series data stream; An encryption module 302 is configured to classify and encrypt the teaching data based on the standardized time series data stream using a dynamic hierarchical storage strategy based on attribute-based encryption, compress the unstructured data using a knowledge distillation algorithm, and generate a unique data fingerprint to obtain a secure hierarchical storage topology. Extraction module 303 is used to extract the target data set from the secure hierarchical storage topology structure according to the user query request and the teaching scenario label, jointly embed the text, video, and behavior log data through a multimodal feature fusion network, and use a generative adversarial network to complete the missing features to obtain an enhanced multimodal teaching data set; A mining module 304 is configured to construct a cross-institutional federated knowledge graph based on the enhanced multimodal teaching dataset, mine potential teaching associations using a differentially private graph attention mechanism, and generate an interpretable teaching mode graph using a dynamic subgraph evolution algorithm; The generation module 305 is used to generate a personalized teaching recommendation strategy based on the teaching mode map and real-time teaching feedback data through a course-learner dual-channel adaptive recommendation model, wherein the course-learner dual-channel adaptive recommendation model dynamically adjusts the recommendation weight by integrating temporal reinforcement learning and meta-path reasoning algorithm.

[0308] It can be seen that according to the heterogeneous data streams generated in real time by the multi-source teaching platform, a standardized time series data stream is obtained; based on the standardized time series data stream, the teaching data is classified and encrypted through a dynamic hierarchical storage strategy based on attribute-based encryption to obtain a secure hierarchical storage topology structure; according to user query requests and teaching scenario labels, the target data set is extracted from the secure hierarchical storage topology structure to obtain an enhanced multimodal teaching data set; based on the enhanced multimodal teaching data set, an interpretable teaching mode map is generated through the dynamic subgraph evolution algorithm; according to the teaching mode map and real-time teaching feedback data, a personalized teaching recommendation strategy is generated through the course-learner dual-channel adaptive recommendation model, which can improve the utilization efficiency of teaching resources and realize personalized and intelligent teaching recommendations and decisions.

[0309] An embodiment of the present invention further provides a storage medium storing a computer program, wherein the computer program is configured to execute the steps of any one of the above method embodiments when running.

[0310] Specifically, in this embodiment, the above-mentioned storage medium may be configured to store a computer program for performing the following steps: S201, based on the heterogeneous data streams generated in real time by the multi-source teaching platform, dynamically parse and normalize the heterogeneous data streams, combine the bidirectional long short-term memory network to identify data format features and build a dynamic interface adapter to obtain a standardized time series data stream; S202: Based on the standardized time series data stream, the teaching data is classified and encrypted using a dynamic hierarchical storage strategy based on attribute-based encryption, and a knowledge distillation algorithm is used to compress the unstructured data and generate a unique data fingerprint to obtain a secure hierarchical storage topology structure. S203, extracting a target dataset from the secure hierarchical storage topology structure based on the user query request and the teaching scenario label, jointly embedding the text, video, and behavior log data using a multimodal feature fusion network, and supplementing the missing features using a generative adversarial network to obtain an enhanced multimodal teaching dataset; S204: Based on the enhanced multimodal teaching dataset, a cross-institutional federated knowledge graph is constructed, potential teaching associations are mined using a differentially private graph attention mechanism, and an interpretable teaching mode graph is generated using a dynamic subgraph evolution algorithm. S205, generating a personalized teaching recommendation strategy through a course-learner dual-channel adaptive recommendation model based on the teaching mode map and real-time teaching feedback data, wherein the course-learner dual-channel adaptive recommendation model dynamically adjusts the recommendation weight by integrating temporal reinforcement learning and meta-path reasoning algorithm.

[0311] It can be seen that according to the heterogeneous data streams generated in real time by the multi-source teaching platform, a standardized time series data stream is obtained; based on the standardized time series data stream, the teaching data is classified and encrypted through a dynamic hierarchical storage strategy based on attribute-based encryption to obtain a secure hierarchical storage topology structure; according to user query requests and teaching scenario labels, the target data set is extracted from the secure hierarchical storage topology structure to obtain an enhanced multimodal teaching data set; based on the enhanced multimodal teaching data set, an interpretable teaching mode map is generated through the dynamic subgraph evolution algorithm; according to the teaching mode map and real-time teaching feedback data, a personalized teaching recommendation strategy is generated through the course-learner dual-channel adaptive recommendation model, which can improve the utilization efficiency of teaching resources and realize personalized and intelligent teaching recommendations and decisions.

[0312] An embodiment of the present invention further provides an electronic device, comprising a memory and a processor, wherein the memory stores a computer program, and the processor is configured to run the computer program to perform the steps in any one of the above method embodiments.

[0313] Specifically, the electronic device may further include a transmission device and an input / output device, wherein the transmission device is connected to the processor, and the input / output device is connected to the processor.

[0314] Specifically, in this embodiment, the processor may be configured to execute the following steps through a computer program: S201, based on the heterogeneous data streams generated in real time by the multi-source teaching platform, dynamically parse and normalize the heterogeneous data streams, combine the bidirectional long short-term memory network to identify data format features and build a dynamic interface adapter to obtain a standardized time series data stream; S202: Based on the standardized time series data stream, the teaching data is classified and encrypted using a dynamic hierarchical storage strategy based on attribute-based encryption, and a knowledge distillation algorithm is used to compress the unstructured data and generate a unique data fingerprint to obtain a secure hierarchical storage topology structure. S203, extracting a target dataset from the secure hierarchical storage topology structure based on the user query request and the teaching scenario label, jointly embedding the text, video, and behavior log data using a multimodal feature fusion network, and supplementing the missing features using a generative adversarial network to obtain an enhanced multimodal teaching dataset; S204: Based on the enhanced multimodal teaching dataset, a cross-institutional federated knowledge graph is constructed, potential teaching associations are mined using a differentially private graph attention mechanism, and an interpretable teaching mode graph is generated using a dynamic subgraph evolution algorithm. S205, generating a personalized teaching recommendation strategy through a course-learner dual-channel adaptive recommendation model based on the teaching mode map and real-time teaching feedback data, wherein the course-learner dual-channel adaptive recommendation model dynamically adjusts the recommendation weight by integrating temporal reinforcement learning and meta-path reasoning algorithm.

[0315] It can be seen that according to the heterogeneous data streams generated in real time by the multi-source teaching platform, a standardized time series data stream is obtained; based on the standardized time series data stream, the teaching data is classified and encrypted through a dynamic hierarchical storage strategy based on attribute-based encryption to obtain a secure hierarchical storage topology structure; according to user query requests and teaching scenario labels, the target data set is extracted from the secure hierarchical storage topology structure to obtain an enhanced multimodal teaching data set; based on the enhanced multimodal teaching data set, an interpretable teaching mode map is generated through the dynamic subgraph evolution algorithm; according to the teaching mode map and real-time teaching feedback data, a personalized teaching recommendation strategy is generated through the course-learner dual-channel adaptive recommendation model, which can improve the utilization efficiency of teaching resources and realize personalized and intelligent teaching recommendations and decisions.

[0316] The above describes in detail the structure, features and effects of the present invention based on the embodiments shown in the drawings. The above is only a preferred embodiment of the present invention, but the scope of implementation of the present invention is not limited to what is shown in the drawings. Any changes made in accordance with the concept of the present invention, or modifications to equivalent embodiments with equivalent changes, which do not exceed the spirit covered by the description and drawings, should be within the scope of protection of the present invention.< / sequencing> < / responsedeclaration> < / sequencing> < / adlcp:location> < / adlcp:score> < / adlcp:location> < / sequencing>

Claims

1. A teaching data management method based on artificial intelligence, characterized in that: The method comprises: According to the heterogeneous data streams generated in real time by the multi-source teaching platform, the heterogeneous data streams are dynamically parsed and normalized, and the data format characteristics are identified by combining the bidirectional long short-term memory network and a dynamic interface adapter is constructed to obtain a standardized time series data stream; Based on the standardized time series data stream, the teaching data is classified and encrypted through a dynamic hierarchical storage strategy based on attribute-based encryption, and the knowledge distillation algorithm is used to compress the unstructured data and generate a unique data fingerprint to obtain a secure hierarchical storage topology structure; Based on user query requests and teaching scenario labels, the target dataset is extracted from the secure hierarchical storage topology. The text, video, and behavior log data are jointly embedded and represented using a multimodal feature fusion network. The missing features are supplemented using a generative adversarial network to obtain an enhanced multimodal teaching dataset. Based on the enhanced multimodal teaching dataset, a cross-institutional federated knowledge graph is constructed. A differentially private graph attention mechanism is used to mine potential teaching associations, and an interpretable teaching model graph is generated through a dynamic subgraph evolution algorithm. According to the teaching mode map and real-time teaching feedback data, a personalized teaching recommendation strategy is generated through a course-learner dual-channel adaptive recommendation model, wherein the course-learner dual-channel adaptive recommendation model dynamically adjusts the recommendation weight by integrating temporal reinforcement learning and meta-path reasoning algorithm.

2. The method according to claim 1, characterized in that The method dynamically analyzes and normalizes the heterogeneous data streams generated in real time by the multi-source teaching platform, combines the bidirectional long short-term memory network to identify the data format characteristics and build a dynamic interface adapter to obtain a standardized time series data stream, including: Receive raw data streams from teaching platforms, learning management systems, and online course platforms, extract the temporal features of the raw data streams through a bidirectional long short-term memory network, identify the implicit patterns of the data format, and obtain multi-source data format feature vectors; Based on the multi-source data format feature vector, a density peak clustering algorithm is used to generate a dynamic interface template library, and the optimal interface template is dynamically matched according to the real-time data flow characteristics to obtain the interface adapter initialization parameters; Based on the interface adapter initialization parameters, a lightweight data conversion rule engine is constructed to convert heterogeneous data including SCORM, xAPI, and IMS-QTI into a unified JSON-LD format to obtain intermediate standardized data blocks; The intermediate standardized data blocks are time-aligned, a sliding window mechanism is used to eliminate cross-platform timestamp deviations, and a continuous, conflict-free, standardized time-series data stream is output through an event-driven pipeline.

3. The method according to claim 2, characterized in that Based on the standardized time series data stream, the teaching data is classified and encrypted through a dynamic hierarchical storage strategy based on attribute-based encryption, and a knowledge distillation algorithm is used to compress unstructured data and generate a unique data fingerprint to obtain a secure hierarchical storage topology structure, including: According to the metadata attributes of the standardized time series data stream, the data sensitivity level label is extracted through the attribute-based encryption algorithm, and the access control tree is defined using the CP-ABE strategy to generate a dynamic hierarchical encryption strategy; Based on the dynamic hierarchical encryption strategy, the teaching video data and text log data are classified and encrypted to generate hierarchical ciphertext data blocks; A knowledge distillation algorithm is used for unstructured video data. Key teaching features are extracted through a teacher model, and a lightweight student model is trained to generate compressed feature vectors, which are then output as a lightweight video feature package that retains semantic meaning. ‌The hierarchical ciphertext data blocks and lightweight video feature packages are integrated into a hash chain, a unique data fingerprint is generated based on the content characteristics of the hierarchical ciphertext data blocks, and a secure hierarchical storage topology with access control tags is constructed.

4. The method according to claim 3, characterized in that According to the user query request and the teaching scenario label, the target data set is extracted from the secure hierarchical storage topology structure, the text, video, and behavior log data are jointly embedded and represented through a multimodal feature fusion network, and the adversarial generative network is used to supplement the missing features to obtain an enhanced multimodal teaching data set, including: Based on the keyword vectors and teaching scenario labels in the user query request, the target data is retrieved in the secure hierarchical storage topology structure through a semantic similarity algorithm to generate a candidate data set index table; Based on the candidate dataset index table, a multi-head attention mechanism is used to align text TF-IDF features, video optical flow features, and behavior log temporal features to generate a multimodal joint embedding matrix; The multimodal joint embedding matrix is ​​input into the adversarial generative network. The discriminator identifies the missing feature locations, and the generator reconstructs the missing video key frames and text semantic segments, outputting the completed feature tensor. ‌Adversarial training optimization is performed on the completed feature tensor, and a gradient penalty strategy is used to stabilize the training process to generate an intermediate multimodal dataset with enhanced robustness; ‌A feature decoupling algorithm is used to separate the modality-specific and common information in the intermediate multimodal dataset, and finally an enhanced multimodal teaching dataset with cross-modal association labels is output.

5. The method according to claim 4, characterized in that Based on the enhanced multimodal teaching dataset, a cross-institutional federated knowledge graph is constructed, a differentially private graph attention mechanism is used to mine potential teaching associations, and an interpretable teaching mode graph is generated through a dynamic subgraph evolution algorithm, including: Based on the entity-relationship triples in the enhanced multimodal teaching dataset, we aggregate cross-institutional data through a federated learning framework, use homomorphic encryption technology to protect institutional privacy, and generate an initial federated knowledge graph. Based on the initial federated knowledge graph, a differentially private graph attention mechanism is designed. Laplace noise injection is used to perturb the attention weights between nodes to generate a privacy-safe relationship strength matrix. Based on the relationship strength matrix, a temporal graph convolutional network is used to capture the evolution of teaching patterns. A dynamic community discovery algorithm is used to identify potential teaching association clusters and generate a set of subgraph evolution paths. Perform causal reasoning analysis on the subgraph evolution path, calculate the interpretability score of the teaching model by combining the Bayesian network, and generate an intermediate teaching model map with confidence labels; ‌The graph neural network distillation technology is used to compress the graph size of the intermediate teaching model graph, and finally output an interpretable teaching model graph that supports real-time reasoning.

6. The method according to claim 5, characterized in that According to the teaching mode map and real-time teaching feedback data, a personalized teaching recommendation strategy is generated through a course-learner dual-channel adaptive recommendation model, wherein the course-learner dual-channel adaptive recommendation model dynamically adjusts the recommendation weight by integrating temporal reinforcement learning and meta-path reasoning algorithm, including: Based on the knowledge point dependency relationships in the teaching model map and real-time learner feedback data, we extract the node weights in the course knowledge topology and the temporal characteristics of the learner behavior trajectory, and construct the topological feature map of the course channel and the behavioral evolution sequence of the learner channel. In the course channel, a temporal reinforcement learning algorithm is used to dynamically plan paths on the topological feature graph. A sliding window mechanism is used to capture historical teaching effect data and generate candidate recommendation sequences based on the correlation strength of knowledge points. In the learner channel, a meta-path inference algorithm based on the knowledge graph analyzes the knowledge transition pattern in the learner's behavior evolution sequence and generates a personalized path candidate set that integrates the ability growth curve; The candidate recommendation sequence of the course channel and the personalized path candidate set of the learner channel are input into the multi-strategy fusion module. The cross-channel weight distribution matrix is ​​calculated through the dynamic attention mechanism to generate a personalized teaching comprehensive recommendation strategy with priority sorting.

7. The method according to claim 3, characterized in that The method extracts data sensitivity level labels based on metadata attributes of standardized time-series data streams through attribute-based encryption (ABE) algorithm, defines access control trees using CP-ABE strategy, and generates dynamic hierarchical encryption strategies, including: Based on the metadata attributes of standardized time-series data streams, a multi-dimensional sensitive feature extraction network is used to analyze the privacy relevance of data fields. A hierarchical clustering algorithm is combined with an autoencoder architecture to map student status information, academic records, and classroom behavior logs to different sensitivity levels, outputting a three-dimensional feature vector of data sensitivity. Based on the three-dimensional feature vector of data sensitivity, a dynamic attenuation decision tree is used to generate a fine-grained access strategy. In this strategy, access rights for course video data are divided according to resolution and content sensitivity, and decryption conditions for test data are defined according to the score distribution range. The initial access control rule set with a timestamp is output. Based on the contextual information of real-time teaching scenarios, the initial access control rule set is dynamically modified through the policy evolution engine. When a cross-campus data sharing request is detected, regional constraint attributes are automatically added and two-factor authentication conditions are introduced to generate a time-space-aware enhanced access control tree. The enhanced access control tree is coupled and optimized with the three-dimensional feature vector of data sensitivity. The policy node weights are calculated using an asymmetric bilinear pairing algorithm. The policy public key matrix is ​​generated through elliptic curve encryption technology. Finally, a CP-ABE hierarchical encryption strategy with dynamic attenuation factors and spatiotemporal constraints is output.

8. An artificial intelligence-based teaching data management system, characterized in that: The system comprises: The processing module is used to dynamically parse and normalize the heterogeneous data streams generated in real time by the multi-source teaching platform, identify the data format characteristics by combining the bidirectional long short-term memory network and build a dynamic interface adapter to obtain a standardized time series data stream; An encryption module is used to classify and encrypt teaching data based on the standardized time series data stream through a dynamic hierarchical storage strategy based on attribute-based encryption, compress unstructured data using a knowledge distillation algorithm and generate a unique data fingerprint to obtain a secure hierarchical storage topology structure; An extraction module is used to extract the target dataset from the secure hierarchical storage topology structure based on user query requests and teaching scenario labels, jointly embed the text, video, and behavior log data through a multimodal feature fusion network, and use a generative adversarial network to complete the missing features to obtain an enhanced multimodal teaching dataset; A mining module is used to construct a cross-institutional federated knowledge graph based on the enhanced multimodal teaching dataset, mine potential teaching associations using a differentially private graph attention mechanism, and generate an interpretable teaching mode graph through a dynamic subgraph evolution algorithm; A generation module is used to generate a personalized teaching recommendation strategy based on the teaching mode map and real-time teaching feedback data through a course-learner dual-channel adaptive recommendation model, wherein the course-learner dual-channel adaptive recommendation model dynamically adjusts the recommendation weight by integrating temporal reinforcement learning and meta-path reasoning algorithm.

9. A storage medium, characterized in that: The storage medium stores a computer program, wherein the computer program is configured to execute the method according to any one of claims 1 to 7 when run.

10. An electronic device comprising a memory and a processor, characterized in that: A computer program is stored in the memory, and the processor is configured to run the computer program to perform the method according to any one of claims 1 to 7.

Images