A cognitive state-based brain disease auxiliary screening system

Abstract

This invention provides a cognitive state-based brain disease screening system. It collects multimodal assessment data from individuals to be screened, encompassing temporal behavioral sequences of multiple cognitive tasks and demographic information. Temporal features are extracted using a temporal convolutional network and a self-attention encoder. Demographic information is then concatenated to obtain initial features of graph nodes, which are input into a graph neural network as multidimensional fused data. An individualized weighted adjacency matrix is ​​constructed using a graph structure learning module combined with the cognitive domain's relational topology. Neighborhood node features are weighted and aggregated using a gated aggregation unit, iteratively updating to obtain a graph embedding vector representing the global cognitive state. This embedding vector is input into a classification module, which uses a prototype mapping network to generate dynamic class prototypes. Distance calculations improve the accuracy of disease screening classification. Finally, a visualized cognitive graph is output based on the weighted adjacency matrix, displaying the cognitive domain's influence weights and enabling interpretable screening results.

Description

Technical Field

[0001] This application belongs to the field of intelligent medical auxiliary screening technology, and in particular relates to a brain disease auxiliary screening system based on cognitive state. Background Technology

[0002] With the aging population, the incidence of brain diseases such as Alzheimer's is rising, making early screening crucial for delaying disease progression. Conventional assessments heavily rely on manual intervention or focus solely on test scores, failing to utilize the temporal behavioral sequences generated by individuals completing multiple cognitive tasks. This leads to the loss of significant process information representing early, subtle cognitive impairments. Human cognitive function is a complex network composed of multiple cognitive domains working together. Brain diseases specifically disrupt the topological connections between these domains, but traditional statistical or simple machine learning methods cannot reliably model and detect these high-dimensional topological relationships. Individual demographic information, such as education level and age, has a fundamental impact on cognitive performance. Existing assessment methods fail to deeply integrate and jointly represent this static demographic information with dynamic behavioral characteristics, resulting in significant assessment biases due to individual differences and failing to meet the clinical need for high-precision disease screening.

[0003] Combining temporal deep feature extraction with graph computation structures represents a new technological convergence point for processing multimodal cognitive assessment data and exploring cognitive domain network topologies. Existing models often employ pre-defined, empirically fixed graph structures when constructing graphs, lacking reliable graph structure learning modules. They cannot generate individualized weighted adjacency matrices by incorporating multidimensional fusion features of individuals, thus failing to accurately represent the strength of associations between specific individuals under screening across different cognitive domains. During the feature update iteration phase of graph nodes, traditional GNNs often employ indiscriminate average aggregation, lacking gating mechanisms based on the relevance of neighborhood information to the update target. This prevents the generation of weights for weighted aggregation and makes them highly susceptible to irrelevant noise input. Most current screening and classification networks are "black box" models, lacking class prototypes based on demographic differences to address intra-class feature shifts. Existing technologies cannot generate visualized cognitive graphs containing cognitive domain influence weights at the output based on the final layer structure, resulting in screening results lacking intuitive pathological and clinical interpretability. Summary of the Invention

[0004] To address the problems of existing technologies, such as over-reliance on scale scores while ignoring procedural temporal behavioral information of cognitive tasks, difficulty in modeling individualized topological relationships between different cognitive tasks or cognitive domains, inability to incorporate demographic information to correct for individual baseline differences, lack of correlation gating mechanisms in graph neural network neighborhood aggregation, and insufficient interpretability of screening results, this invention provides a cognitive state-based brain disease auxiliary screening system.

[0005] The first aspect of this disclosure provides a cognitive state-based brain disease-assisted screening system, comprising: The acquisition module is used to acquire multimodal assessment data of the individuals to be screened. The multimodal assessment data includes temporal behavioral sequences of multiple cognitive tasks and demographic information. Through a temporal convolutional network and a self-attention mechanism encoder, the temporal behavioral sequences of each cognitive task are extracted into task-level temporal feature vectors. The task-level temporal feature vectors are then concatenated with the demographic information to serve as the initial feature vectors of each corresponding graph node, thereby providing the graph neural network with initial input data for nodes that integrate multidimensional information. A generation module is used to construct a graph neural network to iteratively update the graph node features. A graph structure learning module calculates the node relationship strength and fuses a preset cognitive domain association topology to generate an individualized weighted adjacency matrix. The preset cognitive domain association topology is encoded as a prior knowledge matrix and weighted and fused with a data-driven learned node relationship strength matrix. Based on the individualized weighted adjacency matrix, a gated aggregation unit calculates the correlation between neighborhood information and the update target, generating weights for weighted aggregation of neighboring nodes. The gated aggregation unit generates final gate weights based on the features of the central node, neighboring node features, and corresponding adjacency weights. Features are updated based on the aggregation results to obtain a graph embedding vector, which represents the global cognitive state of an individual. The output module is used to input the graph embedding vector into the classification module, generate dynamic class prototypes based on demographic information using a prototype mapping network, calculate the distance between the embedding vector and each dynamic class prototype to output the disease screening results, thereby improving the accuracy of disease-assisted screening classification; based on the weighted adjacency matrix output by the last layer of the graph neural network, a visual cognitive graph containing cognitive domain influence weights is generated to provide an interpretation basis for the disease screening results.

[0006] Preferably, the encoder, which uses a temporal convolutional network and a self-attention mechanism, extracts the temporal behavior sequences of each cognitive task into task-level temporal feature vectors, including: For each cognitive task, a temporal convolutional network is used to perform convolution operations on the input temporal behavior sequence at multiple scales to extract local temporal features; The local temporal features are input into the self-attention mechanism module, and query vector, key vector and value vector are generated through linear mapping. Using a self-attention mechanism, the product of the query vector and the transpose of the key vector is divided by the square root of the key vector dimension, processed by a normalized exponential function, and then multiplied by the value vector to calculate the global dependency and output the temporal feature matrix. The temporal feature matrix is ​​then processed by average pooling, max pooling, or attention pooling along the time dimension to obtain the task-level temporal feature vector.

[0007] Preferably, the step of calculating the node relationship strength through the graph structure learning module and generating an individualized weighted adjacency matrix by fusing a preset cognitive domain association topology includes: The node features of the current layer are mapped to the relation space by a multilayer perceptron, and the inner product of the pairwise node feature vectors is calculated as the initial relation strength. The pre-defined cognitive domain association topology is encoded into a prior knowledge matrix; The initial relation strength and the prior knowledge matrix are weighted and fused according to a preset balance coefficient, and the weighted fused matrix is ​​normalized to generate the individualized weighted adjacency matrix of the current layer. Element-by-element addition can be used as another simplified fusion method.

[0008] Preferably, the step of calculating the correlation between neighborhood information and the update target using a gated aggregation unit based on the individualized weighted adjacency matrix, and generating weights for weighted aggregation of neighboring nodes, includes: The neighboring nodes are determined based on the individualized weighted adjacency matrix. The features of the center node and the features of the neighboring nodes are concatenated, and the attention score is calculated through a fully connected layer with an activation function, or the attention score is calculated through the dot product of the features of the center node and the features of the neighboring nodes. The attention score and the corresponding adjacency weight in the individualized weighted adjacency matrix are used together as the aggregation weight, and multiplied with the corresponding neighbor node features to obtain the weighted neighborhood features. The weighted features of the neighborhood are summed to complete the weighted aggregation of neighbor node information.

[0009] Preferably, updating the features based on the aggregation result to obtain the graph embedding vector includes: Multiply the feature matrix of the current layer's aggregation result with the learnable weight matrix of the current layer, and after processing with a non-linear activation function, update the node feature matrix of the next layer; The graph neural network's final layer outputs all node features, which are then processed by a global pooling layer to reduce dimensionality, generating the graph embedding vector.

[0010] Preferably, the step of generating dynamic class prototypes based on demographic information using a prototype mapping network includes: Demographic information is input into a multilayer perceptron for feature extraction, and a demographic representation vector is output. For each preset disease category, set a base class prototype vector; The demographic representation vector is linearly combined with each basic class prototype vector to generate a dynamic class prototype for the current individual's characteristics.

[0011] Preferably, calculating the distance between the embedding vector and each dynamic class prototype to output the disease screening result includes: Calculate the Euclidean distance between the graph embedding vector and each of the dynamic class prototypes; The negative values ​​of all Euclidean distances are used as the classification log odds, and the probability values ​​of the current individual belonging to each disease category are calculated by normalizing the exponential function. The disease category with the highest probability value is used as the output disease screening result.

[0012] Preferably, the step of generating a visualized cognitive graph containing cognitive domain influence weights based on the weighted adjacency matrix output from the final layer of the graph neural network includes: Extract the element values ​​from the final layer weighted adjacency matrix and use them as the edge weights between different cognitive nodes; A directed or undirected weighted graph is constructed based on the weighted adjacency matrix of the last layer, and the importance score of each cognitive node is calculated using the PageRank algorithm or the weighted degree centrality algorithm. The thickness and color transparency of the edges in the visualization graph are set according to the weight of the edges, and the size of the node area and the color depth of the node in the visualization graph are set according to the importance score. Each cognitive node and its associated edges with a set style are rendered onto the interface to generate the visualized cognitive graph containing the influence weights of the cognitive domain.

[0013] The second aspect of this disclosure provides a method for assisting in the screening of brain diseases based on cognitive states, comprising: Multimodal assessment data of individuals to be screened is obtained, including temporal behavioral sequences of multiple cognitive tasks and demographic information. The temporal behavioral sequences of each cognitive task are extracted into task-level temporal feature vectors through a temporal convolutional network and a self-attention mechanism encoder. The task-level temporal feature vectors are then concatenated with the demographic information to serve as the initial feature vectors of each corresponding graph node, thereby providing the graph neural network with initial node input data that integrates multidimensional information. A graph neural network is constructed to iteratively update the features of graph nodes. The strength of node relationships is calculated through a graph structure learning module, and a personalized weighted adjacency matrix is ​​generated by fusing the pre-defined cognitive domain association topology. Based on the personalized weighted adjacency matrix, a gated aggregation unit is used to calculate the correlation between neighborhood information and the update target, and weights are generated to aggregate neighboring nodes in a weighted manner. The features are updated according to the aggregation results to obtain a graph embedding vector, which is used to represent the global cognitive state of an individual. The embedded vector of the graph is input into the classification module. A prototype mapping network is used to generate dynamic class prototypes based on demographic information. The distance between the embedded vector and each dynamic class prototype is calculated to output the disease screening results, which helps to improve the accuracy of disease-assisted screening classification. Based on the weighted adjacency matrix output by the last layer of the graph neural network, a visual cognitive graph containing the influence weights of the cognitive domain is generated to provide an interpretation basis for the disease screening results.

[0014] Optionally, the encoder, which uses a temporal convolutional network and a self-attention mechanism, extracts the temporal behavior sequences of each cognitive task into task-level temporal feature vectors, including: For each cognitive task, a temporal convolutional network is used to perform convolution operations on the input temporal behavior sequence at multiple scales to extract local temporal features; The local temporal features are input into the self-attention mechanism module, and query vector, key vector and value vector are generated through linear mapping. Using a self-attention mechanism, the product of the query vector and the transpose of the key vector is divided by the square root of the key vector dimension, processed by a normalized exponential function, and then multiplied by the value vector to calculate the global dependency and output the temporal feature matrix. The temporal feature matrix is ​​then processed by average pooling, max pooling, or attention pooling along the time dimension to obtain the task-level temporal feature vector.

[0015] Optionally, the step of calculating the node relationship strength through the graph structure learning module and generating an individualized weighted adjacency matrix by fusing a preset cognitive domain association topology includes: The node features of the current layer are mapped to the relation space by a multilayer perceptron, and the inner product of the pairwise node feature vectors is calculated as the initial relation strength. The pre-defined cognitive domain association topology is encoded into a prior knowledge matrix; The initial relation strength and the prior knowledge matrix are weighted and fused according to a preset balance coefficient, and the weighted fused matrix is ​​normalized to generate the individualized weighted adjacency matrix of the current layer. Element-by-element addition can be used as another simplified fusion method.

[0016] Optionally, the step of calculating the correlation between neighborhood information and the update target using a gated aggregation unit based on the individualized weighted adjacency matrix, and generating weights for weighted aggregation of neighboring nodes, includes: The neighboring nodes are determined based on the individualized weighted adjacency matrix. The features of the center node and the features of the neighboring nodes are concatenated, and the attention score is calculated through a fully connected layer with an activation function, or the attention score is calculated through the dot product of the features of the center node and the features of the neighboring nodes. The attention score and the corresponding adjacency weight in the individualized weighted adjacency matrix are used together as the aggregation weight, and multiplied with the corresponding neighbor node features to obtain the weighted neighborhood features. The weighted features of the neighborhood are summed to complete the weighted aggregation of neighbor node information.

[0017] Optionally, updating the features based on the aggregation result to obtain the graph embedding vector includes: Multiply the feature matrix of the current layer's aggregation result with the learnable weight matrix of the current layer, and after processing with a non-linear activation function, update the node feature matrix of the next layer; The graph neural network's final layer outputs all node features, which are then processed by a global pooling layer to reduce dimensionality, generating the graph embedding vector.

[0018] Optionally, the step of generating dynamic class prototypes based on demographic information using a prototype mapping network includes: Demographic information is input into a multilayer perceptron for feature extraction, and a demographic representation vector is output. For each preset disease category, set a base class prototype vector; The demographic representation vector is linearly combined with each basic class prototype vector to generate a dynamic class prototype for the current individual's characteristics.

[0019] Optionally, calculating the distance between the embedding vector and each dynamic class prototype to output the disease screening result includes: Calculate the Euclidean distance between the graph embedding vector and each of the dynamic class prototypes; The negative values ​​of all Euclidean distances are used as the classification log odds, and the probability values ​​of the current individual belonging to each disease category are calculated by normalizing the exponential function. The disease category with the highest probability value is used as the output disease screening result.

[0020] Optionally, the step of generating a visualized cognitive map containing cognitive domain influence weights based on the weighted adjacency matrix output from the final layer of the graph neural network includes: Extract the element values ​​from the final layer weighted adjacency matrix and use them as the edge weights between different cognitive nodes; A directed or undirected weighted graph is constructed based on the weighted adjacency matrix of the last layer, and the importance score of each cognitive node is calculated using the PageRank algorithm or the weighted degree centrality algorithm. The thickness and color transparency of the edges in the visualization graph are set according to the weight of the edges, and the size of the node area and the color depth of the node in the visualization graph are set according to the importance score. Each cognitive node and its associated edges with a set style are rendered onto the interface to generate the visualized cognitive graph containing the influence weights of the cognitive domain.

[0021] This invention, in the feature update stage of a graph neural network, generates an individualized weighted adjacency matrix by combining a preset cognitive domain association topology and node relationship strength. It then utilizes a gated aggregation unit to calculate the relevance of neighborhood information for weight allocation and feature aggregation, uncovering deep and complex relationships between different cognitive tasks, thus more fully representing an individual's global cognitive state. A personalized classification prototype is constructed using a prototype mapping network combined with individual demographic features, and the classification accuracy for brain disease screening is improved through feature distance measurement. A visualized cognitive atlas is generated based on the weighted adjacency matrix output from the final layer of the model, presenting the influence weights of each cognitive domain, enhancing the clinical transparency, reliability, and practical value of this assisted screening technology. Attached Figure Description

[0022] Figure 1 This is a schematic diagram of the attention score matrix; Figure 2 A schematic diagram of a personalized weighted adjacency matrix; Figure 3 This is a schematic diagram of a cognitive network. Figure 4 This is a diagram illustrating the performance comparison of the screening models. Detailed Implementation

[0023] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0024] In a first embodiment, the present invention proposes a cognitive state-based brain disease assisted screening system, comprising: The acquisition module is used to acquire multimodal assessment data of the individuals to be screened. The multimodal assessment data includes temporal behavioral sequences of multiple cognitive tasks and demographic information. Through a temporal convolutional network and a self-attention mechanism encoder, the temporal behavioral sequences of each cognitive task are extracted into task-level temporal feature vectors. The task-level temporal feature vectors are then concatenated with the demographic information to serve as the initial feature vectors of each corresponding graph node, thereby providing the graph neural network with initial node input data that integrates multidimensional information.

[0025] The system reads tabular files containing multimodal evaluation data stored locally or in the cloud. This data is divided into temporal behavior sequences recording task execution behaviors such as eye-tracking trajectories, mouse movement trajectories, and reaction times, and demographic information such as age, gender, years of education, and underlying medical history. For continuous data, missing values ​​are imputed using the mean, and zero-mean standardization is performed using the StandardScaler algorithm. For discrete demographic information such as gender and underlying medical history, mode imputation, missing category labeling, one-hot encoding, or embedding encoding are used to convert them into numerical features. For continuous data such as age, years of education, reaction time, and trajectory coordinates, standardization is performed separately to eliminate the influence of different units on model training. Within the PyTorch deep learning framework, a temporal convolutional network is constructed to extract local temporal dependency features, and a self-attention mechanism is constructed to detect global long-range dependencies. The standardized temporal behavior sequences are input into an encoder composed of these two components to calculate task-level temporal feature vectors. A multilayer perceptron is used to nonlinearly map demographic information, outputting a demographic feature vector with the same dimension as the task-level temporal feature vector. The task-level temporal feature vector and the demographic feature vector are concatenated along the feature dimension to output an initial feature vector that integrates multidimensional information. This initial feature vector is then assigned to the corresponding graph node when constructing the graph data object as the initial input data for that node. Graph nodes correspond to different cognitive tasks. The demographic feature vector of the same individual to be screened is concatenated to each cognitive task node, ensuring that each task node represents features under the same demographic conditions. This serves as the conditional input for the subsequent model learning of the influence of individual baseline differences. This process helps reduce feature bias caused by demographic differences and provides unified individual background information for the graph neural network to integrate multi-task cognitive states.

[0026] In one possible embodiment, the encoder, which uses a temporal convolutional network and a self-attention mechanism, extracts the temporal behavior sequences of each cognitive task into task-level temporal feature vectors, including: For each cognitive task, a temporal convolutional network is used to perform convolution operations on the input temporal behavior sequence at multiple scales to extract local temporal features; The local temporal features are input into the self-attention mechanism module, and query vector, key vector and value vector are generated through linear mapping. Using a self-attention mechanism, the product of the query vector and the transpose of the key vector is divided by the square root of the key vector dimension, processed by a normalized exponential function, and then multiplied by the value vector to calculate the global dependency and output the temporal feature matrix. The temporal feature matrix is ​​then processed by average pooling, max pooling, or attention pooling along the time dimension to obtain the task-level temporal feature vector.

[0027] For temporal behavior sequences collected from various cognitive tasks, eye-tracking trajectories and mouse movement trajectories, as continuous trajectory sequences, can be formed according to sampling time, for example, with a sampling rate of 100Hz and a sequence length T typically ranging from 1000 to 5000. Reaction time, as an event response sequence, is not processed by continuous sampling at 100Hz, but rather by statistical results based on trial order, task stage, or fixed time window to form an event response sequence of length M. For continuous trajectory sequences and event response sequences, preset input lengths can be set according to data type, and aligned to the corresponding preset length L through padding, truncation, interpolation, or masking. When padding is used, masking is introduced during self-attention calculation and pooling to prevent padding values ​​from participating in attention weight normalization and task-level feature aggregation. The sequences are then input into a temporal convolutional network containing multiple dilated convolutional layers.

[0028] Temporal convolutional networks (TCNNs) are neural network models specifically designed for processing time-series data. The network structure includes one-dimensional fully convolutional layers and dilated causal convolutional layers. The input to the network is a sequence of temporal behaviors for various cognitive tasks, including continuous trajectory sequences and event response sequences. The output of the network is local temporal features within different temporal receptive fields. Preferably, the temporal convolutional network employs three layers of dilated causal convolutions with dilation factors of 1, 2, and 4, and a kernel size of 3, thereby obtaining local temporal features within different temporal receptive fields without losing temporal order. The preferred feature dimension is 64. This local temporal feature is then input into the self-attention mechanism module. The self-attention mechanism module is a network model for calculating internal dependencies within a sequence. Its structure includes a linearly mapped fully connected layer and a dot-product attention layer. The input to this network is the local temporal feature, and the output is a feature containing global dependencies. In the self-attention mechanism module, three independent linearly mapped fully connected layer weight matrices, each with a dimension of 64×64, are used to generate a query vector Q, a key vector K, and a value vector V, all with a dimension of L×64. To detect global dependencies between long-distance behavioral data, scaled dot-product attention is performed. The query vector Q is multiplied by the transpose of the key vector K, K^T, to obtain an attention scoring matrix of size L×L. Each element of this matrix is ​​divided by the square root of the key vector's feature dimension, i.e., 8, to reduce the risk of excessively large dot product values ​​leading to saturation of the normalization exponential function and excessively small gradients. After masking the attention scores corresponding to the filling positions, the normalization exponential function is applied along each row for probability normalization, resulting in a weight matrix. This weight matrix is ​​multiplied by the value vector V to fuse global temporal dependency information. After residual connections and layer normalization, a temporal feature matrix of dimension L×64 is output. Average pooling, max pooling, or attention pooling is then performed along the time dimension of this temporal feature matrix, ignoring the filling positions corresponding to the masked positions during pooling, resulting in a task-level temporal feature vector of dimension 1×64. The self-attention mechanism detects global dependencies in the behavior sequence by calculating the similarity between the query vector and the key vector, generating features such as... Figure 1 The attention score matrix shown indicates that higher values ​​for matrix elements represent stronger correlations between corresponding time steps.

[0029] The generation module is used to construct a graph neural network to iteratively update the features of graph nodes. It calculates the strength of node relationships through a graph structure learning module and integrates the pre-defined cognitive domain association topology to generate an individualized weighted adjacency matrix. Based on the individualized weighted adjacency matrix, a gated aggregation unit is used to calculate the correlation between neighborhood information and the update target, and weights are generated to aggregate neighboring nodes in a weighted manner. The features are updated according to the aggregation results to obtain a graph embedding vector, which is used to represent the global cognitive state of an individual.

[0030] A graph neural network model is initialized within the PyTorchGeometric graph deep learning framework. A graph structure learning module based on metric learning is constructed. A multilayer perceptron is built to first map the feature vectors of any two graph nodes to relation representation vectors, and then calculate the inner product similarity between the relation representation vectors. A preset cognitive domain association topology is constructed based on medical expert knowledge, and the preset cognitive domain association topology is encoded into a cognitive domain prior knowledge matrix. Weighted fusion calculation is performed using preset balance coefficients or learnable balance coefficients constrained to the range of 0 to 1 by the Sigmoid function. After numerical normalization, an individualized weighted adjacency matrix is ​​generated. In the information transmission process of each layer of the graph neural network, a gated aggregation unit is constructed. An attention scoring function is called to calculate the correlation score between the features of neighboring nodes and the features of the central target node. The attention scoring function can adopt dot product attention or concatenated fully connected attention as alternative implementations. The correlation score is converted into aggregation weights, and combined with the adjacency prior weights represented by the corresponding elements in the individualized weighted adjacency matrix, the final aggregation weights are determined. Based on the connection relationship indicated by the individualized weighted adjacency matrix, the features of neighboring nodes are weighted and aggregated. The aggregated neighbor context features and the features from the previous layer of the central target node are input into a gated recurrent unit constructed using `torch.nn.GRUCell`. The updated features of the current layer nodes are calculated. After a preset number of graph network layer iterations, a global average pooling algorithm is called to average the final layer features of all nodes, outputting a graph embedding vector representing the individual's global cognitive state. The individualized weighted adjacency matrix generated in the last layer is retained for subsequent visualization of the cognitive graph. The elements in this matrix can be used as edge weights between cognitive nodes, and mapped to edge thickness, color depth, or transparency during subsequent visualization. In one implementation, `GRUCell` is used for gated updates; in another alternative implementation, a linear transformation combined with a non-linear activation function is used for node feature updates. During the model training phase, training samples with screening category labels are used to train the classification output through classification cross-entropy loss. The parameters of the temporal convolutional network, self-attention module, graph structure learning module, gated aggregation unit, and classification module can be jointly optimized by combining the metric learning loss based on the distance between the graph embedding vector and the category prototype. During the model inference phase, the graph embedding vector and the individualized weighted adjacency matrix of the last layer are output using the trained parameters.

[0031] In one possible embodiment, the step of calculating the node relationship strength through the graph structure learning module and fusing the preset cognitive domain association topology to generate an individualized weighted adjacency matrix includes: The node features of the current layer are mapped to the relation space by a multilayer perceptron, and the inner product of the pairwise node feature vectors is calculated as the initial relation strength. The pre-defined cognitive domain association topology is encoded into a prior knowledge matrix; The initial relation strength and the prior knowledge matrix are weighted and fused according to a preset balance coefficient, and the weighted fused matrix is ​​normalized to generate the individualized weighted adjacency matrix of the current layer. Element-by-element addition can be used as another simplified fusion method.

[0032] In the graph structure learning phase, assuming the number of graph nodes is N (e.g., N=10 representing 10 cognitive task nodes), these cognitive task nodes can be labeled as cognitive domain-related tasks such as attention, memory, and executive function. The feature dimension of the node feature matrix in the current layer l is preferably 128. A multilayer perceptron (MLP) is used to project the node features into a latent relation space. The MLP is a feedforward artificial neural network model. Its structure includes an input layer, multiple hidden layers, and an output layer, with fully connected nodes between adjacent layers. The input to the network is the node features of the current layer, and the output is a relation representation matrix mapped to the latent relation space. The MLP is preferably two-layered, with hidden layer dimensions of 128 and 64 respectively, and the activation function is ReLU. Projection yields a relation representation matrix in a latent relation space with a dimension of 64. The inner product of this relation matrix and its transpose is calculated to obtain an initial relation strength matrix. The elements in the initial relation strength matrix represent the data-driven relation strength between corresponding two nodes. Finally, the preset cognitive domain association topology is uniformly encoded into an N×N binary or continuous prior knowledge matrix. A pre-defined cognitive domain association topology is constructed using neuropsychological scales. This topology is encoded as an N×N binary or continuous prior knowledge matrix. For example, if attention and memory are clinically strongly correlated, the corresponding position weight is set to 0.8; otherwise, it is 0.2. Before fusion, the initial relationship strength matrix and the prior knowledge matrix can be normalized to ensure they are on comparable numerical scales. The data-driven initial relationship strength matrix and the prior knowledge matrix are then weighted and fused using a hyperparameter λ, for example, according to F= A fusion process is performed, where S represents the initial relation strength matrix, P represents the prior knowledge matrix, and F represents the fused relation matrix. The balance coefficient λ is preferably in the range of 0 to 1, with an example value of 0.5. The fused matrix is ​​then normalized row-wise using a normalized exponential function. That is, for each row, the values ​​of all columns are summed after exponential mapping to ensure that the sum of the connection weights of a single node with all other nodes is 1. This process not only preserves medical prior rules but also detects the association characteristics of specific individuals to be screened, thus outputting an N×N individualized weighted adjacency matrix for the current layer. Combining data-driven relation strength and clinical prior topology, the generated individualized weighted adjacency matrix is ​​as follows: Figure 2 As shown, the matrix element values ​​represent the association weights between different cognitive domains.

[0033] In one possible embodiment, the step of calculating the correlation between neighborhood information and the update target using a gated aggregation unit based on the individualized weighted adjacency matrix, and generating weights for weighted aggregation of neighboring nodes, includes: The neighboring nodes are determined based on the individualized weighted adjacency matrix. The features of the center node and the features of the neighboring nodes are concatenated, and the attention score is calculated through a fully connected layer with an activation function, or the attention score is calculated through the dot product of the features of the center node and the features of the neighboring nodes. The attention score and the corresponding adjacency weight in the individualized weighted adjacency matrix are used together as the aggregation weight, and multiplied with the corresponding neighbor node features to obtain the weighted neighborhood features. The weighted features of the neighborhood are summed to complete the weighted aggregation of neighbor node information.

[0034] For any central node i in the graph, the preset neighbor selection rules include selecting the top K neighbor nodes with the largest weights, selecting nodes with weights greater than a preset sparsity threshold, or a combination of both. When no neighbor node satisfies the threshold, the central node's self-loop or at least one neighbor node with the largest weight is retained. During the gated aggregation process, the feature vector of the 128-dimensional central node is concatenated with the feature vectors of each 128-dimensional neighbor node along the feature dimension, forming a combined feature vector of dimension 256. This concatenated feature is input into a single fully connected layer with shared weights. The weight vector of this fully connected layer has a dimension of 256×1, and a LeakyReLU activation function with a negative half-axis slope parameter preferably set to 0.2 is used to calculate a scalar form of the original relevance score. To make the weights of different neighbors comparable, the original scores of all neighbors of the central node are normalized using a normalized exponential function to obtain attention scores ranging from 0 to 1. The attention score is multiplied or weighted and fused with the corresponding adjacency weights in the individualized weighted adjacency matrix, and then normalized again to obtain the final gating weight coefficients. The calculated final gating weight coefficients are then multiplied by a scalar and vector operation with the corresponding neighbor node feature matrix processed by a 128×128 linear transformation matrix to obtain the weighted neighborhood features of each neighbor node towards the central node. A summation pooling operation is performed within the local topology, summing all attention-weighted neighbor features. This gating aggregation mechanism architecture allows the model to assign a higher feature transfer weight to neighboring cognitive nodes highly relevant to disease screening.

[0035] In one possible embodiment, updating the features based on the aggregation result to obtain the graph embedding vector includes: Multiply the feature matrix of the current layer's aggregation result with the learnable weight matrix of the current layer, and after processing with a non-linear activation function, update the node feature matrix of the next layer; The graph neural network's final layer outputs all node features, which are then processed by a global average pooling layer to reduce dimensionality, generating the graph embedding vector.

[0036] After obtaining the weighted and aggregated neighborhood features of the central node, these neighborhood features are concatenated or added to the original features of the central node to form an aggregated feature matrix. When using addition, the dimension of the aggregated feature matrix remains 128, allowing matrix multiplication with a 128×128 learnable weight matrix. When using concatenation, the dimension of the aggregated feature matrix is ​​256, which can be reduced to 128 via linear mapping or multiplied using a 256×128 learnable weight matrix. This aggregated feature matrix is ​​then input into a feature update module, where it is multiplied with the learnable weight matrix of the current layer's graph neural network. A graph neural network is a deep learning model specifically designed for graph-structured data. Its structure includes an information transfer layer, a feature aggregation layer, and a state update layer. The network's input consists of the node feature matrix and adjacency matrix in the graph structure, and its output is a node feature matrix aggregating local and multi-order neighborhood topological information. The size of the learnable weight matrix is ​​set according to the input dimension of the aggregated feature matrix and initialized using a Xavier uniform distribution. The product result is then passed to a nonlinear activation function such as ReLU or ELU to introduce a nonlinear transformation and enhance the expressive power of the feature space, thereby outputting the node feature matrix of the next layer after dimension update. This feature update process is usually repeated 2 to 3 times, that is, a 2 to 3-layer graph neural network structure is used to ensure that neighborhood cognitive association information with multiple hop counts can be aggregated. When the graph neural network completes all forward propagation and reaches the final layer, such as the 3rd layer, it outputs a set of node features containing high-order topology and feature interaction information, with a size of N×128, where N is the total number of graph nodes. The input graph layer is a global average pooling layer, which performs mean feature compression operation along the node number dimension. For example, by applying global average pooling, the mean of the corresponding dimensional features of all N nodes is taken, thereby eliminating the redundancy of the node dimensions and generating a single-dimensional graph embedding vector of size 1×128.

[0037] The output module is used to input the graph embedding vector into the classification module, generate dynamic class prototypes based on demographic information using a prototype mapping network, calculate the distance between the embedding vector and each dynamic class prototype to output the disease screening results, thereby improving the accuracy of disease-assisted screening classification; based on the weighted adjacency matrix output by the last layer of the graph neural network, a visual cognitive graph containing cognitive domain influence weights is generated to provide an interpretation basis for the disease screening results.

[0038] A prototype mapping network module is constructed, inputting demographic information feature vectors into a feedforward neural network containing nonlinear activation function layers. This maps and generates multiple dynamic prototype feature vectors corresponding to different screening categories, such as healthy control groups, mild cognitive impairment, and Alzheimer's disease. The same demographic information can be used as individual background conditions for the initial features of nodes during the front-end node construction stage, and also as conditions for generating dynamic prototypes during the output classification stage. The former constrains the feature expression of each cognitive task node, while the latter adjusts the classification reference for different screening categories. These are different network branches using the same demographic information and do not constitute duplication or conflict. The Euclidean distance between the graph embedding vector representing the global cognitive state and the aforementioned dynamic prototype feature vectors is calculated. The calculated distance values ​​are negative and input into a Softmax function to transform them into predicted probability distributions for each screening category. The category with the highest probability value is output as the disease screening classification result. Extract the individualized weighted adjacency matrix generated by the last layer of the graph neural network and use it as the final layer weighted adjacency matrix. Transform this matrix into a graph structure data object, call the PageRank algorithm to calculate the importance score of each cognitive task node in the graph structure, and render the network topology graph. Use the importance score to determine the size of the node area and the color intensity of the node in the rendered graph, and use the weight values ​​of the adjacency matrix to determine the thickness and transparency of the lines between nodes. Export a visualized cognitive graph image file containing the influence weights of the cognitive domain.

[0039] In one possible embodiment, generating dynamic class prototypes based on demographic information using a prototype mapping network includes: Demographic information is input into a multilayer perceptron for feature extraction, and a demographic representation vector is output. For each preset disease category, set a base class prototype vector; The demographic representation vector is linearly combined with each basic class prototype vector to generate a dynamic class prototype for the current individual's characteristics.

[0040] In the dynamic prototype generation mechanism, preprocessed demographic information of the individuals to be screened, including age, gender, years of education, and basic medical history, is received. This information is standardized, one-hot encoded, or embedded to form a vector, with an example dimension of 1×10. This information vector is then input into a prototype mapping network, a neural network model used to map input features to a specific category prototype space. This network structure includes a feature extraction module and a linear combination mapping module. The input to this network is the demographic information of the individuals to be screened, and the output is a dynamic class prototype vector representing the current individual's features. The prototype mapping network uses a multilayer perceptron module for feature extraction. This module preferably contains two hidden layers with 32 and 64 nodes respectively, with a batch normalization layer and a ReLU activation function embedded in between. An output projection layer is set after the second hidden layer, mapping the 64-dimensional hidden layer representation to a 1×128 demographic representation vector. The multilayer perceptron nonlinearly maps the original demographic attributes to a high-dimensional space matching the disease features, outputting a 1×128 demographic representation vector. Within the model's global parameter space, for three pre-defined screening categories—healthy controls, mild cognitive impairment, and Alzheimer's disease—a learnable base class prototype vector is randomly initialized and maintained based on a standard normal distribution. The dimension of each base class prototype is also set to 1×128. A linear combination is performed using a vector weighting strategy. For example, the learnable combination coefficients corresponding to the categories are preferably used. , During training, it is updated together with the base class prototype vector; as an alternative implementation, a globally shared combination coefficient β can also be used. An addition operation is performed, expressed as the current category's base class prototype vector plus β or... A demographic representation vector is generated, where β is 0.1 for each instance. After linear adjustment mapping, individualized dynamic class prototypes with a dimension of 1×128 are generated for the three preset categories mentioned above.

[0041] In one possible embodiment, calculating the distance between the embedding vector and each dynamic class prototype to output disease screening results includes: Calculate the Euclidean distance between the graph embedding vector and each of the dynamic class prototypes; The negative values ​​of all Euclidean distances are used as the classification log odds, and the probability values ​​of the current individual belonging to each disease category are calculated by normalizing the exponential function. The disease category with the highest probability value is used as the output disease screening result.

[0042] The classification module obtains the individual atlas embedding vector of size 1×128 output from the previous step, as well as multiple dynamic class prototype vectors (e.g., three corresponding to different disease states) generated for the current individual. It then calculates the Euclidean distance (L2 norm distance) in 128-dimensional space between each atlas embedding vector and the aforementioned three dynamic class prototypes to represent the degree of geometric spatial difference between the individual's global cognitive state and the individualized baseline of the screening category. Assuming the calculated Euclidean distance values ​​are as follows... =5.2、 =2.1、 =8.4. To convert the above distance metrics into standard classification probabilities, the negatives of each Euclidean distance, namely -5.2, -2.1, and -8.4, are taken as the log-odds input for the classification module. This set of negative log-odds is fed into the normalized exponential function calculation layer, where the exponential terms of all negative distances for each class are summed and normalized by division. Using the above exponential mapping formula, the output probability distribution of the current individual belonging to the above three preset categories can be obtained. For example, the calculated probability distribution is... =0.043、 =0.955、 =0.002. The maximum probability value, 0.955, is extracted using the maximum index function to obtain the category label, such as Category 2 mild cognitive impairment. This category label is then output as the screening classification result with the highest probability value, thus providing the disease-assisted screening classification result.

[0043] In one possible embodiment, generating a visualized cognitive graph containing cognitive domain influence weights based on the weighted adjacency matrix output from the final layer of the graph neural network includes: Extract the element values ​​from the final layer weighted adjacency matrix and use them as the edge weights between different cognitive nodes; A directed or undirected weighted graph is constructed based on the weighted adjacency matrix of the last layer, and the importance score of each cognitive node is calculated using the PageRank algorithm or the weighted degree centrality algorithm. The thickness and color transparency of the edges in the visualization graph are set according to the weight of the edges, and the size of the node area and the color depth of the node in the visualization graph are set according to the importance score. Each cognitive node and its associated edges with a set style are rendered onto the interface to generate the visualized cognitive graph containing the influence weights of the cognitive domain.

[0044] To ensure the clinical interpretability of the screening results, an individualized weighted adjacency matrix representing cognitive feature interaction patterns, such as a 10×10 matrix, is extracted from the last iteration of the graph neural network, such as layer 3. Off-diagonal elements of this matrix are extracted, and real numbers between 0 and 1 are used as the influence transfer edge weights between corresponding cognitive nodes (e.g., memory node and executive function node) in the mapping graph. To reduce visual noise in the graph and highlight the core cognitive association network, weakly associated edges with weights less than a preset sparsity threshold (preferably 0.1 to 0.2) are filtered out. The remaining edge weights are then visually attribute-encoded based on mapping rules: a linear interpolation algorithm continuously maps the weight values ​​to primitive display attributes; for example, a weight range of 0.1 to 1.0 is proportionally mapped to a line thickness range of 1 to 8 pixels. Simultaneously, a preset color gradient combined with a transparency channel is used to adjust transparency, so that high-weight edges with weights close to 1.0 appear as opaque solid lines approximately 8 pixels wide, while low-weight edges appear as thin, semi-transparent lines. Using a front-end graphics rendering engine such as D3.js, nodes representing 10 different cognitive domains are arranged in a force-guided topology layout, and all related edges with calculated thickness and color transparency are drawn. A customized cognitive graph, which helps interpret the correlation patterns of abnormal individual cognitive states, is output to the doctor's interface. The cognitive network graph, rendered based on an individualized weighted adjacency matrix, is shown below. Figure 3 As shown, nodes represent different cognitive domains, node area and color intensity indicate node importance, and edge thickness and transparency indicate the strength of association between cognitive domains, representing an abnormal pattern in an individual's cognitive network.

[0045] The experiment was conducted on a multi-center cognitive impairment screening dataset, including 800 healthy controls, 600 individuals with mild cognitive impairment, and 400 individuals with Alzheimer's disease. Data collection covered temporal behavioral sequences and individual demographic information. Continuous trajectory sequences were uniformly processed to a length of 5000, while event response sequences had their lengths set according to the number of tests, task stages, or time windows. A masking mechanism was used to eliminate the influence of padding values. The model learning rate was set to 0.001, and the number of iterations was set to 100 rounds. Evaluation metrics included classification accuracy, sensitivity, and specificity. The experiment used a conventional temporal convolutional algorithm combined with a graph convolutional network as the baseline model. Variant models utilizing only individualized weighted adjacency matrices, variant models utilizing only dynamic class prototypes, and a complete scheme model encompassing all the aforementioned modules were constructed. The baseline model retains the temporal convolutional network, self-attention encoder, and conventional graph convolutional classifier structure, but uses a fixed adjacency matrix and a standard fully connected classifier. A variant model that only utilizes an individualized weighted adjacency matrix adds a graph structure learning module to the baseline model, but does not use dynamic class prototype classification. A variant model that only utilizes dynamic class prototypes adds dynamic class prototype classification to the baseline model, but does not use individualized graph structure learning. The complete solution model uses a graph structure learning module, a gated aggregation unit, and a dynamic class prototype classification module simultaneously.

[0046] Evaluation results on the exemplary test set show that the baseline model performs the most basic, achieving only 82.5% accuracy, 78.4% sensitivity, and 85.2% specificity. A variant model utilizing only the individualized weighted adjacency matrix achieves initial performance improvements, reaching 86.1% accuracy, 83.5% sensitivity, and 88.6% specificity. A variant model utilizing only the dynamic class prototype also shows performance improvements, achieving 87.4% accuracy, 84.2% sensitivity, and 89.1% specificity. The complete solution model, including all modules, demonstrates the best performance, achieving 92.8% accuracy, 91.6% sensitivity, and 93.5% specificity.

[0047] Each module contributes to the overall network performance, and the complete solution model improves accuracy by 10.3 percentage points compared to the baseline model. The individualized weighted adjacency matrix module weightedly integrates data-driven learned feature relationships with clinical prior knowledge, enabling the network to utilize more cognitive node association information related to screening categories during feature transmission, thus improving classification performance in the exemplary experiment. The dynamic class prototype mechanism uses a multilayer perceptron to nonlinearly map demographic attributes to a high-dimensional space and perform linear combination, compensating for evaluation bias caused by individual baseline differences. It represents the geometric spatial distance between the global cognitive state and the baseline of each screening category, thereby reducing boundary misjudgment rate and improving the overall model sensitivity. The classification performance comparison results of different model configurations on the test set are as follows: Figure 4As shown, the complete model outperforms the baseline model and other variants in terms of accuracy, sensitivity, and specificity, indicating that each module is effective under the experimental conditions and the overall scheme has good auxiliary screening performance.

[0048] In a second embodiment, the present invention also provides a method for assisting in the screening of brain diseases based on cognitive states, comprising: Multimodal assessment data of individuals to be screened is obtained, including temporal behavioral sequences of multiple cognitive tasks and demographic information. The temporal behavioral sequences of each cognitive task are extracted into task-level temporal feature vectors through a temporal convolutional network and a self-attention mechanism encoder. The task-level temporal feature vectors are then concatenated with the demographic information to serve as the initial feature vectors of each corresponding graph node, thereby providing the graph neural network with initial node input data that integrates multidimensional information. A graph neural network is constructed to iteratively update the features of graph nodes. The strength of node relationships is calculated through a graph structure learning module, and a personalized weighted adjacency matrix is ​​generated by fusing the pre-defined cognitive domain association topology. Based on the personalized weighted adjacency matrix, a gated aggregation unit is used to calculate the correlation between neighborhood information and the update target, and weights are generated to aggregate neighboring nodes in a weighted manner. The features are updated according to the aggregation results to obtain a graph embedding vector, which is used to represent the global cognitive state of an individual. The embedded vector of the graph is input into the classification module. A prototype mapping network is used to generate dynamic class prototypes based on demographic information. The distance between the embedded vector and each dynamic class prototype is calculated to output the disease screening results, which helps to improve the accuracy of disease-assisted screening classification. Based on the weighted adjacency matrix output by the last layer of the graph neural network, a visual cognitive graph containing the influence weights of the cognitive domain is generated to provide an interpretation basis for the disease screening results.

[0049] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0050] The specific embodiments described above do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the principles of this disclosure should be included within the scope of protection of this disclosure.

Claims

1. A cognitive state-based brain disease screening system, characterized in that, include: The acquisition module is used to acquire multimodal assessment data of the individuals to be screened. The multimodal assessment data includes temporal behavioral sequences of multiple cognitive tasks and demographic information. Through a temporal convolutional network and a self-attention mechanism encoder, the temporal behavioral sequences of each cognitive task are extracted into task-level temporal feature vectors. The task-level temporal feature vectors are then concatenated with the demographic information to serve as the initial feature vectors of each corresponding graph node, thereby providing the graph neural network with initial input data for nodes that integrate multidimensional information. A generation module is used to construct a graph neural network to iteratively update the features of graph nodes. A graph structure learning module calculates the strength of node relationships and fuses a preset cognitive domain association topology to generate an individualized weighted adjacency matrix. Based on the individualized weighted adjacency matrix, a gated aggregation unit calculates the correlation between neighborhood information and the update target, generating weights to weighted aggregate neighbor nodes. Features are updated according to the aggregation results to obtain a graph embedding vector, which represents the global cognitive state of an individual. The output module is used to input the graph embedding vector into the classification module, generate dynamic class prototypes based on demographic information using a prototype mapping network, calculate the distance between the embedding vector and each dynamic class prototype to output the disease screening results, thereby improving the accuracy of disease-assisted screening classification. Based on the weighted adjacency matrix output from the final layer of the graph neural network, a visualized cognitive map containing the influence weights of the cognitive domain is generated, providing a basis for interpreting disease screening results.

2. The system according to claim 1, characterized in that, The encoder, which uses a temporal convolutional network and a self-attention mechanism, extracts the temporal behavior sequences of each cognitive task into task-level temporal feature vectors, including: For each cognitive task, a temporal convolutional network is used to perform convolution operations on the input temporal behavior sequence at multiple scales to extract local temporal features; The local temporal features are input into the self-attention mechanism module, and query vector, key vector and value vector are generated through linear mapping. Using a self-attention mechanism, the product of the query vector and the transpose of the key vector is divided by the square root of the key vector dimension, processed by a normalized exponential function, and then multiplied by the value vector to calculate the global dependency and output the temporal feature matrix. The temporal feature matrix is ​​then processed by average pooling, max pooling, or attention pooling along the time dimension to obtain the task-level temporal feature vector.

3. The system according to claim 2, characterized in that, The step of calculating node relationship strength through a graph structure learning module and generating an individualized weighted adjacency matrix by fusing a preset cognitive domain association topology includes: The node features of the current layer are mapped to the relation space by a multilayer perceptron, and the inner product of the pairwise node feature vectors is calculated as the initial relation strength. The pre-defined cognitive domain association topology is encoded into a prior knowledge matrix; The initial relation strength and the prior knowledge matrix are weighted and fused according to a preset balance coefficient, and the weighted fused matrix is ​​normalized to generate the individualized weighted adjacency matrix of the current layer. Element-by-element addition can be used as another simplified fusion method.

4. The system according to claim 1, characterized in that, The method of calculating the correlation between neighborhood information and the update target using a gated aggregation unit based on an individualized weighted adjacency matrix, and generating weights for weighted aggregation of neighboring nodes, includes: The neighboring nodes are determined based on the individualized weighted adjacency matrix. The features of the center node and the features of the neighboring nodes are concatenated, and the attention score is calculated through a fully connected layer with an activation function, or the attention score is calculated through the dot product of the features of the center node and the features of the neighboring nodes. The attention score and the corresponding adjacency weight in the individualized weighted adjacency matrix are used together as the aggregation weight, and multiplied with the corresponding neighbor node features to obtain the weighted neighborhood features. The weighted features of the neighborhood are summed to complete the weighted aggregation of neighbor node information.

5. The system according to claim 1, characterized in that, The step of updating features based on the aggregation result to obtain the graph embedding vector includes: Multiply the feature matrix of the current layer's aggregation result with the learnable weight matrix of the current layer, and after processing with a non-linear activation function, update the node feature matrix of the next layer; The graph neural network's final layer outputs all node features, which are then processed by a global pooling layer to reduce dimensionality, generating the graph embedding vector.

6. The system according to claim 1, characterized in that, The method of generating dynamic class prototypes based on demographic information using a prototype mapping network includes: Demographic information is input into a multilayer perceptron for feature extraction, and a demographic representation vector is output. For each preset disease category, set a base class prototype vector; The demographic representation vector is linearly combined with each basic class prototype vector to generate a dynamic class prototype for the current individual's characteristics.

7. The system of claim 1, wherein, The calculation of the distance between the embedding vector and each dynamic class prototype to output the disease screening result includes: Calculate the Euclidean distance between the graph embedding vector and each of the dynamic class prototypes; The negative values ​​of all Euclidean distances are used as the classification log odds, and the probability values ​​of the current individual belonging to each disease category are calculated by normalizing the exponential function. The disease category with the highest probability value is used as the output disease screening result.

8. The system of claim 1, wherein, The weighted adjacency matrix based on the output of the final layer of the graph neural network generates a visualized cognitive graph containing the influence weights of the cognitive domain, including: Extract the element values ​​from the final layer weighted adjacency matrix and use them as the edge weights between different cognitive nodes; A directed or undirected weighted graph is constructed based on the weighted adjacency matrix of the last layer, and the importance score of each cognitive node is calculated using the PageRank algorithm or the weighted degree centrality algorithm. The thickness and color transparency of the edges in the visualization graph are set according to the weight of the edges, and the size of the node area and the color depth of the node in the visualization graph are set according to the importance score. Each cognitive node and its associated edges with a set style are rendered onto the interface to generate the visualized cognitive graph containing the influence weights of the cognitive domain.

9. A method for assisting in the screening of brain diseases based on cognitive states, characterized in that, include: Multimodal assessment data of individuals to be screened is obtained, including temporal behavioral sequences of multiple cognitive tasks and demographic information. The temporal behavioral sequences of each cognitive task are extracted into task-level temporal feature vectors through a temporal convolutional network and a self-attention mechanism encoder. The task-level temporal feature vectors are then concatenated with the demographic information to serve as the initial feature vectors of each corresponding graph node, thereby providing the graph neural network with initial node input data that integrates multidimensional information. A graph neural network is constructed to iteratively update the features of graph nodes. The strength of node relationships is calculated through a graph structure learning module, and a personalized weighted adjacency matrix is ​​generated by fusing the pre-defined cognitive domain association topology. Based on the personalized weighted adjacency matrix, a gated aggregation unit is used to calculate the correlation between neighborhood information and the update target, and weights are generated to aggregate neighboring nodes in a weighted manner. The features are updated according to the aggregation results to obtain a graph embedding vector, which is used to represent the global cognitive state of an individual. The embedded vector of the graph is input into the classification module, and a prototype mapping network is used to generate dynamic class prototypes based on demographic information. The distance between the embedded vector and each dynamic class prototype is calculated to output the disease screening results, which helps to improve the accuracy of disease-assisted screening classification. Based on the weighted adjacency matrix output from the final layer of the graph neural network, a visualized cognitive map containing the influence weights of the cognitive domain is generated, providing a basis for interpreting disease screening results.

10. The method of claim 9, wherein, The encoder, which uses a temporal convolutional network and a self-attention mechanism, extracts the temporal behavior sequences of each cognitive task into task-level temporal feature vectors, including: For each cognitive task, a temporal convolutional network is used to perform convolution operations on the input temporal behavior sequence at multiple scales to extract local temporal features; The local temporal features are input into the self-attention mechanism module, and query vector, key vector and value vector are generated through linear mapping. Using a self-attention mechanism, the product of the query vector and the transpose of the key vector is divided by the square root of the key vector dimension, processed by a normalized exponential function, and then multiplied by the value vector to calculate the global dependency and output the temporal feature matrix. The temporal feature matrix is ​​then processed by average pooling, max pooling, or attention pooling along the time dimension to obtain the task-level temporal feature vector.

Images