Drug repurposing differential signature quality analysis and drug set coordination method and system, device, storage medium

Abstract

The present application belongs to the technical field of bioinformatics, and relates to a drug repositioning differential signature quality analysis and drug set coordination method, system, equipment and storage medium. The method comprises the following steps: obtaining a differential feature analysis unit and extracting features to generate quality representation; generating an algorithm adaptation state and controlling algorithm execution; generating a native candidate object space or a common candidate object space; generating an evaluation result in the native space after obtaining a ranking result, and generating a common space evaluation result when the common space exists; comparing the evaluation results of the two spaces to generate a candidate space sensitivity state, and determining the state as inapplicable when the common space does not exist; generating a result credibility state according to the quality representation, the algorithm adaptation state and the candidate space sensitivity state; and outputting a structured evaluation result object. The present application can uniformly evaluate the data quality, algorithm adaptation and result credibility of the omics differential signature used for drug repositioning, and improve the explainability and reliability of the analysis.

Description

Technical Field

[0001] This invention belongs to the field of bioinformatics technology, and in particular relates to methods, systems, devices, and storage media for drug repositioning differential signature quality analysis and drug ensemble coordination. Background Technology

[0002] Drug retargeting aims to discover new therapeutic uses for diseases from marketed drugs, clinical candidates, or other interventional targets, offering advantages such as lower cost, shorter development cycles, and more comprehensive safety information. With the advancement of RNA-seq, gene expression microarrays, single-cell sequencing, and multi-omics technologies, a wealth of omics data related to diseases, drug treatments, clinical stages, and molecular subtypes is continuously accumulating. Researchers typically convert disease states or interventions into differential signatures for candidate drug ranking, target interpretation, and evaluation of drug retargeting algorithms.

[0003] Existing methods typically rely on three fundamental conditions: first, the input signature has sufficient quality and a clearly defined biological origin; second, the input signature matches the feature space, candidate object space, or network space required by the candidate algorithm; and third, the output has interpretable external references, stability evidence, or confidence boundaries. However, existing databases and analysis tools primarily address data storage, retrieval, and single algorithm runs, with few systematically answering questions such as "Is this input suitable for the algorithm?", "Is this candidate list stable?", and "Does this evaluation metric have sufficient contextual support?"

[0004] In practical applications, a dataset is not equivalent to an analytical object that can be directly used for algorithm evaluation. The same dataset may contain multiple disease groups, multiple comparison conditions, or multiple molecular subtypes, and data from different sources may differ significantly in terms of sample size, platform type, feature coverage, and candidate space. The smallest object that truly enters the drug repositioning algorithm is an analytical unit with clearly defined sample grouping, differential feature results, and a traceable source. Existing technologies often overlook this point, which can easily lead to the following situations: a dataset has multiple comparison conditions, but the system only provides an overall evaluation; a disease signature can be input into the algorithm, but it has very few significant features or is severely unbalanced; an algorithm can return ranking results, but the input features have very little overlap with the algorithm's feature space; a result lacks external validation labels, random baselines, or candidate space descriptions; real-time calculation results are inconsistent with pre-calculated results, but the system does not indicate the source of the difference.

[0005] Therefore, a general computer implementation method is needed to uniformly evaluate data quality, algorithm adaptability, evaluation context, and result credibility at the differential feature analysis unit level, so that the candidate drug ranking results have interpretability, reusability, and reliability. Summary of the Invention

[0006] The purpose of this invention is to provide a method, system, device, and storage medium for drug repositioning differential signature quality analysis and drug portfolio coordination, in order to solve the problems existing in the prior art.

[0007] The technical solution adopted by this invention to solve its technical problem is:

[0008] In a first aspect, the present invention provides a method for drug repositioning differential signature quality analysis and drug ensemble coordination, executed by a computer device, comprising the following steps:

[0009] (1) Obtain the differential feature analysis unit with sample grouping information and differential feature results, generate a unique identifier for the differential feature analysis unit, and extract sample grouping features, differential signal features and algorithm input features;

[0010] (2) Generate quality representations and algorithm adaptation states corresponding to each candidate algorithm, and control the execution, restrict execution or block execution of candidate algorithms based on the algorithm adaptation states;

[0011] (3) Generate the original candidate object space of each candidate algorithm; when there are at least two candidate algorithms, generate a common candidate object space based on the original candidate object spaces of at least two candidate algorithms;

[0012] (4) Obtain the candidate object ranking results of one or more candidate algorithms based on the same differential feature analysis unit, and generate the original space evaluation result for each candidate algorithm in its original candidate object space; when there is a common candidate object space, project the candidate object ranking results of at least two candidate algorithms to the common candidate object space and generate the common space evaluation result.

[0013] (5) When there is a common candidate object space, compare the evaluation results of the original space and the evaluation results of the common space to generate a candidate space sensitivity state; when there is no common candidate object space, determine the candidate space sensitivity state as an inapplicable state and generate a machine-readable reason code representing the inapplicability of the common candidate object space.

[0014] (6) Generate the result credibility state based on the quality characterization, algorithm adaptation state, and candidate space sensitivity state;

[0015] (7) Output a structured evaluation result object associated with the unique identifier of the difference feature analysis unit, including at least the quality characterization, algorithm adaptation status, candidate space sensitivity status, and result credibility status.

[0016] Furthermore, step (1) also includes the generation of missing risk states, specifically: normalizing and marking missing features, and generating different missing risk states based on whether missing fields affect quality calculation, algorithm input construction, or candidate object evaluation;

[0017] Sample grouping features include the smallest number of samples and inter-group balance; differential signal features include one or more of the following: number of effective features, number of significant features, significant proportion, and directional balance; algorithm input features include one or more of the following: feature space coverage, input direction integrity, cross-species or cross-platform mapping coverage, and network node coverage; differential feature results are derived from transcriptome differential signatures.

[0018] Furthermore, in step (2), the generation of the algorithm adaptation state corresponding to each candidate algorithm is specifically as follows: the quality characterization of the difference feature analysis unit is generated based on the sample grouping characteristics and difference signal characteristics; a candidate algorithm registration object is established for each candidate algorithm; the candidate algorithm registration object records the input requirements, feature space requirements and adaptation threshold; the algorithm input features are matched with the candidate algorithm registration object to generate the algorithm adaptation state corresponding to each candidate algorithm.

[0019] Step (2) also includes the generation of evaluation context state and noise or variability risk state, specifically: generating evaluation context state based on the number of external validation labels, positive object density, external reference sources and pre-recorded native candidate object spatial information in candidate algorithm registration objects; generating noise or variability risk state based on one or more of the following: sample size, intergroup balance, differential signal, platform information and cross-species or cross-platform mapping coverage; the evaluation context state is used to assist in generating result credibility state, and the evaluation context state and noise or variability risk state are written into the structured evaluation result object in step (7);

[0020] Quality characterization includes one or more of the following: sample quality score, differential signal quality score, algorithm input quality score, evaluation context quality score, or comprehensive quality score;

[0021] The candidate algorithm registration object also records the algorithm identifier, algorithm version, input structure, output structure, candidate object space, candidate object identifier namespace, parameter configuration, and failure conditions;

[0022] Algorithm adaptation states include executable, restricted executable, and non-executable; when restricted executable or non-executable, the structured evaluation result object records the unmet input conditions and corresponding reason codes.

[0023] Furthermore, in step (3), the generation of the native candidate object space of each candidate algorithm is specifically as follows: for one or more candidate algorithms in an executable or restricted execution state, read the candidate object set and candidate object identifier namespace corresponding to each candidate algorithm, perform identifier normalization through candidate object identifier mapping rules, and generate the native candidate object space of each candidate algorithm;

[0024] Candidate object identifier mapping rules include one or more of the following: name normalization, synonym merging, database identifier conversion, duplicate object merging, and unmappable object tagging;

[0025] The common candidate object space is generated from the intersection of multiple original candidate object spaces, a preset reference candidate set, or a subset of candidate objects that meet the preset algorithm coverage conditions;

[0026] Candidates include candidate drugs, candidate compounds, candidate targets, candidate pathways, or candidate intervention methods.

[0027] Furthermore, in step (4), during the process of generating the original space evaluation result and the common space evaluation result when there is a common candidate object space, the difference feature analysis unit, the external reference set and the evaluation function are kept consistent.

[0028] The original spatial evaluation results, as well as the shared spatial evaluation results generated when there is a shared candidate object space, include the random baseline and one or more of Hit@K, Precision@K, Recall@K, NDCG@K, MRR and AUPRC; where K represents the number of the top K candidate objects included in the evaluation in the candidate object ranking results;

[0029] In step (5), the generation of the candidate space sensitivity state is based on the candidate object retention ratio, the change of evaluation index, the change of the relative order of the algorithm, and one or more of the Jaccard, RBO, Kendall correlation coefficient or Spearman correlation coefficient.

[0030] Furthermore, step (6) also includes generating a corresponding restricted use status and machine-readable reason code when the quality characterization or algorithm adaptation status does not meet the preset conditions, or when the candidate space sensitivity status indicates that the candidate object ranking result is affected by the candidate object space; when the candidate space sensitivity status is an inapplicable status, generating a result credibility status based on the quality characterization and algorithm adaptation status, and recording the inapplicability of the candidate space sensitivity status and its machine-readable reason code in the result credibility status.

[0031] The result confidence status is generated based on one or more of the following methods:

[0032] The pre-calculated ranking results in the database are compared with the ranking results calculated in real time for the same difference feature analysis unit. Based on the Top-K overlap or ranking correlation, a consistency status between the pre-calculated and real-time calculations is generated. The consistency status between the pre-calculated and real-time calculations is used to assist in generating the credibility status of the results.

[0033] Change one or more of the differential feature screening threshold, the number of input features, or the candidate algorithm parameters, compare the candidate object ranking results before and after parameter perturbation, and generate parameter stability state. The parameter stability state is used to assist in generating the result credibility state.

[0034] A test analysis unit with expected output relationship is constructed. The target implementation output of the candidate algorithm is compared with the independent reference implementation output. The implementation verification status is generated based on numerical error, directional consistency or sorting consistency. The implementation verification status is used to assist in generating the result credibility status. The implementation verification record includes test analysis unit identifier, target algorithm version, reference implementation version, test input hash, error tolerance and error result.

[0035] The system generates version identifiers and hashes for input data, candidate object space, candidate algorithms, parameters, external references, and computation results. It also generates a recalcible state for the results by freezing the input and recalculating the results. The recalcible state of the results is used to assist in generating a confidence state for the results.

[0036] Furthermore, in step (7), the structured evaluation result object also includes the original candidate object space identifier and version information; when there is a common candidate object space, the structured evaluation result object also includes the common candidate object space identifier; when there is no common candidate object space, the structured evaluation result object also includes the inapplicable state and its machine-readable reason code.

[0037] The structured evaluation results also include the analysis link integrity status generated based on the information of the difference feature analysis unit, the difference feature results, the algorithm adaptation status, the candidate object ranking results, and the connectability status between external references.

[0038] Secondly, the present invention provides a drug repositioning differential signature quality analysis and drug ensemble coordination system, configured to perform a drug repositioning differential signature quality analysis and drug ensemble coordination method, including:

[0039] The analysis unit identification and feature extraction module is used to identify differential feature analysis units from differential analysis results, sample grouping information and data source information, generate unique identifiers and version information, and extract sample grouping features, differential signal features and algorithm input features, and perform normalization, missing value marking and outlier processing.

[0040] The quality-aware algorithm adaptation determination module is used to generate quality representations and algorithm adaptation states based on extracted features and candidate algorithm registration objects, and to control the execution, restrict execution, or block execution of candidate algorithms based on the algorithm adaptation states. The quality-aware algorithm adaptation determination module is also used to generate evaluation context states based on the number of external verification labels, positive object density, external reference sources, and pre-recorded native candidate object spatial information in the candidate algorithm registration objects, and to generate noise or variability risk states based on one or more of the following: sample size, inter-group balance, differential signals, platform information, and downstream ranking stability.

[0041] The candidate object identifier standardization module is used to map the candidate object identifiers corresponding to different algorithms to the candidate object identifier namespace according to the candidate object identifier mapping rules, and record the synonym, one-to-many mapping, unmapped and conflicting mapping status.

[0042] The candidate object set coordination and spatial evaluation module is used to generate the original candidate object space of each candidate algorithm, and to generate a common candidate object space when there are at least two candidate algorithms; it is used to generate original spatial evaluation results in the original candidate object spaces of each candidate algorithm, and to generate a common spatial evaluation result when a common candidate space exists.

[0043] The candidate object set sensitivity determination module is used to generate a candidate space sensitivity state when a common candidate object space exists, based on the candidate object retention ratio, changes in evaluation indicators, changes in the relative order of algorithms, and at least one of Jaccard, RBO, Kendall correlation coefficient, or Spearman correlation coefficient; and to generate a candidate space sensitivity inapplicability state and corresponding machine-readable reason code when a common candidate object space does not exist.

[0044] The structured credibility output module is used to generate and output a structured evaluation result object associated with the unique identifier of the differential feature analysis unit. The structured evaluation result object includes the original candidate object space identifier, and includes the common candidate object space identifier when there is a common candidate object space, or includes the inapplicable status and the corresponding machine-readable reason code when there is no common candidate object space.

[0045] The auxiliary verification module is used to perform one or more of the following operations: comparing the pre-calculated sorting results in the database with the real-time calculated sorting results to generate a consistency state between pre-calculation and real-time calculation; changing the difference feature screening threshold, the number of input features, or the parameters of the candidate algorithm to generate a parameter stability state; constructing a test analysis unit with the expected output relationship, comparing the target implementation output of the candidate algorithm with the independent reference implementation output to generate an implementation verification state; generating version identifiers and hashes for the input data, candidate object space, candidate algorithm, parameters, external references, and calculation results, and generating a recalcible state for the results by freezing the input and recalculating; the consistency state between pre-calculation and real-time calculation, the parameter stability state, the implementation verification state, and the recalcible state for the results are used to assist in generating a credibility state for the results.

[0046] Thirdly, the present invention provides an electronic device, including a processor and a memory, wherein the memory stores a computer program, and when the computer program is executed by the processor, it implements a method for drug repositioning differential signature quality analysis and drug set coordination.

[0047] Fourthly, the present invention provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements a method for drug relocation differential signature quality analysis and drug set coordination.

[0048] The present invention has the following beneficial effects:

[0049] 1. This invention uses a multi-dimensional scoring mechanism to not only determine whether a differential signature exists, but also systematically evaluates the sample grouping quality, signal strength, algorithm adaptability, and evaluation context sufficiency, thereby reducing the risk of misleading results caused by low-quality input from the source.

[0050] 2. This invention uses candidate algorithm registration objects and adaptation scores to automatically determine whether the input meets the input requirements of each algorithm before the algorithm runs. Based on hard failure conditions and adaptation score thresholds, it generates executable (RUN), restricted execution (RUN_WITH_WARNING), or non-executable (BLOCK) actions, directly transforming quality and adaptation evaluation into computational task control, reducing the risk of invalid computational tasks and erroneous results being misused by downstream systems.

[0051] 3. This invention interprets performance indicators within an evaluation context, generating evaluation context states based on the number of external labels, the density of positive objects, and the consistency of the candidate space, thus avoiding over-interpretation of ranking results when there is insufficient external reference or inconsistent candidate object spaces.

[0052] 4. This invention judges the reliability of sorting results by means of consistency between pre-computation and real-time computation, parameter sensitivity, stability of repeated runs, and comparison with random baselines. It also generates hashes and dependency lists and performs recalculation verification by freezing the versions of inputs, algorithms, parameters and candidate spaces, so that the official results have version traceability and recalculation auditability.

[0053] 5. This invention uses configurable scoring rules and candidate algorithm registration objects, without limiting specific algorithm names, database names, or output formats. When adding new drug relocation algorithms or expanding omics data types, there is no need to reconstruct the entire system. It can be used in various deployment scenarios such as databases, API services, batch computing, and local software systems.

[0054] 6. This invention, through a test analysis unit with expected output relationship and an independent reference implementation, calculates numerical error and sorting consistency, enabling the system to distinguish between "repeatable operation" and "conforming to mathematical rules," thus avoiding the continuous output of repeatable but erroneous results.

[0055] 7. This invention distinguishes between algorithm differences and candidate object set differences by standardizing candidate object identification, recalculating both native and common spaces, correcting random baselines, and determining spatial sensitivity. This avoids misjudging the increase in absolute indicators caused by shrinking the candidate space as an improvement in algorithm performance, and gives the results of multi-algorithm comparisons clear technical boundaries. Attached Figure Description

[0056] Figure 1 This is a flowchart of the drug repositioning differential signature quality analysis and drug portfolio coordination method of the present invention.

[0057] Figure 2 This is the quality characterization, algorithm adaptation, and operation control diagram of the present invention; where A is a schematic diagram of the features and auxiliary states of the analysis unit; B is the quality characterization and algorithm registration matching, receiving the feature data output by A; C is the algorithm operation control diagram, receiving the algorithm adaptation judgment result output by B, outputting three types of execution actions: executable, restricted execution, and non-executable, and recording the operation control record.

[0058] Figure 3 This is a diagram for candidate object identification standardization, dual-space evaluation, and sensitivity determination in this invention; where A is the original output of multiple algorithms and candidate object identification standardization; B is the evaluation and sensitivity determination diagram of the original candidate object space and the common candidate object space, and accepts the standardized candidate object set output by A.

[0059] Figure 4This diagram illustrates the consistency of results, parameter stability, independent implementation, and frozen recalculation verification of the present invention. A represents the consistency verification between pre-calculation and real-time calculation, B represents the parameter stability verification, C represents the independent reference implementation verification, and D represents the frozen, recalculated, and audited verification. A, B, C, and D represent four independent and parallel verification methods that generate corresponding states and are aggregated into an auxiliary verification state set to assist in generating the credibility state of the results.

[0060] Figure 5 This is a diagram showing the relationship between the system modules, analysis link node status, and structured evaluation result objects of this invention. A represents the system functional module architecture; B represents the analysis link and node status, which is the link monitoring view generated during the operation of system module A, recording the status of each node in the processed link; C represents the structured evaluation result object associated with the unique identifier of the analysis unit, and is the core result object output by system module A; D is a schematic diagram of the storage and retrieval format of the structured evaluation result object. The structured evaluation result object output by C can be stored and retrieved externally according to various formats provided by D. Detailed Implementation

[0061] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to specific embodiments and accompanying drawings. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention.

[0062] Example 1: As Figure 1-4 As shown, the drug repositioning differential signature quality analysis and drug ensemble coordination method, performed by computer equipment, includes the following steps:

[0063] S1: Identify and define the differential feature analysis unit

[0064] The system identifies analytical units from omics differential analysis results or other biomedical feature comparison results. An analytical unit is the smallest algorithm input object with clearly defined sample grouping, differential feature results, and traceable source. In transcriptomics scenarios, this analytical unit can be represented as a differential expression analysis unit; in other scenarios, it can be represented as differentially expressed proteins, differentially expressed metabolites, differentially methylated sites, differentially expressed cell states, or other sets of differential features.

[0065] Analysis units may include, but are not limited to: 1. Comparison between disease groups and normal control groups; 2. Comparison between tumor samples and normal samples; 3. Comparison between different clinical stages and normal samples; 4. Comparison between different molecular subtypes and normal samples; 5. Comparison between long-survival groups and short-survival groups; 6. Comparison between intervention groups and control groups; 7. Comparison between specific phenotype groups and reference groups; 8. Comparison of differential features after cross-species, cross-platform, or cross-data modality mapping.

[0066] Each analysis unit should include at least the following information: unit_identifier, source_identifier, dataset_identifier, comparison_identifier, group_a_identifier, group_b_identifier, organization, platform, data_category, disease_or_condition_label, feature_type, feature_space, signature_data_pointer, and version_information.

[0067] In one implementation, the unit_identifier is generated using deterministic rules. These rules may include: 1. Reading source_identifier, dataset_identifier, comparison_type, group_a_label, group_b_label, and condition_label; 2. Unifying characters to a preset encoding; 3. Replacing spaces, forward slashes, parentheses, punctuation marks, etc., with underscores; 4. Removing consecutive duplicate delimiters; 5. Appending a short hash or sequence number to comparisons with the same name; 6. Saving the original comparison_identifier for traceability.

[0068] This design avoids different modules using different IDs for the same analysis unit, thereby improving system consistency.

[0069] S2: Extracting basic features of the analysis unit

[0070] The system extracts multiple types of features for each analysis unit. The features include at least:

[0071] 2.1 Sample grouping features: n_group_a, n_group_b, min_group_n, max_group_n, sample_balance_ratio, grouping_rule, group_definition_confidence, where:

[0072] min_group_n=min(n_group_a,n_group_b).

[0073] sample_balance_ratio=min(n_group_a,n_group_b) / max(n_group_a,n_group_b).

[0074] 2.2 Difference signal features: n_valid_features, n_significant_features, n_positive_direction_features, n_negative_direction_features, significant_feature_ratio, direction_balance, missing_effect_size_ratio, missing_pvalue_ratio, missing_adjusted_pvalue_ratio. Among them: significant_feature_ratio=n_significant_features / max(n_valid_features,1)

[0075] direction_balance=n_positive_direction_features / (n_positive_direction_features+n_negative_direction_features+epsilon).

[0076] Here, epsilon is a preset positive number used to prevent the denominator from being zero. epsilon is greater than 0, and its value is saved according to the scoring configuration version; for example, epsilon can be 10. -8 However, these specific values ​​do not constitute a limitation of the present invention. In the context of differential transcriptome expression, a feature can be a gene, transcript, or probe; positive_direction_features and negative_direction_features can correspond to upregulated and downregulated features, respectively; effect_size can correspond to logFC or other effect sizes. In other omics scenarios, a feature can be a protein, metabolite, methylation site, cell subpopulation, imaging feature, or other quantifiable biomedical feature.

[0077] 2.3 Algorithm input features: n_input_features, n_matched_algorithm_features, feature_overlap_ratio, direction_information_available, n_scoreable_candidates, candidate_space_ratio, native_candidate_space_identifier, native_candidate_count, network_coverage_ratio, cross_space_mapping_coverage.

[0078] In the transcriptome implementation, `feature_overlap_ratio` can be specifically represented as `gene_overlap_ratio`, and `cross_space_mapping_coverage` can be specifically represented as homologous gene mapping coverage, platform probe mapping coverage, or gene nomenclature system conversion coverage. `native_candidate_space_identifier` is used to identify the set of native candidate objects that the candidate algorithm can score; `shared_candidate_count` represents the number of candidate objects jointly covered by two or more candidate algorithms after candidate object identification normalization; `candidate_retention_ratio` can be calculated as the ratio of the number of common candidate objects to the corresponding number of native candidate objects.

[0079] 2.4 Evaluation context features: external_reference_available, reference_source_count, n_positive_objects, n_mapped_positive_objects, positive_object_density, registered_candidate_space_available, registered_candidate_count, candidate_identifier_namespace_available and label_confidence.

[0080] When an external reference record, candidate object set, or candidate object identifier namespace is missing, the system does not directly set the corresponding field to zero. Instead, it generates a corresponding missing label and a machine-readable cause code. The cause code includes one or more of the following: missing_external_reference, sparse_positive_labels, candidate_space_metadata_missing, and identifier_namespace_missing.

[0081] The system generates evaluation context states based on the aforementioned pre-run evaluation context features. Evaluation context states include context_sufficient, context_limited, and context_insufficient. Evaluation context states are used to limit the interpretation scope of subsequent ranking evaluation indicators; they do not directly determine whether candidate algorithms are executed, nor do they directly form clinical medication conclusions.

[0082] 2.5 Result stability characteristics: precomputed_result_available, realtime_result_available, parameter_perturbation_available, repeat_run_available, topk_overlap_metrics, rank_correlation_metrics, imp lementation_reference_available, implementation_validation_error, implementation_validation_status, recalculation_validation_status, runtime_metrics, cache_or_version_status.

[0083] 2.6 This step only extracts the input features that can be obtained before the algorithm runs; the fields generated during the candidate object identification normalization, common candidate object space and dual-space evaluation process will be written into the feature record of the same analysis unit in subsequent steps.

[0084] S3: Feature Preprocessing and Missing Labeling

[0085] The system preprocesses the extracted features. Count features are log-normalized: `norm_count(x,cap)=min(log(1+x) / log(1+cap),1)`. Proportional features are limited to between 0 and 1. Boolean features are converted to 0 or 1. For missing values, the system does not directly delete the analysis unit, but instead generates a `missing_flag`. Examples include: `missing_fdr`, `missing_logfc`, `missing_group_size`, `missing_candidate_space`, and `missing_external_reference`.

[0086] Missing markers are incorporated into subsequent scoring and explanatory vectors to prevent the system from implicitly ignoring quality issues.

[0087] In one implementation, the system stores a configuration profile to record thresholds, weights, normalization upper limits, version numbers, and scoring dates. This allows the evaluation results of the same analysis unit at different times to be traced and reproduced.

[0088] S4: Calculate the sample quality score

[0089] The system calculates a sample quality score based on sample size, minimum group size, between-group balance, and the reliability of the grouping rule. In one implementation:

[0090] sample_size_component=min(log(1+min_group_n) / log(1+T_sample),1)

[0091] balance_component=min(sample_balance_ratio / T_balance,1)

[0092] group_definition_component=group_definition_confidence

[0093] sample_quality_score=w_sample_1*sample_size_component+w_sample_2*balance_component+w_sample_3*group_definition_component

[0094] The values ​​for T_sample, T_balance, and weights can be set according to the data type. For example, case-control or clinical stratified data may require a higher T_sample; intervention data may have a lower sample size threshold but increased treatment_definition_confidence; cross-species, cross-platform, or cross-modal data may include mapping_quality_component. The system outputs the following based on sample_quality_score: high_sample_quality, medium_sample_quality, low_sample_quality, and review_required.

[0095] S5: Calculate the differential signal quality score

[0096] The system calculates the difference signal quality score based on the number of effective features, the number of significant features, the significance ratio, directional balance, and the presence of missing statistics. In one implementation:

[0097] valid_component=norm_count(n_valid_features,C_valid)

[0098] significant_component=norm_count(n_significant_features,C_sig)

[0099] ratio_component=min(significant_feature_ratio / T_sig_ratio,1)

[0100] direction_component=max(1-2*abs(direction_balance-0.5),0)

[0101] missing_penalty=f(missing_effect_size_ratio,missing_adjusted_pvalue_ratio)

[0102] signal_quality_score=w_sig_1*valid_component+w_sig_2*significant_component+w_sig_3*ratio_component+w_sig_4*direction_component-w_sig_5*missing_penalty

[0103] Where f is a preset monotonic non-decreasing normalization function, used to map the missing effect size proportion and the corrected significance probability missing proportion to a missing penalty value between 0 and 1; when any missing proportion increases, missing_penalty does not decrease.

[0104] In one non-limiting implementation: missing_penalty = w_miss_1 × missing_effect_size_ratio + w_miss_2 × missing_adjusted_pvalue_ratio. Where w_miss_1 and w_miss_2 are both non-negative weights, and w_miss_1 + w_miss_2 = 1; these weights are saved according to the scoring configuration version.

[0105] If n_significant_features is 0, the system does not delete the unit, but marks it as low_signal or no_significant_signal. If the direction is severely skewed, it is marked as direction_biased_signal. This score is used to determine whether the differential signature is suitable as algorithm input, rather than directly determining whether the biological mechanism or clinical conclusion is valid.

[0106] S6: Establish candidate algorithm registration objects

[0107] The system establishes a candidate algorithm registration object for each candidate algorithm. The candidate algorithm registration object is used to describe the algorithm's input requirements, candidate object space, output structure, and adaptation threshold.

[0108] Candidate algorithm registration objects may include: algorithm_identifier, algorithm_family, algorithm_core_rule, required_min_features, required_feature_direction, required_feature_space, candidate_object_space, candidate_identifier_namespace, candidate_normalization_r ule, network_or_signature_space, supports_ranked_input, supports_up_down_input, supports_batch_run, output_schema, applicability_thresholds, runtime_profile, version_information, independent_reference_information, numeric_tolerance.

[0109] This invention does not limit the specific type of algorithm. Candidate algorithms may include similarity or inverse correlation algorithms, set enrichment algorithms, weighted ranking algorithms, network propagation algorithms, statistical learning models, machine learning models, deep learning models, knowledge graph reasoning models, or other algorithms that rely on differential signatures.

[0110] By registering objects using candidate algorithms, the system can integrate new algorithms without modifying the overall evaluation framework.

[0111] S7: Calculate the algorithm input adaptation score

[0112] The system matches the features of the analysis units with the registered objects of the candidate algorithms, and calculates the fit score of each analysis unit for each algorithm. In one implementation:

[0113] feature_overlap_component=min(feature_overlap_ratio / T_feature_overlap,1)

[0114] candidate_space_component=min(candidate_space_ratio / T_candidate_space,1)

[0115] direction_component=1 if required_feature_direction is satisfied else0

[0116] network_component=min(network_coverage_ratio / T_network,1)

[0117] algorithm_fit_score=w_alg_1*feature_overlap_component+w_alg_2*candidate_space_component+w_alg_3*direction_component+w_alg_4*network_component

[0118] If an algorithm does not require network input, the weight of `network_component` can be set to 0, and the other weights can be renormalized. The system outputs `applicable`, `limited_applicable`, and `not_applicable` based on `algorithm_fit_score`, and generates `failure_reason` values, such as: `insufficient_input_features`, `insufficient_feature_overlap`, `missing_feature_direction`, `insufficient_candidate_space`, `insufficient_network_coverage`, and `cross_space_mapping_insufficient`.

[0119] In a preferred embodiment, the algorithm fit state directly controls subsequent computational tasks, rather than merely serving as a label. The system first checks for hard failure conditions, including missing necessary directional information, a number of valid input features below the minimum specified for the candidate algorithm's registration, unmapped feature space, or network node coverage below a blocking threshold. When any hard failure condition is met, the system outputs `not_applicable`, sets the execution action to `BLOCK`, and does not create a formal scoring task for the algorithm. If no hard failure condition exists, `algorithm_fit_score` is compared with configurable thresholds `T_applicable` and `T_limited`.

[0120] if hard_failure==true:

[0121] applicability_status=not_applicable

[0122] execution_action=BLOCK

[0123] elif algorithm_fit_score >=T_applicable:

[0124] applicability_status=applicable

[0125] execution_action=RUN

[0126] elif algorithm_fit_score>=T_limited:

[0127] applicability_status=limited_applicable

[0128] execution_action=RUN_WITH_WARNING

[0129] else:

[0130] applicability_status=not_applicable

[0131] execution_action=BLOCK

[0132] In this system, `T_applicable` is greater than `T_limited`; both, along with the `hard_failure` rule, are saved and versioned along with the candidate algorithm registration object. For `RUN_WITH_WARNING`, the system allows the generation of algorithm results, but writes the limitation reason, missing features, and recommended use into the result object; for `BLOCK`, the system saves the input summary and reason code of the blocked task without generating a candidate object ranking. Thus, the quality and fit of the results can change the computer task scheduling and result state, reducing invalid computation and uninterpretable output. The technical effect of this step is: to determine whether the input is suitable before the algorithm runs, reducing invalid execution and uninterpretable results.

[0133] S8: Calculate the evaluation context score

[0134] The system determines whether the analysis unit has the context needed to evaluate the algorithm results. The context includes external reference labels, the number of positive objects, the consistency of the candidate object space, label density, and the credibility of the reference sources.

[0135] In one implementation:

[0136] reference_component=1 if external_reference_available else 0

[0137] positive_component=norm_count(n_positive_objects,C_positive)

[0138] density_component=min(positive_object_density / T_density,1)

[0139] space_metadata_component=1 if registered_candidate_space_availableand candidate_identifier_namespace_available else 0

[0140] confidence_component = label_confidence

[0141] context_score=w_ctx_1*reference_component+w_ctx_2*positive_component+w_ctx_3*density_component+w_ctx_4*space_metadata_component+w_ctx_5*confidence_component

[0142] If the context_score is low, the system does not prohibit the algorithm from running, but instead lowers the interpretation level of the result to exploratory or insufficient_reference_context. This mechanism avoids misinterpreting a lack of external references as an algorithm failure, and also avoids misreading low evaluation metrics caused by insufficient external labels as an invalid algorithm.

[0143] S9: Generate a comprehensive quality evaluation

[0144] The system integrates sample quality, differential signal quality, algorithm input adaptation, and evaluation context scoring to generate a comprehensive quality score.

[0145] In one implementation: overall_quality_score = w_all_1 * sample_quality_score + w_all_2 * signal_quality_score + w_all_3 * median_algorithm_fit_score + w_all_4 * context_score

[0146] Where `median_algorithm_fit_score` represents the median score of the analysis unit for adapting to multiple candidate algorithms; the maximum, mean, or weighted mean can also be used. The system outputs the following scores based on the overall quality score: `high_quality`, `medium_quality`, `low_quality`, and `review_required`.

[0147] The system also generates an `explanation_vector`. This `explanation_vector` records the main factors affecting the synthesis quality, such as:

[0148] main_limiting_factor=low_sample_size

[0149] secondary_limiting_factor=insufficient_external_reference

[0150] recommended_use=exploratory_analysis

[0151] not_recommended_use=primary_confirmatory_evaluation

[0152] S10: Calculate the risk of noise or variability

[0153] Based on one or more of the following factors: sample size, intergroup balance, differential signal quality, data platform information, and cross-species or cross-platform mapping quality, noise or variability risk states are generated.

[0154] The process involves generating risk components for insufficient sample size, group imbalance, insufficient differential signal, and platform or mapping, and combining them according to preset weights to obtain a noise or variability risk score: noise_variability_risk_score = w1 × sample_size_risk + w2 × group_imbalance_risk + w3 × signal_insufficiency_risk + w4 × platform_or_mapping_risk. Here, w1, w2, w3, and w4 are non-negative weights, and their sum is 1. Each risk component is normalized to 0 to 1, with higher values ​​indicating higher risk. Based on the comparison between the noise or variability risk score and a preset threshold, low-risk, medium-risk, or high-risk states are generated, and the risk score, risk state, participating risk components, and corresponding cause codes are written into a structured evaluation result object.

[0155] S11: Verification of the reliability of execution results

[0156] Once the analysis unit has generated algorithm output results, the system verifies the reliability of the results. Verification methods include: 1. Consistency between pre-calculated results and real-time calculation results; 2. Consistency between default parameter and perturbation parameter results; 3. Consistency of repeated run results; 4. Consistency of results between similar or related analysis units; 5. The degree of improvement of the algorithm results relative to a random baseline or empty model. For ranking outputs, the system can calculate:

[0157] Jaccard@K=|TopK_A∩TopK_B| / |TopK_A∪TopK_B|

[0158] Where TopK_A and TopK_B represent the sets of the top K candidate objects in the ranking results of the two candidate objects to be compared, and the symbol |·| represents the number of candidate objects in the set;

[0159] RBO = rank-biased overlap;

[0160] MRR = mean reciprocal rank, which is the average reciprocal rank.

[0161] AUPRC = area under the precision-recall curve;

[0162] NDCG = normalized discounted cumulative gain.

[0163] precision_lift=observed_precision / random_precision

[0164] Among them, observed_precision represents the actual precision of the candidate algorithm ranking results at the preset truncation position, and random_precision represents the precision of the random baseline in the corresponding candidate object space. The system outputs the following reliability metrics: stable_result, moderately stable_result, parameter_sensitive_result, inconsistent_result, and insufficient_evidence.

[0165] S12: Generate structured evaluation result objects

[0166] The system encapsulates the above evaluation results into a structured evaluation result object. This object is not limited to a specific format and can be a database record, JSON, XML, TSV, message queue object, API response, document report object, or other machine-readable object.

[0167] Structured evaluation result objects include: unit_identifier, version_information, sample_quality_score, signal_quality_score, algorithm_fit_scores, context_score, overall_quality_score, noise_variability_risk_score, quality_label, applicable_algorithms, limited_applicable_algorithms, non_applicable_algorithms, failure_reasons, reliability_metrics, reliability_label, native_candidate_space_identifier, shared_candidate_space_identifier, candidate_retention_ratio, candidate_space_sensitivity_status, implementation_validation_status, recalculation_validation_status, explanation_vector, recommended_use, warning_messages.

[0168] Among them, noise_variability_risk_score represents the noise or variability risk score. The higher the value, the higher the risk of unstable results caused by sample size, intergroup imbalance, insufficient differential signals, platform differences, or insufficient mapping.

[0169] `native_candidate_space_identifier` is used to record the native candidate space identifier, which is recorded in scenarios with one or more candidate algorithms. When there are at least two candidate algorithms and a common candidate space is generated, `shared_candidate_space_identifier` is used to record the common candidate space identifier; when there is no common candidate space, `shared_candidate_space_identifier` may not be generated, may be recorded as null, or may be recorded as an inapplicable flag, `candidate_space_sensitivity_status` may be recorded as inapplicable, and the reason code `shared_candidate_space_not_applicable` may be recorded in `failure_reasons`. This object can be used for subsequent algorithm execution, report generation, interactive display, API output, batch analysis, data encapsulation, model auditing, or other computing system calls.

[0170] S13: Optional analysis link integrity assessment

[0171] In one optional implementation, the system performs an integrity evaluation on the data-algorithm-result link of the analysis unit. This link may include: metadata_node, sample_group_node, signature_node, quality_node, algorithm_fit_node, algorithm_output_node, reliability_node, and output_package_node, each node may have:

[0172] node_status=available / partial / missing / blocked / not_required

[0173] node_reason

[0174] node_version

[0175] The system generates a chain_completeness_score based on the node status. This mechanism can be used in any system that needs to interpret whether the analysis process is complete, and is not limited to any specific display term, interaction method, or output method.

[0176] S14: Optional result object encapsulation and integrity verification

[0177] In one optional implementation, the system encapsulates the structured evaluation results, algorithm output, relevant metadata, and credibility verification results into a result object based on user query conditions, batch tasks, or downstream call requirements. The result object can be used for file export, database record generation, interface response, message queue, audit log generation, or report generation, and is not limited to a specific download package format.

[0178] The system generates integrity records for the result objects. These records may include: object_identifier, module_name, source_unit_identifier, object_type, object_location, object_format, status, missing_reason, record_count, version, created_time, and checksum. The status field may include: available, generated, missing, skipped, and failed. The technical effect of this mechanism is to ensure that the output results are traceable and verifiable, preventing downstream systems from misusing incomplete results.

[0179] S15: Coordinating the candidate object space of multiple candidate algorithms

[0180] When the system needs to compare two or more candidate algorithms, it reads the candidate_object_space, candidate_identifier_namespace, and candidate_normalization_rule from the registration objects of each candidate algorithm to generate the original candidate object set for each algorithm. The system then standardizes the candidate object name, database identifier, synonym, salt type, combination form, or other candidate object representations to obtain normalized candidate object identifiers.

[0181] In one implementation, candidate object space coordination includes:

[0182] 1. Read the original candidate object set and version of each algorithm; 2. Map the original candidate object identifiers to a unified identifier space; 3. Record the one-to-one, one-to-many, unmapped, and conflict mapping states; 4. Generate the normalized original candidate space for each algorithm; 5. Find the intersection, union, or preset reference set for at least two normalized candidate spaces; 6. Calculate the number of original candidate objects, the number of common candidate objects, and the candidate retention ratio; 7. Save the version of the common candidate space and the hash of the candidate object list.

[0183] Candidate object identifier mapping can be performed according to the following priorities: 1. Stable database identifiers are preferred for complete matching; 2. For objects without stable identifiers, versioned thesaurus, standardized name table, or database cross-reference table are used for mapping; 3. Candidate drug names are standardized for case, whitespace, punctuation, and non-semantic suffixes, but the original names are preserved; 4. Mapping relationships are established for salt forms, solvates, stereoisomers, and parent active ingredients, and mapping_relation_type is used to distinguish between exact, synonym, salt_to_parent, stereoisomer, and related_form; 5. Fixed dose combinations or multi-component candidate objects are retained as independent objects by default and are not automatically split when there are no explicit rules; 6. Conflict records are generated for one-to-many mappings and multiple original objects mapped to the same standardized object, and retention, merging, or exclusion are performed according to the conflict strategy in the candidate algorithm registered objects; 7. For objects that cannot be mapped, the original identifier is retained, and mapping_status is set to unmapped, so that they are not included in the common candidate space that requires unified identifiers. Each mapping record includes at least: source_algorithm_identifier, source_candidate_identifier, source_candidate_name, source_identifier_namespace, canonical_candidate_identifier, canonical_candidate_name, canonical_identifier_namespace, mapping_relation_type, mapping_status, mapping_evidence, and mapping_rule_version. Let C_i be the set of native candidate objects normalized by the i-th algorithm, and A be the set of algorithms participating in fair comparison. Then the common candidate object space C_shared can be generated by the following formula: C_shared = intersection(C_i for i in A). In another implementation, C_shared can be the intersection of a preset reference set C_ref and each native space, or a set of candidate objects covered by no less than a preset number of algorithms. The system simultaneously projects the external positive object set onto the corresponding candidate space, generating P_i=P∩C_i and P_shared=P∩C_shared respectively, to avoid including positive objects that do not exist in the current candidate space in the number of recallable objects.

[0184] Among them: candidate_retention_ratio=shared_candidate_count / max(native_candidate_count,1)

[0185] When the number of common candidates is below a preset threshold, the system outputs `insufficient_shared_candidates`; when there are conflicts in candidate identifiers, the system outputs `candidate_identifier_conflict`. This step avoids directly comparing incomparable ranking results due to differences in drug names, database namespaces, or candidate set sizes.

[0186] S16: Perform candidate object space evaluation

[0187] For each candidate algorithm in an executable or restricted execution state, the system generates a native space evaluation result in the native candidate object space of that algorithm, while maintaining consistency in analysis units, external reference labels, evaluation functions, and parameter configurations. When a common candidate object space exists, the system also projects the candidate object ranking results of at least two candidate algorithms into the common candidate object space and generates a common space evaluation result, thus performing a dual-track evaluation of the native and common candidate object spaces. When no common candidate object space exists, the system only generates a native space evaluation result, does not perform a comparison between the native and common space evaluation results, and records the candidate space sensitivity state as inapplicable.

[0188] When a common candidate object space exists, the dual-track evaluation can include: native_space_metrics, shared_space_metrics, native_random_baseline, shared_random_baseline, metric_delta_shared_minus_native, algorithm_rank_change, candidate_retention_ratio, topk_jaccard_native_vs_shared, topk_rbo_native_vs_shared, and rank_correlation_native_vs_shared.

[0189] For a scenario where the total number of candidate objects is N, the number of positive objects in the current space is M, and the cutoff position is K, the system can recalculate the random baseline based on the current candidate space. For example, the expected value of random sorting, Precision@K, can be expressed as M / N; the random hit probability and other random baselines can be obtained through analytical calculation, permutation sampling, or Monte Carlo simulation. The original space and the common space use their corresponding N, M, and positive object projection sets, respectively, without reusing the random baseline of the other space.

[0190] When a common candidate object space exists and sufficient evaluation information for the common space is available, the system can generate a candidate space sensitivity score. In one non-limiting implementation:

[0191] metric_change_component=normalized_absolute_metric_change

[0192] rank_change_component=normalized_algorithm_rank_change

[0193] overlap_loss_component=1-topk_rbo_native_vs_shared

[0194] retention_loss_component=1-candidate_retention_ratio

[0195] candidate_space_sensitivity_score=w_space_1*metric_change_component+w_space_2*rank_change_component+w_space_3*overlap_loss_component+w_space_4*retention_loss_component

[0196] Each component is limited to 0 to 1, with a weight sum of 1, and is saved with each scoring configuration version. For example, when `candidate_space_sensitivity_score` is not higher than `T_robust`, it is labeled `candidate_space_robust`; when it is higher than `T_robust` but not higher than `T_sensitive`, it is labeled `candidate_space_moderately_sensitive`; and when it is higher than `T_sensitive`, it is labeled `candidate_space_sensitive`. If the number of common candidates is less than `max(K, T_shared_count)`, or the candidate retention ratio of any algorithm is lower than `T_retention_min`, then `insufficient_shared_candidates` or `candidate_space_low_retention` are output first, and the insufficient data state is not replaced by a regular sensitivity label.

[0197] Each sensitivity state simultaneously outputs a reason_code, which may include metric_shift_exceeds_threshold, algorithm_order_changed, low_rank_overlap, low_candidate_retention, positive_density_shift, and random_baseline_shift. The thresholds and weights are configurable parameters, and their specific values ​​are not limited in this invention.

[0198] The system generates candidate spatial sensitivity states based on changes in evaluation metrics, changes in relative algorithm rankings, changes in random baselines, the retention rate of candidate objects, and one or more of the following: Jaccard, RBO, Kendall correlation coefficient, or Spearman correlation coefficient. Examples include: candidate_space_robust, candidate_space_moderately_sensitive, candidate_space_sensitive, and insufficient_shared_candidates.

[0199] When the absolute index in the common space is higher than that in the original space, the system does not directly generate `algorithm_improved`. Instead, it combines the number of candidate objects, the density of positive objects, and the random baseline to output `candidate_space_restriction_effect`. This mechanism can distinguish between changes in the algorithm itself and changes in the index caused by changes in the evaluation space.

[0200] S17: Verify the numerical correctness of the candidate algorithm implementation

[0201] The system establishes one or more test analysis units with expected output relationships for candidate algorithms. Test analysis units may include expected positive or negative correlation vectors, expected enrichment locations, expected similarity directions, test networks with near-end and far-end nodes, or other artificial or standardized inputs that can determine the expected numerical relationships.

[0202] The system calls both the target algorithm implementation and a reference implementation whose code paths are independent of the target implementation, to obtain the target numerical result and the reference numerical result. System calculation:

[0203] absolute_error=abs(target_value-reference_value)

[0204] relative_error=absolute_error / max(abs(reference_value),epsilon)

[0205] direction_consistent

[0206] ranking_consistent

[0207] The system reads the numeric_tolerance from the candidate algorithm registration object and outputs it:

[0208] implementation_validated

[0209] implementation_mismatch

[0210] reference_implementation_unavailable

[0211] test_input_invalid

[0212] The verification record should include at least the test analysis unit identifier, target algorithm version, reference implementation and version, test input hash, expected relationship, numerical error, tolerance, and verification time. This step verifies whether the computational implementation of the candidate algorithm conforms to the mathematical rules declared in the candidate algorithm registration object, distinguishing it from simply comparing the results of repeated runs of the same implementation.

[0213] S18: Perform post-hoc aggregation and update the result confidence status.

[0214] After the candidate algorithm completes its execution and obtains the original space evaluation results, the system performs a post-hoc aggregation. When a common candidate object space exists, the system also obtains the common space evaluation results and the candidate space sensitivity status. When no common candidate object space exists, the system obtains the candidate space sensitivity inapplicability status and the corresponding machine-readable reason code. The system reads the quality characterization, algorithm fit status, evaluation context status, and noise or variability risk status generated before execution, and updates the result credibility status by combining the available post-run evaluation results and related missing markers. The result credibility status includes one of the following: trustworthy use, restricted use, warning use, blocked use, and insufficient evidence, and simultaneously generates the corresponding machine-readable reason code.

[0215] When no common candidate object space exists, the candidate space sensitivity state is not assigned to zero, but is recorded as inapplicable, and a reason code `shared_candidate_space_not_applicable` is generated. When the information required for posterior evaluation is missing, a reason code `posterior_evidence_insufficient` is generated. In the above cases, the structured evaluation result object retains the original candidate object space identifier, does not record the valid value of the common candidate object space identifier, and records the inapplicable state and the corresponding machine-readable reason code.

[0216] The system writes the credibility status of the results generated by the post-hoc summary, the status information of the summarized results, the cause code, the algorithm version, the candidate object space version, and the evaluation configuration version into the structured evaluation result object.

[0217] S19: Freeze and review the calculation results

[0218] The system creates frozen result objects for results used in formal evaluations or public output. A frozen result object is associated with at least the following: input_unit_version, algorithm_version, parameter_profile, candidate_space_version, external_reference_version, runtime_environment, input_hashes, result_hashes, and dependency_manifest.

[0219] The system recalculates based on the frozen input and compares the recalculation result with the precalculation result field by field or sort by sorted object. When the numerical error and sorting difference are below the preset tolerance, it outputs recalculation_verified; otherwise, it outputs recalculation_mismatch and records the field, candidate object, version, or parameter where the difference occurred.

[0220] Freezing results objects saves them as new versions rather than overwriting old versions. The system generates a manifest for each freeze, recording the file size, hash, generation time, dependent inputs, and result roles. This step allows the final results to be recalculated, audited, and version differences located.

[0221] Example 2: As Figure 5 As shown, the present invention also provides a drug repositioning differential signature quality analysis and drug ensemble coordination system, configured to perform a drug repositioning differential signature quality analysis and drug ensemble coordination method, including:

[0222] The analysis unit identification and feature extraction module is used to identify differential feature analysis units from differential analysis results, sample grouping information and data source information, generate unique identifiers and version information, and extract sample grouping features, differential signal features and algorithm input features, and perform normalization, missing value marking and outlier processing.

[0223] The quality-aware algorithm adaptation determination module is used to generate quality representations and algorithm adaptation states based on extracted features and candidate algorithm registration objects, and to control the execution, restrict execution, or block execution of candidate algorithms based on the algorithm adaptation states. The quality-aware algorithm adaptation determination module is also used to generate evaluation context states based on the number of external verification labels, positive object density, external reference sources, and pre-recorded native candidate object spatial information in the candidate algorithm registration objects, and to generate noise or variability risk states based on one or more of the following: sample size, inter-group balance, differential signals, platform information, and downstream ranking stability.

[0224] The candidate object identifier standardization module is used to map the candidate object identifiers corresponding to different algorithms to the candidate object identifier namespace according to the candidate object identifier mapping rules, and record the synonym, one-to-many mapping, unmapped and conflicting mapping status.

[0225] The candidate object set coordination and spatial evaluation module is used to generate the original candidate object space of each candidate algorithm, and to generate a common candidate object space when there are at least two candidate algorithms; it is used to generate original spatial evaluation results in the original candidate object spaces of each candidate algorithm, and to generate a common spatial evaluation result when a common candidate space exists.

[0226] The candidate object set sensitivity determination module is used to generate a candidate space sensitivity state when a common candidate object space exists, based on the candidate object retention ratio, changes in evaluation indicators, changes in the relative order of algorithms, and at least one of Jaccard, RBO, Kendall correlation coefficient, or Spearman correlation coefficient; and to generate a candidate space sensitivity inapplicability state and corresponding machine-readable reason code when a common candidate object space does not exist.

[0227] The structured credibility output module is used to generate and output a structured evaluation result object associated with the unique identifier of the differential feature analysis unit. The structured evaluation result object includes the original candidate object space identifier, and includes the common candidate object space identifier when there is a common candidate object space, or includes the inapplicable status and the corresponding machine-readable reason code when there is no common candidate object space.

[0228] The auxiliary verification module is used to perform one or more of the following operations: comparing the pre-calculated sorting results in the database with the real-time calculated sorting results to generate a consistency state between pre-calculation and real-time calculation; changing the difference feature screening threshold, the number of input features, or the parameters of the candidate algorithm to generate a parameter stability state; constructing a test analysis unit with the expected output relationship, comparing the target implementation output of the candidate algorithm with the independent reference implementation output to generate an implementation verification state; generating version identifiers and hashes for the input data, candidate object space, candidate algorithm, parameters, external references, and calculation results, and generating a recalcible state for the results by freezing the input and recalculating; the consistency state between pre-calculation and real-time calculation, the parameter stability state, the implementation verification state, and the recalcible state for the results are used to assist in generating a credibility state for the results.

[0229] As an optional implementation, the following modules are also included:

[0230] The results credibility verification module is used to compare the algorithm output results of different versions, different parameters, different running modes, or different related analysis units, and generate stability and consistency indicators.

[0231] An independent verification module is implemented to manage test analysis units with expected output relationships, independent reference implementations and error tolerances, and to generate algorithm implementation numerical verification status and audit logs.

[0232] The result freezing and recalculation audit module is used to record inputs, algorithms, parameters, candidate space, external references and runtime environment versions, generate hashes and dependency manifests, and generate recalcible verification states by freezing inputs and recalculating them.

[0233] Interfaces and extension modules are used to provide structured output results to interactive interfaces, APIs, batch tasks, report generators or other downstream systems, while also supporting the addition of new algorithms, adjustment of scoring configurations and output of results in different formats.

[0234] Module Collaboration and State Transition: Each module is associated through a unique unit identifier, algorithm identifier, candidate space version, and runtime identifier. The system can divide a processing cycle into states such as UNIT_REGISTERED, QUALITY_ASSESSED, APPLICABILITY_ASSESSED, CANDIDATE_SPACE_READY, ALGORITHM_COMPLETED, CANDIDATE_SPACE_EVALUATED, TRUST_STATUS_GENERATED, and RESULT_FROZEN. When the input conditions of the previous step are not met, the system does not fabricate an empty result but records BLOCKED, SKIPPED, or FAILED along with the reason code. When a common candidate object space exists, DUAL_SPACE_EVALUATED can also be recorded; when no common candidate object space exists, the dual-space evaluation node is recorded as SKIPPED along with the corresponding reason code.

[0235] Preferred data objects include: analysis_unit_record, algorithm_registry_record, algorithm_applicability_record, candidate_mapping_record, candidate_space_record, algorithm_run_record, dual_space_evaluation_record, trust_status_record, and frozen_result_manifest.

[0236] The `analysis_unit_record` stores the differential feature analysis unit and its version; `algorithm_applicability_record` stores the fit score, status, and executed actions; `candidate_space_record` stores the number, version, and hash of the original or common candidate object set; `algorithm_run_record` stores the input version, algorithm version, parameters, and ranking result position; `dual_space_evaluation_record` stores the metrics, random baseline, candidate retention ratio, and sensitivity status in both spaces; and `trust_status_record` stores the quality constraints, fit constraints, spatial sensitivity, stability verification, and recommended uses. Through these connections, the system can reverse-engineer the input unit, algorithm implementation, candidate object space, and evaluation configuration from any publicly available result.

[0237] When an exception occurs during system execution, status is recorded instead of being silently discarded. For example, if a candidate identifier conflict prevents the common space from being generated, the original space result can still be saved, but the cross-algorithm fair comparison is marked as BLOCKED; if an external reference is missing, the algorithm ranking can still be generated, but the external retrieval index is marked as SKIPPED_NO_REFERENCE; if an independent reference implementation is unavailable, it is not mistakenly recorded as a verification failure, but rather as REFERENCE_UNAVAILABLE.

[0238] Example 3: Disease-specific signatures for evaluation prior to candidate drug ranking

[0239] The system reads the differential signature formed between a disease group and a control group. This signature may include gene logFC, p-value, and FDR in a transcriptomics scenario, and may also include characteristic effect sizes and significance correction values ​​in other omics scenarios. The system first generates a unit_identifier, and then extracts the number of samples, group balance, number of effective features, number of significant features, and number of positive and negative features.

[0240] The system calculates the `sample_quality_score` and `signal_quality_score`. If the sample sizes for both the disease group and the control group are sufficient and the number of significantly differentiating features is high, the analysis unit receives a high data quality score. The system then reads the input requirements of the candidate drug ranking algorithm and calculates the `feature_overlap_ratio` and `candidate_space_ratio`. If the analysis unit meets the input requirements of multiple algorithms, it outputs a list of `applicable_algorithms`.

[0241] Example 4: Evaluation of clinical subtype signatures for subtype-related drug candidate ranking

[0242] The system reads the differential signatures formed between a disease subtype or tumor subtype and a reference sample. Because subtype analysis may suffer from insufficient reference samples or inconsistent subtype definitions, the system incorporates `group_definition_confidence` into the sample quality score. If the subtype definition is clear but the reference sample is small, the `sample_quality_score` decreases, but the unit can still be retained as `limited_applicable` for exploratory drug candidate ranking.

[0243] Example 5: Evaluation of cross-species, cross-platform, or cross-feature space mapping analysis units

[0244] The system reads differential signatures from mouse sources, different detection platforms, or other feature space sources and maps them to the feature space required by the target algorithm. The system calculates `cross_space_mapping_coverage`. If the mapping coverage is high, the unit can be used for candidate drug ranking algorithms that depend on the target feature space; if the mapping coverage is low, the system marks `cross_space_mapping_insufficient`.

[0245] Example 6: Handling Algorithm Input Adaptation Failure

[0246] A certain analysis unit possesses sufficiently significant features, but these features have low overlap with the feature space of a candidate drug ranking algorithm. Instead of directly running the algorithm, the system outputs "not_applicable" and records "failure_reason = insufficient_feature_overlap". For another algorithm that does not depend on this feature space, the system can still output "applicable".

[0247] Example 7: Interpreting Results with Insufficient Evaluation Context

[0248] A certain analysis unit can generate a ranking of candidate drugs or objects, but lacks external positive labels. The system sets the context_score to a lower value and marks recommended_use as exploratory_analysis instead of primary_confirmatory_evaluation. This mechanism prevents users from interpreting ranking results without external evaluation labels as strong performance evidence or direct treatment recommendations.

[0249] Example 8: Consistency Verification between Pre-calculation and Real-time Calculation

[0250] The system saves the pre-calculated sorting results for a specific analysis unit. When a user or downstream system requests real-time execution, the system regenerates the sorting results and calculates Jaccard@K and RBO. If the consistency is high, reliability_label = stable_result; if the consistency is low, the system checks version information, parameter settings, and candidate object space, and outputs requirements_review.

[0251] Example 9: Parameter Sensitivity Verification

[0252] The system runs or reads the algorithm results under default, strict, and lenient parameters respectively. If the candidate objects highly overlap in their sorting under different parameters, it outputs `stable_result`; if the highly sorted candidate objects change significantly, it outputs `parameter_sensitive_result` and records `sensitive_to_threshold` in `explanation_vector`.

[0253] Example 10: Structured output for different scenarios

[0254] The system encapsulates the evaluation results into structured objects. These objects can be read and displayed by an interactive interface, returned to external programs by an API, or used by a report generation program to create automated analysis reports. Because the structured objects are separated from the specific presentation method, this invention does not depend on any particular page or file format.

[0255] Example 11: Result Encapsulation Integrity Verification

[0256] The system generates a set of result objects based on downstream requests. If a module's result exists, its status is set to available; if it is generated by the system immediately, its status is set to generated; if it should exist but is not found, its status is set to missing; if the user did not request the module, its status is set to skipped. Downstream systems can determine the completeness of the results based on the status.

[0257] Example 12: Candidate drug space coordination among multiple drug ranking algorithms

[0258] The system reads the candidate algorithm registration objects of four candidate drug ranking algorithms. Three of these algorithms rely on drug perturbation signatures and each has 1,601 native candidate drugs, while one algorithm relies on a drug target network and has 4,383 native candidate drugs. The system normalizes the drug names and database identifiers, generating 577 common candidate drugs.

[0259] The system calculates the candidate_retention_ratio for each algorithm. The first three algorithms have a ratio of approximately 0.360, while the network algorithm has a ratio of approximately 0.132. Because the network algorithm has a lower common space retention ratio, the system maintains a candidate_space_low_retention warning in subsequent comparisons. The specific values ​​mentioned above are for illustrating one implementation method and do not limit the applicability of this invention to other numbers of candidate objects or other candidate space construction rules.

[0260] Example 13: Dual-track evaluation of native space and shared space

[0261] For analysis units with external reference labels, the system calculates NDCG@50, AUPRC, MRR, Precision@50, randomized Precision@50, precision_lift, Jaccard@50, and RBO in the native candidate drug space and the common candidate drug space, respectively.

[0262] In one practical implementation, some absolute evaluation metrics in the common space are higher than those in the original space, but the number of candidate drugs, positive label density, and random baseline also change simultaneously. The relative ranking of the network algorithm changes from a lower position in the original space to a higher position in the common space, while its average Jaccard@50 in the original / common space is approximately 0.078, and its average RBO is approximately 0.141. Based on this, the system outputs `candidate_space_sensitive` and `candidate_space_restriction_effect` instead of `algorithm_improved`.

[0263] This embodiment illustrates that the present invention can automatically identify whether the algorithm comparison results are affected by changes in the candidate object space, and generate technical constraint information for the interpretation of indicators.

[0264] Example 14: Independent numerical correctness verification of four types of candidate algorithms

[0265] The system constructs manual testing and analysis units for four types of algorithms: correlation inversion, rank enrichment, weighted vector similarity, and network propagation. The correlation test includes perfectly aligned and perfectly reversed vectors; the rank enrichment test includes ideal inversion and ideal aligned sorting; the vector similarity test includes reversed vectors; and the network propagation test includes test networks with near-end and far-end candidate targets.

[0266] System call target implementation and independent reference implementation, and in 10 -10 As an example of error tolerance, all 7 preset cases passed; the maximum absolute error between the network propagation case and the independent reference implementation was less than 4.8 × 10⁻⁶. -15 The system outputs `implementation_validated` and saves the test input hash, target algorithm version, reference implementation version, error, and tolerance.

[0267] Example 15: Formal Result Freezing and Full Recalculation Verification

[0268] The system froze all candidate algorithm scores, candidate drug sets, external drug-disease references, evaluation parameters, and evaluation scripts. It then recalculated the native spatial indices for 1,354 algorithm-analysis unit evaluation combinations and compared them field-by-field with existing pre-calculated results. The maximum numerical difference between the recalculated results and the pre-calculated results was approximately 9.7 × 10⁻⁶.-17 If the value is below the preset tolerance, the system outputs recalculation_verified.

[0269] The system further generates a FROZEN_RESULT_MANIFEST that includes file role, file size, SHA-256 hash, generation time, and dependent inputs. Subsequent changes to the external reference, candidate space, or algorithm version will generate a new frozen version that does not overwrite the original frozen result.

[0270] Example 16: End-to-end processing of quality perception adaptation to credibility output

[0271] The system receives a transcriptome analysis unit containing case group, control group, and differential expression results. It generates a unit_identifier and calculates sample quality, differential signal quality, and input coverage for each candidate algorithm. For candidate algorithms that meet the hard input requirements and whose fit score reaches the threshold, the system creates a RUN task; for algorithms with input coverage within the restricted range, a RUN_WITH_WARNING task is created; for algorithms lacking necessary directional information or with insufficient mapping coverage, a BLOCK is recorded without performing formal candidate drug scoring.

[0272] The system reads the candidate drug set of the executed algorithm and maps LINCS perturbation signature candidate drugs and ChEMBL target-associated candidate drugs to a unified drug_id. The original candidate spaces of the three perturbation signature algorithms each contain 1,601 drugs, and the original candidate space of the network algorithm contains 4,383 drugs. Dynamic intersection yields 577 common candidate drugs. The system saves the original identifier, canonical identifier, mapping relationship, mapping rule version, and candidate list hash.

[0273] The system projects external positive drugs into its own native space and a common candidate drug space of 577 drugs, and calculates ranking evaluation indicators and random baselines. The candidate retention ratio of the three perturbation signature-based candidate algorithms is approximately 0.3604, and that of the network algorithm is approximately 0.1316. The average Jaccard@50 of the network algorithm in both the native and common spaces is approximately 0.078, and the average RBO is approximately 0.141, with changes in the relative ranking of the algorithms. Based on this, the system generates `candidate_space_sensitive`, `candidate_space_low_retention`, and `algorithm_order_changed`, while retaining the results in the native space and not interpreting an increase in the common space indicators as an improvement in algorithm performance.

[0274] The final structured evaluation result object simultaneously returns the unit_identifier, quality characterization, execution actions of each algorithm, original and common candidate space versions, dual-space metrics, candidate space sensitivity, credibility status, cause code, and version hash. This example demonstrates how quality status controls algorithm tasks, how candidate space limits evaluation objects, and how dual-track evaluation changes result interpretation, forming a complete computational processing closed loop.

[0275] Example 17: Exception handling for candidate object mapping conflicts and insufficient common space

[0276] When two candidate algorithms have candidate drugs with the same name but different names, one-to-many database mappings, or combination drugs that cannot be mapped to a single standard drug, the system marks the relevant records as conflicted or unmapped. If the common candidate space after excluding conflicting objects is less than the preset minimum number of candidates, the system does not perform a cross-algorithm common space performance comparison, outputs insufficient_shared_candidates, and sets the dual_space_evaluation_record status to BLOCKED.

[0277] Meanwhile, the candidate rankings of each algorithm in its own native space are still saved as their native versions, with the status set to AVAILABLE_NATIVE_ONLY. The structured result objects clearly distinguish between "the algorithm has no result" and "fair comparison was not performed due to insufficient candidate space", thereby preventing downstream programs from misinterpreting missing common space indicators as zero or algorithm failure.

[0278] It should be noted that this invention is preferably used for drug relocation algorithms based on omics differential signatures, but can also be used for gene set enrichment, disease subtyping, prognostic modeling, network propagation, candidate target screening, and multi-omics signature analysis. The scoring formula in this invention can be implemented using rule-based thresholding, weighted linear models, machine learning models, Bayesian models, or hybrid models. Features in this invention can come from database tables, calculation results, user-uploaded files, API inputs, or real-time intermediate calculation results. The structured evaluation result object in this invention can be saved as a database record, JSON, XML, TSV, message queue object, report object, or other machine-readable format. The candidate algorithm registration object in this invention can describe traditional statistical methods, machine learning methods, deep learning methods, network algorithms, or rule-based algorithms. The result credibility indicators in this invention can include Jaccard, RBO, Kendall, Spearman, MRR, AUPRC, AUROC, NDCG, precision_lift, or other consistency and ranking evaluation indicators. The link integrity evaluation and result encapsulation integrity verification in this invention are optional implementations and are not limited to implementation through specific interactive pages or specific file packages. The common candidate object space in this invention can be generated from the intersection of multiple native candidate spaces, a preset reference set, a subset of candidates that meet the coverage threshold, or other normalization rules. The sensitivity of the candidate space in this invention can be determined based on one or more of the following: changes in evaluation metrics, changes in random baselines, changes in algorithm ranking, the retention rate of candidate objects, Jaccard, RBO, Kendall correlation coefficient, or Spearman correlation coefficient. The independent reference implementation in this invention can be a third-party mathematical function library, an independently written reference algorithm, a verified software tool, or an analytical computation capable of providing the expected output relationship. The frozen result object in this invention can be implemented using a manifest file, a database snapshot, a container image, a workflow dependency graph, or other forms that can record the relationship between input and result versions.

[0279] The above embodiments are merely descriptions of preferred embodiments of the present invention and are not intended to limit the concept and scope of the present invention. Various modifications and improvements made to the technical solutions of the present invention by those skilled in the art without departing from the design concept of the present invention should fall within the protection scope of the present invention.

[0280] The technologies, shapes, and structures not described in detail in this invention are all known technologies.

Claims

1. A method for drug repositioning differential signature quality analysis and drug ensemble coordination, executed by computer equipment, characterized in that: Includes the following steps: (1) Obtain the differential feature analysis unit with sample grouping information and differential feature results, generate a unique identifier for the differential feature analysis unit, and extract sample grouping features, differential signal features and algorithm input features; (2) Generate quality representations and algorithm adaptation states corresponding to each candidate algorithm, and control the execution, restrict execution or block execution of candidate algorithms based on the algorithm adaptation states; (3) Generate the original candidate object space of each candidate algorithm; when there are at least two candidate algorithms, generate a common candidate object space based on the original candidate object spaces of at least two candidate algorithms; (4) Obtain the candidate object ranking results of one or more candidate algorithms based on the same differential feature analysis unit, and generate the native space evaluation results for each candidate algorithm in its native candidate object space; When a common candidate object space exists, the candidate object ranking results of at least two candidate algorithms are projected onto the common candidate object space, and a common space evaluation result is generated. (5) When there is a common candidate object space, compare the evaluation results of the original space and the evaluation results of the common space to generate the candidate space sensitivity state; When there is no common candidate object space, the candidate space sensitivity state is determined as an inapplicable state, and machine-readable reason code representing the inapplicability of the common candidate object space is generated. (6) Generate the result credibility state based on the quality characterization, algorithm adaptation state, and candidate space sensitivity state; (7) Output a structured evaluation result object associated with the unique identifier of the difference feature analysis unit, including at least the quality characterization, algorithm adaptation status, candidate space sensitivity status, and result credibility status.

2. The method according to claim 1, characterized in that, In step (1), the generation of missing risk status is also included, specifically: normalization and missing labeling are performed on the extracted features, and different missing risk statuses are generated according to whether the missing fields affect quality calculation, algorithm input construction or candidate object evaluation; Sample grouping features include the smallest group number of samples and inter-group balance; differential signal features include one or more of the following: number of effective features, number of significant features, significant proportion, and directional balance; algorithm input features include one or more of the following: feature space coverage, input directional integrity, cross-species or cross-platform mapping coverage, and network node coverage. The differential signature results were derived from transcriptome differential signatures.

3. The method according to claim 1, characterized in that, In step (2), the generation of the algorithm adaptation state corresponding to each candidate algorithm is specifically as follows: the quality characterization of the difference feature analysis unit is generated based on the sample grouping characteristics and difference signal characteristics; a candidate algorithm registration object is established for each candidate algorithm; the candidate algorithm registration object records the input requirements, feature space requirements and adaptation threshold; the algorithm input features are matched with the candidate algorithm registration object to generate the algorithm adaptation state corresponding to each candidate algorithm. Step (2) also includes the generation of evaluation context state, noise or variability risk state, specifically: generating evaluation context state based on the number of external validation labels, positive object density, external reference sources and pre-recorded native candidate object spatial information in the candidate algorithm registration objects; generating noise or variability risk state based on one or more of the following: sample size, intergroup balance, differential signal, platform information and cross-species or cross-platform mapping coverage. The evaluation context state is used to assist in generating the result confidence state, and the evaluation context state, noise or variability risk state are written into the structured evaluation result object in step (7); Quality characterization includes one or more of the following: sample quality score, differential signal quality score, algorithm input quality score, evaluation context quality score, or comprehensive quality score; The candidate algorithm registration object also records the algorithm identifier, algorithm version, input structure, output structure, candidate object space, candidate object identifier namespace, parameter configuration, and failure conditions; Algorithm adaptation states include executable, restricted executable, and non-executable; when restricted executable or non-executable, the structured evaluation result object records the unmet input conditions and corresponding reason codes.

4. The method according to claim 1, characterized in that, In step (3), the generation of the native candidate object space of each candidate algorithm is specifically as follows: for one or more candidate algorithms in an executable or restricted execution state, read the candidate object set and candidate object identifier namespace corresponding to each candidate algorithm, perform identifier normalization through candidate object identifier mapping rules, and generate the native candidate object space of each candidate algorithm. Candidate object identifier mapping rules include one or more of the following: name normalization, synonym merging, database identifier conversion, duplicate object merging, and unmappable object tagging; The common candidate object space is generated from the intersection of multiple original candidate object spaces, a preset reference candidate set, or a subset of candidate objects that meet the preset algorithm coverage conditions; Candidates include candidate drugs, candidate compounds, candidate targets, candidate pathways, or candidate intervention methods.

5. The method according to claim 1, characterized in that, In step (4), during the process of generating the original space evaluation result and generating the common space evaluation result when there is a common candidate object space, the difference feature analysis unit, the external reference set and the evaluation function are kept consistent. The original spatial evaluation results, as well as the shared spatial evaluation results generated when there is a shared candidate object space, include the random baseline and one or more of Hit@K, Precision@K, Recall@K, NDCG@K, MRR and AUPRC; where K represents the number of the top K candidate objects included in the evaluation in the candidate object ranking results; In step (5), the generation of the candidate space sensitivity state is based on the candidate object retention ratio, the change of evaluation index, the change of the relative order of the algorithm, and one or more of the Jaccard, RBO, Kendall correlation coefficient or Spearman correlation coefficient.

6. The method according to claim 1, characterized in that, In step (6), when the quality characterization or algorithm adaptation status does not meet the preset conditions, or when the candidate space sensitivity status indicates that the candidate object ranking result is affected by the candidate object space, the corresponding restricted use status and machine-readable reason code are generated. When the candidate space sensitivity state is an inapplicable state, the result credibility state is generated based on the quality characterization and algorithm adaptation state, and the inapplicability of the candidate space sensitivity state and its machine-readable reason code are recorded in the result credibility state. The result confidence status is generated based on one or more of the following methods: The pre-calculated ranking results in the database are compared with the ranking results calculated in real time for the same difference feature analysis unit. Based on the Top-K overlap or ranking correlation, a consistency status between the pre-calculated and real-time calculations is generated. The consistency status between the pre-calculated and real-time calculations is used to assist in generating the credibility status of the results. Change one or more of the differential feature screening threshold, the number of input features, or the candidate algorithm parameters, compare the candidate object ranking results before and after parameter perturbation, and generate parameter stability state. The parameter stability state is used to assist in generating the result credibility state. A test analysis unit with expected output relationship is constructed. The target implementation output of the candidate algorithm is compared with the independent reference implementation output. The implementation verification status is generated based on numerical error, directional consistency or sorting consistency. The implementation verification status is used to assist in generating the result credibility status. The implementation verification record includes test analysis unit identifier, target algorithm version, reference implementation version, test input hash, error tolerance and error result. The system generates version identifiers and hashes for input data, candidate object space, candidate algorithms, parameters, external references, and computation results. It also generates a recalcible state for the results by freezing the input and recalculating the results. The recalcible state of the results is used to assist in generating a confidence state for the results.

7. The method according to claim 1 or 3, characterized in that, In step (7), the structured evaluation result object also includes the original candidate object space identifier and version information; when there is a common candidate object space, the structured evaluation result object also includes the common candidate object space identifier; when there is no common candidate object space, the structured evaluation result object also includes the inapplicable state and its machine-readable reason code. The structured evaluation results also include the analysis link integrity status generated based on the information of the difference feature analysis unit, the difference feature results, the algorithm adaptation status, the candidate object ranking results, and the connectability status between external references.

8. A drug repositioning differential signature quality analysis and drug portfolio coordination system, characterized in that, Configured to perform the drug repositioning differential signature quality analysis and drug portfolio coordination method according to any one of claims 1-7, comprising: The analysis unit identification and feature extraction module is used to identify differential feature analysis units from differential analysis results, sample grouping information and data source information, generate unique identifiers and version information, and extract sample grouping features, differential signal features and algorithm input features, and perform normalization, missing value marking and outlier processing. The quality-aware algorithm adaptation determination module is used to generate quality representations and algorithm adaptation states based on extracted features and candidate algorithm registration objects, and to control the execution, restrict execution, or block execution of candidate algorithms based on the algorithm adaptation states. The quality-aware algorithm adaptation determination module is also used to generate evaluation context states based on the number of external verification labels, positive object density, external reference sources, and pre-recorded native candidate object spatial information in the candidate algorithm registration objects, and to generate noise or variability risk states based on one or more of the following: sample size, inter-group balance, differential signals, platform information, and downstream ranking stability. The candidate object identifier standardization module is used to map the candidate object identifiers corresponding to different algorithms to the candidate object identifier namespace according to the candidate object identifier mapping rules, and record the synonym, one-to-many mapping, unmapped and conflicting mapping status. The candidate object set coordination and spatial evaluation module is used to generate the original candidate object space of each candidate algorithm, and to generate a common candidate object space when there are at least two candidate algorithms; it is used to generate original spatial evaluation results in the original candidate object spaces of each candidate algorithm, and to generate a common spatial evaluation result when a common candidate space exists. The candidate object set sensitivity determination module is used to generate a candidate space sensitivity state when a common candidate object space exists, based on the candidate object retention ratio, changes in evaluation indicators, changes in the relative order of algorithms, and at least one of Jaccard, RBO, Kendall correlation coefficient, or Spearman correlation coefficient; and to generate a candidate space sensitivity inapplicability state and corresponding machine-readable reason code when a common candidate object space does not exist. The structured credibility output module is used to generate and output a structured evaluation result object associated with the unique identifier of the differential feature analysis unit. The structured evaluation result object includes the original candidate object space identifier, and includes the common candidate object space identifier when there is a common candidate object space, or includes the inapplicable status and the corresponding machine-readable reason code when there is no common candidate object space. The auxiliary verification module is used to perform one or more of the following operations: comparing the pre-calculated sorting results in the database with the real-time calculated sorting results to generate a consistency state between pre-calculation and real-time calculation; changing the difference feature screening threshold, the number of input features, or the parameters of the candidate algorithm to generate a parameter stability state; constructing a test analysis unit with the expected output relationship, comparing the target implementation output of the candidate algorithm with the independent reference implementation output to generate an implementation verification state; generating version identifiers and hashes for the input data, candidate object space, candidate algorithm, parameters, external references, and calculation results, and generating a recalcible state for the results by freezing the input and recalculating; the consistency state between pre-calculation and real-time calculation, the parameter stability state, the implementation verification state, and the recalcible state for the results are used to assist in generating a credibility state for the results.

9. An electronic device, characterized in that, It includes a processor and a memory, wherein the memory stores a computer program that, when executed by the processor, implements the method of any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, It stores a computer program thereon, which, when executed by a processor, implements the method of any one of claims 1 to 7.

Images