A method and related apparatus for quantitative analysis of evidence chain data

Abstract

This application discloses a method and related apparatus for quantitative analysis of evidence chain data, relating to the field of data processing. It involves acquiring raw data and reference information; determining a standardized evidence record structure, which includes at least input data, reference information, calculation rule identifiers, output results, and a completeness assessment field. Based on the raw data and reference information, quantitative calculations are performed on at least one quantitative dimension, and evidence records are synchronously created and populated according to the standardized evidence record structure during each quantitative calculation. All evidence records are organized into a structured evidence chain, which is then output after being correlated with the comprehensive result. This application enables the quantitative calculation process to produce traceable structured evidence during calculation, achieving transparency in the calculation process, traceability of results, and explicit data quality. It overcomes the shortcomings of existing quantitative analysis technologies, such as the black box nature and lack of traceability, and can be widely applied in fields requiring multi-dimensional quantitative analysis, such as medicine.

Description

Technical Field

[0001] This application relates to the field of data processing technology, and in particular to a method and related apparatus for quantitative analysis of evidence chain data. Background Technology

[0002] In the field of data-driven quantitative analysis, especially in complex scenarios involving multi-dimensional, multi-source, heterogeneous data, such as medical testing data analysis, risk assessment, and quality evaluation, it is often necessary to calculate multiple quantitative dimensions separately and then synthesize the results to arrive at the final quantitative conclusion. Existing solutions mostly employ deep learning models, large language models, or other black-box models for end-to-end feature extraction and score prediction. The internal reasoning logic of these models is difficult to understand; users only receive the final score result but cannot ascertain how it was derived. This black-box characteristic leads to insufficient reliability and credibility of the scoring results, especially in fields like healthcare, making it difficult to meet the rigid requirements for auditable and verifiable decision-making processes. Summary of the Invention

[0003] In view of the above problems, this application provides a method and related apparatus for quantitative analysis of evidence chain data, so as to achieve transparency in the quantitative analysis process of evidence chain data and traceability of results. The specific solution is as follows:

[0004] The first aspect of this application provides a method for quantitative analysis of evidence chain data, including:

[0005] Obtain the raw data to be analyzed and the corresponding reference information;

[0006] A standardized evidence record structure is determined, which includes at least: an input data field, a reference information field, a calculation rule identifier field, an output result field, and a completeness assessment field.

[0007] Based on the original data and the reference information, a quantitative calculation is performed for at least one quantitative dimension. During each quantitative calculation, an evidence record is synchronously created and populated according to the standardized evidence record structure. The population process includes: writing the input data used for the quantitative calculation into the input data field; writing the reference information on which the quantitative calculation is based into the reference information field; writing the calculation rule version identifier used by the quantitative calculation into the calculation rule identifier field; writing the output result of the quantitative calculation into the output result field; and generating a completeness assessment result based on the completeness status of the data on which the quantitative calculation depends and writing it into the completeness assessment field. The population process is completed synchronously with the execution of the quantitative calculation.

[0008] All generated evidence records are arranged according to a preset sequence to form a structured evidence chain, and the structured evidence chain and the comprehensive result of the quantitative calculation are associated and output.

[0009] In one possible implementation, the standardized evidence recording structure further includes a missing information recording field, which is used to record the missing field names, catch-all values, processing strategies, and remarks of the input data during the quantification calculation process.

[0010] In one possible implementation, the completeness assessment result includes at least: complete state, partially missing state, and completely missing state.

[0011] In one possible implementation, the step of synchronously creating and populating an evidence record according to the standardized evidence record structure includes:

[0012] Before the quantification calculation begins, the skeleton of the evidence record is pre-created and each field is initialized to a state to be filled.

[0013] During the quantitative calculation process, the input data, the reference information, the calculation rule version identifier, the output result, and the completeness assessment result are respectively filled into the corresponding fields of the evidence record skeleton;

[0014] After the quantification calculation is completed, timestamp information is added to the filled evidence record and the required fields are validated. The encapsulated evidence record is then added to the evidence chain list.

[0015] In one possible implementation, the evidence chain data quantification analysis method further includes:

[0016] When a missing field is detected in the input data, a fallback value is determined according to a preset missing data processing strategy. The name of the missing field, the fallback value, the missing data processing strategy adopted, and the remarks information are recorded in the missing information recording field of the standardized evidence recording structure.

[0017] In one possible implementation, arranging all generated evidence records according to a preset sequence to form a structured evidence chain, and then outputting the structured evidence chain in conjunction with the comprehensive result of the quantitative calculation, includes:

[0018] All the evidence records are sorted according to a preset sequence identifier;

[0019] Obtain the dimension weights corresponding to the output fields in each evidence record;

[0020] The comprehensive result of the quantitative calculation is calculated based on the weighted average of each output result and its corresponding dimension weight, and then output after being correlated with the sorted evidence records.

[0021] In one possible implementation, performing quantization calculations for at least one quantization dimension includes:

[0022] Using the original data and the reference information as input parameters, a request is made to the large language model to generate pre-scoring results for all quantization dimensions;

[0023] The system receives the pre-scoring results returned by the large language model, which include the pre-scoring values ​​corresponding to each of the quantization dimensions; the pre-scoring values ​​are generated by the large language model based on the input parameters and in combination with preset scoring criteria.

[0024] A second aspect of this application provides an evidence chain data quantification analysis device, comprising:

[0025] The raw data acquisition module is used to acquire the raw data to be analyzed and the reference information corresponding to the raw data;

[0026] The data structure determination module is used to determine the standardized evidence record structure, which includes at least: an input data field, a reference information field, a calculation rule identifier field, an output result field, and a completeness assessment field.

[0027] A quantization result filling module is used to perform quantization calculations for at least one quantization dimension based on the original data and the reference information, and to synchronously create and fill an evidence record according to the standardized evidence record structure during each quantization calculation. The filling process includes: writing the input data used for the quantization calculation into the input data field, writing the reference information on which the quantization calculation is based into the reference information field, writing the calculation rule version identifier used by the quantization calculation into the calculation rule identifier field, writing the output result of the quantization calculation into the output result field, and generating a completeness assessment result based on the completeness status of the data on which the quantization calculation depends and writing it into the completeness assessment field. The filling process is completed synchronously with the execution of the quantization calculation.

[0028] The evidence chain integration module is used to arrange all the generated evidence records according to a preset sequence to form a structured evidence chain, and output the structured evidence chain and the comprehensive result of the quantitative calculation.

[0029] A third aspect of this application provides a computer program product including computer-readable instructions that, when executed on an electronic device, cause the electronic device to implement the evidence chain data quantification analysis method described in the first aspect or any implementation thereof.

[0030] A fourth aspect of this application provides an electronic device, including at least one processor and a memory connected to the processor, wherein:

[0031] The memory is used to store computer programs;

[0032] The processor is used to execute the computer program so that the electronic device can implement the evidence chain data quantification analysis method of the first aspect or any implementation thereof.

[0033] The fifth aspect of this application provides a computer storage medium carrying one or more computer programs, which, when executed by an electronic device, enable the electronic device to implement the evidence chain data quantification analysis method described in the first aspect or any implementation thereof.

[0034] By employing the aforementioned technical solution, the evidence chain data quantification analysis method provided in this application predefines a standardized evidence record structure that includes at least input data, reference information, calculation rule identifiers, output results, and completeness assessment fields. This evidence record is created and populated synchronously during each quantification calculation, ensuring that the calculation process for each quantification dimension is fully recorded. Users can fully reconstruct the original input data, referenced knowledge information, rule versions used, and data completeness status of each scoring result through the output evidence chain, transforming the quantification calculation process from a black box to a white box, greatly improving the credibility of the scoring results. Attached Figure Description

[0035] The above and other features, advantages, and aspects of the embodiments of this disclosure will become more apparent from the accompanying drawings and the following detailed description. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic, and the originals and elements are not necessarily drawn to scale.

[0036] Figure 1 A flowchart of a method for quantitative analysis of evidence chain data provided in this application;

[0037] Figure 2 A flowchart of an evidence chain data quantification analysis method based on data flow path provided in this application;

[0038] Figure 3 A structural diagram of an evidence chain data quantification analysis device provided in this application;

[0039] Figure 4 This is a structural diagram of an electronic device provided in this application. Detailed Implementation

[0040] The embodiments of this application are described below with reference to the accompanying drawings. The terminology used in the implementation section of this application is for explaining specific embodiments only and is not intended to limit the scope of this application.

[0041] The embodiments of this application will now be described with reference to the accompanying drawings. Those skilled in the art will recognize that, with technological advancements and the emergence of new scenarios, the technical solutions provided in the embodiments of this application are equally applicable to similar technical problems.

[0042] The terms "first," "second," etc., used in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such terms are interchangeable where appropriate; this is merely a way of distinguishing objects with the same attributes in the embodiments of this application. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion, so that a process, method, system, product, or apparatus that comprises a series of elements is not necessarily limited to those elements, but may include other elements not explicitly listed or inherent to those processes, methods, products, or apparatuses.

[0043] Currently, the core application of combining artificial intelligence and metagenomic sequencing in the upstream detection stage is to improve sequence alignment accuracy and reduce false positives. At the algorithmic level, general AI models (including but not limited to Large Language Models (LLM), deep learning neural networks, etc.) are mainly used for feature extraction and classification prediction, improving accuracy through multi-feature fusion. However, such solutions generally suffer from the black-box problem, meaning the model's reasoning process is unexplainable and the feature extraction logic is opaque. While existing general AI models are highly effective in feature extraction, their neural network-based feature extraction process is a black-box operation, making their reasoning process difficult to interpret and unable to meet the requirements of precise and traceable applications.

[0044] To address the aforementioned problems, embodiments of this application provide a method for quantitative analysis of evidence chain data. The method for quantitative analysis of evidence chain data according to embodiments of this application will be described in detail below with reference to the accompanying drawings.

[0045] Reference Figure 1 , Figure 1 A flowchart illustrating an evidence chain data quantification analysis method provided in this application embodiment is shown below. Figure 1As shown, the evidence chain data quantification analysis method provided in this application embodiment may include steps S101 to S104, which are described in detail below.

[0046] S101. Obtain the raw data to be analyzed and the corresponding reference information.

[0047] The raw data to be analyzed is the quality test data of sample A from a certain laboratory. Specifically, the raw data includes the following three indicators:

[0048] Defect rate: Of the 1000 samples sampled for inspection, 5 were found to have defects, resulting in a defect rate of 0.5%. This data is from the quality inspection report.

[0049] User satisfaction rating: The questionnaire results for sample A show that users gave an average score of 8.2 out of 10. This data comes from the user research report.

[0050] Service life test value: Sample A has an average service life of 1200 hours in accelerated aging tests. This data comes from the laboratory test report.

[0051] Reference information includes:

[0052] National Standard: The relevant general requirements for quality evaluation stipulate that a defect rate of less than 1% is considered acceptable. This reference information is a standard, stating that a defect rate of less than 1% is acceptable, and is identified as GB / T XXXX-2023.

[0053] Industry literature: For example, in a study on the correlation between sample quality and user satisfaction, the average user satisfaction score for similar products is 7.5. This reference information is classified as literature, its content is the average satisfaction score for similar products being 7.5, and it is identified as PMID-78901.

[0054] The aforementioned raw data and reference information can be obtained in various ways. In this embodiment, it can be read from an input file in JSON format.

[0055] S102. Determine the standardized evidence record structure, which shall include at least: input data field, reference information field, calculation rule identifier field, output result field, and completeness assessment field.

[0056] Specifically, a standardized evidence record structure can be predefined before performing the quantification calculation. This structure can be used to encapsulate the complete context information of a single quantification calculation. In practical use, this standardized evidence record structure should contain at least the following five fields:

[0057] Input data fields: These fields store the raw data items used in this quantitative calculation. Each data item typically records the field name, value, and data source in key-value pairs. The data source indicates the origin of the data (e.g., quality inspection report, user survey report, laboratory test report, etc.) to facilitate subsequent verification of the data's reliability.

[0058] Reference Information Field: This field stores the external knowledge or reference standards upon which this quantitative calculation was based. Each piece of reference information includes the type of document (such as standard, literature, guideline, expert consensus, etc.), specific content, and document identifier (such as standard number, literature PMID, guideline number, etc.).

[0059] The calculation rule identifier field stores the rule version identifier used in this quantization calculation. This identifier is usually a string, such as QUAL-RULE-v1.0, BH1-RULE-v2.1, etc. Through this identifier, users can trace the specific formulas, parameters, thresholds, and the evolution history of the rule.

[0060] Output field: Used to store the final output value of this quantization calculation. In this embodiment, the output result is usually normalized to the range of 0 to 1 to facilitate subsequent weighted averaging or comparison.

[0061] Completeness Assessment Field: This field stores the completeness assessment results of the data upon which this quantification calculation relies. It identifies whether data is missing during the calculation and the extent of the missing data, thereby quantifying the impact of data quality on the calculation results.

[0062] S103. Based on the original data and reference information, perform quantitative calculations for at least one quantitative dimension, and during each quantitative calculation: synchronously create and populate an evidence record according to the standardized evidence record structure; the population process includes: writing the input data used for the quantitative calculation into the input data field, writing the reference information on which the quantitative calculation is based into the reference information field, writing the version identifier of the calculation rule used for the quantitative calculation into the calculation rule identifier field, writing the output result of the quantitative calculation into the output result field, and generating a completeness assessment result based on the integrity status of the data on which the quantitative calculation depends and writing it into the completeness assessment field. The population process is completed synchronously with the execution of the quantitative calculation.

[0063] Specifically, taking a quantitative dimension (e.g., overall quality score) as an example, a record of evidence needs to be created.

[0064] Before the quantitative calculation begins, a blank evidence record skeleton is created based on the standardized evidence record structure defined above. This skeleton initializes all fields to their default values: input_data is an empty list, reference_info is an empty list, rule_version is an empty string, output_value is 0.0, and completeness is set to COMPLETE (default is complete).

[0065] Simultaneously, a unique identifier is generated for this evidence record, such as PROD-A-001-001, where PROD-A-001 is the sample identifier and 001 is the dimension number. This identifier is used for subsequent chaining.

[0066] The raw data (defect rate 0.5%, satisfaction score 8.2, service life 1200 hours, etc.) is converted into a list of InputDataItem objects and written to the input_data field of the evidence record. The source of each data item is marked.

[0067] The reference information (national standards, industry documents, etc.) is converted into a list of ReferenceInfo objects and written into the reference_info field of the evidence record.

[0068] The version identifier of the calculation rule used in this quantitative calculation, QUAL-RULE-v1.0, is written into the rule_version field. The specific content of this rule is: Overall Quality Score = Defect Rate Score × 0.3 + Satisfaction Score × 0.4 + Service Life Score × 0.3, where:

[0069] Defect rate score = 1 - min(defect rate / 0.01, 1.0) (i.e., deduct 100 points for every 1% increase in defect rate, but the minimum is 0).

[0070] Satisfaction score = Satisfaction rating / 10.0 (mapping 0-10 to the 0-1 range);

[0071] Service life score = min(service life / 1500, 1.0) (1500 hours is the full score threshold).

[0072] Performing the above calculations yields the following output: Defect rate score = 1 - 0.005 / 0.01 = 0.5, Satisfaction score = 8.2 / 10 = 0.82, Service life score = 1200 / 1500 = 0.8, Weighted summation: 0.5×0.3 + 0.82×0.4 + 0.8×0.3 = 0.15 + 0.328 + 0.24 = 0.718. Write this value into the `output_value` field.

[0073] Next, the integrity of the data on which this calculation depends is checked. In this embodiment, all three input fields (defect_rate, satisfaction_score, lifetime_hours) exist and their values ​​are not empty (0.005, 8.2, and 1200 are all non-empty). Therefore, the integrity evaluation result is COMPLETE, and this enumeration value is written to the completeness field.

[0074] At this point, all required fields for the evidence record have been filled in. The entire filling process was completed simultaneously with the execution of the quantitative calculation. Instead of calculating the result first and then going back to fill in the evidence, the process of collecting input, referencing references, and recording outputs was carried out simultaneously during the calculation, achieving the goal of recording while calculating.

[0075] After the quantification calculation is completed, the evidence record is encapsulated: a timestamp is added (to record the time the calculation was completed, such as 2026-05-20, 10:30:00), the required fields are validated (to ensure that input_data is not empty, rule_version is not empty, etc.), and then the encapsulated evidence record is added to an evidence chain list.

[0076] S104. Arrange all generated evidence records according to a preset sequence to form a structured evidence chain, and output the structured evidence chain and the comprehensive result of quantitative calculation.

[0077] Specifically, this evidence record is directly used as a structured chain of evidence. It is organized according to a preset sequence (e.g., sorted by the serial number in the record identifier). The comprehensive result of the quantitative calculation (i.e., the output_value of this evidence record = 0.718) is associated with the chain of evidence.

[0078] As can be seen above, this evidence chain data quantification analysis method, through predefined standardized evidence record structures that include at least input data, reference information, calculation rule identifiers, output results, and completeness assessment fields, and synchronously creates and populates these evidence records during each quantification calculation, ensures that the calculation process for each quantification dimension is fully recorded. Users can fully reconstruct the original input data, referenced knowledge information, rule versions used, and data completeness status of each scoring result through the output evidence chain, realizing the transformation of the quantification calculation process from a black box to a white box, greatly improving the credibility of the scoring results.

[0079] The following section uses the multi-dimensional quantitative analysis of mNGS (metagenomic sequencing) detection data as a specific application scenario to illustrate the complete implementation process of this application.

[0080] mNGS technology uses high-throughput sequencing of clinical samples (such as bronchoalveolar lavage fluid, blood, and cerebrospinal fluid) to unbiasedly detect the nucleic acid sequences of all microorganisms in the sample, making it valuable in the diagnosis of complex infectious diseases. However, mNGS test results need to be comprehensively and quantitatively evaluated in conjunction with clinical information, reference knowledge bases, and other multidimensional data to determine whether the detected microorganism is a pathogenic agent or a colonizing / contaminating bacterium. This evaluation process is usually based on a modified Bradford Hill criterion, scoring multiple dimensions (such as association strength, analogy, specificity, consistency, biological gradient, biological plausibility, and confirmatory power) separately, and then weighted and synthesized to obtain the final confidence score.

[0081] In existing technologies, the scoring of these dimensions often relies on human experience or black-box AI models, resulting in an opaque scoring process and untraceable results. The method in this application transforms the entire multi-dimensional quantitative analysis process into a white-box process using an evidence chain data model.

[0082] Input data is uniformly encapsulated into a SampleInput data structure, which contains the following six types of fields, as shown in Table 1:

[0083] Table 1

[0084]

[0085] Based on the improved Bradford Hill criteria, seven evaluation dimensions were designed (Association Strength BH1, Analogy BH2, Specificity BH3, Consistency BH4, Biological Gradient BH5, Biological Rationality BH6, and Confirmatory Power BH7). The quantitative calculation of each dimension generates one dimensional evidence record. Each dimensional evidence record contains the following nine fields, as shown in Table 2:

[0086] Table 2

[0087]

[0088] The following is combined Figure 2 As shown, the complete data flow path from the original input to the final output demonstrates the data format and processing at each stage:

[0089] Step 1: The sample input data is in JSON format (denoted as SampleInput), which includes the following specific data items: sample_id:"S001", microbe_name:"CMV", sequencing reads:12501, reads per kilobase per million sequencing fragments (rpkm):350.0, taxonomic reads (kingdom_reads):null, total_reads:50000, onset_days:4, severity_score:7.0, minimum incubation_min:1, maximum incubation_max:6, and references:[{Guide GUID-001}, {Literature PMID-12345}], where the kingdom_reads field is missing (null).

[0090] Taking a bronchoalveolar lavage fluid (BALF) sample from an immunosuppressed patient as an example, mNGS testing was performed. The results showed 12,501 reads for cytomegalovirus (CMV), an RPKM value of 350.0, and a total sample read count of 50,000, but the total number of borderline reads (kingdom_reads) was missing. Clinical records showed the patient had been ill for 4 days and a clinical severity score of 7.0 (0-10). The knowledge base recorded the incubation period for this pathogen as 1–6 days. In addition, two references were provided: a guideline (CMV pneumonia reporting criteria: BALF reads > 1000) and a literature report (CMV incubation period is typically 1–6 weeks).

[0091] All input data is encapsulated in JSON format according to the SampleInput data structure:

[0092] {

[0093] "sample_id": "S001",

[0094] "microbe_name": "CMV",

[0095] "reads": 12501,

[0096] "rpkm": 350.0,

[0097] "kingdom_reads": null,

[0098] "total_reads": 50000,

[0099] "competitor_reads": null,

[0100] "sample_type": "BALF",

[0101] "onset_days": 4,

[0102] "incubation_min": 1,

[0103] "incubation_max": 6,

[0104] "severity_score": 7.0,

[0105] "reads_baseline": null,

[0106] "treatment_response": null,

[0107] "reads_after": null,

[0108] "references": [

[0109] {"type": "Guidelines", "content": "CMV Pneumonia Reporting Criteria: BALF Reads > 1000", "ref_id": "GUID-001"},

[0110] {"type": "Literature", "content": "CMV incubation period is usually 1-6 weeks", "ref_id": "PMID-12345"} ]

[0112] }

[0113] Step 2: Split and parse the sample input data obtained in Step 1.

[0114] The `to_input_data()` function is called to perform structured processing on the detection and clinical-related fields in the sample input data, generating 10 InputData records. The structure of each InputData record is as follows: field: reads, value: 12501, source: mNGS. The 10 records have the same structure and correspond to different detection and clinical fields in the sample input data.

[0115] The `to_reference_info()` function is called to parse the `references` field, generating a structured list of reference information. Each reference entry contains three subfields: `type`, `content`, and `ref_id`. After parsing, two reference entries are obtained:

[0116] Reference Information 1: type="Guidelines", content="CMV Pneumonia Reporting Standards: BALF reads>1000", ref_id="GUID-001".

[0117] Reference 2: type="literature", content="CMV incubation period is usually 1-6 weeks", ref_id="PMID-12345".

[0118] Step 3: Call the `_score_all()` function to integrate the 10 `InputData` records and 2 `RefInfo` records generated in Step 2, using them as input parameters to initiate a single LLM (Large Language Model) API call, achieving unified data input and score request. The Large Language Model can generate pre-scored scores for all dimensions based on the input parameters and preset scoring criteria. Pre-scored scores for all dimensions are obtained through a single Large Language Model call and then injected into the evidence chain generation process for each dimension. This implementation method has advantages such as high efficiency and good score consistency.

[0119] The `_score_all()` function is called. This method first integrates the input data and reference information obtained in step one. The input data includes 10 `InputDataItem` entries (representing test and clinical data), and the reference information includes 2 `ReferenceInfo` entries. Based on this information, a prompt word containing 7-dimensional scoring criteria is constructed. The prompt word is constructed as follows:

[0120] Convert the input data into readable text lines, such as "reads: 12501", "rpkm: 350.0", "kingdom_reads: missing", etc.

[0121] Convert the reference information into text lines, such as "[Guidelines] CMV pneumonia reporting criteria: BALF reads > 1000" and "[Literature] CMV incubation period is usually 1-6 weeks".

[0122] List the scoring criteria for 7 dimensions (0.0 lowest → 1.0 highest) and their brief descriptions, such as "BH1_strength (Association Strength): Assess the degree of association between pathogen and disease based on the number of reads".

[0123] The model is required to output only JSON in a specific format, such as {"BH1_strength": 0.00, "BH2_analogy": 0.00, ...}.

[0124] A complete Prompt example is as follows:

[0125] "

Test Data

[0126] Reads: 12501

[0127] rpkm: 350.0,

[0128] kingdom_reads: missing.

[0129] total_reads: 50000

[0130] sample_type: BALF

[0131] microbe_name: CMV

[0132] onset_days: 4,

[0133] incubation_min: 1,

[0134] incubation_max: 6

[0135] severity_score: 7.0.

[0136] [Reference Knowledge Base]

[0137] [Guidelines] CMV pneumonia reporting criteria: BALF reads > 1000.

[0138] [Literature] The incubation period for CMV is usually 1-6 weeks.

[0139] [7-Dimensional Scoring Criteria (0.0 Lowest → 1.0 Highest)]

[0140] BH1_strength (Association Strength): ...

[0141] BH2_analogy: ...

[0142] BH3_specificity: ...

[0143] BH4_coherence: ...

[0144] BH5_gradient (biological gradient): ...

[0145] BH6_plausibility (biological rationality): ...

[0146] BH7_experiment (verification): ...

[0147] Output only JSON in the following format:

[0148] {"BH1_strength": 0.00, "BH2_analogy": 0.00, "BH3_specificity": 0.00, "BH4_coherence": 0.00, "BH5_gradient": 0.00, "BH6_plausibility": 0.00, "BH7_experiment": 0.00}".

[0149] Send the above prompt to the API of the large language model, and set the prompt "You are an mNGS detection data analysis expert, output only JSON, no explanation required." The response returned by the model is parsed into a JSON dictionary.

[0150] {

[0151] "BH1_strength": 0.83,

[0152] "BH2_analogy": 1.00,

[0153] "BH3_specificity": 0.25,

[0154] "BH4_coherence": 0.50,

[0155] "BH5_gradient": 0.70,

[0156] "BH6_plausibility":1.00,

[0157] "BH7_experiment": 0.50

[0158] }

[0159] Step 4: Receive the scoring results from the large language model and generate 7-dimensional evidence records using the with_evidence decorator.

[0160] The algorithm iterates through the seven-dimensional calculator. For each dimension, it retrieves the corresponding pre-score value from the dictionary returned by the LLM and creates a closure function `score_fn = lambda **_, s = pre_score: s`. This function ignores input parameters and directly returns a fixed pre-score. The pre-score is generated by the large language model based on the input parameters and a preset scoring standard. The pre-score and the preset scoring standard identifier are recorded in the evidence log. Then, the `with_evidence` decorator is called to wrap `score_fn` into a function with evidence chain generation capabilities, and this function is executed.

[0161] The core function of the `with_evidence` decorator is to automatically embed the three steps of evidence record pre-creation, data population, and encapsulation into the execution process of `score_fn`. Decorator internals:

[0162] Call builder.create_record_skeleton to pre-create the skeleton.

[0163] Extract input_data and reference_info from keyword parameters.

[0164] Call builder.fill_data, passing in the skeleton, input data, reference information, and score_fn. Inside fill_data, score_fn will be executed to obtain the output value and handle missing data and completeness evaluation.

[0165] The encapsulation is completed by calling builder.finalize_record.

[0166] Therefore, it is evident that a single LLM call yields pre-scored results across seven dimensions. Then, by leveraging closure and decorator mechanisms, score results with evidence chains can be generated in batches without requiring separate scoring logic for each dimension. This method utilizes the powerful semantic understanding capabilities of LLM (capable of combining clinical knowledge and test data for professional judgment) while ensuring the interpretability and traceability of the scores through evidence chains.

[0167] The process of generating 7-dimensional evidence records based on the with_evidence decorator includes: pre-creating the evidence record skeleton, data filling, and encapsulation.

[0168] To facilitate more comprehensive data recording, a missing information recording field can be added. This field records the name of any missing field in the input data during the quantitative calculation process, the catch-all value, the processing strategy, and any remarks. Specifically, when a field in the input data has a null value or an empty string, the missing data processing flow is triggered, generating a missing information entry containing the following four subfields:

[0169] field: The name of the missing field, such as "kingdom_reads".

[0170] fallback: A fallback value, which is used to replace missing values ​​in calculations, such as 0.50, 0, N / A, etc.

[0171] strategy: The processing strategy describes the method used to determine the fallback value, such as: default median, zero-filling, missing value marking, linear interpolation, etc.

[0172] Note: Additional information explaining why this strategy was chosen and its potential impact.

[0173] This field can be a list, as a single quantization calculation may involve multiple missing fields. In this embodiment, since only the kingdom_reads field is missing, the list of missing information records contains one entry.

[0174] Add enumeration values ​​to the completeness assessment field:

[0175] The completeness assessment field is no longer simply a boolean value for complete / incomplete, but instead uses an enumeration of values, including at least the following three states:

[0176] COMPLETE: All input data required for this quantization calculation exists and is not empty.

[0177] PARTIAL: Some dependent data is missing, but the continuity of computation is ensured through a fallback strategy.

[0178] MISSING: All key data is missing, making effective calculation impossible. The output may contain default values ​​or invalid values.

[0179] In this embodiment, because kingdom_reads is missing, but other fields (reads, total_reads, rpkm, etc.) exist, the completeness assessment result is PARTIAL. Based on this:

[0180] Step 4.1: Pre-create the evidence record skeleton:

[0181] For each dimension (in the order of BH1 to BH7), the `create_record_skeleton` method is called before the quantization calculation begins, passing in the dimension identifier, rule version, and weights. Internally, this method:

[0182] An incrementing dimension counter (starting from 1).

[0183] Generate a unique identifier for dimensional evidence records, in the format of "{sample_id}-{microbe_id}-{serial number:03d}", for example, "S001-CMV-001".

[0184] Create a DimensionEvidenceRecord instance and set dimension_record_id, dimension_key, rule_version, and weight. Keep the other fields at their default values ​​(input_data is an empty list, output_value=0.0, completeness=COMPLETE, etc.).

[0185] Return the skeleton instance.

[0186] Taking BH1 (association strength) as an example, the pre-created skeleton includes:

[0187] dimension_record_id = "S001-CMV-001".

[0188] dimension_key = "BH1_strength".

[0189] rule_version = "RULE-BH1-v2.1".

[0190] weight = 0.2681.

[0191] output_value = 0.0 (to be filled later).

[0192] This skeleton does not signify that the calculation is complete, but rather serves as a placeholder to ensure that evidence recording and the calculation process are initiated simultaneously.

[0193] Step 4.2: Data Population:

[0194] The `fill_data` method is called, passing in the input data, reference information, and calculation function to complete the substantive filling of the evidence record. This step is further divided into the following sub-steps:

[0195] (1) Fill in the input data and reference information:

[0196] The prepared raw data (10 InputDataItems obtained from SampleInput parsing) is directly assigned to the input_data field of the evidence record. These 10 data items cover the mNGS test report fields (reads, rpkm, kingdom_reads, total_reads, competitor_reads, sample_type, microbe_name), clinical record fields (onset_days, severity_score), and knowledge base parameters (incubation_min, incubation_max). In the example, the value of kingdom_reads is None, indicating that it is missing.

[0197] Assign the two reference information values ​​parsed in step one to the reference_info field.

[0198] (2) Missing data handling:

[0199] After populating the input data, the private method `_handle_missing_data` is called to iterate through each data item in the `input_data` list. If the value of an item is `None` or an empty string, it is determined to be a missing field. Missing fields are then categorized and processed according to a preset strategy.

[0200] For example, if the `kingdom_reads` field has a value of `None`, the missing data handling logic is triggered. Since this field is one that "can be missing but will affect the consistency dimension score," the default strategy is to use a baseline value of 0.50 based on historical distribution as a safety net. This baseline value is derived from a measure of central tendency of the statistical distribution of similar samples and is dynamically updated as the sample size increases. The strategy is named "Default Median," and the comment is "Kingdom-reads data is missing; the default median is used to ensure calculation continuity." Based on this, a `MissingInfo` object is generated, containing:

[0201] field = "kingdom_reads".

[0202] fallback = "0.50".

[0203] strategy = "default median".

[0204] note = "Kingdom-reads data is missing; the default median is used to ensure computational continuity."

[0205] The MissingInfo object is appended to the missing_info list of the evidence record. Additionally, a fallback value of 0.50 will be used in subsequent calculations to replace the missing kingdom_reads (this is specifically reflected in the calculation function).

[0206] For other potentially missing fields (such as competitor_reads), there are corresponding strategies: when reads / rpkm is missing, it is filled with zero; when other fields are missing, they are marked as N / A. In this embodiment, only kingdom_reads is missing, so only one missing record is recorded.

[0207] (3) Perform quantization calculations and fill in the output results:

[0208] In this embodiment, the quantification calculations for the seven dimensions are not performed using independently designed algorithms. Instead, a unified call to the Large Language Model (LLM) is used to obtain pre-scoring results. The pre-scoring results are generated by the Large Language Model based on the input parameters and a preset scoring standard. The pre-scoring result for BH1 is 0.83. The evidence record simultaneously records the preset scoring standard identifier for subsequent tracing of the basis for generating the pre-scoring results.

[0209] The LLM pre-scoring is injected into the evidence chain framework using a closure function. Specifically, the `fill_data` method takes a `calculator_func` parameter, which accepts two positional arguments, `input_data` and `reference_info`, and returns a floating-point number as the calculation result. For the BH1 dimension, `calculator_func` is encapsulated as a closure function that ignores its input arguments and directly returns 0.83 (because the pre-scoring has already been determined).

[0210] Calling `calculator_func(record.input_data, record.reference_info)` returns a value of 0.83, which is then assigned to the `output_value` field of the evidence record, thus updating the skeleton's initial value of 0.0 to the actual score of 0.83.

[0211] If the calculation function throws an exception (e.g., due to an incorrect data format), the `_apply_fallback_strategy` method is called, returning a safe fallback value based on the current completeness status: 0.0 if the completeness is MISSING, 0.5 if it is PARTIAL, and 0.0 otherwise. In this example, the calculation proceeded normally and no exception was triggered.

[0212] (4) Assess and mark the integrity status:

[0213] After the data is populated, the `validate_completeness` method (or the method built into `fill_data`) is called to determine the completeness status based on whether there are any missing fields in the input data. The rules are as follows:

[0214] If the input_data list is empty, the completeness is MISSING.

[0215] If the value of any item in the input_data list is None, then the completeness is PARTIAL.

[0216] Otherwise, the completeness is COMPLETE.

[0217] In this embodiment, since the value of kingdom_reads is None, the completeness is set to PARTIAL. This enumeration value is written to the completeness field of the evidence record.

[0218] Step 4.3: Packaging:

[0219] After the single-dimensional calculation is completed, the `finalize_record` method is called to perform the following operations:

[0220] Add the current timestamp to the evidence record, for example, datetime.now().

[0221] Validate required fields: Ensure that dimension_record_id and dimension_key are not empty, otherwise throw an exception.

[0222] The encapsulated evidence record is appended to the evidence_records list inside EvidenceChainBuilder.

[0223] At this point, a complete evidence record for one dimension has been generated. Repeat steps 4.1 to 4.3 above, processing dimensions BH2, BH3, BH4, BH5, BH6, and BH7 in sequence. Each dimension will generate an independent evidence record, recording its dimension identifier, rule version, weight, output result (from LLM pre-scoring), completeness status, and missing information. Since all dimensions share the same input data, the completeness status for all dimensions is PARTIAL, and the missing information record is always "kingdom_reads missing".

[0224] Step 5: All evidence records are arranged according to a preset sequence to form a structured chain of evidence. The structured chain of evidence is then linked with the comprehensive result of quantitative calculation and output, specifically including:

[0225] Calling the `organize_chain` method to perform chain-based organization operations mainly involves three steps:

[0226] Step 5.1: Sort all evidence records according to the preset sequence identifier:

[0227] The evidence records are sorted in ascending order based on the sequence number (three digits) in the dimension_record_id of each record. In this embodiment, the record identifiers are S001-CMV-001 to S001-CMV-007, and the sorted order is consistent with the dimension order (BH1 to BH7). This sorting ensures the readability and determinism of the evidence chain; regardless of the time order in which the calculations for each dimension are completed, the output evidence chain is always arranged in a unified dimension order.

[0228] Step 5.2: Obtain the dimension weights corresponding to the output fields in each evidence record:

[0229] Read the value of the weight field from each evidence record. These weight values ​​were set when the skeleton was pre-created, and they correspond to the preset weights of the seven dimensions (BH1: 0.2681, BH2: 0.1143, BH3: 0.1143, BH4: 0.2857, BH5: 0.0714, BH6: 0.0714, BH7: 0.0748).

[0230] Step 5.3: Calculate the comprehensive result of the quantitative calculation based on the weighted average of each output result and its corresponding dimension weight, and output it after associating it with the sorted evidence records:

[0231] Calculate the overall score using the weighted average formula:

[0232] weighted_score = Σ (output_value_i × weight_i) / Σ weight_i.

[0233] Where Σweight_i is the sum of all weights. In this embodiment, since the sum of weights is 1 (0.2681+0.1143+0.1143+0.2857+0.0714+0.0714+0.0748=1.0000), the weighted average is simplified to a weighted sum. The calculation result is:

[0234] weighted_score = 0.83×0.2681 + 1.00×0.1143 + 0.25×0.1143 + 0.50×0.2857 + 0.70×0.0714 + 1.00×0.0714 + 0.50×0.0748= 0.2225 + 0.1143 + 0.0286+ 0.1429 + 0.0500 + 0.0714 + 0.0374= 0.6671 ≈ 0.667.

[0235] Construct the final output data structure, including:

[0236] Top-level basic information: sample_id, microbe_id, total_dimensions (value is 7), weighted_score (value is 0.667), analysis_timestamp (value is the current time).

[0237] Top-level shared data: the `input_data` array, containing 12 data entries in a uniform format (merging the detection / clinical fields and reference information fields from the original data). This approach avoids repeatedly storing the same input data and reference information in each evidence record, thus reducing data redundancy.

[0238] The evidence_chain array contains 7 dimensional evidence records, but input_data and reference_info are no longer stored repeatedly in each record (because they have been moved to the top level). Only the dimension-specific fields (record_id, dimension_key, rule_version, output_value, weight, completeness, missing_info, timestamp) are retained.

[0239] The final complete chain of evidence is presented in tabular form, as shown in Table 3:

[0240] Table 3

[0241]

[0242] Among them, the top-level input_data (12 records in total):

[0243]

[0244] evidence_chain (7-dimensional evidence records):

[0245] Since input_data has been elevated to the top level for sharing across all dimensions, each dimension evidence record only retains dimension-specific fields, as shown in Table 4 below:

[0246] Table 4

[0247]

[0248] In some embodiments, the effects of making traceability and data quality explicit include:

[0249] For example, downstream analysis reveals a low CMV overall score (specifically 0.667). It's necessary to investigate the reasons for this low score. The problem can be quickly located using the evidence chain constructed above. The specific tracing process is as follows:

[0250] The correlation strength (BH1_strength) score is 0.83, with a weight of 0.2681, corresponding to 12501 reads (close to the full score threshold of 15000), which contributes normally to the overall score.

[0251] The consistency (BH4_coherence) score is 0.50, which is the default median value, with a weight of 0.2857 (the highest weight). Upon verification, the reason for the low score in this dimension is that the kingdom_reads data is missing, which triggered the default median strategy and resulted in a low score.

[0252] The specificity score (BH3_specificity) was 0.25, which is low because reads / total_reads = 12501 / 50000 = 25%, indicating a low percentage of sequencing reads and a lack of competing pathogen data to support the score.

[0253] Conclusions: Consistency (BH4) had the highest weight, and its low score was primarily due to missing kingdom_reads data, triggering the default median strategy and significantly impacting the overall score. Specificity (BH3) was the second lowest due to insufficient sequencing reads and the lack of competing pathogen data. Association strength (BH1=0.83) scored reasonably, with clear evidence indicating reads=12501 > threshold=1000 (GUID-001), and the rule matching was clearly traceable. It is recommended to prioritize supplementing kingdom_reads data and then reassess the score.

[0254] Example of making data quality explicit:

[0255] In this embodiment, the completeness of all seven evidence records is PARTIAL, with each record including a missing_info description, explicitly indicating missing kingdom_reads, and employing a default median strategy with fallback=0.50. This data quality issue is not ignored or hidden, but rather retained as structured information in the evidence chain. This allows downstream analysis to accurately quantify the impact of missing data on the overall score, thereby clarifying the correlation between missing data and the overall score. This explicit presentation of data quality issues avoids scoring bias caused by data quality problems and ensures the verifiability of the analysis results.

[0256] As can be seen from the above embodiments, this application achieves automatic extraction of key features, accurately captures the effective information, clinical indicators and the correlation between reference standards in mNGS detection data, and automatically completes feature screening, matching and priority ranking without manual data processing; at the same time, combined with the structured evidence chain design, the automatically extracted key features are combined with the structured evidence chain such as scoring rules and data sources, realizing the interpretability and traceability of the score.

[0257] The above describes a method for quantitative analysis of evidence chain data provided by embodiments of this application. The following describes the apparatus for performing the above-described method for quantitative analysis of evidence chain data.

[0258] Please see Figure 3 , Figure 3 This is a schematic diagram of the structure of an evidence chain data quantification analysis device provided in an embodiment of this application. Figure 3 As shown, the evidence chain data quantification analysis device includes:

[0259] The raw data acquisition module 301 is used to acquire the raw data to be analyzed and the corresponding reference information.

[0260] The data structure determination module 302 is used to determine the standardized evidence record structure. The standardized evidence record structure includes at least: input data field, reference information field, calculation rule identifier field, output result field, and completeness assessment field.

[0261] The quantization result filling module 303 is used to perform quantization calculations for at least one quantization dimension based on the original data and reference information. During each quantization calculation, it synchronously creates and fills an evidence record according to the standardized evidence record structure. The filling process includes: writing the input data used for the quantization calculation into the input data field, writing the reference information on which the quantization calculation is based into the reference information field, writing the version identifier of the calculation rule used for the quantization calculation into the calculation rule identifier field, writing the output result of the quantization calculation into the output result field, and generating a completeness assessment result based on the integrity status of the data on which the quantization calculation depends and writing it into the completeness assessment field. The filling process is completed synchronously with the execution of the quantization calculation.

[0262] The evidence chain integration module 304 is used to arrange all the generated evidence records according to a preset sequence organization method to form a structured evidence chain, and output the structured evidence chain and the comprehensive result of quantitative calculation.

[0263] In one possible implementation, the standardized evidence record structure in the data structure determination module 302 also includes a missing information record field, which is used to record the missing field names, catch-all values, processing strategies, and remarks of the input data during the quantification calculation process.

[0264] In one possible implementation, the completeness evaluation results in the quantization result filling module 303 include at least: complete state, partially missing state, and completely missing state.

[0265] In one possible implementation, the process by which the quantification result filling module 303 synchronously creates and fills an evidence record according to the standardized evidence record structure includes:

[0266] Before the quantitative calculation begins, the skeleton of the evidence record is pre-created and each field is initialized to a state to be filled.

[0267] During the quantitative calculation process, the input data, reference information, calculation rule version identifier, output results, and completeness assessment results are filled into the corresponding fields of the evidence record skeleton.

[0268] After the quantification calculation is completed, timestamp information is added to the filled evidence record and the required fields are validated. The encapsulated evidence record is then added to the evidence chain list.

[0269] In one possible implementation, the quantization result filling module 303 is also used for:

[0270] When a missing field is detected in the input data, a catch-all value is determined according to the preset missing data processing strategy. The missing field name, the catch-all value, the missing data processing strategy adopted, and the remarks information are recorded in the missing information recording field of the standardized evidence recording structure.

[0271] In one possible implementation, the evidence chain integration module 304 arranges all generated evidence records according to a preset sequence to form a structured evidence chain, and outputs the process of associating the structured evidence chain with the comprehensive result of quantitative calculation, including:

[0272] All evidence records are sorted according to a preset sequence identifier;

[0273] Obtain the dimension weights corresponding to the output fields in each evidence record;

[0274] The comprehensive result of the quantitative calculation is calculated based on the weighted average of each output result and its corresponding dimension weight, and then output after being correlated with the sorted evidence records.

[0275] In one possible implementation, the quantization result filling module 303 performs a quantization calculation process for at least one quantization dimension, including:

[0276] Using the raw data and reference information as input parameters, the large language model is requested to generate pre-scoring results for all quantization dimensions;

[0277] The system receives pre-scoring results from a large language model, which include pre-scoring values ​​for each quantization dimension. These pre-scoring values ​​are generated by the large language model based on the input parameters and pre-defined scoring criteria.

[0278] This application also provides an electronic device in its embodiments. (See reference...) Figure 4 The diagram illustrates a structural schematic suitable for implementing the electronic device in the embodiments of this application. The electronic device in the embodiments of this application may include, but is not limited to, fixed terminals such as laptops, desktop computers, etc. Figure 4 The electronic device shown is merely an example and should not impose any limitation on the functionality and scope of use of the embodiments of this application.

[0279] like Figure 4As shown, the electronic device may include a processing unit (e.g., a central processing unit, a graphics processing unit, etc.) 401, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 402 or a program loaded from a storage device 408 into a random access memory (RAM) 403. When the electronic device is powered on, the RAM 403 also stores various programs and data required for the operation of the electronic device. The processing unit 401, ROM 402, and RAM 403 are interconnected via a bus 404. An input / output (I / O) interface 405 is also connected to the bus 404.

[0280] Typically, the following devices can be connected to I / O interface 405: input devices 406 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 407 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 408 including, for example, memory cards, hard drives, etc.; and communication devices 409. Communication device 409 allows electronic devices to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 4 Electronic devices with various devices are shown, but it should be understood that it is not required to implement or have all of the devices shown. More or fewer devices may be implemented or have instead.

[0281] This application also provides a computer program product including computer-readable instructions, which, when executed on an electronic device, cause the electronic device to implement any of the evidence chain data quantification analysis methods provided in this application.

[0282] This application also provides a computer-readable storage medium that carries one or more computer programs. When the one or more computer programs are executed by an electronic device, the electronic device can implement any of the evidence chain data quantification analysis methods provided in this application.

[0283] It should also be noted that the device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. In addition, in the device embodiment drawings provided in this application, the connection relationship between modules indicates that they have a communication connection, which can be implemented as one or more communication buses or signal lines.

[0284] Through the above description of the embodiments, those skilled in the art can clearly understand that this application can be implemented by means of software plus necessary general-purpose hardware, or it can be implemented by special-purpose hardware including application-specific integrated circuits, special-purpose CPUs, special-purpose memory, special-purpose components, etc. Generally, any function performed by a computer program can be easily implemented by corresponding hardware, and the specific hardware structure used to implement the same function can also be diverse, such as analog circuits, digital circuits, or special-purpose circuits. However, for this application, software program implementation is more often the preferred implementation method. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a readable storage medium, such as a computer floppy disk, USB flash drive, mobile hard disk, ROM, RAM, magnetic disk, or optical disk, etc., and includes several instructions to cause a computer device (which may be a personal computer, training equipment, or network device, etc.) to execute the evidence chain data quantification analysis method described in the various embodiments of this application.

[0285] 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.

[0286] 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 this application 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, training device, or data center to another website, computer, training device, or data center via wired (e.g., coaxial cable, fiber optic, digital subscriber line (DSL)) 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 training device or data center that integrates one or more available media. The available media may be magnetic media (e.g., floppy disks, hard disks, magnetic tapes), optical media (e.g., DVDs), or semiconductor media (e.g., solid-state drives (SSDs)).

Claims

1. A method for quantitative analysis of evidence chain data, characterized in that, include: Obtain the raw data to be analyzed and the corresponding reference information; A standardized evidence record structure is determined, which includes at least: an input data field, a reference information field, a calculation rule identifier field, an output result field, and a completeness assessment field. Based on the original data and the reference information, a quantitative calculation is performed for at least one quantitative dimension. During each quantitative calculation, an evidence record is synchronously created and populated according to the standardized evidence record structure. The population process includes: writing the input data used for the quantitative calculation into the input data field; writing the reference information on which the quantitative calculation is based into the reference information field; writing the calculation rule version identifier used by the quantitative calculation into the calculation rule identifier field; writing the output result of the quantitative calculation into the output result field; and generating a completeness assessment result based on the completeness status of the data on which the quantitative calculation depends and writing it into the completeness assessment field. The population process is completed synchronously with the execution of the quantitative calculation. All generated evidence records are arranged according to a preset sequence to form a structured evidence chain, and the structured evidence chain and the comprehensive result of the quantitative calculation are associated and output.

2. The method for quantitative analysis of evidence chain data according to claim 1, characterized in that, The standardized evidence recording structure also includes a missing information recording field, which is used to record the missing field names, catch-all values, processing strategies, and remarks of the input data during the quantification calculation process.

3. The method for quantitative analysis of evidence chain data according to claim 1, characterized in that, The completeness assessment results include at least: complete state, partially missing state, and completely missing state.

4. The method for quantitative analysis of evidence chain data according to claim 1, characterized in that, The step of synchronously creating and populating an evidence record according to the standardized evidence record structure includes: Before the quantification calculation begins, the skeleton of the evidence record is pre-created and each field is initialized to a state to be filled. During the quantitative calculation process, the input data, the reference information, the calculation rule version identifier, the output result, and the completeness assessment result are respectively filled into the corresponding fields of the evidence record skeleton; After the quantification calculation is completed, timestamp information is added to the filled evidence record and the required fields are validated. The encapsulated evidence record is then added to the evidence chain list.

5. The evidence chain data quantification analysis method according to claim 4, characterized in that, Also includes: When a missing field is detected in the input data, a fallback value is determined according to a preset missing data processing strategy. The name of the missing field, the fallback value, the missing data processing strategy adopted, and the remarks information are recorded in the missing information recording field of the standardized evidence recording structure.

6. The method for quantitative analysis of evidence chain data according to claim 1, characterized in that, The step of arranging all generated evidence records according to a preset sequence to form a structured evidence chain, and then outputting the structured evidence chain in conjunction with the comprehensive result of the quantitative calculation, includes: All the evidence records are sorted according to a preset sequence identifier; Obtain the dimension weights corresponding to the output fields in each evidence record; The comprehensive result of the quantitative calculation is calculated based on the weighted average of each output result and its corresponding dimension weight, and then output after being correlated with the sorted evidence records.

7. The method for quantitative analysis of evidence chain data according to claim 1, characterized in that, The execution of quantization calculations for at least one quantization dimension includes: Using the original data and the reference information as input parameters, a request is made to the large language model to generate pre-scoring results for all quantization dimensions; The system receives the pre-scoring results returned by the large language model, which include the pre-scoring values ​​corresponding to each of the quantization dimensions; the pre-scoring values ​​are generated by the large language model based on the input parameters and in combination with preset scoring criteria.

8. A device for quantitative analysis of evidence chain data, characterized in that, include: The raw data acquisition module is used to acquire the raw data to be analyzed and the reference information corresponding to the raw data; The data structure determination module is used to determine the standardized evidence record structure, which includes at least: an input data field, a reference information field, a calculation rule identifier field, an output result field, and a completeness assessment field. A quantization result filling module is used to perform quantization calculations for at least one quantization dimension based on the original data and the reference information, and to synchronously create and fill an evidence record according to the standardized evidence record structure during each quantization calculation. The filling process includes: writing the input data used for the quantization calculation into the input data field, writing the reference information on which the quantization calculation is based into the reference information field, writing the calculation rule version identifier used by the quantization calculation into the calculation rule identifier field, writing the output result of the quantization calculation into the output result field, and generating a completeness assessment result based on the completeness status of the data on which the quantization calculation depends and writing it into the completeness assessment field. The filling process is completed synchronously with the execution of the quantization calculation. The evidence chain integration module is used to arrange all the generated evidence records according to a preset sequence to form a structured evidence chain, and output the structured evidence chain and the comprehensive result of the quantitative calculation.

9. An electronic device, characterized in that, It includes at least one processor and a memory connected to the processor, wherein: The memory is used to store computer programs; The processor is used to execute the computer program to enable the electronic device to implement the evidence chain data quantification analysis method as described in any one of claims 1 to 7.

10. A computer storage medium, characterized in that, The storage medium carries one or more computer programs that, when executed by an electronic device, enable the electronic device to implement the evidence chain data quantification analysis method as described in any one of claims 1 to 7.

Images