Methods, apparatus, equipment and storage media for correcting event time information

Abstract

This invention belongs to the field of data processing technology and discloses a method, apparatus, device, and storage medium for correcting event time information. The method includes: analyzing events based on a set of temporal constraint relationships, constructing a temporal knowledge graph with event types as nodes and temporal constraint relationships between event types as directed edges; mapping the temporal data of events to event type nodes in the temporal knowledge graph to generate an instantiated temporal graph; performing interval constraint propagation on the instantiated temporal graph to detect node pairs that violate temporal constraint relationships; and performing a minimum cost correction strategy on nodes based on the correction cost weight of node pairs to generate corrected temporal data for the target node. This invention can be applied to business management systems in fintech, healthcare, and other fields, solving the technical problem of balancing the comprehensiveness of temporal data verification with the economy and adaptability of temporal data correction.

Description

Technical Field

[0001] This invention belongs to the field of data processing technology and is applied in the fields of financial technology and healthcare. In particular, it relates to a method, apparatus, device and storage medium for correcting event time information. Background Technology

[0002] In fields such as health insurance and medical technology, which rely on event time-series data, the correctness of the temporal logic between events directly determines the compliance of business operations and the standardization of treatment processes. Deviations in time-series data can lead to serious business risks and medical errors. For example, in health insurance scenarios, the temporal relationship between events such as claims application, claims review, and disease diagnosis directly affects the compliance and accuracy of claims processing; in medical technology scenarios, the temporal logic of events such as initial diagnosis, examination, and test result issuance directly relates to the rationality of treatment plans and the quality of medical care. Therefore, the verification and correction of event time-series data is one of the core requirements in these fields.

[0003] Currently, existing solutions for processing event time-series data generally suffer from core bottlenecks that are difficult to overcome: when validating time-series data, existing solutions often only focus on some time-series logic requirements and cannot fully cover various time-series rules. This results in a large amount of deviation data that does not meet implicit time-series requirements not being effectively detected, which in turn affects the standardization of subsequent business processing or diagnosis and treatment procedures. After detecting deviations in time-series data, existing solutions lack scientific correction and evaluation standards and cannot formulate differentiated correction strategies based on the characteristics of different events. They can only adopt a uniform and non-targeted correction method, which leads to excessive and unnecessary investment of resources in the correction process, resulting in high correction costs. Moreover, the corrected time-series data often does not conform to actual business processes and diagnosis and treatment standards, and has poor adaptability.

[0004] Specifically in the health insurance scenario, existing solutions, when correcting time-series data related to claims, often only check whether the basic sequence of events is reasonable, failing to comprehensively cover various time-series requirements. This results in some time-series deviations that do not conform to business specifications going undetected. Furthermore, once a time-series deviation is detected, the time-series data of the relevant events can only be adjusted randomly or uniformly. This not only increases correction costs but may also lead to problems such as invalid claims evidence and business process violations due to incorrectly correcting the time-series data of core business events. For example, some existing solutions, after discovering anomalies in the time-series of claims-related events, fail to distinguish between core events such as disease diagnosis and claims review and other auxiliary events, blindly adjusting the time-series data of core events. This results in conflicts with actual diagnosis and treatment and claims processes, increasing business risks and correction costs.

[0005] In medical technology scenarios, existing solutions for correcting discrepancies in treatment time-series data also suffer from similar problems: the verification process only focuses on some basic time-series logic, failing to comprehensively detect various time-series deviations, resulting in the failure to promptly identify issues such as abnormal test result issuance times; after detecting deviations, there is a lack of scientific evaluation criteria for correction, making it impossible to develop appropriate correction strategies based on the characteristics of different treatment events. Instead, the time-series data of related events is uniformly adjusted, leading to discrepancies between the corrected time-series data and laboratory operating procedures and treatment guidelines, affecting the accuracy and quality of medical traceability. For example, after discovering time-series anomalies in treatment events, existing solutions fail to differentiate the reliability differences between manually entered data and automatically generated data, blindly adjusting the core treatment data automatically generated by the system. This results in a disconnect between the correction results and actual treatment operations, increasing the risk of medical traceability problems.

[0006] Furthermore, existing technologies have consistently failed to resolve the balance between "comprehensiveness of time-series data verification" and "economic efficiency and adaptability of time-series data correction." Either the pursuit of comprehensive verification leads to uncontrolled correction costs, or the pursuit of economic efficiency neglects comprehensive verification. Ultimately, the overall effect of time-series data correction fails to meet the actual business needs of the target business domain and cannot efficiently solve the problem of time-series data correction in complex scenarios. Summary of the Invention

[0007] This invention provides a method, apparatus, device, and storage medium for correcting event time information, which can solve the technical problem in the prior art that it is impossible to simultaneously take into account the comprehensiveness of time series data verification and the economy and adaptability of time series data correction when correcting event time information.

[0008] In a first aspect, the present invention provides a method for correcting event time information, comprising: Obtain a preset set of temporal constraint relationships between event types, wherein the set of temporal constraint relationships includes a first type of temporal constraint, a second type of temporal constraint, and a third type of temporal constraint. The first type of temporal constraint is used to characterize the sequential relationship between event types, the second type of temporal constraint is used to characterize the time interval between event types, and the third type of temporal constraint is used to characterize the time offset interval between event types and reference time points. Based on the set of temporal constraint relationships, analyze each event in the preset event set, take the event type of each event as the node of the temporal knowledge graph, and the temporal constraint relationship between the event types as the directed edge of the temporal knowledge graph, and construct the temporal knowledge graph corresponding to the event set. Obtain the time-series data between multiple events associated with the target object; The temporal data between multiple events is mapped to the event type nodes corresponding to each event in the temporal knowledge graph to generate an instantiated temporal graph; Based on the temporal constraint relationships between event types in the instantiated temporal graph, interval constraint propagation is performed on the instantiated temporal graph to detect whether there are node pairs that violate the temporal constraint relationships; In response to the detection of a node pair that violates the temporal constraint relationship, the target node that violates the temporal constraint relationship is located, and a minimum cost correction strategy is executed on the target node based on the preset correction cost weight of the target node to generate the corrected temporal data of the target node.

[0009] Secondly, the present invention provides an event time information correction device, comprising: The first acquisition module is used to acquire a preset set of temporal constraint relationships between event types. The set of temporal constraint relationships includes a first type of temporal constraint, a second type of temporal constraint, and a third type of temporal constraint. The first type of temporal constraint is used to characterize the sequential relationship between event types. The second type of temporal constraint is used to characterize the time interval between event types. The third type of temporal constraint is used to characterize the time offset interval between event types and reference time points. The graph construction module is used to analyze each event in the preset event set based on the set of temporal constraint relationships, and to construct the temporal knowledge graph corresponding to the event set by taking the event type of each event as the node of the temporal knowledge graph and the temporal constraint relationship between the event types as the directed edge of the temporal knowledge graph. The second acquisition module is used to acquire the time-series data between multiple events associated with the target object; The mapping module is used to map the temporal data between multiple events to the event type nodes corresponding to each event in the temporal knowledge graph, and generate an instantiated temporal graph. The detection module is used to perform interval constraint propagation on the instantiated time series graph based on the temporal constraint relationship between each event type in the instantiated time series graph, and to detect whether there are node pairs that violate the temporal constraint relationship; The correction module is used to respond to the detection of a node pair that violates the temporal constraint relationship, locate the target node that violates the constraint temporal relationship, and perform a minimum cost correction strategy on the target node based on the preset correction cost weight of the target node to generate the corrected temporal data of the target node.

[0010] Thirdly, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the above-mentioned method for correcting event time information.

[0011] Fourthly, a computer-readable storage medium is provided, which stores a computer program, and when the computer program is executed by a processor, it implements the steps of the above-mentioned method for correcting event time information.

[0012] Understandably, this solution addresses the issue of insufficient comprehensiveness in time-series data verification by constructing a complete set of temporal constraint relationships and building a temporal knowledge graph, laying the foundation for balancing the economic efficiency and adaptability of corrections. The solution first clearly extracts three types of temporal constraints (the first type representing the chronological order of events, the second type representing the time interval between events, and the third type representing the offset relationship between events and a reference time point), comprehensively covering all core dimensions of event temporal logic and avoiding the omissions caused by existing technologies that only verify single temporal rules. Then, using event types as nodes and temporal constraints as directed edges, a temporal knowledge graph is constructed, transforming abstract constraint rules into a visual and reusable graph structure, achieving systematic integration of various temporal constraints. Based on this, the temporal data of events associated with the target object is obtained and mapped to the temporal knowledge graph, generating an instantiated temporal graph. This ensures that the specific event temporal data of the target object is precisely bound to comprehensive constraint rules, guaranteeing that subsequent verification can fully cover all temporal requirements and solving the problem of incomplete verification from the source.

[0013] Secondly, the solution addresses the issues of insufficient economy and adaptability in time-series data correction by pre-setting correction cost weights and executing a minimum-cost correction strategy. Simultaneously, it leverages comprehensive prior validation to ensure that the corrected data conforms to all time-series constraints without sacrificing validation comprehensiveness. Before correction, the solution configures correction cost weights for the time-series data of each event in the instantiated time-series graph, quantitatively differentiating the correction costs of different events. For example, core business events and high-reliability data have high correction cost weights (high correction costs), while auxiliary business events and low-reliability data have low correction cost weights (low correction costs), providing a quantitative basis for achieving economical correction. Upon detecting node pairs violating time-series constraints, the solution locates the target node. Assuming all time-series constraints are met, and aiming to minimize the sum of correction cost weights for the corrected nodes, it executes a minimum-cost correction strategy, prioritizing the correction of nodes with low cost weights. This avoids the problems of blindly correcting core nodes, which could lead to increased correction costs and a disconnect from actual business needs, ensuring both economy and adaptability in the correction.

[0014] Finally, the solution employs a closed-loop logic of "verification-correction-verification" to ensure the accuracy of time-series data correction while balancing the comprehensiveness of verification with the economy and adaptability of correction. After performing minimum-cost correction, the corrected time-series data still needs to have a corresponding time-series graph instantiated, and the interval constraint propagation process re-executed to verify whether all time-series constraints are satisfied. This ensures that the corrected time-series data does not violate any type of time-series rule and does not sacrifice the comprehensiveness of verification. If constraint conflicts still exist, the process of locating the target node and performing minimum-cost correction is repeated until all constraints are satisfied. This closed-loop logic not only guarantees the comprehensiveness of time-series data verification but also controls the correction cost and improves the adaptability of correction through the minimum-cost correction strategy, completely solving the technical problem that existing technologies cannot simultaneously achieve both. Attached Figure Description

[0015] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the description of the embodiments of the present invention will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0016] Figure 1 This is a flowchart illustrating a method for correcting event time information in one embodiment of the present invention.

[0017] Figure 2 yes Figure 1 A flowchart of step S150.

[0018] Figure 3 yes Figure 2 A flowchart of step S152.

[0019] Figure 4 yes Figure 1 Another flowchart of step S160.

[0020] Figure 5 This is a schematic diagram of a device for correcting event time information in one embodiment of the present invention.

[0021] Figure 6 This is a schematic diagram of the structure of a computer device according to an embodiment of the present invention.

[0022] Figure 7 This is another structural schematic diagram of a computer device according to one embodiment of the present invention. Detailed Implementation

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

[0024] Figure 1 A flowchart of the event time information correction method provided in the embodiments of the present invention is shown below. Figure 1 As shown, the method for correcting event time information provided in this embodiment of the invention includes the following steps.

[0025] Step S110: Obtain the set of time-series constraint relationships between preset event types.

[0026] The time-series constraint relationship set includes a first type of time-series constraint, a second type of time-series constraint, and a third type of time-series constraint. The first type of time-series constraint is used to characterize the sequential relationship between event types, the second type of time-series constraint is used to characterize the time interval between event types, and the third type of time-series constraint is used to characterize the time offset interval between an event type and a reference time point.

[0027] Specifically, the core of this step is to extract and integrate three types of temporal constraints from domain rules, industry standards, and historical data to form a standardized set of constraint relationships, providing basic rules for subsequent graph construction.

[0028] To be more specific, we first need to clarify the core definitions of the three types of constraints. The first type of timing constraint only defines the logical order between event types, without involving specific time values, and only requires that one event type occurs before another event type. The second type of timing constraint, based on the order, adds the time interval range between two event types, clarifying the time interval limit for the event to occur. The third type of timing constraint defines the time offset range between a single event type and an external reference time point, binding the event time to a fixed reference point.

[0029] More specifically, in this step, when acquiring constraints, the first step is to identify standardized rules within the domain, such as regulatory policies for health insurance and treatment guidelines for the medical industry. These rules are the core source of constraints. Secondly, historical business data is analyzed. By examining the time distribution of a large number of historical events, reasonable time intervals between events are determined, supplementing the constraint parameters not explicitly defined in the standardized rules. Finally, all constraints are integrated and validated, eliminating logically conflicting constraints, such as avoiding cyclical constraints where event A must precede event B, and event B must precede event A. Constraints are also categorized and stored according to different application scenarios, such as health insurance and medical technology, supporting differentiated access in different scenarios. During storage, each constraint is labeled with its type, associated event type, constraint parameters, and applicable scope to ensure that constraints can be quickly retrieved and accessed.

[0030] As a concrete example, in the health insurance scenario, a set of temporal constraint relationships can be extracted and integrated for the lifecycle of an individual health insurance policy. The first type of temporal constraint includes the requirement that the underwriting approval event must occur before the claim application event, and that the disease diagnosis event must occur before the hospitalization event. The second type of temporal constraint includes a time interval of 1 to 3 days between the claim application event and the claim review event, and a time interval of 0.5 to 2 hours between the examination event and the test result issuance event. The third type of temporal constraint includes a time offset of 0 to 7 days between the claim payment event and the regulatory claim deadline reference point, and a time offset of 0 to 1 day between the diagnosis event and the laboratory report issuance reference point. These constraints are categorized according to scenario to form a dedicated set of constraint relationships for subsequent graph construction.

[0031] As another concrete example, in the medical technology scenario, a set of temporal constraints can be extracted and integrated for the entire outpatient treatment process. The first type of temporal constraint includes the requirement that the initial diagnosis event must occur before the examination event, and the examination event must occur before the test result issuance event. The second type of temporal constraint includes constraints on the order of the initial diagnosis event and the examination event without specific numerical values, and a time interval of 0 to 1 day between the test result issuance event and the confirmed diagnosis event. The third type of temporal constraint includes a time offset of 0 to 1 day between the confirmed diagnosis event and the laboratory report issuance reference point, and a time offset of 0 to 3 days between the treatment event and the medical insurance settlement reference point. This integrated constraint set forms the treatment process constraint set, adapting to the hospital's treatment management needs.

[0032] Step S120: Analyze each event in the preset event set based on the set of temporal constraint relationships, take the event type of each event as the node of the temporal knowledge graph, and the temporal constraint relationship between the event types as the directed edge of the temporal knowledge graph, and construct the temporal knowledge graph corresponding to the event set.

[0033] Specifically, the core of this step is to transform the abstract set of temporal constraint relationships into a visualized knowledge graph, with event types as core nodes and temporal constraint relationships as directed edges, forming a standardized graph structure.

[0034] More specifically, firstly, all unique event types can be extracted from the constraint set as the basic nodes of the graph. Each node represents only the event type and does not involve a specific instance. Secondly, directed edges are added between event types based on the constraint type. The directed edges corresponding to the first type of time-series constraint only reflect the order, the directed edges corresponding to the second type of time-series constraint reflect both the order and the time interval, and the directed edges corresponding to the third type of time-series constraint associate the event type node with the reference time point node. Finally, the graph is improved by adding basic attributes to nodes and edges. Node attributes include the event type name and the business scenario to which it belongs, while edge attributes include the constraint type, core parameters, and priority. At the same time, the graph is ensured to be an acyclic directed graph to avoid logical loops and improve the stability and usability of the graph. After construction, the graph is indexed and optimized to support fast queries by event type and constraint type, adapting to the calling needs of different business scenarios.

[0035] As a concrete example, in the health insurance scenario, a temporal knowledge graph can be constructed based on the constraint relationship set from the previous step. First, the nodes of the graph are identified as event types: policy activation, underwriting approval, claim application, claim review, claim payment, disease diagnosis, hospitalization, and discharge settlement. Then, directed edges are added: the underwriting approval node points to the claim application node, representing the first type of sequential constraint; the claim application node points to the claim review node, with a time interval parameter of 1 to 3 days, representing the second type of temporal constraint; the claim payment node is associated with the supervisory claim deadline reference node, with an offset parameter of 0 to 7 days, representing the third type of temporal constraint. Simultaneously, each edge is labeled with priority and constraint type, forming a complete temporal knowledge graph covering the entire process constraint logic of health insurance policies and claims.

[0036] As another concrete example, in the medical technology scenario, a temporal knowledge graph can be constructed based on the constraint relationship set of the diagnosis and treatment process. The nodes of the graph represent event types such as registration, initial consultation, examination, test result issuance, diagnosis, treatment, follow-up examination, and discharge. When adding directed edges, the initial consultation node points to the examination node, representing the first type of sequential constraint; the examination node points to the test result issuance node, with an additional time interval parameter of 0.5 to 2 hours, representing the second type of temporal constraint; the diagnosis node is associated with the laboratory report issuance reference node, with an additional offset parameter of 0 to 1 day, representing the third type of temporal constraint. At the same time, the attributes of the nodes and edges are improved to form a temporal knowledge graph adapted to the outpatient diagnosis and treatment process, meeting the constraint analysis needs of the medical technology scenario.

[0037] Step S130: Obtain the time-series data between multiple events associated with the target object; Specifically, the core of this step is to collect time-series data of all events associated with a specific target object. In the health insurance scenario, the target object is the insured person, and in the medical technology scenario, it is the patient.

[0038] More specifically, in this step, the data collection process first identifies the target object through a unique identifier. In the health insurance scenario, the insured's unique number is used, and in the medical technology scenario, the patient's unique medical record number is used. Then, data is collected from multiple business systems. Structured data is directly read from core business systems, including the core systems of insurance companies, hospital HIS systems, and laboratory systems. Semi-structured and unstructured data are extracted from texts such as claims applications and medical records using text parsing technology to ensure the comprehensiveness of data collection.

[0039] More specifically, after collecting the raw time data, it can be standardized to unify the time representation format, remove invalid and erroneous time data, and for events with missing time information, only the missing status is recorded, without arbitrarily adding false data. Simultaneously, each time-series data entry is labeled with its data source and confidence level. Confidence levels are determined by the authority of the data source; automatically collected authoritative data has higher confidence levels, while manually entered data has relatively lower confidence levels, providing a data basis for subsequent constraint verification and correction. After collection, the time-series data is categorized and stored according to the target object, forming a dedicated event time-series data set.

[0040] As a concrete example, in a health insurance scenario, we can target the insured Zhang San and collect time-series data of related events using his unique policy number. We extract the diagnosis date from the hospital's diagnostic report, the claim application date from the insurance company's app, and the claim review date from the insurance company's core system. The collected time data includes the specific dates of diagnosis, claim application, and claim review, while also labeling the source of each data point (e.g., hospital diagnostic report, insurance company app, insurance company system) and its corresponding confidence level. This forms Zhang San's event time-series data set, containing the time information of the three core events.

[0041] As another concrete example, in a medical technology scenario, patient Li Si can be targeted, and time-series data of related events can be collected using his unique medical record number. The specific times of the initial consultation and examinations can be extracted from the hospital's HIS system, and the specific times of test result issuance can be extracted from the laboratory system. The collected time data is accurate to the hour and minute, and the data sources are labeled as the hospital's HIS system, the laboratory system, and the corresponding confidence level, forming Li Si's event time-series data set, containing the time information of the three core medical events: initial consultation, examination, and test result issuance.

[0042] Step S140: Map the temporal data between multiple events to the event type nodes corresponding to each event in the temporal knowledge graph to generate an instantiated temporal graph; Specifically, the core of this step is to combine the general temporal knowledge graph with the temporal data of the specific target object to generate an instantiated temporal graph for a single target object, thereby achieving the binding of general rules with specific data.

[0043] More specifically, in this step, we first traverse the time-series data set of the target object, matching the event type corresponding to each data point to the event type node in the time-series knowledge graph, generating specific event instance nodes. Each instance node uniquely corresponds to an event of the target object, containing core information such as event type, original time, data source, and confidence level. Secondly, based on the type associations between event instances, we match directed edges in the time-series knowledge graph, generating instantiated directed edges. Instantiated edges inherit the original constraint types and parameters, while marking the initial state of the constraints as unvalidated. Finally, using the unique identifier of the target object as the dimension, we integrate all instance nodes and instance edges to form an independent instantiated time-series graph. This graph is only for the current target object and is isolated from the graphs of other target objects, ensuring the independence and accuracy of the data.

[0044] As a concrete example, in a health insurance scenario, an instantiated time-series graph can be generated for the insured Zhang San's time-series data. The three events—disease diagnosis, claim application, and claim review—are each matched as independent instance nodes. Each node is labeled with its corresponding event type, original time, data source, and confidence level. Then, based on the constraints of the event types, instantiated edges are added to the three instance nodes: the disease diagnosis instance node points to the claim application instance node, inheriting the first type of sequential constraint; the claim application instance node points to the claim review instance node, inheriting the second type of time interval constraint. This ultimately forms Zhang San's own instantiated time-series graph, containing three instance nodes and two instantiated edges, providing a specific analysis object for subsequent constraint verification.

[0045] As another concrete example, in a medical technology scenario, an instantiated time series graph can be generated based on the time series data of patient Li Si. The three events—initial diagnosis, examination, and test result issuance—are matched as independent instance nodes, labeled with their corresponding event type, precise time, data source, and confidence level. When adding instantiated edges, the initial diagnosis instance node points to the examination instance node, inheriting the first type of sequential constraint, while the examination instance node points to the test result issuance instance node, inheriting the second type of time interval constraint. This ultimately forms Li Si's specific instantiated time series graph, containing three instance nodes and two instantiated edges, adapting to the constraint analysis needs of the diagnosis and treatment process.

[0046] Step S150: Based on the temporal constraint relationship between each event type in the instantiated temporal graph, perform interval constraint propagation on the instantiated temporal graph to detect whether there are node pairs that violate the temporal constraint relationship; Specifically, this step is the core verification step, which uses interval constraint propagation to detect whether there are event node pairs in the instantiated time sequence graph that violate the time sequence constraints.

[0047] More specifically, the time-series data of each event instance is first converted into time intervals. Precise time data is converted into intervals with the same start and end boundaries, while data with unknown times is converted into intervals covering the entire range. Then, based on three types of time-series constraints, iterative propagation calculations are performed on all time intervals, continuously tightening the boundaries of the time intervals through constraint rules until the intervals no longer change or a preset number of iterations is reached. Finally, for each time-series constraint, it is verified whether the time intervals of the associated node pairs meet the constraint requirements. Node pairs that do not meet the requirements are determined to be constraint-violation pairs, and the core information and reasons for the conflict of the node pairs are recorded to provide a basis for subsequent correction work. The entire process strictly follows the constraint priority, processing high-priority constraints first to ensure the accuracy of the verification results.

[0048] As a concrete example, in a health insurance scenario, interval constraint propagation can be performed on the instantiated time series graph of the insured Zhang San. First, the precise times of the three events are converted into time intervals with a single boundary. Then, the sequence constraints and time interval constraints are checked sequentially. The sequence constraints are all satisfied, requiring no boundary adjustments. When checking the time interval constraint between the claim application and the claim review, the actual time interval between the two events is calculated, revealing that this interval exceeds the preset range of 1 to 3 days. Finally, it is determined that the node pair of these two events violates the second type of time series constraint. Information such as the node pair, constraint type, and conflicting time interval value is recorded as the target for subsequent corrections.

[0049] As another concrete example, in a medical technology scenario, interval constraint propagation can be performed on the instantiated time series graph of patient Li Si. The precise times of the three diagnostic events are transformed into time intervals with a single boundary, and the sequential constraints all meet the requirements; the time interval between the issuance of examination and test results is calculated, and this interval falls within the preset range of 0.5 to 2 hours, which meets the second type of time series constraint; there are no node pairs that violate the constraints in the entire graph, and no conflict records are recorded after the verification process is completed.

[0050] In some embodiments of the present invention, such as Figure 2 As shown, step S150 includes the following steps.

[0051] Step S151: Represent the time series data of each event in the instantiated time series graph as a time interval variable; The time interval variable includes the earliest time boundary and the latest time boundary; Specifically, this step is the foundation of interval constraint propagation. Its core is to uniformly transform the time series data of events into standardized time interval variables. Each time interval variable contains the earliest time boundary and the latest time boundary, which are used to quantify the time range of events.

[0052] More specifically, for events with precise timestamps, the earliest and latest time boundaries can be set to the same precise time to form a single-point interval; for events with time information errors or conflicts between multiple data sources, the earliest boundary can be set to the minimum of all possible times, and the latest boundary can be set to the maximum value to form a range interval; for events with completely missing time information, the earliest boundary can be set to the earliest time that the system can record, and the latest boundary can be set to the latest time that the system can record to form a full range interval.

[0053] More specifically, during the transformation process, the units and formats of time can be standardized to avoid calculation errors caused by inconsistent units. Simultaneously, each time interval variable is associated with a corresponding event instance node to ensure a one-to-one correspondence between intervals and events. All time interval variables are stored in the order of the instantiated time series graph nodes to ensure that subsequent propagation operations can be executed in an orderly manner according to the graph topology.

[0054] As a concrete example, in a health insurance scenario, the time-series data of three events for the insured, Zhang San, can be transformed into time interval variables. The time of diagnosis is a precise date, so the earliest and latest boundaries of its time interval variable are both this precise date; the times of claim application and claim review are also precise dates, and the corresponding time interval variables are also single-boundary intervals. All variables are fixed time points with no range fluctuations.

[0055] As another concrete example, in a medical technology scenario, the time-series data of patient Li Si's three medical events can be transformed into time interval variables. The times of the initial diagnosis, examination, and test results are all accurate to the hour and minute. The earliest and latest boundaries of the time interval variable corresponding to each event are their respective precise times, forming three fixed single-point time intervals, providing basic data for subsequent constraint propagation.

[0056] Step S152: Perform interval propagation operation on the time interval variables according to the time sequence constraint relationship, and iteratively update the boundary values ​​of each time interval variable; Specifically, this step is the core execution link of interval constraint propagation. It tightens the boundaries of the time interval variables through iterative calculations, while verifying the constraint satisfaction status.

[0057] More specifically, firstly, all temporal constraints in the instantiated graph can be traversed according to constraint priority. The propagation rule for the first type of sequential constraint is that the latest time boundary of the preceding event must not be later than the earliest time boundary of the following event. Based on this rule, the interval boundaries of the two events are adjusted. The propagation rule for the second type of time interval constraint is that the time interval between the following event and the preceding event must fall within a preset interval. This rule is used to adjust the interval boundaries of the two events simultaneously to achieve joint tightening. The propagation rule for the third type of reference offset constraint is that the time interval of the event must fall within the offset interval of the reference time point. The interval boundaries of the event are adjusted accordingly.

[0058] More specifically, during the iteration process, constraint propagation calculations are repeatedly performed until the boundaries of all time interval variables no longer change, or the preset maximum number of iterations is reached to avoid infinite loops. Each iteration adjusts the interval boundaries based on the previous iteration, gradually narrowing the time range of events, while simultaneously verifying the constraint satisfaction in real time, providing the latest interval data for subsequent conflict detection.

[0059] As a concrete example, in a health insurance scenario, interval propagation operations can be performed on Zhang San's instantiated graph. First, the sequential constraint is checked, and the latest boundary of the disease diagnosis matches the earliest boundary of the claim application, so no boundary adjustment is needed. Then, the time interval constraint between the claim application and the claim review is checked. The actual interval between the two exceeds the preset range. Since the times of both events are precise values, the interval boundary cannot be tightened, and there is no boundary change during the iteration process, ultimately maintaining the initial interval state.

[0060] As another concrete example, in a medical technology scenario, interval propagation operations can be performed on Li Si's instantiated atlas. Under the sequential constraint, the interval boundaries for initial diagnosis and examination remain unchanged; under the time interval constraint, the time interval between the issuance of examination and test results falls within a preset range, so the interval boundaries do not need to be adjusted; after multiple iterations, the boundaries of all time interval variables remain unchanged, the propagation operation is completed, and there is no boundary update operation.

[0061] In some embodiments of the present invention, the time interval in the second type of timing constraint is determined based on a predefined standardized process time window or statistical distribution information interval in the domain knowledge base; Specifically, the time interval of the second type of time sequence constraint is not randomly set. The core basis can be the predefined standardized process time window in the domain knowledge base, and the statistical distribution confidence interval obtained based on historical data statistics.

[0062] More specifically, firstly, standardized process time windows can be extracted from industry standardization rules, regulatory policies, and domain-specific knowledge bases. These serve as fundamental constraints. For example, the claims process in the health insurance industry and the diagnosis and treatment process in the medical industry both have standard time requirements set by industry associations or regulatory agencies. Secondly, massive amounts of historical event data in the target scenario are collected, and the time intervals of event pairs are statistically analyzed. By using distribution fitting and confidence interval calculation, the time interval range that conforms to business patterns can be determined. Commonly used statistical methods include normal distribution confidence intervals and quartile intervals, ensuring that the intervals cover the vast majority of normal time intervals in the business.

[0063] More specifically, when determining the interval, adjustments need to be made based on the characteristics of the scenario. For businesses with rigid processes, the interval range should be narrower; for businesses with individual differences, the interval range should be appropriately widened. At the same time, the determined intervals should be validated to ensure that the minimum value of the interval is not less than 0, avoiding logical errors such as negative time intervals, ultimately forming a standardized and reusable second-type time-constrained time interval range.

[0064] like Figure 3 As shown, step S152 includes the following steps.

[0065] Step S1521: Perform interval propagation operation on the time interval variables according to the time sequence constraint relationship; Step S1522: During the interval propagation operation, the time interval of the node pair in the instantiated time series graph is used as the difference constraint between the two time interval variables associated with the node pair. The boundary values ​​of the two time interval variables are jointly tightened to obtain the boundary values ​​of each time interval variable after iterative update.

[0066] Specifically, in the above embodiments, the first step is to identify all node pairs associated with the second type of time-series constraint in the instantiated time-series graph and clarify the time interval parameter corresponding to each node pair; the second step is to convert the time interval into a difference constraint between the time interval variables corresponding to the two nodes, that is, the difference between the time interval of the subsequent event and the time interval of the preceding event must fall within a preset interval; the third step is to jointly adjust the earliest time boundary and the latest time boundary of the two time interval variables simultaneously based on the operation rules of interval arithmetic, and tighten the boundary range of the two intervals simultaneously through the limitation of the difference constraint, rather than adjusting only one of them; the fourth step is to repeatedly execute the joint tightening operation and iteratively update the boundary of the two time interval variables until the interval boundary of all node pairs no longer changes, or the preset maximum number of iterations is reached, to ensure interval convergence.

[0067] Understandably, the core advantage of joint tightening lies in its ability to better align with the temporal relationships between events through the coordinated adjustment of two variables. This avoids unreasonable ranges caused by adjusting a single variable, thereby improving the accuracy and effectiveness of constraint propagation. During the calculation process, a unified time unit ensures consistency in difference calculations, while adhering to constraint priorities and prioritizing higher-priority second-type temporal constraints to guarantee the efficiency of propagation operations.

[0068] More specifically, the joint tightening operation rule can be as follows: Let the time interval variable of the preceding event be [T1s, T1e], the time interval variable of the following event be [T2s, T2e], and the time interval of the second type of time series constraint be [Tmin, Tmax]. Then the difference constraint is Tmin ≤ T2 - T1 ≤ Tmax. Based on this constraint, the joint tightening rule is: update the latest boundary of the preceding event to the earliest boundary of the following event minus the minimum interval, and update the earliest boundary of the following event to the latest boundary of the preceding event plus the minimum interval; simultaneously, update the earliest boundary of the preceding event to the latest boundary of the following event minus the maximum interval, and update the latest boundary of the following event to the earliest boundary of the preceding event plus the maximum interval. Through these two sets of boundary adjustments, the synchronous tightening of the two interval variables is achieved, strictly adhering to the requirements of the difference constraint.

[0069] As a concrete example, in a health insurance scenario, the time interval between claim application and claim review is set to 1 to 3 days based on the standardized claims process time window in the insurance industry. Furthermore, by statistically analyzing the company's historical claims review data over the past year, a 95% confidence interval of 1 to 3 days is calculated, ultimately determining the interval for this second type of time-series constraint. During interval propagation, joint tightening is performed on the time interval variables of the two events. Since the times of the two events are precise values, the difference exceeds the preset interval, and the joint tightening operation cannot adjust the boundaries; it only completes constraint verification and identifies conflicting node pairs.

[0070] As another concrete example, in a medical technology scenario, the time interval between the release of examination and test results can be set to 0.5 to 2 hours according to the hospital's standardized treatment process. Simultaneously, historical test data from the outpatient department is statistically analyzed, yielding a statistical confidence interval of 0.5 to 2 hours. During interval propagation, the time interval variables of the two events are jointly tightened. Because the actual interval falls within the preset interval, the interval boundary remains unchanged after joint tightening, thus satisfying the constraint requirements.

[0071] It is understood that the above embodiments clarify the basis for determining the time interval of the second type of time series constraint. At the same time, by performing a joint tightening interval propagation operation on the two time interval variables, the problems of unreasonable intervals and large constraint verification deviations caused by adjusting a single interval variable are avoided, thereby improving the accuracy and rigor of the second type of time series constraint verification and enhancing the rationality and efficiency of the interval constraint propagation operation.

[0072] Step S153: For each of the time-series constraints in the instantiated time-series graph, if the boundary value of the corresponding time interval variable of the node pair associated with the time-series constraint violates the time-series constraint, then the node pair is determined to have violated the time-series constraint.

[0073] Specifically, this step is the final stage of conflict detection. Its core is to verify the validity of each temporal constraint one by one based on the iterated time interval variables and identify the node pairs that violate the constraints.

[0074] More specifically, for the first type of timing constraint, if the earliest time boundary of the preceding event is later than the latest time boundary of the following event, then the two nodes are determined to have violated the constraint; for the second type of timing constraint, if the time interval between the two events is less than a preset minimum value or greater than a preset maximum value, then the nodes are determined to have violated the constraint; for the third type of timing constraint, if the time interval of the event completely exceeds the offset interval of the reference time point, then the nodes are determined to have violated the constraint.

[0075] More specifically, after the determination is completed, information on all node pairs that violate constraints is recorded, including the target object corresponding to the node, the event type, the original time, the constraint type, and the specific reason for the conflict. This information is summarized into a conflict log, providing a clear target for subsequent node location and correction work. All determination results are based on the interval data after the final iteration, ensuring the accuracy of conflict determination.

[0076] As a specific example, in the health insurance scenario, constraint verification can be performed based on the iterated interval data. If the time interval between the claim application and the claim review exceeds the preset range of 1 to 3 days, it meets the conflict judgment condition of the second type of constraint. Therefore, it is determined that the two nodes violate the constraint. The information such as the node pair, the cause of the conflict, and the constraint parameters are recorded in the conflict log as the core basis for subsequent correction.

[0077] As another concrete example, in a medical technology scenario, all constraints can be verified one by one. The constraints on the order of initial diagnosis and examination, and the time interval constraints on the issuance of examination and test results, all meet the requirements. No node violates the timing constraints, the conflict log is empty, and no subsequent correction operations are required.

[0078] Understandably, by transforming time-series data into time interval variables and tightening the interval boundaries through iterative operations of interval constraint propagation, node pairs that violate time-series constraints can be accurately detected. This solves the problems of inaccurate conflict detection and missed conflict nodes caused by inconsistent time-series data representation and imprecise verification logic in traditional time-series verification. It improves the accuracy and comprehensiveness of time-series constraint violation detection and provides a clear and reliable target basis for subsequent time-series data correction.

[0079] Step S160: In response to detecting a node pair that violates the temporal constraint relationship, locate the target node that violates the temporal constraint relationship, and perform a minimum cost correction strategy on the target node based on the preset correction cost weight of the target node to generate the corrected temporal data of the target node.

[0080] Specifically, in this step, which is the core of conflict resolution, the first step is to locate the target node that violates the constraint, that is, the event instance in the conflict node pair that needs to adjust the time series data. Then, based on the correction cost weight, the minimum cost correction strategy is executed, prioritizing the correction of the node with the lower cost to ensure that the correction cost is minimized.

[0081] More specifically, firstly, a correction cost weight can be configured for each event instance node. The weight is determined based on factors such as the confidence level of the data source, the business importance of the event, and the authority of the data. Authoritative data and core business events have higher weights and greater correction costs, while less authoritative data and core business events have lower weights and smaller correction costs. After configuration, a correction model is constructed, taking all time-series constraints as mandatory conditions, the correction value of the node's time-series data as the adjustment basis, and minimizing the sum of the cost weights of all corrected nodes as the objective. By solving this model, the optimal correction scheme is obtained, and the nodes that need to be corrected and their corresponding time adjustments are determined. Finally, the time-series data of the nodes is adjusted according to the correction scheme to complete the conflict correction, and the constraints are re-verified to ensure that the corrected graph is conflict-free.

[0082] As a concrete example in the health insurance scenario, the claims review node can be identified as the target node violating constraints. After assigning correction cost weights to each node, a correction model is constructed with the goal of minimizing the total correction cost. The model must satisfy the time interval constraint between the claims application and review. After solving the model, the time-series data of the corrected claims review node is determined, and its time is adjusted to an earlier date so that the time interval falls within a preset range. The total correction cost is the weight value of that node, achieving minimum cost correction. After correction, the constraints are re-verified, and all constraints are satisfied, resolving the conflict issue. As another concrete example in the medical technology scenario, there are no node pairs violating constraints, so there is no need to perform target node location and correction operations, and the process terminates directly.

[0083] In some embodiments of the present invention, such as Figure 4 As shown, step S160 includes the following steps.

[0084] Step S161: Configure corrected cost weights for the time series data of each event in the instantiated time series graph; Specifically, the core of this step is to construct a standardized and implementable correction cost weighting system. Non-negative integer weights are assigned to the time-series data of each event instance, and these weights directly determine the correction priority (higher weights mean greater correction costs and priority for preserving original data; lower weights mean lower correction costs and priority for correction). The specific technical implementation is as follows: More specifically, in this step, a weight configuration rule base can be established to clarify the core dimensions and quantitative standards for weight assignment. The dimensions include: data source confidence (automatic collection from authoritative systems > synchronization from third-party interfaces > manual entry, quantified as 5-10 points, 3-5 points, and 1-3 points respectively), event business importance (core business events > auxiliary business events; core events such as diagnosis, claims payment, and test result issuance have a weight of 8-10 points; auxiliary events such as registration and claims application have a weight of 3-7 points), data accuracy (accurate to minutes / hours > accurate to days > fuzzy time, corresponding to weights of 7-10 points, 4-6 points, and 1-3 points respectively), and historical correction records (no rejections in the past 3 months > rejected once > rejected twice or more, with the weight decreasing by 2-3 points respectively).

[0085] More specifically, it can traverse all event nodes in the instantiated time series graph, extract the time series data features (source, precision, business type, historical records) of each node, match the corresponding standards in the rule base, automatically complete the weight assignment, and generate a weight comparison table after assignment, marking the weight of each node and the basis for assignment.

[0086] More specifically, it can support manual fine-tuning to adapt to the differentiated needs of different scenarios, with the fine-tuning range controlled within [-2, +2] points to avoid excessive weight deviation; at the same time, a weight update mechanism is established to optimize the quantitative standards in the rule base every quarter based on business feedback and changes in data quality, ensuring that the weight system fits the actual business.

[0087] More specifically, after the weights are assigned, they can be bound and stored with event nodes and time-series data, and synchronously written into the node attributes of the instantiated time-series graph. This provides quantification parameters for the subsequent construction of integer linear programming models, ensuring that the model can directly call the weight data for calculation.

[0088] As a concrete example, in a health insurance scenario, weights can be assigned to the instantiated graph nodes for the insured Zhang San: Disease diagnosis node (data source: electronic diagnostic report from a top-tier hospital, accurate to the day, core business event, no historical rejection records), weight assigned 9 points; Claim application node (data source: manual entry from the insurance company's APP, accurate to the day, auxiliary business event, no historical rejection records), weight assigned 5 points; Claim review node (data source: automatic collection from the insurance company's core system, accurate to the day, core business event, rejected once in the past 3 months), weight assigned 7 points; Inpatient settlement node (data source: synchronization from the hospital's HIS system, accurate to the day, auxiliary business event, no historical rejection records), weight assigned 4 points. A weight comparison table is created to clarify the correction priority for each node, prioritizing the correction of low-cost nodes such as inpatient settlement and claim application, while retaining the original data for high-weight nodes such as disease diagnosis.

[0089] As another concrete example, in a medical technology scenario, weights can be assigned to the instantiated atlas nodes of patient Li Si. For instance, the initial diagnosis node (data source: automatically collected from the hospital HIS system, accurate to the minute, core business event, no historical rejection records) is assigned a weight of 10 points; the examination node (data source: synchronized from the hospital examination system, accurate to the minute, auxiliary business event, no historical rejection records) is assigned a weight of 6 points; the test result issuance node (data source: automatically collected from the laboratory LIS system, accurate to the minute, core business event, no historical rejection records) is assigned a weight of 9 points; and the diagnosis node (data source: manually entered by the doctor, accurate to the day, core business event, rejected once in the past 3 months) is assigned a weight of 7 points. After weighting, low-cost nodes such as the examination node are corrected first. Due to their high weights, the initial diagnosis and test result issuance nodes retain their original time data as much as possible to avoid incorrect correction of core treatment times.

[0090] Step S162: Using all time-series constraints as constraints, the correction values ​​of each time-series data as integer decision variables, and minimizing the sum of the correction cost weights of the modified time-series data as the objective, construct an integer linear programming model. Specifically, this step is the core of minimum cost correction. It requires transforming business constraints into a solvable mathematical model, ensuring that the model balances constraint satisfaction and cost minimization. The specific technical implementation can be as follows: Specifically, you can first define model variables, clarifying their types and value ranges: Decision variables: Let x_i be an integer variable between 0 and 1 (i is the event node number), x_i=1 indicates that the time series data of the i-th node is corrected, and x_i=0 indicates that no correction is made; let t_i is an integer variable representing the time correction amount of the i-th node (the unit is consistent with the time precision, such as days or hours; a positive number indicates time delay, and a negative number indicates time advance). The range of t_i is preset according to the business scenario (e.g., health insurance ±3 days, medical technology ±24 hours) to avoid excessive adjustment that could lead to unreasonable business logic.

[0091] Target variable: Cost = Σ(w_i) x_i), where w_i is the correction cost weight of the i-th node, and the objective function is Min(Cost), which is to minimize the sum of the weights of all corrected nodes.

[0092] Furthermore, the constraints can be transformed into hard constraints of the model (which must be satisfied), ensuring that all constraints are effective after the correction: First type of temporal constraint (order of precedence): For any node pair (i,j) with an order of precedence, it is transformed into an inequality: in Let i be the original latest time boundary. Let be the original earliest time boundary of node j, ensuring that node i still occurs before node j after correction.

[0093] Second type of temporal constraint (time interval): For any node pair (i,j) associated with a second type of constraint, it is transformed into an inequality: ,in , The upper and lower limits of the time interval for the second type of constraint are used to ensure that the corrected time interval falls within the preset range.

[0094] Third type of temporal constraint (reference offset): For node i associated with the third type of constraint, it is transformed into an inequality: ,in For reference time points, , These are the upper and lower limits of the offset range, ensuring that the corrected node time meets the reference offset requirements.

[0095] More specifically, model standardization can be performed, such as unifying time units (e.g., converting them all to minutes), eliminating redundant constraints (e.g., repeated sequential constraints), simplifying variable relationships, and avoiding redundant calculations during model solving; at the same time, model boundary conditions can be set to ensure that all variable values ​​conform to business logic (e.g., correction amounts do not exceed preset ranges, and time values ​​do not become negative).

[0096] More specifically, after the model is built, it is stored in a standardized format (compatible with open-source solvers such as Gurobi and SCIP), clearly defining the correspondence between variables, objective functions, and constraints to ensure that the solver can directly read and perform calculations. At the same time, a model building log is generated to record the constraint transformation process and the basis for variable definition, which facilitates subsequent model debugging and optimization.

[0097] As a concrete example, in a health insurance scenario, we construct an integer linear programming model for the instantiated graph of the insured Zhang San (where there is a conflict in the time interval between the claim application and claim review nodes). We define decision variables x2 (claim application node, weight 5 points) and x3 (claim review node, weight 7 points). ; , = represents the correction amount, ranging from ±3 days. The objective function is Min(5x2+7x3), ensuring the correction cost is minimized. Constraints include: the time of disease diagnosis (weight 9 points, x1=0, no correction) ≤ the corrected time of the claim application; the time interval between the corrected claim application and claim review is within 1-3 days; the corrected time of the claim payment is within the 0-7 day offset range of the supervisory claim deadline. All constraints are converted into inequalities, standardized, and adapted to the solver to ensure that the correction satisfies all time-series constraints while prioritizing the correction of low-cost nodes.

[0098] As a concrete example in a medical technology scenario, considering the instantiated graph of patient Li Si (where there is a conflict in the time interval between examination and test result issuance nodes), an integer linear programming model is constructed. Decision variables x5 (examination node, weight 6 points) and x6 (test result issuance node, weight 9 points) are defined. ; , The correction factor is set to ±24 hours. The objective function is Min(6x5+9x6), prioritizing the correction of low-cost examination nodes. Constraints include: the time for the initial diagnosis node (weight 10 points, x4=0, no correction) is less than or equal to the corrected time for the examination node; the time interval between the corrected examination and test results is within 0.5-2 hours; and the corrected time for the confirmed diagnosis node is within a 0-1 day offset from the laboratory report issuance time. All constraints are transformed into inequalities, the time unit is standardized to minutes, variable relationships are simplified, and a model adapted to the solver is generated to ensure that the correction results conform to the diagnostic and treatment process specifications.

[0099] Step S163: Solve the integer linear programming model to obtain the correction value of each time series data that minimizes the sum of the correction cost weights of all the time series constraints and the modified time series data. Specifically, in this step, the model is solved using a specialized solver. The core objective is to obtain the optimal correction scheme, ensuring that all constraints are satisfied and the correction cost is minimized. The specific technical implementation is as follows: Solver selection and parameter configuration: An open-source integer linear programming solver is selected. The solution parameters are set according to the model complexity, including the maximum solution time (preset 5-10 seconds, suitable for small and medium scale graphs), the optimality tolerance (set to 0 to ensure that the optimal solution is obtained rather than an approximate solution), and the upper limit of the number of iterations (preset 50 times) to avoid solution timeout or getting stuck in an infinite loop.

[0100] Model preprocessing and solution execution: The standardized model is imported into the solver. Before solving, the model is preprocessed to check the range of variable values ​​and the rationality of constraints, eliminate invalid constraints, correct variable association errors, and improve solution efficiency. During the solution process, the solver uses the branch and bound method to traverse all possible combinations of variables, selects the solution that satisfies all constraints and minimizes the objective function value, and records intermediate results in the solution process for subsequent debugging.

[0101] Solution Result Verification and Interpretation: After the solution is completed, the optimal solution is output, including the x_i of each node (whether it is corrected). (Correction amount), minimum total cost; First, verify the feasibility of the solution by checking whether all time constraints are met. If any constraints are not met, adjust the model constraints or solution parameters and solve again; Second, verify the rationality of the correction amount to ensure that the corrected time does not exceed the scope of business logic (e.g., no future time or logical conflicts with other nodes); Finally, interpret the results, identify the nodes to be corrected first and the specific correction amount, and form a solution result report.

[0102] Anomaly Handling: If the solver cannot obtain a feasible solution (e.g., constraint conflicts cannot be resolved), an anomaly message will be output. At the same time, the model constraints will be adjusted (e.g., the time interval of the second type of constraint will be appropriately relaxed), the model will be rebuilt and solved. If there are multiple optimal solutions (with the same total cost), the solution with the smallest correction amount and the closest fit to the original data will be selected to ensure the rationality of the correction result and its adaptability to business.

[0103] As a concrete example, in a health insurance scenario, the constructed model can be imported into the solver, with a maximum solution time of 8 seconds and an optimality tolerance of 0. The solver uses the branch and bound method to traverse the variable combinations and finally outputs the optimal solution: x2=0 (no correction to the claim application node, original time 2025-01-08), x3=1 (correction to the claim review node, weight 7 points). =-2 days (correcting the original time 2025-01-12 to 2025-01-10), minimum total cost Cost = 7 × 1 = 7. Verification results show that the time interval between the corrected claim application and claim review is 2 days, which meets the 1-3 day constraint; the sequential relationship between the disease diagnosis node and the claim application node, and the offset constraint between the claim payment node and the reference time point are all satisfied; the correction amount of -2 days is within the preset ±3 days range, with no logical errors. This solution is a feasible optimal solution and can be directly used for subsequent data correction.

[0104] As another concrete example, in a medical technology scenario, the model can be imported into the solver, with a maximum solution time of 10 seconds and an optimality tolerance of 0. After the solver iterates through all variable combinations, it outputs the optimal solution: x5=1 (correction check node, weight 6 points). =0.5 hours (correcting the original time 2025-02-10 10:00 to 2025-02-10 10:30), x6=0 (no correction to the test result issuance node, original time 2025-02-10 11:30), minimum total cost = 6×1=6. The verification results show that the time interval between the examination and the issuance of test results after correction is 1 hour, which meets the constraint of 0.5-2 hours; the sequential relationship between the initial diagnosis node and the examination node, and the offset constraint between the confirmed diagnosis node and the reference time point are all satisfied; the correction amount of 0.5 hours is within the preset ±24-hour range, closely matches the actual treatment process (a reasonable half-hour delay after examination), and has no logical conflicts. This optimal solution can be directly implemented.

[0105] Step S164: Correct the time series data based on the correction values ​​of each of the time series data.

[0106] Specifically, this step involves the implementation of the optimal solution. The core is to update the time-series data based on the solution results, ensuring the corrected data is accurate and consistent, and that all constraints are satisfied. The specific technical implementation is as follows: Target node location and data update: Traverse the instantiated time series graph, and locate the target node that needs to be corrected based on x_i=1 in the solution result; for each target node, according to... Calculate the corrected time. If it is a precise timestamp, then the corrected time = original time + If it is a time interval, then the earliest and latest time boundaries will be adjusted synchronously. (If the value is positive, the boundary values ​​are all delayed; if the value is negative, they are all advanced.) After the update, the corrected time is written to the node attributes, and the correction status (corrected), correction time, and correction basis (solvent optimal solution) are marked.

[0107] Correction logs and data synchronization: Generate detailed correction logs, recording the node ID, event type, original time, correction amount, post-correction time, correction cost weight, and correction basis for each target node. The logs are stored in categories according to the target object ID for subsequent data traceability, business review, and weight optimization. At the same time, the instantiated graph data in the time series database is updated synchronously to ensure data consistency between the database and the visualization graph and avoid data deviation.

[0108] Corrected constraint verification: After the correction is completed, the interval constraint propagation operation is re-executed (step S150) to verify the satisfaction status of all time-series constraints one by one, with a focus on verifying the constraints associated with the corrected nodes to ensure that there are no new constraint conflicts after the correction; if conflicts still exist, backtrack to check the solution results and model construction process, adjust the model parameters or correction amount, and re-execute the solution and correction process until all constraints are satisfied.

[0109] Data archiving and feedback: The corrected instantiated time series graph is archived by target object ID and synchronously pushed to the business system for subsequent business processing and data statistics; at the same time, the correction results and correction logs are fed back to the weight optimization module to provide data support for the subsequent update of correction cost weights and continuously improve the rationality of the correction scheme.

[0110] As a concrete example, in a health insurance scenario, the target node (claims review node) can be located based on the solution results, and its original time 2025-01-12 can be corrected to 2025-01-10. =-2 days), update the time data in the node attributes, mark the correction status as "corrected", and record the correction basis as "optimal solution of integer linear programming". Generate a correction log, which records in detail the node's ID, event type, original time, correction amount, corrected time, and correction cost of 7 points, and stores it according to the insured Zhang San's ID. Synchronously update the graph data in the time series database to ensure data consistency. Re-execute the interval constraint propagation verification. The verification results show that the time interval between the claim application and the review is 2 days, which meets the 1-3 day constraint. All other time series constraints are satisfied, and there are no new conflicts. The correction is complete, and the corrected data is synchronously pushed to the insurance company's claims system for subsequent claims processing.

[0111] As another concrete example, in a medical technology scenario, based on the solution results, the target node (inspection node) is located, and its original time 2025-02-10 10:00 is corrected to 2025-02-10 10:30. =0.5 hours), update node attributes, mark correction status and correction basis. Generate correction log, recording the node ID, event type, original time, correction amount, corrected time and 6-point correction cost, and archive according to patient Li Si's diagnosis and treatment number. Synchronously update the graph data in the hospital HIS system and time series database to ensure data synchronization and consistency. Re-execute interval constraint propagation verification, the time interval between the issuance of examination and test results is 1 hour, which meets the 0.5-2 hour constraint. The constraints of initial diagnosis and examination, diagnosis and reference time points are all satisfied, and there are no new conflicts. The corrected data is synchronized to the electronic medical record system for subsequent diagnosis and treatment process traceability and medical insurance settlement review.

[0112] It is understandable that the above embodiments, by configuring correction cost weights for each event time series data and combining them with an integer linear programming model to solve for the optimal correction value, achieve minimum cost control for time series data correction. This solves the problems of indiscriminate correction, high correction costs, and disconnect between correction results and business requirements in traditional correction methods. Under the premise of ensuring that all time series constraints are met, the correction cost is reduced to the minimum, and the economy and rationality of the correction scheme are improved.

[0113] Understandably, this solution addresses the issue of insufficient comprehensiveness in time-series data verification by constructing a complete set of temporal constraint relationships and building a temporal knowledge graph, laying the foundation for balancing the economic efficiency and adaptability of corrections. The solution first clearly extracts three types of temporal constraints (the first type representing the chronological order of events, the second type representing the time interval between events, and the third type representing the offset relationship between events and a reference time point), comprehensively covering all core dimensions of event temporal logic and avoiding the omissions caused by existing technologies that only verify single temporal rules. Then, using event types as nodes and temporal constraints as directed edges, a temporal knowledge graph is constructed, transforming abstract constraint rules into a visual and reusable graph structure, achieving systematic integration of various temporal constraints. Based on this, the temporal data of events associated with the target object is obtained and mapped to the temporal knowledge graph, generating an instantiated temporal graph. This ensures that the specific event temporal data of the target object is precisely bound to comprehensive constraint rules, guaranteeing that subsequent verification can fully cover all temporal requirements and solving the problem of incomplete verification from the source.

[0114] Secondly, the solution addresses the issues of insufficient economy and adaptability in time-series data correction by pre-setting correction cost weights and executing a minimum-cost correction strategy. Simultaneously, it leverages comprehensive prior validation to ensure that the corrected data conforms to all time-series constraints without sacrificing validation comprehensiveness. Before correction, the solution configures correction cost weights for the time-series data of each event in the instantiated time-series graph, quantitatively differentiating the correction costs of different events. For example, core business events and high-reliability data have high correction cost weights (high correction costs), while auxiliary business events and low-reliability data have low correction cost weights (low correction costs), providing a quantitative basis for achieving economical correction. Upon detecting node pairs violating time-series constraints, the solution locates the target node. Assuming all time-series constraints are met, and aiming to minimize the sum of correction cost weights for the corrected nodes, it executes a minimum-cost correction strategy, prioritizing the correction of nodes with low cost weights. This avoids the problems of blindly correcting core nodes, which could lead to increased correction costs and a disconnect from actual business needs, ensuring both economy and adaptability in the correction.

[0115] Finally, the solution employs a closed-loop logic of "verification-correction-verification" to ensure the accuracy of time-series data correction while balancing the comprehensiveness of verification with the economy and adaptability of correction. After performing minimum-cost correction, the corrected time-series data still needs to have a corresponding time-series graph instantiated, and the interval constraint propagation process re-executed to verify whether all time-series constraints are satisfied. This ensures that the corrected time-series data does not violate any type of time-series rule and does not sacrifice the comprehensiveness of verification. If constraint conflicts still exist, the process of locating the target node and performing minimum-cost correction is repeated until all constraints are satisfied. This closed-loop logic not only guarantees the comprehensiveness of time-series data verification but also controls the correction cost and improves the adaptability of correction through the minimum-cost correction strategy, completely solving the technical problem that existing technologies cannot simultaneously achieve both.

[0116] In some embodiments of the present invention, the reference time points in the third type of timing constraints include at least two reference time points from different sources; Specifically, this embodiment clarifies that the reference time point for the third type of timing constraint must adopt time bases from at least two different sources. Different sources can be defined as standardized time nodes from different business systems, different business entities, and different business processes. For example, in the health insurance scenario, the claims processing time from regulatory agencies and the settlement time from hospitals; in the medical technology scenario, the report time from laboratories and the settlement time from the medical insurance system.

[0117] In practical implementation, we can first identify the core reference time points in the target scenario, selecting time nodes with business authority and uniqueness. This ensures that two or more reference time points cover different business dimensions, avoiding constraint redundancy caused by data from the same source. Simultaneously, each reference time point should be labeled with basic attributes such as source identifier, business meaning, and time precision, providing a foundation for subsequent interval variable configuration and confidence calculation. Reference time points need to be associated with event type nodes in the instantiated time series graph, clearly defining the associated events corresponding to each reference time point to ensure clear binding relationships of time series constraints.

[0118] The method for correcting event time information also includes the following steps.

[0119] Step S171: Configure reference interval variables for the at least two different reference time points; Specifically, the core of this step is to configure a dedicated reference interval variable for each independent reference time point. Each reference interval variable contains the earliest time boundary and the latest time boundary, which is the basis for realizing interval constraint propagation.

[0120] More specifically, the configuration rules can be divided into three cases: First, if the reference time point is a precise standardized time (such as a fixed date stipulated by regulations or a precise timestamp generated by the system), then the earliest and latest time boundaries of the reference interval variable are both set to this precise time, forming a single-point interval variable; Second, if the reference time point has data errors, multi-source data conflicts, or time precision limitations, then the initial interval is set to a reasonable range that includes this time, with the earliest boundary being the minimum time value and the latest boundary being the maximum time value; Third, if the reference time point is an estimated value, then the initial interval boundaries are set based on the estimated range.

[0121] More specifically, all reference interval variables can be bound one-to-one with their corresponding reference time points. During storage, the source identifier and associated event information of the reference time point are linked, and the data is incorporated into the overall data system of the instantiated time series graph, ensuring consistent access for subsequent propagation calculations. During configuration, a unified time unit and format are used to avoid calculation errors caused by inconsistent units and formats. Additionally, an initial state is marked for each reference interval variable for subsequent confidence calculations and relaxation strategy triggering.

[0122] As a concrete example, in the health insurance scenario, a reference interval variable can be configured for the claims deadline of the supervisory authority, with the boundary being the precise statutory deadline date; a reference interval variable can be configured for the hospital discharge settlement time, with the boundary being the precise settlement date recorded by the hospital system. Both variables are single-point intervals, respectively associated with the corresponding claims and hospitalization event nodes. As another concrete example, in the medical technology scenario, reference interval variables for single-point intervals can be configured for laboratory report issuance time and reference interval variables for medical insurance settlement time, which are then bound to the diagnosis and treatment event nodes and incorporated into the graph system.

[0123] Step S172: During the interval constraint propagation process, based on the temporal constraint relationship between the reference interval variable corresponding to each reference time point and the associated node of the reference time point, calculate the confidence score of each reference time point, wherein the confidence score is inversely proportional to the degree of deviation between the reference time point and the cluster of reference points from the same source. Specifically, the core of this step is to calculate the confidence score of the reference time point. The score is inversely proportional to the degree to which the reference time point deviates from the cluster of reference points from the same source, and is used to measure the reliability and rationality of the reference time point.

[0124] More specifically, the specific calculation process is as follows: First, cluster all configured reference time points. Based on the similarity of time values, group reference points into clusters with the same source. Reference time points within a cluster belong to the same time base under the same business logic. Clustering can adopt a simple grouping method based on time difference, which is suitable for the rapid classification of time series data. Second, calculate the deviation distance between each reference time point and its cluster center. The cluster center is selected as the time mean or median of all reference time points within the cluster, and the deviation distance is the time difference between the reference time point and the cluster center. Third, normalize the deviation distance, mapping the value to the interval between 0 and 1. Fourth, calculate the confidence score. The score equals 1 minus the normalized deviation ratio, finally obtaining a score value between 0 and 1. The closer the score is to 1, the more closely the reference time point conforms to the cluster pattern, and the higher the reliability; the closer the score is to 0, the greater the deviation and the lower the reliability. During the calculation process, it is necessary to ensure that the time unit is consistent, and the clustering rules should be adapted to the business scenario to avoid unreasonable cluster division. At the same time, the calculation results should be bound and stored with reference interval variables and reference time points to provide data support for subsequent adaptive relaxation.

[0125] As a specific example, in the health insurance scenario, two reference time points can be divided into the same source cluster, and the deviation distance between each point and the cluster center can be calculated. After normalization, a confidence score is obtained. If the scores are all lower than the preset threshold, it means that there is a significant deviation between the two reference time points. As another concrete example, in the medical technology scenario, when two reference time points are grouped into the same cluster, after calculating the deviation distance, the deviation distance of the laboratory report issuance time is higher after normalization, and the final confidence score is lower than the preset threshold, while the score of the medical insurance settlement time is higher than the threshold, indicating stronger reliability.

[0126] Step S173: For the target reference time point among the reference time points, when the confidence score of the target reference time point is lower than a preset threshold, the time offset interval of the third type of time series constraint corresponding to the target reference time point is adaptively relaxed in the subsequent interval constraint propagation, wherein the relaxation amount of the adaptive relaxation is negatively correlated with the confidence score of the target reference time point.

[0127] Specifically, in this step, the core dynamic adjustment strategy is to adaptively relax the time offset interval of the corresponding third type of time series constraint when the confidence score of the target reference time point is lower than the preset threshold. The relaxation amount is negatively correlated with the confidence score.

[0128] More specifically, the technical process is as follows: First, a confidence threshold is preset. This threshold can be determined based on business experience or historical data statistics and is used to distinguish between normal and abnormal reference time points. Second, target reference time points with confidence scores lower than the threshold are selected and identified as abnormal reference points. Third, the relaxation amount is calculated. The relaxation amount is linearly negatively correlated with the confidence score; that is, the lower the score, the larger the relaxation amount. It can be calculated by multiplying a preset coefficient by (1 minus the confidence score) to ensure the rationality of the relaxation amount. Fourth, the time offset interval is adjusted by reducing the relaxation amount at the earliest time boundary and increasing the relaxation amount at the latest time boundary of the original offset interval to achieve overall expansion of the interval. Fifth, in the subsequent interval constraint propagation process, the relaxed time offset interval is used uniformly for calculations, replacing the original constraint interval.

[0129] More specifically, the core purpose of adaptive relaxation is to reduce the interference of abnormal reference time points on the overall constraint propagation, avoid the failure of constraint verification for the entire graph due to a single abnormal data point, and at the same time, retain reasonable constraint boundaries for business purposes by dynamically adjusting the interval range, ensuring the effectiveness of the correction results. After relaxation is executed, relevant information about the relaxation operation needs to be recorded, including the original interval, relaxation amount, and relaxed interval, forming a log for subsequent strategy optimization and data traceability.

[0130] As a concrete example, in the health insurance scenario, a confidence threshold can be preset. If the scores at both reference time points are lower than the threshold, the corresponding relaxation amount is calculated to expand the original offset interval from 0 to 7 days. The relaxed interval is then used in subsequent interval constraint propagation to reduce the impact of abnormal reference points. As another specific example, in the medical technology scenario, if the score of the laboratory report issuance time is lower than the threshold, the relaxation amount is calculated and its corresponding time offset interval is expanded. The relaxed interval is used in the propagation operation, which does not affect the overall verification process.

[0131] It is understood that the above embodiments, by employing at least two reference time points from different sources, configuring reference interval variables, and combining confidence score calculation with adaptive relaxation strategies, solve the problems of insufficient reliability of a single reference time point and interference of abnormal reference time points in constraint propagation, thereby improving the reliability and adaptability of the third type of time series constraints, ensuring that interval constraint propagation can be executed stably and accurately, and avoiding verification failures caused by abnormal reference time points.

[0132] In some embodiments of the present invention, the following steps are included after step S160.

[0133] Step S181: Push the corrected timing data to the interactive interface and receive the target object's confirmation or modification instruction for the corrected timing data. Specifically, this step implements human-machine collaborative correction. The core is to visually push the correction results while simultaneously receiving interactive instructions from the target object, ensuring that the correction results align with actual business needs. The specific technical implementation is as follows: Interactive Interface Design and Data Push: Design a visual interactive interface (Web / Client) adapted to business scenarios. The interface layout includes basic information about the target object, a list of corrected time-series data, a comparison with the original data, an explanation of the reasons for the correction, and constraint satisfaction status annotations. The corrected data is highlighted with a prominent color to distinguish it from the original data. The correction amount, cost, and constraint satisfaction status of each correction node are also annotated, allowing the target object to clearly understand the correction logic. The push mechanism uses real-time push, delivering the data to the target object's interactive interface within 10 seconds of correction completion, accompanied by a message notification to ensure timely viewing. Batch push (correcting data for multiple target objects) and single push are supported to adapt to different business scenarios.

[0134] Command Reception and Verification: The interface allows the target object to click the "Confirm" or "Modify" button to submit the corresponding command. When receiving a command, the format and content of the command are verified. Confirmed commands must include the target object ID and the correction node ID to ensure that the command can be accurately located. Modified commands must include the adjusted time value and the reason for modification. The time value must conform to the business time format (such as YYYY-MM-DD HH:MM:SS) and not exceed the reasonable business range (such as not earlier than the time of the preceding event associated with the event). If the verification fails, a prompt is returned, requiring the target object to resubmit.

[0135] Interaction Log Recording: Upon receiving an instruction, an interaction log is generated, recording the instruction type (confirmation / modification), target object ID, correction node ID, instruction submission time, submitter, and adjustment time and reason in the modification instruction. The log is stored in association with the correction log, forming a complete correction-interaction traceability chain; at the same time, the instruction status is synchronized to the business system in real time, making it convenient for business personnel to track the processing progress.

[0136] Exception handling: If the push fails (e.g., the target is not logged in, or there is a network error), a retry mechanism will be triggered (retry 3 times, with a 30-second interval between each retry). After a retry fails, an exception log will be recorded, and an email will be sent to remind the target and the business administrator. If the command submission times out (more than 10 minutes have passed without submission), the target will be automatically reminded to avoid process stagnation.

[0137] As a concrete example, in a health insurance scenario, after the claims review node is corrected, the corrected data is pushed to the insurance company's claims agent's web interface within 10 seconds. The interface displays the insured Zhang San's basic information, and the corrected data list indicates the original time of the claims review node (2025-01-12), the corrected time (2025-01-10), the correction amount (-2 days), and the correction cost (7 points). It also explains that the reason for the correction is "meeting the 1-3 day time interval constraint between claims application and review," and marks the constraint satisfaction status as "met." After reviewing the data and confirming that the correction result matches the actual business situation, the agent clicks the "Confirm" button to submit the confirmation instruction. Upon receiving the instruction, the system verifies that the instruction format is correct, generates an interaction log, records the relevant information of the confirmation instruction, and synchronizes it to the claims system, completing the interactive confirmation process.

[0138] As another concrete example, in a medical technology scenario, after the examination node is corrected, it is pushed to the hospital's treatment administrator's client interface in real time. The interface displays patient Li Si's treatment number and basic information. The corrected data list marks the original time (2025-02-10 10:00), the corrected time (2025-02-10 10:30), the correction amount (+0.5 hours), and the correction cost (6 points) of the examination node. It explains that the reason for the correction is "to meet the 0.5-2 hour time interval constraint between the examination and test results," and marks the constraint satisfaction status. After reviewing it, the administrator believes that the corrected time does not match the patient's actual examination time. He clicks the "Modify" button, submits the modification instruction, fills in the adjusted time as 2025-02-10 10:15, and the reason for the modification is "to match the patient's actual examination registration time." After the system verifies that the time format and logic are correct, it receives the instruction and records the interaction log.

[0139] Step S182: In response to the confirmation instruction or the modification instruction, update the temporal data of the target node in the instantiated temporal graph, and re-execute the interval constraint propagation and the minimum cost correction strategy until all the temporal constraint relationships are satisfied or the number of iterations reaches a preset threshold.

[0140] Specifically, this step is an instruction-driven iterative optimization. Its core is to update data based on the instructions for the target object, and through repeated verification and correction, ensure that the final data meets all constraints. The specific technical implementation is as follows: Command Response and Data Update: When responding to a confirmation command, retain the corrected time series data, mark the correction process as "completed", terminate the correction process, and synchronously update the relevant data in the instantiated time series graph, time series database, and business system to ensure data consistency; when responding to a modification command, extract the adjustment time from the command, update the time series data of the corresponding target node in the instantiated time series graph (overwriting the original corrected data), and update the correction log at the same time, recording the modified time, reason for modification, modifier, and modification time, and linking it with the original correction log to achieve complete traceability.

[0141] Iterative execution verification and correction: After the data is updated, the interval constraint propagation operation is re-executed (step S150) to verify the satisfaction status of all time-series constraints one by one; if all constraints are satisfied, the iteration is terminated and the process is marked as complete; if there are still constraint conflicts, the minimum cost correction strategy is called again (step S160) to rebuild the integer linear programming model, solve for the optimal solution, correct the data, and form an iterative loop.

[0142] Iteration termination condition settings: Preset iteration number threshold (e.g., 5 times), record the iteration number, constraint verification result, and correction / adjustment content after each iteration; when the iteration number reaches the threshold but constraint conflicts still exist, terminate the iteration, output an exception prompt, and push the exception information to the business administrator for manual intervention and adjustment to avoid infinite loops; if all constraints are satisfied during the iteration process, terminate the iteration in advance to ensure process efficiency.

[0143] Iteration result archiving: After the iteration is completed, regardless of whether all constraints are met, all data during the iteration process (correction log, interaction log, verification results, iteration records) will be archived by target object ID and synchronously pushed to the business system and data management module to provide data support for subsequent business optimization and model adjustment.

[0144] As a concrete example, in a health insurance scenario, the system responds to the agent's confirmation instruction, retains the corrected time of the claims review node (2025-01-10), marks the correction process as "completed," and synchronously updates the data in the instantiated graph, time-series database, and claims system to ensure data consistency. The system re-executes the interval constraint propagation verification; if all time-series constraints are satisfied and there are no conflicts, the iteration process terminates. If the agent submits a modification instruction to adjust the claims review time to 2025-01-11, the system updates the node data and re-executes the verification. It finds that the time interval between the claims application and review is 3 days (compliant with constraints), and all other constraints are satisfied, requiring no further correction, and the iteration terminates. If the adjusted time is 2025-01-13, and the verification finds the interval is 5 days (violation of constraints), then the minimum cost correction strategy is executed again, the model is re-solved, and the data is corrected until the constraints are satisfied or the iteration reaches the 5-times threshold.

[0145] As another concrete example, in a medical technology scenario, the system responds to the administrator's modification command, updating the examination node time to 2025-02-10 10:15, updating the atlas data and correction log, and re-executing the interval constraint propagation verification. The calculated time interval between the examination and test results is 1 hour and 15 minutes, meeting the 0.5-2 hour constraint. The constraints between the initial diagnosis and examination, and between the confirmed diagnosis and the reference time point, are all satisfied without conflict. The iteration process terminates, and the correction is marked as complete. If the administrator adjusts the examination time to 2025-02-10 09:00, verification reveals it is earlier than the initial diagnosis time (09:30), violating the sequential constraint. The system again calls the minimum cost correction strategy, rebuilds the model, solves for the optimal solution, corrects the examination node or initial diagnosis node time, and iteratively executes verification and correction until all constraints are satisfied or the 5-iteration threshold is reached. If conflicts still exist, an exception notification is pushed to the administrator for manual handling.

[0146] Understandably, by pushing corrected data and receiving instructions from the target object, combined with iterative verification and correction after the instruction response, human-machine collaborative time-series data correction is achieved. This solves the problems of traditional correction schemes lacking human interaction and having poor adaptability of correction results, making the corrected time-series data more in line with actual business needs. At the same time, iterative verification ensures that the correction results meet all time-series constraints, improving the adaptability and accuracy of time-series data correction.

[0147] In some embodiments of the present invention, the following steps are included after step S160.

[0148] Step S191: Store each node pair that violates the timing constraint relationship, the timing data of the node pair after correction, and the feedback record of the target object on the corrected timing data in the historical database. The feedback record includes a confirmation instruction or a modification instruction on the corrected timing data. Specifically, this step forms the foundation for building the feedback optimization dataset. Its core is the full retention of key data from the time-series correction process, providing data support for subsequent weight optimization. First, the data field system to be stored is defined, covering information on node pairs violating constraints (unique identifier of the target object, event type, node ID, constraint type, and conflict reason), corrected time-series data (original time, corrected time, correction amount, correction cost weight, and correction basis), and target object feedback records (instruction type, adjusted time, feedback opinion, submission time, and operator). Second, the database storage structure is designed, using a relational database to store structured data and a time-series database to store time-related sequence data, ensuring data query efficiency and traceability. Simultaneously, data associations are established, linking the three types of data through target object ID and node ID to form a complete correction-feedback data link. Finally, data storage rules are configured, with new data added in real-time, historical data archived quarterly, sensitive data anonymized, and data storage logs recorded, including storage time, operator, and data version, ensuring data traceability and auditability, providing a complete raw data foundation for subsequent feedback signal calculation and weight optimization.

[0149] As a concrete example, in a health insurance scenario, regarding the correction of the claim review process for insured Zhang San, core data is stored in a historical database. The stored content includes: information on node pairs violating constraints, i.e., Zhang San's claim application and claim review node, the second type of time interval constraint, and the reasons for the conflict due to the interval exceeding the range; corrected data, including the original claim review time, the corrected time, the correction amount two days earlier, and the correction cost weight of 7 points; and feedback records including the salesperson's confirmation instruction, submission time, and operator information. The database links all data through Zhang San's policy ID, uses a relational database structured storage, and performs real-time data entry and storage log recording. Subsequently, the full set of data for this correction can be quickly retrieved via the policy ID, providing a complete raw dataset for calculating feedback signals and optimizing correction cost weights, while simultaneously archiving historical data to meet business traceability and compliance requirements.

[0150] As another concrete example in a medical technology scenario, data storage is completed for a correction scenario of patient Li Si's examination nodes. The stored data includes: information on node pairs violating constraints, Li Si's examination and test result issuance nodes, the second type of time interval constraint, and the reasons for the conflict due to non-compliance with interval requirements; corrected data, including the original examination node time, the corrected time, the correction amount of half an hour delay, and a correction cost weight of 6 points; and feedback records including the administrator's modification instructions, the adjusted examination time, the reason for modification, the submission time, and the operator's information. The data is linked through Li Si's treatment number and stored in the hospital's time-series database and relational database, with real-time data entry and the generation of storage logs. This dataset comprehensively records the entire process of correction and feedback, which can be used to calculate feedback signals, providing data support for subsequent adjustments to correction cost weights and optimization of correction strategies. Furthermore, after archiving, it supports the traceability of medical data and medical quality analysis.

[0151] Step S192: Based on the feedback record of the target object to the corrected time series data, determine the correction scheme of the time series data actually received by the target object, and calculate the difference between the correction scheme of the time series data and the corrected time series data as a feedback signal; Specifically, this step is the core of quantifying the feedback effect. By comparing the corrected data generated by the system with the corrected solution actually accepted by the target object, a standardized feedback signal is calculated to measure the suitability of the corrected solution. First, the feedback records of the target object are extracted, distinguishing between confirmation instructions and modification instructions: for confirmation instructions, the actual accepted solution is the corrected data generated by the system; for modification instructions, the actual accepted solution is the adjusted time specified in the instruction, and this time needs to be extracted as a benchmark. Second, the corrected data generated by the system is extracted, and the difference between it and the actual accepted time is calculated. After unifying the time unit, the time difference value is obtained. At the same time, combined with the correction node range and event type, the difference value is normalized and mapped to a standardized feedback signal range (e.g., between 0 and 1, the smaller the value, the smaller the difference, and the more closely the correction solution meets the requirements). Finally, the feedback signal is associated and stored with the corresponding target object ID, node ID, and correction batch to form a feedback signal dataset, providing input parameters for the optimization of the gradient descent algorithm. During the calculation process, invalid feedback (such as format errors or meaningless adjustments) must be excluded to ensure the validity and accuracy of the feedback signal. At the same time, a signal calculation log should be recorded, including the calculation basis, normalization rules, and signal values, to ensure that the calculation process is traceable.

[0152] As a concrete example, in a health insurance scenario, a feedback signal is calculated based on Zhang San's feedback record. The system-generated claim review correction time is 2025-01-10. The agent sends a confirmation instruction, and the actual accepted plan matches the system's correction data. Extracting the time data from both, the time difference is calculated to be 0 days. After normalization, the feedback signal value is 0, indicating that the correction plan fully meets business needs. This feedback signal is associated with Zhang San's policy ID, claim review node ID, and correction batch, and stored in the feedback signal dataset. If the agent sends a modification instruction, adjusting the review time to 2025-01-11, the difference between the actual acceptance time and the system correction time is 1 day. After normalization, the feedback signal value is 0.2. This signal value is recorded and associated with relevant identifiers, providing a clear optimization direction for subsequent gradient descent optimization of the correction cost weights. The smaller the signal value, the more priority should be given to optimizing the weight configuration for this type of correction scenario.

[0153] As another concrete example, in a medical technology scenario, a feedback signal is calculated based on Li Si's feedback records. The system-generated correction time for the examination node was 10:30 on February 10, 2025. The administrator submitted a modification command, adjusting the time to 10:15 on February 10, 2025. There was a 15-minute difference between the actual received time and the system's correction time. After standardizing the time unit to minutes, the difference was calculated and normalized, resulting in a feedback signal value of 0.1. This value represents a slight deviation in the correction scheme. The feedback signal value is bound and stored with Li Si's diagnosis number, examination node ID, and correction batch, and included in the feedback signal dataset. This signal value will serve as input to the gradient descent algorithm to optimize the correction cost weight of the examination node, further reducing the difference between subsequent correction schemes for similar treatment scenarios and the schemes actually received by the target object, thus improving the adaptability of the correction scheme.

[0154] Step S193: Using the feedback signal as the optimization target, the gradient descent algorithm is used to update the correction cost weight, so that the difference between the corrected time series data generated in the subsequent correction process and the correction scheme actually accepted by the target object gradually decreases.

[0155] Specifically, this step is the core of dynamic weight optimization. It minimizes the feedback signal using the gradient descent algorithm to adaptively adjust the correction cost weights, improving the adaptability of subsequent correction schemes. First, the objective function for weight optimization is defined, aiming to minimize the mean or sum of all feedback signals, ensuring a continuous reduction in the difference between the overall correction scheme and the target object's requirements. Second, the parameters to be optimized are determined as the correction cost weights of each event type node. A correlation model between weights and feedback signals is established to clarify the gradient of the impact of weight adjustments on the feedback signals. Then, iterative optimization is performed using the gradient descent algorithm. The gradient direction of the feedback signal relative to each weight is calculated, and the weight values ​​are adjusted along the negative gradient direction. The adjustment magnitude is controlled by the learning rate to avoid sudden weight changes that could lead to system imbalance. During iteration, convergence conditions are set. When the mean of the feedback signal is lower than a preset threshold or the weight change magnitude is less than a set value, iteration stops, and the weight update is completed. Simultaneously, a weight update verification mechanism is established to verify whether the updated weights conform to business logic (e.g., the weight of core events is not lower than that of auxiliary events), and the updated weights are synchronized to the weight rule base to cover subsequent correction processes. In addition, a weight update log is recorded, including the weights before and after the update, gradient values, learning rate, and number of optimization iterations, to ensure that the weight adjustment process is traceable. At the same time, the updated weights are applied to real-time time-series correction tasks to achieve closed-loop optimization.

[0156] As a concrete example in the health insurance scenario, using feedback signals as the optimization target, a gradient descent algorithm is employed to optimize the correction cost weight of the claims review node. Currently, the weight of this node is 7 points, corresponding to a feedback signal value of 0 (no difference). If a similar scenario subsequently results in a feedback signal value of 0.3, the algorithm calculates the gradient direction corresponding to this weight, adjusts the weight value in the negative direction, sets the learning rate to 0.5, and lowers the weight to 6.5 points. During the iteration process, the mean of the feedback signal is continuously monitored. When the mean falls below 0.1, the iteration stops, and the weight update is completed. After the update, the weight is synchronized to the weight rule base. When subsequently correcting the claims review node for the insured, a lower weight is prioritized, making the correction scheme more aligned with the actual needs of business personnel. Simultaneously, a weight update log is recorded, including the values ​​before and after adjustment, gradient calculation results, and iteration count, ensuring the weight optimization process is traceable and continuously reducing the discrepancy between subsequent corrections and the accepted solution for the target audience.

[0157] As another concrete example, in a medical technology scenario, the gradient descent algorithm is used to optimize the correction cost weights of examination nodes based on feedback signals. The current weight is 6 points, corresponding to a feedback signal value of 0.1. The algorithm calculates the gradient of this weight, adjusts it in the negative direction, and sets the learning rate to 0.3, reducing the weight to 5.7 points. Optimization terminates when the average feedback signal value falls below 0.05, completing the weight update. The updated weights are synchronized to the hospital's weight configuration library. In subsequent time-series corrections of patient examination nodes, the correction priority of this node is increased, prioritizing adjustments to match the actual needs of the medical administrator. Simultaneously, a full log of weight updates is recorded, including the gradient calculation process, adjustment magnitude, and number of iterations, ensuring the optimization process is traceable. Through continuous weight iteration, the difference between subsequent correction schemes and the actual accepted schemes for the target audience is gradually reduced, improving the business adaptability of time-series corrections.

[0158] It is understood that the above embodiments achieve adaptive optimization of correction cost weights by storing the entire correction process data, calculating feedback signals, and updating the correction cost weights using the gradient descent algorithm. This solves the problem that the traditional correction scheme has fixed weights and cannot be dynamically adjusted according to actual feedback, making the cost control of subsequent time series data correction more precise and the correction scheme more in line with the needs of the target object. This continuously improves the efficiency and adaptability of time series data correction, forming a closed loop of correction optimization.

[0159] It should be understood that the sequence number of each step in the above embodiments does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of the present invention. Software tools or components not belonging to this company that appear in the embodiments of this application are merely illustrative examples and do not represent actual use.

[0160] In one embodiment, an event time information correction device is provided, which corresponds one-to-one with the event time information correction methods described in the above embodiments. For example... Figure 5 As shown, the event time information correction device includes a first acquisition module 510, a map construction module 520, a second acquisition module 530, a mapping module 540, a detection module 550, and a correction module 560. Detailed descriptions of each functional module are as follows: The first acquisition module 510 is used to acquire a preset set of temporal constraint relationships between event types, wherein the set of temporal constraint relationships includes a first type of temporal constraint, a second type of temporal constraint, and a third type of temporal constraint. The first type of temporal constraint is used to characterize the sequential relationship between event types, the second type of temporal constraint is used to characterize the time interval between event types, and the third type of temporal constraint is used to characterize the time offset interval between event types and reference time points. The graph construction module 520 is used to analyze each event in the preset event set based on the set of temporal constraint relationships, using the event type of each event as the node of the temporal knowledge graph, and the temporal constraint relationship between the event types as the directed edge of the temporal knowledge graph, to construct the temporal knowledge graph corresponding to the event set. The second acquisition module 530 is used to acquire the time sequence data between multiple events associated with the target object; The mapping module 540 is used to map the temporal data between multiple events to the event type nodes corresponding to each event in the temporal knowledge graph, and generate an instantiated temporal graph. The detection module 550 is used to perform interval constraint propagation on the instantiated time series graph based on the temporal constraint relationship between each event type in the instantiated time series graph, and to detect whether there are node pairs that violate the temporal constraint relationship; The correction module 560 is used to respond to the detection of a node pair that violates the temporal constraint relationship, locate the target node that violates the temporal constraint relationship, and perform a minimum cost correction strategy on the target node based on the preset correction cost weight of the target node to generate the corrected temporal data of the target node.

[0161] In one embodiment, the detection module 550 is specifically used for: The time series data of each event in the instantiated time series graph are represented as time interval variables, wherein the time interval variables include the earliest time boundary and the latest time boundary; Based on the temporal constraint relationship, interval propagation operation is performed on the time interval variables to iteratively update the boundary values ​​of each time interval variable; For each of the temporal constraints in the instantiated temporal graph, if the boundary value of the corresponding time interval variable of the node pair associated with the temporal constraint violates the temporal constraint, then the node pair is determined to violate the temporal constraint.

[0162] In one embodiment, the time interval in the second type of timing constraint is determined based on a predefined standardized process time window or statistical distribution information interval in the domain knowledge base; The detection module 550 is also used for: Based on the aforementioned temporal constraints, interval propagation operations are performed on the time interval variables; During the interval propagation operation, the time interval of the node pair in the instantiated time series graph is used as the difference constraint between the two time interval variables associated with the node pair. The boundary values ​​of the two time interval variables are jointly tightened to obtain the boundary values ​​of each time interval variable after iterative update.

[0163] In one embodiment, the reference time points in the third type of timing constraints include reference time points from at least two different sources; The correction module 560 is also used for: Configure reference interval variables for the at least two different reference time points; During the interval constraint propagation process, based on the temporal constraint relationship between the reference interval variable corresponding to each reference time point and the associated node of the reference time point, the confidence score of each reference time point is calculated, wherein the confidence score is inversely proportional to the degree of deviation between the reference time point and the cluster of reference points from the same source. For the target reference time point among the reference time points, when the confidence score of the target reference time point is lower than a preset threshold, the time offset interval of the third type of time series constraint corresponding to the target reference time point is adaptively relaxed in the subsequent interval constraint propagation, wherein the relaxation amount of the adaptive relaxation is negatively correlated with the confidence score of the target reference time point.

[0164] In one embodiment, the correction module 560 is specifically used for: Configure corrected cost weights for the time series data of each event in the instantiated time series graph; Using all temporal constraints as constraints, the correction values ​​of each temporal data as integer decision variables, and minimizing the sum of the correction cost weights of the modified temporal data as the objective, an integer linear programming model is constructed. Solve the integer linear programming model to obtain the correction value of each time series data that minimizes the sum of the correction cost weights of all the time series constraints and the modified time series data; The time series data are corrected based on the correction values ​​of each of the time series data.

[0165] In one embodiment, the correction module 560 is further configured to: The corrected time series data is pushed to the interactive interface, and the target object is received confirmation or modification instructions for the corrected time series data. In response to the confirmation instruction or the modification instruction, the temporal data of the target node in the instantiated temporal graph is updated, and the interval constraint propagation and the minimum cost correction strategy are re-executed until all the temporal constraint relationships are satisfied or the number of iterations reaches a preset threshold.

[0166] In one embodiment, the correction module 560 is further configured to: Each node pair that violates the timing constraint relationship, the timing data of the node pair after correction, and the feedback record of the target object on the corrected timing data are stored in the historical database. The feedback record includes a confirmation instruction or a modification instruction on the corrected timing data. Based on the feedback record of the target object to the corrected time series data, determine the correction scheme of the time series data actually accepted by the target object, calculate the difference between the correction scheme of the time series data and the corrected time series data, and use it as a feedback signal; Using the feedback signal as the optimization target, the gradient descent algorithm is used to update the correction cost weight, so that the difference between the corrected time series data generated in the subsequent correction process and the correction scheme actually received by the target object gradually decreases.

[0167] Understandably, this solution addresses the issue of insufficient comprehensiveness in time-series data verification by constructing a complete set of temporal constraint relationships and building a temporal knowledge graph, laying the foundation for balancing the economic efficiency and adaptability of corrections. The solution first clearly extracts three types of temporal constraints (the first type representing the chronological order of events, the second type representing the time interval between events, and the third type representing the offset relationship between events and a reference time point), comprehensively covering all core dimensions of event temporal logic and avoiding the omissions caused by existing technologies that only verify single temporal rules. Then, using event types as nodes and temporal constraints as directed edges, a temporal knowledge graph is constructed, transforming abstract constraint rules into a visual and reusable graph structure, achieving systematic integration of various temporal constraints. Based on this, the temporal data of events associated with the target object is obtained and mapped to the temporal knowledge graph, generating an instantiated temporal graph. This ensures that the specific event temporal data of the target object is precisely bound to comprehensive constraint rules, guaranteeing that subsequent verification can fully cover all temporal requirements and solving the problem of incomplete verification from the source.

[0168] Secondly, the solution addresses the issues of insufficient economy and adaptability in time-series data correction by pre-setting correction cost weights and executing a minimum-cost correction strategy. Simultaneously, it leverages comprehensive prior validation to ensure that the corrected data conforms to all time-series constraints without sacrificing validation comprehensiveness. Before correction, the solution configures correction cost weights for the time-series data of each event in the instantiated time-series graph, quantitatively differentiating the correction costs of different events. For example, core business events and high-reliability data have high correction cost weights (high correction costs), while auxiliary business events and low-reliability data have low correction cost weights (low correction costs), providing a quantitative basis for achieving economical correction. Upon detecting node pairs violating time-series constraints, the solution locates the target node. Assuming all time-series constraints are met, and aiming to minimize the sum of correction cost weights for the corrected nodes, it executes a minimum-cost correction strategy, prioritizing the correction of nodes with low cost weights. This avoids the problems of blindly correcting core nodes, which could lead to increased correction costs and a disconnect from actual business needs, ensuring both economy and adaptability in the correction.

[0169] Finally, the solution employs a closed-loop logic of "verification-correction-verification" to ensure the accuracy of time-series data correction while balancing the comprehensiveness of verification with the economy and adaptability of correction. After performing minimum-cost correction, the corrected time-series data still needs to have a corresponding time-series graph instantiated, and the interval constraint propagation process re-executed to verify whether all time-series constraints are satisfied. This ensures that the corrected time-series data does not violate any type of time-series rule and does not sacrifice the comprehensiveness of verification. If constraint conflicts still exist, the process of locating the target node and performing minimum-cost correction is repeated until all constraints are satisfied. This closed-loop logic not only guarantees the comprehensiveness of time-series data verification but also controls the correction cost and improves the adaptability of correction through the minimum-cost correction strategy, completely solving the technical problem that existing technologies cannot simultaneously achieve both.

[0170] Correction methods based on the above event time information, such as Figure 6 As shown in the diagram, this embodiment of the invention also provides a schematic diagram of the device for the event time information correction method steps. The device includes a processor 61 and a memory 62 coupled to the processor 61. The memory 62 stores a computer program, which, when executed by the processor 61, causes the processor 61 to perform the steps of the event time information correction method in the above embodiment.

[0171] For further details regarding the implementation of the above technical solution by the processor 61 in the device for the above-mentioned method steps for correcting event time information, please refer to the description in the above-mentioned embodiment of the invention for the method of correcting event time information, which will not be repeated here.

[0172] The processor 61 can also be called a CPU (Central Processing Unit). The processor 61 may be an integrated circuit chip with signal processing capabilities. The processor 61 can also be a general-purpose processor, a DSP (Digital Signal Processor), an ASIC (Application Specific Integrated Circuit), an FPGA (Field Programmable Gate Array), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. The general-purpose processor can be a microprocessor, or the processor 61 can be any conventional processor.

[0173] like Figure 7 As shown in the diagram, this embodiment of the invention also provides a schematic diagram of a computer-readable storage medium, on which a readable computer program 71 is stored. The computer program 71 can be stored in the storage medium in the form of a software product, including several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) or processor to execute all or part of the steps of the methods described in various embodiments of the invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, magnetic disks or optical disks, ROM (Read-Only Memory), RAM (Random Access Memory), or terminal devices such as computers, servers, mobile phones, and tablets.

[0174] In the embodiments provided by this invention, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of modules is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple modules or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be indirect coupling or communication connection through some interfaces, apparatuses, or modules, and may be electrical, mechanical, or other forms.

[0175] The modules described as separate components may or may not be physically separate. The components shown as modules may or may not be physical modules; that is, they may be located in one place or distributed across multiple network modules. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.

[0176] Furthermore, the functional modules in the various embodiments of this invention can be integrated into one processing module, or each module can exist physically separately, or two or more modules can be integrated into one module. The integrated module can be implemented in hardware or as a software functional module. If the integrated module is implemented as a software functional module and sold or used as an independent product, it can be stored in a computer-readable storage medium.

[0177] In the above embodiments, implementation can be achieved, in whole or in part, through software, hardware, firmware, or any combination thereof. When implemented in software, it can be implemented, in whole or in part, as a computer program product.

[0178] The computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, all or part of the processes or functions described in the embodiments of the present invention are generated. The computer may be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions may be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions may be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired (e.g., coaxial cable, fiber optic, digital subscriber line) or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium may be any available medium that a computer can store or a data storage device such as a server or data center that integrates one or more available media. The available medium may be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium, or a semiconductor medium (e.g., SSD (solid state disk)).

[0179] The technical solution provided by the present invention has been described in detail above. Specific examples have been used to illustrate the principle and implementation of the present invention. The description of the above embodiments is only for the purpose of helping to understand the method and core idea of ​​the present invention. At the same time, for those skilled in the art, there will be changes in the specific implementation and application scope based on the idea of ​​the present invention. Therefore, the content of this specification should not be construed as a limitation of the present invention.

[0180] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, optical storage, etc.) containing computer-usable program code.

[0181] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0182] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0183] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0184] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

Claims

1. A method for correcting event time information, characterized in that, include: Obtain a preset set of temporal constraint relationships between event types, wherein the set of temporal constraint relationships includes a first type of temporal constraint, a second type of temporal constraint, and a third type of temporal constraint. The first type of temporal constraint is used to characterize the sequential relationship between event types, the second type of temporal constraint is used to characterize the time interval between event types, and the third type of temporal constraint is used to characterize the time offset interval between event types and reference time points. Based on the set of temporal constraint relationships, analyze each event in the preset event set, take the event type of each event as the node of the temporal knowledge graph, and the temporal constraint relationship between the event types as the directed edge of the temporal knowledge graph, and construct the temporal knowledge graph corresponding to the event set. Obtain the time-series data between multiple events associated with the target object; The temporal data between multiple events is mapped to the event type nodes corresponding to each event in the temporal knowledge graph to generate an instantiated temporal graph; Based on the temporal constraint relationships between event types in the instantiated temporal graph, interval constraint propagation is performed on the instantiated temporal graph to detect whether there are node pairs that violate the temporal constraint relationships; In response to the detection of a node pair that violates the temporal constraint relationship, the target node that violates the temporal constraint relationship is located, and a minimum cost correction strategy is executed on the target node based on the preset correction cost weight of the target node to generate the corrected temporal data of the target node.

2. The method for correcting event time information according to claim 1, characterized in that, The step of performing interval constraint propagation on the instantiated time series graph based on the temporal constraint relationships between event types in the instantiated time series graph, and detecting whether there are node pairs that violate the temporal constraint relationships, includes: The time series data of each event in the instantiated time series graph are represented as time interval variables, wherein the time interval variables include the earliest time boundary and the latest time boundary; Based on the temporal constraint relationship, interval propagation operation is performed on the time interval variables to iteratively update the boundary values ​​of each time interval variable; For each of the temporal constraints in the instantiated temporal graph, if the boundary value of the corresponding time interval variable of the node pair associated with the temporal constraint violates the temporal constraint, then the node pair is determined to violate the temporal constraint.

3. The method for correcting event time information according to claim 2, characterized in that, The time interval in the second type of timing constraint is determined based on the predefined standardized process time window or statistical distribution information interval in the domain knowledge base; Based on the aforementioned temporal constraints, interval propagation operations are performed on the time interval variables to iteratively update the boundary values ​​of each time interval variable, including: Based on the aforementioned temporal constraints, interval propagation operations are performed on the time interval variables; During the interval propagation operation, the time interval of the node pair in the instantiated time series graph is used as the difference constraint between the two time interval variables associated with the node pair. The boundary values ​​of the two time interval variables are jointly tightened to obtain the boundary values ​​of each time interval variable after iterative update.

4. The method for correcting event time information according to claim 1, characterized in that, The reference time points in the third type of timing constraints include at least two reference time points from different sources; The method for correcting the event time information also includes: Configure reference interval variables for the at least two different reference time points; During the interval constraint propagation process, based on the temporal constraint relationship between the reference interval variable corresponding to each reference time point and the associated node of the reference time point, the confidence score of each reference time point is calculated, wherein the confidence score is inversely proportional to the degree of deviation between the reference time point and the cluster of reference points from the same source. For the target reference time point among the reference time points, when the confidence score of the target reference time point is lower than a preset threshold, the time offset interval of the third type of time series constraint corresponding to the target reference time point is adaptively relaxed in the subsequent interval constraint propagation, wherein the relaxation amount of the adaptive relaxation is negatively correlated with the confidence score of the target reference time point.

5. The method for correcting event time information according to claim 1, characterized in that, The process involves applying a minimum cost correction strategy to the target node based on a preset correction cost weight, generating the corrected time-series data for the target node, including: Configure corrected cost weights for the time series data of each event in the instantiated time series graph; Using all temporal constraints as constraints, the correction values ​​of each temporal data as integer decision variables, and minimizing the sum of the correction cost weights of the modified temporal data as the objective, an integer linear programming model is constructed. Solve the integer linear programming model to obtain the correction value of each time series data that minimizes the sum of the correction cost weights of all the time series constraints and the modified time series data; The time series data are corrected based on the correction values ​​of each of the time series data.

6. The method for correcting event time information according to claim 1, characterized in that, After responding to the detection of a node pair violating the temporal constraint relationship, locating the target node violating the constraint relationship, and performing a minimum cost correction strategy on the target node based on a preset correction cost weight of the target node to generate the corrected temporal data of the target node, the method further includes: The corrected time series data is pushed to the interactive interface, and the target object is received confirmation or modification instructions for the corrected time series data. In response to the confirmation instruction or the modification instruction, the temporal data of the target node in the instantiated temporal graph is updated, and the interval constraint propagation and the minimum cost correction strategy are re-executed until all the temporal constraint relationships are satisfied or the number of iterations reaches a preset threshold.

7. The method for correcting event time information according to claim 1, characterized in that, After responding to the detection of a node pair violating the temporal constraint relationship, locating the target node violating the constraint relationship, and performing a minimum cost correction strategy on the target node based on a preset correction cost weight of the target node to generate the corrected temporal data of the target node, the method further includes: Each node pair that violates the timing constraint relationship, the timing data of the node pair after correction, and the feedback record of the target object on the corrected timing data are stored in the historical database. The feedback record includes a confirmation instruction or a modification instruction on the corrected timing data. Based on the feedback record of the target object to the corrected time series data, determine the correction scheme of the time series data actually accepted by the target object, calculate the difference between the correction scheme of the time series data and the corrected time series data, and use it as a feedback signal; Using the feedback signal as the optimization target, the gradient descent algorithm is used to update the correction cost weight, so that the difference between the corrected time series data generated in the subsequent correction process and the correction scheme actually received by the target object gradually decreases.

8. A device for correcting event time information, characterized in that, include: The first acquisition module is used to acquire a preset set of temporal constraint relationships between event types. The set of temporal constraint relationships includes a first type of temporal constraint, a second type of temporal constraint, and a third type of temporal constraint. The first type of temporal constraint is used to characterize the sequential relationship between event types. The second type of temporal constraint is used to characterize the time interval between event types. The third type of temporal constraint is used to characterize the time offset interval between event types and reference time points. The graph construction module is used to analyze each event in the preset event set based on the set of temporal constraint relationships, and to construct the temporal knowledge graph corresponding to the event set by taking the event type of each event as the node of the temporal knowledge graph and the temporal constraint relationship between the event types as the directed edge of the temporal knowledge graph. The second acquisition module is used to acquire the time-series data between multiple events associated with the target object; The mapping module is used to map the temporal data between multiple events to the event type nodes corresponding to each event in the temporal knowledge graph, and generate an instantiated temporal graph. The detection module is used to perform interval constraint propagation on the instantiated time series graph based on the temporal constraint relationship between each event type in the instantiated time series graph, and to detect whether there are node pairs that violate the temporal constraint relationship; The correction module is used to respond to the detection of a node pair that violates the temporal constraint relationship, locate the target node that violates the constraint temporal relationship, and perform a minimum cost correction strategy on the target node based on the preset correction cost weight of the target node to generate the corrected temporal data of the target node.

9. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the steps of the method for correcting event time information as described in any one of claims 1 to 7.

10. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by the processor, it implements the steps of the method for correcting event time information as described in any one of claims 1 to 7.

Images