A grassroots social digital governance method and system

Abstract

The application discloses a kind of grassroots social digital governance method and system, method includes: through the real-time acquisition of multiple-source heterogeneous data of Internet of Things sensing network deployed in grassroots community, generate standardized multimodal perception data stream;Based on multimodal perception data stream, output the data set after washing of space-time correlation;The data set after washing is input into multi-scale space-time encoder, generates the feature tensor containing regional hotspot distribution and risk propagation path;Based on feature tensor, construct dynamic risk knowledge graph, output the decision matrix containing risk level and optimal intervention path;Decision matrix is input into strategy optimization engine, and hierarchical governance instruction set is obtained;Based on the real-time governance feedback data after executing hierarchical governance instruction set, conflict instruction in strategy chain is autonomously corrected by fuzzy reinforcement learning algorithm.Utilize the embodiment of the application, can realize efficient, intelligent and have the digital governance scheme of traceability, to improve the efficiency and service quality of social governance.

Description

Technical Field

[0001] This invention belongs to the field of digital technology, specifically a method and system for digital governance at the grassroots level. Background Technology

[0002] With the rapid development of information technology, digital governance has gradually become an important means to improve the efficiency and quality of public management and services. Grassroots social governance, as a fundamental link in social governance, involves multiple aspects such as residents' lives, public facility management, and environmental protection, and faces numerous challenges, including information silos, uneven resource allocation, and outdated management methods. Traditional grassroots governance models often rely on manual operation and experience-based judgment, making it difficult to effectively cope with the complex and ever-changing social environment and residents' needs, thus leading to low management efficiency, resource waste, and decreased resident satisfaction.

[0003] Against this backdrop, the rise of IoT and big data technologies has provided new opportunities for grassroots social governance. By deploying IoT sensors, multi-source heterogeneous data such as resident behavior, public facility status, and environmental indicators can be collected in real time, providing support for scientific decision-making and dynamic governance. However, in practice, this data often contains noise, ambiguity, and logical conflicts. How to effectively clean and process this data and extract useful information to guide governance decisions is key to achieving digital governance. Summary of the Invention

[0004] The purpose of this invention is to provide a method and system for digital governance at the grassroots level, in order to overcome the shortcomings of existing technologies and achieve a digital governance solution that is efficient, intelligent and traceable, thereby improving the efficiency and quality of social governance.

[0005] One embodiment of this application provides a method for digital governance of grassroots society, the method comprising:

[0006] The IoT sensor network deployed in grassroots communities collects multi-source heterogeneous data in real time. The multi-source heterogeneous data includes residents' behavior trajectories, public facility status and environmental monitoring indicators. An adaptive spatiotemporal filtering algorithm is used to remove abnormal noise and perform spatiotemporal alignment processing on the multi-source heterogeneous data to generate a standardized multimodal sensing data stream.

[0007] Based on the multimodal sensing data stream, semantic ambiguity and logical conflict in the data are detected by conflict resolution knowledge graph, a data cleaning model is constructed using dynamic rule engine, and graph neural network is used to perform topological structure matching and deduplication of duplicate data, outputting a spatiotemporally related cleaned dataset.

[0008] The cleaned dataset is input into a multi-scale spatiotemporal encoder. The spatiotemporal correlation features in the data are extracted by fusing a temporal convolutional network and a graph attention mechanism. The evolution trend of different modal data is aligned based on a dynamic time warping algorithm to generate a feature tensor containing regional hotspot distribution and risk propagation path.

[0009] Based on the aforementioned feature tensor, a dynamic risk knowledge graph is constructed. A causal reasoning model is used to predict the probability of potential risks in grassroots social governance. A cross-modal adversarial generative network is used to simulate the intervention effects of different governance strategies, and a decision matrix containing risk levels and optimal intervention paths is output.

[0010] The decision matrix is ​​input into the strategy optimization engine, and the multi-objective particle swarm algorithm is used to simultaneously optimize the governance efficiency, resource consumption and resident satisfaction indicators to generate a preliminary governance instruction set. The execution effect of the instructions is then virtually simulated through a digital twin platform. The instruction priority is dynamically adjusted based on the simulation results to obtain a hierarchical governance instruction set and form an intelligent governance strategy chain.

[0011] Based on real-time governance feedback data after executing the hierarchical governance instruction set, the conflicting instructions in the policy chain are autonomously corrected through fuzzy reinforcement learning algorithm, and the policy iteration trajectory is recorded in the blockchain evidence storage network to achieve the verifiability and traceability of the governance process.

[0012] According to a preferred embodiment of the present invention, the process of generating a multimodal sensing data stream by performing abnormal noise removal and spatiotemporal alignment processing on multi-source heterogeneous data based on an adaptive spatiotemporal filtering algorithm includes:

[0013] Based on the sliding window mechanism in the adaptive spatiotemporal filtering algorithm, local variance analysis is performed on the data stream of each sensor node, and outliers exceeding the preset range are marked as noise candidate regions to generate an initial noise mask matrix.

[0014] Based on the initial noise mask matrix, the timestamp offset in the heterogeneous data is compensated; the environmental monitoring indicators and public facility status data are spatiotemporally aligned, and the spatiotemporal density of residents' movement trajectories is introduced as a weighting factor to correct the alignment path, generating multimodal data blocks;

[0015] The multimodal data block is input into a multichannel autoencoder for feature weight allocation, thereby generating a multimodal sensing data stream.

[0016] According to a preferred embodiment of the present invention, the process of detecting semantic ambiguity and logical conflict based on a multimodal sensing data stream, constructing a data cleaning model using a dynamic rule engine, performing topological structure matching and deduplication on duplicate data, and outputting a cleaned dataset includes:

[0017] Based on the entity relationships in the multimodal perception data stream, semantic triples are extracted and combined with the domain knowledge base to construct a conflict resolution knowledge graph. The nodes in the conflict resolution knowledge graph represent entities or events, and the edges represent logical dependencies.

[0018] Based on the logical dependencies, a dynamic rule engine is used to detect semantic ambiguity, calculate the conflict confidence, and generate a set of logical conflict events.

[0019] The set of logical conflict events is input into a graph neural network, and the repeated events are matched for topological structure. Redundant nodes are aggregated, and the cleaned dataset is output.

[0020] According to a preferred embodiment of the present invention, the process of generating a feature tensor containing regional hotspot distribution and risk propagation paths based on the cleaned dataset includes:

[0021] The cleaned dataset is input into a multi-scale spatiotemporal encoder, and the periodic patterns of residents' behavior trajectories are extracted through a temporal convolutional network. At the same time, a graph attention mechanism is used to capture the spatial dependencies between public facility nodes to generate a primary feature vector.

[0022] Based on the primary feature vector, a dynamic time warping algorithm is used to align the evolution trends of environmental monitoring indicators and residents' behavioral trajectories, and a multimodal feature matrix is ​​generated by eliminating sensor acquisition delay through elastic matching of curvature constraints.

[0023] The multimodal feature matrix is ​​subjected to Fourier transform to extract the frequency domain energy distribution features, and then the probability density function of the regional hotspot distribution is calculated. Areas exceeding a preset threshold are marked as high-risk areas.

[0024] Based on the high-risk areas, a graph diffusion model is used to simulate the propagation path of risks along the facility network, thereby generating a risk propagation path map;

[0025] The risk propagation path map is fused with the multimodal feature matrix using tensor fusion to generate a feature tensor that includes regional hotspot distribution and risk propagation path.

[0026] According to a preferred embodiment of the present invention, the process of constructing a dynamic risk knowledge graph based on a feature tensor and then generating a decision matrix includes:

[0027] Based on the risk propagation path in the feature tensor, a dynamic risk knowledge graph is constructed, and the conditional probability of each risk node is calculated using a causal reasoning model to generate the probability prediction result of the risk transmission chain.

[0028] The probability prediction results are input into a cross-modal adversarial generative network, which then outputs a set of policies with weighted scores.

[0029] Pareto front analysis is performed on the set of strategies to generate a decision matrix that includes the optimal intervention path and risk level.

[0030] According to a preferred embodiment of the present invention, the process of forming an intelligent governance strategy chain based on a decision matrix includes:

[0031] The final decision matrix is ​​input into the strategy optimization engine to generate a preliminary governance instruction set, which is then mapped to the digital twin platform to generate a simulation and evaluation report.

[0032] Based on the aforementioned simulation and evaluation report, the urgency score of each instruction is calculated using a fuzzy controller, the instruction priority is dynamically adjusted, a hierarchical governance instruction set is generated, and thus an intelligent governance strategy chain is formed.

[0033] According to a preferred embodiment of the present invention, the process of achieving verifiability and traceability of the governance process based on a hierarchical governance instruction set includes:

[0034] Based on the real-time governance feedback data after the execution of the hierarchical governance instruction set, conflicting instructions in the intelligent governance strategy chain are detected by the fuzzy Q-learning algorithm, the conflict intensity value between instructions is calculated, and a set of conflicting instructions is generated.

[0035] The set of conflict instructions is input into the deep deterministic policy gradient model, and then the optimized intelligent governance policy is output.

[0036] The strategy iteration trajectory is encapsulated into a smart contract, thereby generating an immutable record with timestamps and hash values, achieving verifiability and traceability of the governance process.

[0037] Another embodiment of this application provides a grassroots social digital governance system, the system comprising:

[0038] The data acquisition module is used to collect multi-source heterogeneous data in real time through an Internet of Things sensor network deployed in grassroots communities. The multi-source heterogeneous data includes residents' behavior trajectories, public facility status and environmental monitoring indicators. The module performs abnormal noise removal and spatiotemporal alignment processing on the multi-source heterogeneous data to generate a multimodal sensing data stream.

[0039] The detection module is used to detect multimodal sensing data streams, build a data cleaning model, combine graph neural networks to perform topological structure matching and deduplication of duplicate data, and output the cleaned dataset.

[0040] The extraction module is used to extract the spatiotemporal correlation features from the cleaned dataset and align the evolution trends of different modal data based on the dynamic time warping algorithm to generate feature tensors;

[0041] The prediction module is used to construct a dynamic risk knowledge graph, perform probabilistic predictions of potential risks in grassroots social governance, and then generate a decision matrix.

[0042] The generation module is used to input the decision matrix into the strategy optimization engine, generate a preliminary governance instruction set, and virtually simulate the execution effect of the instructions through the digital twin platform. Based on the simulation results, the priority of the instructions is dynamically adjusted to obtain a hierarchical governance instruction set, thereby forming an intelligent governance strategy chain.

[0043] The correction module, based on the hierarchical governance instruction set, further enables the verifiability and traceability of the governance process.

[0044] Another embodiment of this application provides a storage medium storing a computer program, wherein the computer program is configured to execute the method described in any of the preceding claims when running.

[0045] Another embodiment of this application provides an electronic device including 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 method described in any of the preceding claims.

[0046] Compared with existing technologies, this invention provides a grassroots social digital governance method that collects multi-source heterogeneous data in real time through an Internet of Things (IoT) sensor network deployed in grassroots communities, generating a standardized multimodal sensing data stream. Based on the multimodal sensing data stream, a spatiotemporally correlated cleaned dataset is output. The cleaned dataset is input into a multi-scale spatiotemporal encoder to generate a feature tensor containing regional hotspot distribution and risk propagation paths. Based on the feature tensor, a dynamic risk knowledge graph is constructed, outputting a decision matrix containing risk levels and optimal intervention paths. The decision matrix is ​​input into a strategy optimization engine to obtain a hierarchical governance instruction set. Based on real-time governance feedback data after executing the hierarchical governance instruction set, a fuzzy reinforcement learning algorithm is used to autonomously correct conflicting instructions in the strategy chain, thereby achieving an efficient, intelligent, and traceable digital governance solution to improve the efficiency and service quality of social governance. Attached Figure Description

[0047] Figure 1 A hardware structure block diagram of a computer terminal for a grassroots social digital governance method provided in an embodiment of the present invention;

[0048] Figure 2 A flowchart illustrating a grassroots social digital governance method provided in an embodiment of the present invention;

[0049] Figure 3 This is a schematic diagram of the structure of a grassroots social digital governance system provided in an embodiment of the present invention. Detailed Implementation

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

[0051] This invention first provides a method for digital governance at the grassroots level, which can be applied to electronic devices, such as computer terminals, specifically ordinary computers.

[0052] The following detailed explanation uses a computer terminal as an example. Figure 1 This is a hardware structure block diagram of a computer terminal for a grassroots social digital governance method provided in an embodiment of the present invention. (See diagram below.) Figure 1 As shown, the computer device includes a processor, memory, and network interface connected via a system bus, wherein the memory may include non-volatile storage media and internal memory.

[0053] Non-volatile storage media can store operating systems and computer programs. These computer programs include program instructions that, when executed, cause the processor to perform any grassroots digital governance method.

[0054] The processor provides computing and control capabilities, supporting the operation of the entire computer device.

[0055] Internal memory provides an environment for the execution of computer programs in non-volatile storage media. When the computer program is executed by the processor, it enables the processor to execute any grassroots digital governance method.

[0056] This network interface is used for network communication, such as sending assigned tasks. Those skilled in the art will understand that... Figure 1 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0057] It should be understood that the processor can be a Central Processing Unit (CPU), but it can also be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. Among these, a general-purpose processor can be a microprocessor or any conventional processor.

[0058] See Figure 2 The present invention provides a method for digital governance at the grassroots level, which may include the following steps:

[0059] S201, real-time collection of multi-source heterogeneous data through IoT sensor networks deployed in grassroots communities, including residents' behavior trajectories, public facility status and environmental monitoring indicators, and the use of an adaptive spatiotemporal filtering algorithm to remove abnormal noise and perform spatiotemporal alignment processing on the multi-source heterogeneous data to generate a standardized multimodal sensing data stream.

[0060] S202, based on the multimodal perception data stream, semantic ambiguity and logical conflict in the data are detected by conflict resolution knowledge graph, a data cleaning model is constructed using dynamic rule engine, and graph neural network is used to perform topological structure matching and deduplication of duplicate data, and a spatiotemporally related cleaned dataset is output.

[0061] S203: The cleaned dataset is input into a multi-scale spatiotemporal encoder. The spatiotemporal correlation features in the data are extracted by fusing a temporal convolutional network and a graph attention mechanism. The evolution trend of different modal data is aligned based on a dynamic time warping algorithm to generate a feature tensor containing regional hotspot distribution and risk propagation path.

[0062] S204. Based on the feature tensor, a dynamic risk knowledge graph is constructed. A causal reasoning model is used to predict the probability of potential risks in grassroots social governance. The intervention effects of different governance strategies are simulated through a cross-modal adversarial generative network. A decision matrix containing risk level and optimal intervention path is output.

[0063] S205 inputs the decision matrix into the strategy optimization engine, uses a multi-objective particle swarm algorithm to simultaneously optimize governance efficiency, resource consumption and resident satisfaction indicators, generates a preliminary governance instruction set, and uses a digital twin platform to virtually simulate the execution effect of the instructions. Based on the simulation results, the priority of the instructions is dynamically adjusted to obtain a hierarchical governance instruction set and form an intelligent governance strategy chain.

[0064] S206, based on real-time governance feedback data after executing the hierarchical governance instruction set, autonomously corrects conflicting instructions in the policy chain through a fuzzy reinforcement learning algorithm, and records the policy iteration trajectory in the blockchain evidence storage network, thereby achieving the verifiability and traceability of the governance process.

[0065] Specifically, based on the multi-source heterogeneous data of residents' behavioral trajectories, public facility status, and environmental monitoring indicators collected by the Internet of Things sensor network, and using the sliding window mechanism in the adaptive spatiotemporal filtering algorithm, the specific process of performing local variance analysis on the data stream of each sensor node is as follows:

[0066] It should be noted that during local variance analysis, outliers that exceed the preset range are marked as noise candidate regions to generate an initial noise mask matrix.

[0067] The Internet of Things (IoT) sensor network consists of various types of sensors deployed within the community, including:

[0068] Resident behavior trajectory sensor: based on Bluetooth beacon and mobile phone positioning data, sampling frequency 1Hz, accuracy ±1 meter;

[0069] Public facility status sensor: monitors elevator operating status (current fluctuations) and trash can fullness (ultrasonic ranging), with a sampling frequency of 0.5Hz;

[0070] Environmental monitoring sensors: PM2.5 (laser scattering), temperature and humidity (capacitive), sampling frequency 0.2Hz.

[0071] The adaptive spatiotemporal filtering algorithm achieves dynamic noise detection through a sliding window mechanism:

[0072] Window settings: The time window length is 30 seconds (covering 30 resident trajectory points, 15 facility status points, and 6 environmental indicator points), and the spatial window is a circular area with a radius of 50 meters (based on sensor deployment density).

[0073] Local variance analysis: Calculate the standard deviation (σ) of the data within the window. If the absolute difference between a data point and the mean exceeds 3σ (preset threshold), it is marked as a noise candidate point.

[0074] For example, if a sensor for a trash can reports 100% full load five times in a row, while other sensors in the same area show an actual usage rate of less than 30%, it is considered abnormal.

[0075] Initial noise mask matrix generation: Construct a binary matrix with the same dimensions as the original data (0 represents normal, 1 represents noise). For example, if there is a sudden drop in elevator current data at a certain moment (from 5A to 0A for 2 seconds), the corresponding position in the mask matrix is ​​marked as 1.

[0076] Furthermore, the optimization mechanism for local variance analysis is as follows:

[0077] Dynamic threshold adjustment: The 3σ threshold is dynamically adjusted based on historical data statistics (such as the noise ratio over the past 24 hours). For example, if the noise rate remains below 5%, the threshold is relaxed to 2.5σ to improve sensitivity.

[0078] Spatial correlation verification: A secondary verification is performed on isolated noise points (such as single sensor malfunctions). If the data from adjacent sensors are normal, the marking is removed.

[0079] Based on the initial noise mask matrix, timestamp offsets in heterogeneous data are compensated. A dynamic time warping algorithm is used to align environmental monitoring indicators with public facility status data in time and space. The spatiotemporal density of residents' movement trajectories is introduced as a weighting factor to correct the alignment path, generating spatiotemporally synchronized multimodal data blocks. Furthermore, timestamp offsets are mainly caused by sensor clock asynchrony (±500ms) and transmission delay (4G network jitter ±200ms).

[0080] Furthermore, the specific process for compensating for timestamp offsets in heterogeneous data is as follows:

[0081] Time reference synchronization: The clocks of each sensor node are calibrated using the high-precision GNSS clock (error ±1ms) at the community center as the reference and via the NTP protocol.

[0082] Dynamic Time Warping (DTW):

[0083] Input sequence: Time series data of environmental monitoring indicators (such as PM2.5) and public facility status (such as elevator current);

[0084] Alignment path: Calculates the minimum cumulative distance path between two sequences, allowing for local stretching or compression.

[0085] For example, a sudden surge in elevator current needs to be aligned with PM2.5 data for the same period (which may decrease due to the activation of the ventilation system).

[0086] Spatiotemporal density weights:

[0087] Resident trajectory heat map: Count the number of trajectory points within a grid (10m×10m) every 5 minutes. The higher the density, the greater the weight (weight range 0.5~1.5).

[0088] Alignment correction: Force alignment priority in high-density areas (such as community squares) to ensure data consistency in key areas.

[0089] The heterogeneous data after timestamp offset compensation is denoted as a multimodal data block:

[0090] Furthermore, the multimodal data block includes: a time dimension: uniformly set to 1-second time slices; a spatial dimension: data aggregated according to a 50-meter grid; and data fields: including the number of trajectory points, elevator status codes (0 / 1), PM2.5 concentration values, etc.

[0091] The spatiotemporally synchronized multimodal data blocks are input into a multi-channel autoencoder. The intermodal attention mechanism is used to assign feature weights to residents’ behavior trajectories, public facility status and environmental monitoring indicators. Z-score standardization is used to eliminate dimensional differences and output a standardized multimodal perception data stream containing spatiotemporally related features.

[0092] Furthermore, the multi-channel self-encoder is structurally designed as follows:

[0093] Encoder branches: Trajectory branch: 1D convolution (kernel size 3, number of channels 32) to extract movement patterns; Facility branch: LSTM (64 hidden layers) to capture temporal state changes; Environment branch: Fully connected layer (6-dimensional input → 16-dimensional output) for dimensionality reduction.

[0094] Furthermore, spatiotemporal correlation features are generated, with 128-dimensional features generated for each time slice, including trajectory clustering, facility anomaly indicators, and environmental risk level;

[0095] Furthermore, the specific process of Z-score standardization is as follows:

[0096] Formula: (x - μ) / σ, where μ is the mean of the corresponding data and σ is the standard deviation of the corresponding data;

[0097] For example, trajectory data: μ=50 points / minute, σ=15; elevator current: μ=4.5A, σ=1.2; PM2.5: μ=35μg / m³, σ=10.

[0098] According to the formula: original trajectory point 80 → standardized value (80-50) / 15=2.0; elevator current 5A → (5-4.5) / 1.2≈0.42; PM2.5 50μg / m³ → (50-35) / 10=1.5.

[0099] Data stream format: One record per second, transmitted to downstream systems in real time via Kafka message queue.

[0100] Specifically, based on the entity relationships in the multimodal perception data stream, semantic triples are extracted using a pre-trained BERT model, and a conflict resolution knowledge graph is constructed by combining it with a domain knowledge base. It should be noted that the nodes in the conflict resolution knowledge graph represent entities / events, and the edges represent logical dependencies.

[0101] It should be noted that the multimodal perception data stream includes heterogeneous data such as text data (e.g., resident complaint records), sensor values ​​(e.g., overflowing trash can status), and images (e.g., community surveillance footage). For text data, a pre-trained BERT model (e.g., bert-base-chinese) is fine-tuned, with the input being a description of resident behavior (e.g., "stacked items in the corridor of Unit 2, Building 3"). Global semantic features are extracted using [CLS] tags, and entities ("Unit 2, Building 3", "corridor", "stacked items") are labeled using an entity recognition module (e.g., BiLSTM-CRF). Finally, a relation classifier (e.g., Softmax layer) outputs semantic triples (subject: Unit 2, Building 3, relation: exists, object: stairwell stacked items). For non-text data, such as the "overflowing trash can" event in an image, the Faster R-CNN object detection model is used for recognition, and the data is converted into structured triples (subject: trash can in Area A, relation: state, object: overflowing).

[0102] It should be noted that the domain knowledge base consists of community governance rules (such as prohibiting the accumulation of items in corridors) and event handling procedures (such as "overflowing trash cans must be emptied within 2 hours").

[0103] Furthermore, the specific process of constructing a conflict resolution knowledge graph using the Neo4j graph database includes:

[0104] Node types include:

[0105] Entity nodes: geographical location (building, unit), facilities (trash cans, fire exits), events (piling up items, overflowing);

[0106] Logical edges: Dependencies (e.g., "stacked materials → blocked fire exit → fire risk"), processing flow (e.g., "overflow → triggering a cleanup work order").

[0107] When constructing the graph, set node attributes (such as the coordinates of fire lanes) and edge weights (such as the correlation strength between piled-up materials and fire risk, which is 0.8).

[0108] For example, when the event "stacked items in the corridor of Unit 2, Building 3" is detected, the triple extracted by BERT matches the "fire escape blocked" rule in the knowledge base, generating the logical edge "stacked items - violation → fire regulations", with the conflict confidence initialized to 0.75.

[0109] Furthermore, based on the logical dependencies in the knowledge graph, the specific process of using a dynamic rule engine to detect semantic ambiguity, calculating conflict confidence through a fuzzy inference algorithm, and generating a set of logical conflict events containing conflict types and location labels includes:

[0110] Furthermore, the dynamic rule engine adopts the Drools framework, and the rule base contains two types of rules:

[0111] Conflict detection rules: For example, "IF if 'stacked items' and 'fire lane obstruction' exist simultaneously at the same location, then 'fire safety conflict' is triggered";

[0112] Priority rules: For example, "fire safety conflict priority = 5 (highest), environmental complaint conflict priority = 3".

[0113] Furthermore, the mechanism for dynamically updating the rule base is as follows:

[0114] Real-time learning: When a new event triggers an uncovered conflict pattern (such as "heavy rain causing sewer blockage + overflowing trash can"), the rule base is expanded through online learning with a learning rate of 0.01.

[0115] Weight decay: The weight of rules that have not been triggered for a long time decays by 5% per month to avoid the rule base from expanding.

[0116] It should be noted that fuzzy reasoning algorithms handle uncertain conflicts. For example, a resident's complaint of "unpleasant smell in the stairwell" may be related to "garbage not being collected in a timely manner" or "sewage odor coming from the sewer."

[0117] Furthermore, the specific process of constructing a fuzzy inference algorithm includes:

[0118] Fuzzification: Define a membership function, such as dividing "odor intensity" into low (0~3), medium (2~5), and high (4~7), and use a trapezoidal membership function;

[0119] Fuzzy inference rule base: such as "IF high odor intensity AND overflowing trash can THEN odor confidence = 0.9";

[0120] Defuzzing: The centroid method is used to calculate the final confidence level, with a threshold of 0.6. If the threshold is exceeded, the system is marked as conflicting.

[0121] Furthermore, the set of logical conflict events includes:

[0122] Conflict type labels: such as "fire safety", "environmental sanitation", "public facility malfunction";

[0123] Location tags: GeoHash encoded (e.g., wx4g0), with a precision of 10 meters;

[0124] Confidence level: range 0~1, such as "items piled up in the fire lane of Unit 2, Building 3" with a confidence level of 0.88.

[0125] For example, in a certain instance, the correlation between "overflowing trash cans in Zone A" and "missing collection records" was detected. The confidence level calculated by fuzzy inference was 0.78, and a conflict event {Type: Environmental Sanitation, Location: wx4g0, Confidence Level: 0.78} was generated.

[0126] The set of logically conflicting events is input into a graph neural network. The node embedding algorithm is used to perform topological structure matching on repeated events, and redundant nodes are aggregated based on a community detection algorithm to output a cleaned dataset with spatiotemporal correlation.

[0127] Furthermore, the graph neural network (GNN) adopts the GraphSAGE architecture, and the input graph is a heterogeneous graph constructed from a set of conflict events:

[0128] Node: Conflict event (Attributes: type, location, confidence);

[0129] Edges: Spatiotemporal relationships (e.g., if the time difference between two events is less than 1 hour and the distance is less than 50 meters, then an edge is created).

[0130] Topology matching:

[0131] Node embedding: Neighbor features are aggregated by mean, with the embedding dimension set to 128 and the learning rate to 0.001;

[0132] Similarity calculation: Cosine similarity is used to measure the embedded vectors, with a threshold of 0.85. Events exceeding this threshold are considered duplicates. For example, two "overflowing trash can" events that are spatiotemporally adjacent and have similar confidence levels are merged into the same event.

[0133] Furthermore, the community detection algorithm employs the Louvain method:

[0134] Modularity optimization: Maximize the connection density within the community, with resolution parameter γ=1.0;

[0135] Redundancy aggregation: Merge events within the same community into a main event, such as merging 5 "stacked items in the corridor" events into "stacked items problem in all 3 buildings".

[0136] Dataset structure after cleaning:

[0137] Fields: Event ID, Type, Location, Confidence, List of Related Events;

[0138] Deduplication rate: Controlled by adjusting the similarity threshold, the default is to remove 30%~40% of duplicate data.

[0139] Example: The original data contained 10 "streetlight failure in area A" events. After GNN matching and Louvain clustering, they were merged into 1 main event and associated with 9 sub-events, saving 90% of storage space.

[0140] The cleaned dataset is reverse-validated, and the missing data is filled in using the spatiotemporal kriging interpolation algorithm. The spatiotemporal consistency of the data is ensured by the Markov random field model, and the final spatiotemporally correlated cleaned dataset is generated.

[0141] Furthermore, the specific process of using the spatiotemporal kriging interpolation algorithm to complete missing data includes:

[0142] Variation function modeling: A spherical model was used to fit the spatial correlation, with a range of 50 meters and a nugget value of 0.1.

[0143] Interpolation execution: Estimate the value of missing locations (such as coordinates wx4g0t), such as "probability of trash can overflowing = 0.65".

[0144] Furthermore, the specific process by which the Markov random field guarantees data consistency includes:

[0145] Neighborhood definition: Events whose spatiotemporal neighborhood is the same building and whose time difference is less than 2 hours;

[0146] Energy function: E(x) = Σ(1 - similarity(x, neighbors)), minimized by Gibbs sampling;

[0147] x represents the data node that needs to be optimized or evaluated. Specifically, in the context of grassroots governance, x can be a specific conflict event (such as "stacked items in the corridor of Unit 2, Building 3"), sensor observation (such as "probability of overflowing trash cans in Area A = 0.8"), or the state of a spatial grid (such as the "fire risk level" of a certain area).

[0148] It should be noted that neighbors refer to other nodes that are related to the current node x in the spatiotemporal dimension. The definition depends on the specific scenario: Spatial neighbors: nodes that are geographically close (such as other events or sensor data within 50 meters of x's location). Temporal neighbors: nodes that are close in time (such as other events that occurred within 2 hours of x). Logical neighbors: nodes that have a direct edge connection to x in the knowledge graph (e.g., the neighbor of the "stairwell clutter" event might be the "fire escape blocked" event).

[0149] It should be noted that by minimizing E(x), the state of x is made as similar as possible to that of its neighbors, thereby ensuring the smoothness (consistency) of the data in time, space or logic.

[0150] Iterative optimization: 100 iterations, initial temperature parameter 1.0, decreasing by 0.01 in each iteration.

[0151] Specifically, the cleaned dataset is input into a multi-scale spatiotemporal encoder, and the periodic patterns of residents' behavioral trajectories are extracted through a temporal convolutional network. At the same time, a graph attention mechanism is used to capture the spatial dependencies between public facility nodes, generating a spatiotemporally separated primary feature vector.

[0152] Furthermore, the multi-scale spatiotemporal encoder consists of a dual-channel temporal convolutional network (TCN) and a graph attention network (GAT). By fusing the temporal convolutional network and the graph attention mechanism, it extracts spatiotemporal correlation features from the data, processing time-series data and spatial topological relationships respectively. For resident behavior trajectory data (such as movement paths recorded by Bluetooth beacons), the TCN adopts a dilated convolution structure, setting the dilation factor to 2 and the convolution kernel size to 5, and gradually extracting multi-scale periodic patterns such as hourly, daily, and weekly patterns by stacking 4 layers of convolution.

[0153] For example, a resident's cyclical behavior of spending 30 minutes in the community fitness area at 18:00 every day will be captured as a feature peak by the third convolutional layer.

[0154] It should be noted that public facility status data (such as street light failure rate and trash can fullness rate) are processed using a graph attention network. The facility node embedding dimension is set to 128, and the number of graph attention heads is set to 8, with each head focusing on different spatial relationships (such as physical proximity and functional association). Taking the lighting facilities in a community park as an example, the attention weight between node A (the main park light) and node B (the walkway light) may be 0.8, while the weight with node C (the parking lot light) is only 0.2, reflecting the strength of spatial functional association.

[0155] Furthermore, the specific process of extracting spatiotemporal correlation features from the data by fusing temporal convolutional networks and graph attention mechanisms includes:

[0156] Temporal feature gate: The temporal feature vector (dimension 256) output by TCN is weighted by 0 to 1 using the Sigmoid function;

[0157] Spatial feature gating: The spatial feature vector (dimension 256) output by GAT is normalized by the Tanh function;

[0158] Fusion output: The temporal weights and spatial features are multiplied element-wise to generate a 256-dimensional primary feature vector.

[0159] For example, a surge in foot traffic in the fitness area during a certain period (time feature weight 0.9) is combined with a faulty street light in the adjacent area (spatial feature value -0.3) to generate a high-weight warning feature.

[0160] Furthermore, based on the primary feature vector, a dynamic time warping algorithm is used to align the evolution trends of environmental monitoring indicators and residents' behavioral trajectories, and elastic matching with curvature constraints is used to eliminate sensor acquisition delay, generating a spatiotemporally consistent multimodal feature matrix.

[0161] Furthermore, the specific process by which the Dynamic Time Warping (DTW) algorithm aligns asynchronous time-series data of environmental monitoring (such as PM2.5 concentration curves) with resident behavior (such as outdoor activity duration) includes:

[0162] Cost matrix construction: Calculate the Euclidean distance between each point of the two sequences to form a 100×100 matrix (assuming each sequence is 100 in length).

[0163] Path search: Limit the slope of curved paths to ≤2 to avoid excessive distortion;

[0164] Curvature constraint: The local curvature radius of the path must be >5 (through the second derivative constraint) to eliminate abrupt inflection points caused by sensor delay.

[0165] Example of flexible matching: Between 14:00 and 15:00 on a certain day, the PM2.5 concentration increased from 35 μg / m³ to 55 μg / m³, while the number of people engaged in outdoor activities decreased by 30% during this period. After DTW alignment, it was found that the peak lag was 3 minutes. By correcting the alignment path through curvature constraints, the trend matching degree of the two curves improved from 0.7 to 0.92.

[0166] Furthermore, the specific process of generating a spatiotemporally consistent multimodal feature matrix includes:

[0167] Rows: Time slices (one slice every 5 minutes);

[0168] Examples: Modal characteristics (environmental indicators, behavioral density, facility status, etc.);

[0169] Element values: Feature values ​​after Z-score standardization. For example, the feature vector of a certain time slice is [1.2, -0.5, 2.1], which corresponds to high pollution, low population flow, and normal facilities, respectively.

[0170] The multimodal feature matrix is ​​subjected to Fourier transform to extract frequency domain energy distribution features, and the probability density function of regional hotspot distribution is calculated by kernel density estimation algorithm. Areas exceeding a preset threshold are marked as high-risk areas.

[0171] Furthermore, the Fourier transform employs the Fast Fourier Transform (FFT) algorithm, with a window length set to 24 hours (288 5-minute slices), to extract the main frequency components:

[0172] Fundamental frequency: corresponding to the daily cycle (1 / 86400 Hz);

[0173] Harmonics: Capture abnormal fluctuations (such as garbage collection disturbances that occur every 3 hours).

[0174] Frequency domain energy characteristics are used to calculate the power spectral density (PSD) of each frequency component. For example, an anomalous peak at 2.78e-5 Hz (approximately a 10-hour period) in a certain region indicates that periodic clustering activities may pose a risk.

[0175] Kernel density estimation (KDE) uses a Gaussian kernel function, and the bandwidth is selected using the Silverman criterion.

[0176] Where σ is the standard deviation, IQR is the interquartile range, and n is the number of samples. Hotspot probabilities are calculated for a community grid (50m × 50m), with the threshold set at the 85th percentile.

[0177] For example, the fitness area reached a density value of 0.92 at night (threshold 0.85), and was marked as a high-risk area.

[0178] Based on the spatiotemporal location of high-risk areas, a graph diffusion model is used to simulate the propagation path of risks along the facility network, and a random walk algorithm is used to predict potential propagation directions to generate a weighted risk propagation path map.

[0179] Furthermore, the graph diffusion model is based on a facility topology graph (nodes = facilities, edges = physical connections / functional dependencies):

[0180] Initialization: Inject initial energy E (e.g., energy value 1.0 in the fitness area) into nodes in high-risk areas.

[0181] Diffusion equation: The thermal diffusion equation is adopted. The diffusion coefficient α = 0.3, t is time, and the simulation shows the decay and propagation of energy over time steps (5 minutes each).

[0182] Boundary constraints: Energy reflection boundaries are set at road nodes to prevent energy from overflowing the community area.

[0183] Furthermore, the specific process of prediction by the random walk algorithm includes:

[0184] Transition probability: The probability of moving from node i to j Weight Take the facility association strength (e.g., the weight from the fitness area to the trail is 0.7), where k is the number of nodes;

[0185] Walk path: Starting from a high-risk node, perform 1000 walks with a step size of 50 steps, and record the frequency of visits;

[0186] Path weights: Normalized frequency is used as weights (0~1) to generate a risk propagation path map.

[0187] For example, the risk of transmission from fitness areas to children's playgrounds has a weight of 0.65, while the risk of transmission to community service centers has a weight of only 0.15.

[0188] Specifically, the risk propagation path map is fused with the multimodal feature matrix using tensor fusion, and redundant dimensions are compressed using high-order singular value decomposition to output a low-rank feature tensor containing regional hotspot distribution and risk propagation path.

[0189] Furthermore, the specific process of tensor fusion of the risk propagation path map and the multimodal feature matrix includes:

[0190] It should be noted that tensor fusion is achieved through a third-order tensor. accomplish;

[0191] Timeline: 288 slices (24 hours);

[0192] Spatial axis: 100 grids in the community;

[0193] Characteristic axes: 10 dimensions including environmental indicators, behavioral density, facility status, and propagation weight.

[0194] Furthermore, the specific process of Higher-Order Singular Value Decomposition (HOSVD) includes:

[0195] Kernel tensor extraction: retain the top 5, 10, and 3 principal components in the time, space, and feature dimensions, respectively;

[0196] Dimensional compression: The original tensor (288×100×10) is compressed to (5×10×3), with a compression rate of 98.3%;

[0197] Reconstruction error control: Set a relative error threshold of <5%, and adjust the number of principal components iteratively to meet the requirements;

[0198] The output is a low-rank feature tensor containing the distribution of regional hotspots and the risk propagation path.

[0199] For example, the low-rank feature tensor is as follows: Temporal pattern: capturing the bimodal features of morning and evening rush hours; Spatial pattern: identifying three hotspots: fitness area, children's playground, and garbage station; Feature pattern: environmental indicator weight 0.7, behavior density weight 0.5, and propagation weight 0.9.

[0200] Specifically, based on the risk propagation path in the low-rank feature tensor, a dynamic risk knowledge graph is constructed, and the conditional probability of each risk node is calculated using a causal inference model to generate the probability prediction result of the risk transmission chain.

[0201] It should be noted that the construction of the dynamic risk knowledge graph is based on a graph database (such as Neo4j). Key nodes in the risk propagation path (such as "garbage accumulation", "equipment aging", and "resident complaints") are used as graph nodes. Node attributes include risk type, geographical location, and occurrence frequency. Edges represent causal relationships (such as "garbage accumulation → increased probability of germ growth"), and edge weights are jointly determined by the co-occurrence frequency in historical data and expert experience.

[0202] For example, if historical data from a community shows that resident complaints increase by 60% after garbage accumulates for more than 48 hours, then the weight of that side is set to 0.6.

[0203] It should be noted that the causal inference model employs a Bayesian Network, automatically constructing a causal relationship graph through a structure learning algorithm (such as PC algorithm). The node conditional probability table (CPT) is calculated using maximum likelihood estimation (MLE).

[0204] For example, the failure probability of the "equipment aging" node under the condition of "maintenance cycle > 2 years" is 35%. The probability prediction of the risk propagation chain is implemented through the Junction Tree Algorithm, which calculates the cumulative probability of multiple propagation paths. The total probability of the "equipment aging → circuit short circuit → fire risk" path is 0.35 × 0.7 = 24.5%.

[0205] Specifically, the probability prediction results are input into a cross-modal adversarial generative network. The generator simulates the intervention effects of different governance strategies, and the discriminator evaluates the feasibility of the strategies by combining resident satisfaction feedback data, and outputs a set of strategies with weighted scores.

[0206] It should be noted that the Cross-Modal GAN ​​includes the following components: Generator: Input: risk probability vector (e.g., [fire risk 0.25, complaint risk 0.4]) and resource constraints (budget ≤ 100,000 yuan); Structure: 4-layer fully connected network (512-256-128-64), activation function is LeakyReLU (negative slope 0.2); Output: governance strategy vector, such as "increase garbage collection frequency (3 times / day), with a budget of 20,000 yuan".

[0207] Discriminator: Input: governance strategy vector + resident satisfaction score (from historical survey data, 0~100 points); Structure: 3-layer convolutional network (kernel size 3×3, number of channels 32-64-128), output is the feasibility score of the strategy (0~1); Training objective: to distinguish between generated strategies and effective strategies formulated by experts (positive samples).

[0208] Adversarial training process: Generator training: Generate 100 policy sets, score them through the discriminator, and then optimize the generator parameters through backpropagation (Adam optimizer, learning rate 0.0002); Discriminator training: Mix generated policies with real policies (1:1 ratio), use binary classification cross-entropy loss function (BCELoss), learning rate 0.0001; Multimodal fusion: Associate environmental monitoring data (such as PM2.5 values) with policy effects. For example, if PM2.5 decreases by 15% after the frequency of waste collection increases, the policy weight will be increased.

[0209] For example, a strategy scoring example is as follows:

[0210] Strategy A: Add 5 trash cans, budget 15,000 yuan, feasibility score 0.88;

[0211] Strategy B: Conduct environmental protection publicity, budget 0.8 million yuan, score 0.75.

[0212] Specifically, Pareto frontier analysis is performed on the strategy set, and the comprehensive weights of risk level, resource consumption and resident satisfaction are calculated using the entropy weight method to generate a decision matrix that includes the optimal intervention path and risk level.

[0213] It should be noted that the Pareto front analysis uses the NSGA-II algorithm (non-dominated sorting genetic algorithm): population size: 100 policy individuals; objective function: minimize risk level (normalized to 0~1); minimize resource consumption (budget percentage, 0~1); maximize resident satisfaction (normalized to 0~1).

[0214] Genetic operations: simulated binary crossover (crossover probability 0.8) and polynomial mutation (mutation probability 0.1).

[0215] Entropy weight method for calculating weights: Data standardization: normalize each indicator (e.g., risk level = 0.7, resource consumption = 0.3, satisfaction = 0.8); Information entropy calculation: risk level entropy value H1 = 0.65; resource consumption entropy value H2 = 0.82; satisfaction entropy value H3 = 0.58.

[0216] Weighting: Risk weight W1=(1-H1) / Σ(1-H)= (0.35) / (0.35+0.18+0.42)= 0.37; Resource weight W2=0.19; Satisfaction weight W3=0.44.

[0217] Furthermore, the specific process of generating the decision matrix includes:

[0218] Column definition: Strategy number, risk level, resource consumption, satisfaction, overall score (0.37 × risk + 0.19 × resources + 0.44 × satisfaction).

[0219] Sorting rule: Sort by overall score in descending order, and select the top 10% as the optimal solution. For example:

[0220] Table 1

[0221] Strategy risk resource Satisfaction Overall score A 0.2 0.3 0.9 0.69 B 0.4 0.2 0.8 0.62

[0222] The robustness of the decision matrix is ​​verified using a counterfactual reasoning model. The comparison results without intervention are simulated, and the decision parameters are dynamically adjusted based on the comparison differences to generate the final decision matrix.

[0223] It should be noted that the counterfactual reasoning model is based on the structural causal model (SCM) and constructs a "intervention-outcome" comparison scenario:

[0224] Real-world scenario: After implementing strategy A, the risk level is 0.2, and the satisfaction level is 0.9.

[0225] Counterfactual scenario: Assume strategy A is not implemented, risk level = 0.6, satisfaction level = 0.7;

[0226] Effect calculation: Risk reduction Δ=0.4, satisfaction increase Δ=0.2.

[0227] Furthermore, the specific process of dynamically adjusting decision parameters based on comparative differences includes:

[0228] Sensitivity analysis: Adjust the edge weights in the cause-effect graph (e.g., the weight of "number of trash cans → satisfaction" from 0.6 to 0.8), and recalculate the strategy score;

[0229] Robustness threshold: If the strategy score fluctuates by more than 10%, it is judged as an unstable strategy and needs to be re-optimized;

[0230] Parameter update: Adjust the weight allocation in the entropy weight method according to the counterfactual difference (e.g., risk weight from 0.37 to 0.4).

[0231] Specifically, the final decision matrix is ​​input into the strategy optimization engine, the particle swarm is initialized using Latin hypercube sampling, governance efficiency, resource consumption and resident satisfaction are defined as optimization objectives, and a preliminary governance instruction set is generated through non-dominated sorting.

[0232] It should be noted that the core of the strategy optimization engine is to find the optimal balance among three conflicting objectives—governance efficiency, resource consumption, and resident satisfaction—using the multi-objective particle swarm optimization (MOPSO) algorithm. First, Latin hypercube sampling (LHS) is used to generate the initial particle swarm, ensuring uniform coverage of the solution space.

[0233] Furthermore, the specific parameters of the strategy optimization engine are set as follows:

[0234] Number of particles: 200, each particle corresponds to a governance strategy (such as "increase the frequency of community patrols to 3 times a day" or "invest 500,000 yuan in waste sorting facilities").

[0235] Search space dimensions: 3 dimensions, corresponding to governance efficiency (unit: event processing volume / hour), resource consumption (unit: 10,000 yuan), and resident satisfaction (0~100 points).

[0236] Sampling rule: Each dimension is divided into 20 equally probable intervals, ensuring that each interval is covered by only one particle. For example, the intervals for the resource consumption dimension are [0,5), [5,10)...[95,100], and a value is randomly selected from each interval.

[0237] Furthermore, after particle swarm initialization, the specific process of stratifying particles through non-dominated sorting includes:

[0238] Objective function calculation: Three objective values ​​are evaluated for each particle.

[0239] For example, a certain strategy has a governance efficiency of 80 events / hour, a resource consumption of 300,000 yuan, and a satisfaction score of 75.

[0240] Dominance determination: If particle A is not inferior to particle B on all targets and is superior to particle B on at least one target, then A dominates B;

[0241] Pareto hierarchy: The first layer consists of all non-dominated particles, the second layer consists of particles dominated by the first layer but not by any other layer, and so on. After 5 iterations, the top 50 non-dominated particles are selected to form the initial governance instruction set.

[0242] For example, after a certain initialization, non-dominated sorting generates the following typical strategies:

[0243] Strategy A: Efficiency 85 / hour, Consumption 450,000, Satisfaction 80;

[0244] Strategy B: Efficiency 70 / hour, Consumption 250,000, Satisfaction 85;

[0245] Strategy C: Efficiency 90 / hour, Consumption 600,000, Satisfaction 70.

[0246] Specifically, the initial governance instruction set is mapped to a digital twin platform, the instruction execution process is simulated through discrete event simulation, governance effect data is collected in the virtual environment, and a simulation evaluation report is generated.

[0247] It should be noted that the digital twin platform is built based on the AnyLogic simulation tool, mapping the governance instruction set to executable actions in the virtual community model. Simulation parameters include:

[0248] Time step: 1 minute, simulation period is 30 days (i.e. 43,200 steps).

[0249] Entities: Resident Agents (1000), Public Facilities (50 categories), Environmental Sensors (200);

[0250] Event triggering rules: If the garbage sorting error rate exceeds 5%, an educational publicity instruction will be triggered.

[0251] Furthermore, the specific process of the discrete event simulation includes:

[0252] Command Injection: The "increase patrol frequency" command of Strategy A is converted into the movement path planning of virtual security guards, and the patrol interval is shortened from 4 hours to 2 hours;

[0253] Data collection on governance effectiveness:

[0254] Governance efficiency: Statistics on incident response time (e.g., the time from reporting to resolution);

[0255] Resource consumption: Calculate virtual budget expenditures (security personnel costs + facility maintenance costs);

[0256] Resident satisfaction: dynamically scored using an agent-based sentiment model (based on event processing speed and fairness).

[0257] Based on the collected data on governance effectiveness, a projection and evaluation report is generated;

[0258] It should be noted that the aforementioned simulation and evaluation report includes:

[0259] Key metrics: Efficiency improvement rate (%), resource overrun rate (%), and satisfaction fluctuation range;

[0260] Anomaly detection: Mark conflict events that occur in the simulation (such as instruction delays caused by resource contention).

[0261] For example, simulation results for Strategy A show that increasing patrol frequency reduces the time to handle security incidents from 2 hours to 1 hour, but increases manpower costs by 12% and reduces satisfaction by 5% due to increased noise complaints.

[0262] Specifically, based on the aforementioned simulation and evaluation report, a fuzzy controller is used to calculate the urgency score of each instruction, dynamically adjust the instruction priority, generate a hierarchical governance instruction set, and form an intelligent governance strategy chain.

[0263] Furthermore, the input variables of the fuzzy controller are the three indicators in the deduction report:

[0264] Efficiency deviation (ΔE): The difference between actual efficiency and target efficiency (e.g., target 100 events / hour, actual 85 → ΔE = 15).

[0265] Resource Deviation (ΔR): The difference between actual consumption and budget (budget 400,000, actual 450,000 → ΔR = 50,000).

[0266] Satisfaction deviation (ΔS): The difference between the actual rating and the expected rating (expected 80, actual 75 → ΔS=5).

[0267] The fuzzy rule base contains 27 rules, for example:

[0268] Rule 1: If ΔE is high, ΔR is low, and ΔS is medium, then the urgency score is high;

[0269] Rule 2: If ΔE is medium, ΔR is high, and ΔS is low, then the urgency score is medium.

[0270] Defuzzification uses the centroid method to convert fuzzy outputs into specific scores (0-100 points). For example, the fuzzy inference result of a certain instruction is "high urgency", with a score of 85 points.

[0271] Furthermore, the specific process of dynamically adjusting instruction priorities, generating a hierarchical governance instruction set, and forming an intelligent governance strategy chain includes:

[0272] Score Ranking: Instructions are sorted in descending order of urgency, such as: Instruction X (score 92): Emergency response to rainstorm; Instruction Y (score 85): Construction of additional waste sorting facilities;

[0273] Resource allocation: Reserve resources for high-priority instructions (e.g., instruction X uses 30% of the budget);

[0274] Based on the scoring and resource allocation, a hierarchical governance instruction set is generated, thereby forming an intelligent governance strategy chain; it should be noted that the intelligent governance strategy chain includes:

[0275] Emergency Layer (score ≥ 80): Execute immediately; Regular Layer (60 ≤ score < 80): Execute as planned; Optimization Layer (score < 60): Execute temporarily and re-optimize.

[0276] For example: After adjustment, the policy chain becomes:

[0277] Emergency Level: Rainstorm Emergency Response (to be activated within 24 hours);

[0278] Regular level: Increase security patrols (to be completed within 7 days);

[0279] Optimization layer: Community greening renovation (redesign plan required).

[0280] Specifically, based on real-time governance feedback data after the execution of the hierarchical governance instruction set, the fuzzy Q-learning algorithm is used to detect conflicting instructions in the intelligent governance strategy chain, calculate the conflict intensity value between instructions, and generate a set of conflicting instructions.

[0281] After the hierarchical governance instruction set is executed, real-time governance feedback data is collected through community IoT terminals, including indicators such as resident satisfaction scores (0~100 points), resource consumption (such as electricity consumption kWh), and task completion time (seconds).

[0282] It should be noted that the fuzzy Q-learning algorithm is used to detect instruction conflicts, and its core is to fuzzify continuous feedback data into discrete states:

[0283] For example, fuzzification processing based on the fuzzy Q-learning algorithm includes:

[0284] Satisfaction level: Divided into three fuzzy sets: "low (0~30)", "medium (31~70)" and "high (71~100)".

[0285] Resource consumption: Classified into "low (<50kWh)", "medium (50~100kWh)" and "high (>100kWh)";

[0286] Task time is divided into "fast (<30s)", "normal (30~60s)" and "slow (>60s)".

[0287] State-Action Mapping: Define 27 fuzzy states (3×3×3) and correspond to 9 actions (such as "increase resource input" and "adjust task priority").

[0288] Furthermore, the specific process for calculating the conflict intensity value between instructions includes:

[0289] The command's performance deviates when using Euclidean distance as a metric.

[0290] For example, instruction A expects a satisfaction score of 80 but the actual score is 50, the deviation distance is... Conflict intensity = 30 / 100 = 0.3 (the threshold is set to 0.2; exceeding this value indicates a conflict).

[0291] Conflict detection process:

[0292] Q-table update: learning rate α = 0.1, discount factor γ = 0.9, initial Q values ​​are all 0;

[0293] Conflict flag: When the feedback data of two commands both trigger a conflict within the same time period (e.g., command 1 exceeds the resource consumption limit, command 2 experiences a sharp drop in satisfaction), they are marked as a conflicting command pair;

[0294] Generate a set of conflicting instructions based on the conflicting instruction pairs;

[0295] It should be noted that the set of conflicting instructions includes: conflicting instruction pairs, conflict types (resource-satisfaction conflict, time-resource conflict, etc.), and conflict intensity values;

[0296] For example, the conflicting instruction pair is: Instruction 23 (resource consumption 105kWh) & Instruction 45 (satisfaction score 42); Conflict type: resource-satisfaction conflict; Conflict intensity value: 0.65.

[0297] Specifically, the set of conflict instructions is input into the deep deterministic policy gradient model, the parameter correction scheme is generated through the Actor network, the comprehensive benefits after correction are evaluated through the Critic network, and the optimized intelligent governance strategy is output.

[0298] It should be noted that the Deep Deterministic Policy Gradient (DDPG) model consists of an Actor network and a Critic network: the Actor network (4 fully connected layers, 512 / 256 hidden layers, 9-dimensional output layer): the input is the conflict instruction features (such as conflict type and intensity value), and the output is the parameter correction scheme (such as resource allocation ratio ±15%, task priority adjustment level ±2); the Critic network (3 convolutional layers + 2 fully connected layers): the input is the corrected policy parameters, and the output is the comprehensive benefit score (0~1, 0.8 indicates excellent).

[0299] The final output is the optimized intelligent governance strategy;

[0300] It should be noted that the intelligent governance strategy adjusts and encapsulates the parameters of conflicting instruction pairs into a new instruction version.

[0301] The iterative trajectory of the intelligent governance strategy is encapsulated into a smart contract, written into the blockchain evidence storage network through a consensus algorithm, and an immutable record with timestamps and hash values ​​is generated to achieve the verifiability and traceability of the governance process.

[0302] As can be seen, by deploying an IoT sensor network in grassroots communities to collect multi-source heterogeneous data in real time, a standardized multimodal sensing data stream is generated. Based on the multimodal sensing data stream, a spatiotemporally correlated cleaned dataset is output. The cleaned dataset is input into a multi-scale spatiotemporal encoder to generate a feature tensor containing regional hotspot distribution and risk propagation paths. Based on the feature tensor, a dynamic risk knowledge graph is constructed, and a decision matrix containing risk levels and optimal intervention paths is output. The decision matrix is ​​input into a strategy optimization engine to obtain a hierarchical governance instruction set. Based on real-time governance feedback data after executing the hierarchical governance instruction set, a fuzzy reinforcement learning algorithm is used to autonomously correct conflicting instructions in the strategy chain. This enables an efficient, intelligent, and traceable digital governance solution to improve the efficiency and service quality of social governance.

[0303] Another embodiment of the present invention provides a grassroots social digital governance system, see [link to relevant documentation]. Figure 3 The system may include:

[0304] The acquisition module 301 is used to collect multi-source heterogeneous data in real time through the Internet of Things sensor network deployed in grassroots communities. The multi-source heterogeneous data includes residents' behavior trajectories, public facility status and environmental monitoring indicators. An adaptive spatiotemporal filtering algorithm is used to remove abnormal noise and perform spatiotemporal alignment processing on the multi-source heterogeneous data to generate a standardized multimodal sensing data stream.

[0305] The detection module 302 is used to detect semantic ambiguity and logical conflict in the data based on the multimodal perception data stream by using a conflict resolution knowledge graph, construct a data cleaning model using a dynamic rule engine, and perform topological structure matching and deduplication on duplicate data using a graph neural network, and output a spatiotemporally related cleaned dataset.

[0306] The extraction module 303 is used to input the cleaned dataset into the multi-scale spatiotemporal encoder, extract the spatiotemporal correlation features in the data by fusing a temporal convolutional network and a graph attention mechanism, and align the evolution trends of different modal data based on the dynamic time warping algorithm to generate a feature tensor containing regional hotspot distribution and risk propagation path.

[0307] The prediction module 304 is used to construct a dynamic risk knowledge graph based on the feature tensor, use a causal reasoning model to predict the probability of potential risks in grassroots social governance, simulate the intervention effects of different governance strategies through a cross-modal adversarial generative network, and output a decision matrix containing risk level and optimal intervention path.

[0308] The generation module 305 is used to input the decision matrix into the strategy optimization engine, and simultaneously optimize the governance efficiency, resource consumption and resident satisfaction indicators using a multi-objective particle swarm algorithm to generate a preliminary governance instruction set. The execution effect of the instructions is then virtually simulated through a digital twin platform, and the instruction priority is dynamically adjusted based on the simulation results to obtain a hierarchical governance instruction set, forming an intelligent governance strategy chain.

[0309] The correction module 306 is used to autonomously correct conflicting instructions in the policy chain based on real-time governance feedback data after executing the hierarchical governance instruction set, and record the policy iteration trajectory in the blockchain evidence storage network to achieve the verifiability and traceability of the governance process.

[0310] As can be seen, by deploying an IoT sensor network in grassroots communities to collect multi-source heterogeneous data in real time, a standardized multimodal sensing data stream is generated. Based on the multimodal sensing data stream, a spatiotemporally correlated cleaned dataset is output. The cleaned dataset is input into a multi-scale spatiotemporal encoder to generate a feature tensor containing regional hotspot distribution and risk propagation paths. Based on the feature tensor, a dynamic risk knowledge graph is constructed, and a decision matrix containing risk levels and optimal intervention paths is output. The decision matrix is ​​input into a strategy optimization engine to obtain a hierarchical governance instruction set. Based on real-time governance feedback data after executing the hierarchical governance instruction set, a fuzzy reinforcement learning algorithm is used to autonomously correct conflicting instructions in the strategy chain. This enables an efficient, intelligent, and traceable digital governance solution to improve the efficiency and service quality of social governance.

[0311] This invention also provides a storage medium storing a computer program, wherein the computer program is configured to execute the steps in any of the above method embodiments when running.

[0312] Specifically, in this embodiment, the storage medium can be configured to store a computer program for performing the following steps:

[0313] S201, real-time collection of multi-source heterogeneous data through IoT sensor networks deployed in grassroots communities, including residents' behavior trajectories, public facility status and environmental monitoring indicators, and the use of an adaptive spatiotemporal filtering algorithm to remove abnormal noise and perform spatiotemporal alignment processing on the multi-source heterogeneous data to generate a standardized multimodal sensing data stream.

[0314] S202, based on the multimodal perception data stream, semantic ambiguity and logical conflict in the data are detected by conflict resolution knowledge graph, a data cleaning model is constructed using dynamic rule engine, and graph neural network is used to perform topological structure matching and deduplication of duplicate data, and a spatiotemporally related cleaned dataset is output.

[0315] S203: The cleaned dataset is input into a multi-scale spatiotemporal encoder. The spatiotemporal correlation features in the data are extracted by fusing a temporal convolutional network and a graph attention mechanism. The evolution trend of different modal data is aligned based on a dynamic time warping algorithm to generate a feature tensor containing regional hotspot distribution and risk propagation path.

[0316] S204. Based on the feature tensor, a dynamic risk knowledge graph is constructed. A causal reasoning model is used to predict the probability of potential risks in grassroots social governance. The intervention effects of different governance strategies are simulated through a cross-modal adversarial generative network. A decision matrix containing risk level and optimal intervention path is output.

[0317] S205 inputs the decision matrix into the strategy optimization engine, uses a multi-objective particle swarm algorithm to simultaneously optimize governance efficiency, resource consumption and resident satisfaction indicators, generates a preliminary governance instruction set, and uses a digital twin platform to virtually simulate the execution effect of the instructions. Based on the simulation results, the priority of the instructions is dynamically adjusted to obtain a hierarchical governance instruction set and form an intelligent governance strategy chain.

[0318] S206, based on real-time governance feedback data after executing the hierarchical governance instruction set, autonomously corrects conflicting instructions in the policy chain through a fuzzy reinforcement learning algorithm, and records the policy iteration trajectory in the blockchain evidence storage network, thereby achieving the verifiability and traceability of the governance process.

[0319] As can be seen, by deploying an IoT sensor network in grassroots communities to collect multi-source heterogeneous data in real time, a standardized multimodal sensing data stream is generated. Based on the multimodal sensing data stream, a spatiotemporally correlated cleaned dataset is output. The cleaned dataset is input into a multi-scale spatiotemporal encoder to generate a feature tensor containing regional hotspot distribution and risk propagation paths. Based on the feature tensor, a dynamic risk knowledge graph is constructed, and a decision matrix containing risk levels and optimal intervention paths is output. The decision matrix is ​​input into a strategy optimization engine to obtain a hierarchical governance instruction set. Based on real-time governance feedback data after executing the hierarchical governance instruction set, a fuzzy reinforcement learning algorithm is used to autonomously correct conflicting instructions in the strategy chain. This enables an efficient, intelligent, and traceable digital governance solution to improve the efficiency and service quality of social governance.

[0320] This invention also provides an electronic device, including 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 of the above method embodiments.

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

[0322] Specifically, in this embodiment, the processor can be configured to perform the following steps via a computer program:

[0323] S201, real-time collection of multi-source heterogeneous data through IoT sensor networks deployed in grassroots communities, including residents' behavior trajectories, public facility status and environmental monitoring indicators, and the use of an adaptive spatiotemporal filtering algorithm to remove abnormal noise and perform spatiotemporal alignment processing on the multi-source heterogeneous data to generate a standardized multimodal sensing data stream.

[0324] S202, based on the multimodal perception data stream, semantic ambiguity and logical conflict in the data are detected by conflict resolution knowledge graph, a data cleaning model is constructed using dynamic rule engine, and graph neural network is used to perform topological structure matching and deduplication of duplicate data, and a spatiotemporally related cleaned dataset is output.

[0325] S203: The cleaned dataset is input into a multi-scale spatiotemporal encoder. The spatiotemporal correlation features in the data are extracted by fusing a temporal convolutional network and a graph attention mechanism. The evolution trend of different modal data is aligned based on a dynamic time warping algorithm to generate a feature tensor containing regional hotspot distribution and risk propagation path.

[0326] S204. Based on the feature tensor, a dynamic risk knowledge graph is constructed. A causal reasoning model is used to predict the probability of potential risks in grassroots social governance. The intervention effects of different governance strategies are simulated through a cross-modal adversarial generative network. A decision matrix containing risk level and optimal intervention path is output.

[0327] S205 inputs the decision matrix into the strategy optimization engine, uses a multi-objective particle swarm algorithm to simultaneously optimize governance efficiency, resource consumption and resident satisfaction indicators, generates a preliminary governance instruction set, and uses a digital twin platform to virtually simulate the execution effect of the instructions. Based on the simulation results, the priority of the instructions is dynamically adjusted to obtain a hierarchical governance instruction set and form an intelligent governance strategy chain.

[0328] S206, based on real-time governance feedback data after executing the hierarchical governance instruction set, autonomously corrects conflicting instructions in the policy chain through a fuzzy reinforcement learning algorithm, and records the policy iteration trajectory in the blockchain evidence storage network, thereby achieving the verifiability and traceability of the governance process.

[0329] As can be seen, by deploying an IoT sensor network in grassroots communities to collect multi-source heterogeneous data in real time, a standardized multimodal sensing data stream is generated. Based on the multimodal sensing data stream, a spatiotemporally correlated cleaned dataset is output. The cleaned dataset is input into a multi-scale spatiotemporal encoder to generate a feature tensor containing regional hotspot distribution and risk propagation paths. Based on the feature tensor, a dynamic risk knowledge graph is constructed, and a decision matrix containing risk levels and optimal intervention paths is output. The decision matrix is ​​input into a strategy optimization engine to obtain a hierarchical governance instruction set. Based on real-time governance feedback data after executing the hierarchical governance instruction set, a fuzzy reinforcement learning algorithm is used to autonomously correct conflicting instructions in the strategy chain. This enables an efficient, intelligent, and traceable digital governance solution to improve the efficiency and service quality of social governance.

[0330] The above description, based on the embodiments shown in the figures, details the structure, features, and effects of the present invention. The above description is only a preferred embodiment of the present invention, but the present invention is not limited to the scope of implementation shown in the figures. Any changes made in accordance with the concept of the present invention, or equivalent embodiments modified to have equivalent changes, that do not exceed the spirit covered by the specification and figures, should be within the protection scope of the present invention.

Claims

1. A method for digital governance at the grassroots level, characterized in that, The method includes: The IoT sensor network deployed in grassroots communities collects multi-source heterogeneous data in real time. The multi-source heterogeneous data includes residents' behavior trajectories, public facility status and environmental monitoring indicators. An adaptive spatiotemporal filtering algorithm is used to remove abnormal noise and perform spatiotemporal alignment processing on the multi-source heterogeneous data to generate a standardized multimodal sensing data stream. Based on the multimodal sensing data stream, semantic ambiguity and logical conflict in the data are detected by conflict resolution knowledge graph, a data cleaning model is constructed using dynamic rule engine, and graph neural network is used to perform topological structure matching and deduplication of duplicate data, outputting a spatiotemporally related cleaned dataset. The cleaned dataset is input into a multi-scale spatiotemporal encoder. Spatiotemporal correlation features are extracted from the data by fusing a temporal convolutional network and a graph attention mechanism. The evolution trends of different modalities are aligned using a dynamic time warping algorithm to generate feature tensors containing regional hotspot distributions and risk propagation paths. The process of generating feature tensors containing regional hotspot distributions and risk propagation paths based on the cleaned dataset includes: inputting the cleaned dataset into the multi-scale spatiotemporal encoder; extracting periodic patterns of residents' behavioral trajectories using a temporal convolutional network; simultaneously capturing spatial dependencies between public facility nodes using a graph attention mechanism to generate a primary feature vector; and then, based on the primary feature vector, further processing is performed. The evolution trend of environmental monitoring indicators and residents' behavioral trajectories is aligned using a dynamic time warping algorithm, and sensor acquisition delay is eliminated through elastic matching with curvature constraints to generate a multimodal feature matrix. A Fourier transform is performed on the multimodal feature matrix to extract frequency domain energy distribution features, and then the probability density function of regional hotspot distribution is calculated. Areas exceeding a preset threshold are marked as high-risk areas. Based on these high-risk areas, a graph diffusion model is used to simulate the propagation path of risks along the facility network, thereby generating a risk propagation path map. The risk propagation path map is then fused with the multimodal feature matrix using tensors to generate a feature tensor containing regional hotspot distribution and risk propagation paths. Based on the aforementioned feature tensor, a dynamic risk knowledge graph is constructed. A causal reasoning model is used to predict the probability of potential risks in grassroots social governance. A cross-modal adversarial generative network is used to simulate the intervention effects of different governance strategies, and a decision matrix containing risk levels and optimal intervention paths is output. The decision matrix is ​​input into the strategy optimization engine, and the multi-objective particle swarm algorithm is used to simultaneously optimize the governance efficiency, resource consumption and resident satisfaction indicators to generate a preliminary governance instruction set. The execution effect of the instructions is then virtually simulated through a digital twin platform. The instruction priority is dynamically adjusted based on the simulation results to obtain a hierarchical governance instruction set and form an intelligent governance strategy chain. Based on real-time governance feedback data after executing the hierarchical governance instruction set, the conflicting instructions in the policy chain are autonomously corrected through fuzzy reinforcement learning algorithm, and the policy iteration trajectory is recorded in the blockchain evidence storage network to achieve the verifiability and traceability of the governance process.

2. The method according to claim 1, characterized in that, The process of generating a multimodal sensing data stream by performing abnormal noise removal and spatiotemporal alignment on multi-source heterogeneous data based on an adaptive spatiotemporal filtering algorithm includes: Based on the sliding window mechanism in the adaptive spatiotemporal filtering algorithm, local variance analysis is performed on the data stream of each sensor node, and outliers exceeding the preset range are marked as noise candidate regions to generate an initial noise mask matrix. Based on the initial noise mask matrix, the timestamp offset in the heterogeneous data is compensated; the environmental monitoring indicators and public facility status data are spatiotemporally aligned, and the spatiotemporal density of residents' movement trajectories is introduced as a weighting factor to correct the alignment path, generating multimodal data blocks; The multimodal data block is input into a multichannel autoencoder for feature weight allocation, thereby generating a multimodal sensing data stream.

3. The method according to claim 2, characterized in that, Based on the multimodal sensing data stream, semantic ambiguity and logical conflicts are detected. A data cleaning model is built using a dynamic rule engine. Duplicate data is then subjected to topological structure matching and deduplication. The process of outputting the cleaned dataset includes: Based on the entity relationships in the multimodal perception data stream, semantic triples are extracted and combined with the domain knowledge base to construct a conflict resolution knowledge graph. The nodes in the conflict resolution knowledge graph represent entities or events, and the edges represent logical dependencies. Based on the logical dependencies, a dynamic rule engine is used to detect semantic ambiguity, calculate the conflict confidence, and generate a set of logical conflict events. The set of logical conflict events is input into a graph neural network, and the repeated events are matched for topological structure. Redundant nodes are aggregated, and the cleaned dataset is output.

4. The method according to claim 3, characterized in that, The process of constructing a dynamic risk knowledge graph based on the feature tensor, and then generating a decision matrix, includes: Based on the risk propagation path in the feature tensor, a dynamic risk knowledge graph is constructed, and the conditional probability of each risk node is calculated using a causal reasoning model to generate the probability prediction result of the risk transmission chain. The probability prediction results are input into a cross-modal adversarial generative network, which then outputs a set of policies with weighted scores. Pareto front analysis is performed on the set of strategies to generate a decision matrix that includes the optimal intervention path and risk level.

5. The method according to claim 4, characterized in that, Based on the decision matrix, the process of forming an intelligent governance strategy chain includes: The decision matrix is ​​input into the strategy optimization engine to generate a preliminary governance instruction set, which is then mapped to the digital twin platform to generate a simulation and evaluation report. Based on the aforementioned simulation and evaluation report, the urgency score of each instruction is calculated using a fuzzy controller, the instruction priority is dynamically adjusted, a hierarchical governance instruction set is generated, and thus an intelligent governance strategy chain is formed.

6. The method according to claim 5, characterized in that, Based on a hierarchical governance instruction set, the process of achieving verifiability and traceability of the governance process includes: Based on the real-time governance feedback data after the execution of the hierarchical governance instruction set, conflicting instructions in the intelligent governance strategy chain are detected by the fuzzy Q-learning algorithm, the conflict intensity value between instructions is calculated, and a set of conflicting instructions is generated. The set of conflict instructions is input into the deep deterministic policy gradient model, and then the optimized intelligent governance policy is output. The strategy iteration trajectory is encapsulated into a smart contract, thereby generating an immutable record with timestamps and hash values, achieving verifiability and traceability of the governance process.

7. A grassroots social digital governance system, characterized in that, The system includes: The data acquisition module is used to collect multi-source heterogeneous data in real time through an Internet of Things sensor network deployed in grassroots communities. The multi-source heterogeneous data includes residents' behavior trajectories, public facility status and environmental monitoring indicators. The module performs abnormal noise removal and spatiotemporal alignment processing on the multi-source heterogeneous data to generate a multimodal sensing data stream. The detection module is used to detect multimodal sensing data streams, build a data cleaning model, combine graph neural networks to perform topological structure matching and deduplication of duplicate data, and output the cleaned dataset. The extraction module is used to extract spatiotemporal correlation features from the cleaned dataset and align the evolution trends of different modalities based on the dynamic time warping algorithm to generate feature tensors. The process of generating feature tensors containing regional hotspot distribution and risk propagation paths based on the cleaned dataset includes: inputting the cleaned dataset into a multi-scale spatiotemporal encoder, extracting periodic patterns of residents' behavioral trajectories through a temporal convolutional network, and simultaneously capturing the spatial dependencies between public facility nodes using a graph attention mechanism to generate primary feature vectors; and using the dynamic time warping algorithm to correlate environmental monitoring indicators with residents' behavior. Aligning the trajectory evolution trend and eliminating sensor acquisition delay through elastic matching with curvature constraints, a multimodal feature matrix is ​​generated. Fourier transform is performed on the multimodal feature matrix to extract frequency domain energy distribution features, and then the probability density function of regional hotspot distribution is calculated. Areas exceeding a preset threshold are marked as high-risk areas. Based on these high-risk areas, a graph diffusion model is used to simulate the risk propagation path along the facility network, thereby generating a risk propagation path map. The risk propagation path map is then fused with the multimodal feature matrix using tensors to generate a feature tensor containing regional hotspot distribution and risk propagation paths. The prediction module is used to construct a dynamic risk knowledge graph, perform probabilistic predictions of potential risks in grassroots social governance, and then generate a decision matrix. The generation module is used to input the decision matrix into the strategy optimization engine, generate a preliminary governance instruction set, and virtually simulate the execution effect of the instructions through the digital twin platform. Based on the simulation results, the priority of the instructions is dynamically adjusted to obtain a hierarchical governance instruction set, thereby forming an intelligent governance strategy chain. The correction module, based on the hierarchical governance instruction set, further enables the verifiability and traceability of the governance process.

8. A storage medium, characterized in that, The storage medium stores a computer program, wherein the computer program is configured to execute the method of any one of claims 1-6 when it is run.

9. An electronic device comprising a memory and a processor, characterized in that, The memory stores a computer program, and the processor is configured to run the computer program to perform the method of any one of claims 1-6.

Images