Technical demand-oriented expert and team intelligent matching method and system

Abstract

The invention discloses an expert and team intelligent matching method and system oriented to technical requirements, and belongs to the technical field of natural language processing. The method aims at solving the problems that according to an existing scheme, retrieval precision and recall rate are contradictory, single corpus is limited, team synthesis ability is lacked, and interpretability is insufficient. The method comprises the following steps: processing paper and patent data in a cross-domain manner, and constructing vectors, keyword indexes and a heterogeneous knowledge graph; executing cross-domain name disambiguation to obtain a unified expert entity; performing three-mode parallel retrieval and adaptive fusion sorting; sorting comprehensive scores of experts; performing multi-constraint team synthesis optimization; and generating a recommendation explanation containing the evidence number. The system comprises eight core modules. The method is excellent in retrieval performance, accurate in disambiguation, capable of supporting intelligent team synthesis, high in interpretability and suitable for talent discovery and scientific research transformation scenes.

Description

Technical Field

[0001] This application belongs to the field of natural language processing technology and discloses an intelligent matching method and system for experts and teams oriented towards technical needs. Background Technology

[0002] In the fields of natural language processing, information retrieval, and data mining, accurately identifying paper authors is a fundamental and crucial task in applications such as academic literature retrieval, researcher evaluation, and academic collaboration network analysis. With the rapid development of academic research, the number of research papers is growing exponentially, posing numerous challenges to author identification: different researchers may share the same name, especially prevalent in Chinese; researchers may change employers during their careers, resulting in different affiliations for papers published by the same author at different times; paper metadata may contain quality issues such as spelling errors and inconsistent formatting; and modern research involves increasing interdisciplinary collaboration, meaning the same author may publish papers in different academic fields.

[0003] Existing intelligent matching methods for experts and teams based on technical needs have significant shortcomings: some methods use multi-feature weighted similarity and threshold merging, lacking consideration for the directionality and time decay of collaborator relationships, and failing to design a specific identification mechanism for changes in work unit; some methods employ a two-stage clustering strategy, with the first stage based on collaborator relationship graph similarity and AP clustering, and the second stage based on inter-cluster semantic similarity of document vectors, and adopt a conservative strategy of "not merging different schools," affecting the recall rate of authors who have changed work units; some methods prioritize email consistency, combining similarity of institutions, disciplines, co-authorship networks, and citation relationships, but lack a hard constraint mechanism in the time dimension, resulting in poor performance in sparse data scenarios; and some methods use Chinese-to-English name conversion rules combined with TF-IDF features and classifiers, failing to fully utilize the structural information of collaborator networks and insufficiently considering scenarios involving changes in work unit.

[0004] Therefore, the urgent technical problem to be solved is to improve the accuracy and recall of disambiguation of authors with the same name, especially to accurately identify cases where authors have changed their work units, given only abstracts and metadata. Summary of the Invention

[0005] This application provides an intelligent matching method and system for experts and teams based on technical needs, which solves the problem of improving the disambiguation accuracy and recall rate of authors with the same name under the condition of only having abstracts and metadata, especially accurately identifying the situation of authors changing their work units, as follows.

[0006] On the one hand, a method for intelligently matching experts and teams based on technical needs, the method comprising: S1. Obtain paper and patent data, perform segmented vectorization processing on the data, and construct a keyword inverted index. S2 extracts entities and relationships from paper and patent data to construct a heterogeneous knowledge graph containing nodes of experts, papers, patents, institutions, and classification numbers. S3 performs cross-domain name disambiguation on paper authors and patent inventors, merging them to obtain a unified expert entity; S4 receives user technical requirements, parses and extracts elements from the requirements, and then performs semantic retrieval, keyword retrieval, and knowledge graph retrieval in parallel. S5 extracts query features and retrieval result features, dynamically adjusts the weights of the three retrieval results through a learnable gating function, and merges and sorts the retrieval scores; S6: Aggregate the hit documents after fusion and ranking to the corresponding unified expert entity, calculate the expert comprehensive score and complete the ranking; S7, based on the capability coverage requirements of technical needs and the historical collaboration relationships among experts, solves the team composition optimization problem with institutional constraints and conflict of interest constraints to obtain the optimal technical team; S8 extracts evidence fragments aligned with the required elements from the hit literature and assigns them unique numbers. It then generates recommended explanations containing the evidence numbers using a large language model and outputs expert ranking results, the best technical team, and the recommended explanations.

[0007] Optionally, the step of acquiring paper and patent data and performing segmented vectorization processing on the data includes: The paper and patent texts were divided into different text segments according to title, abstract and claims, and each text segment was encoded using a domain pre-trained model (SciBERT / PatentBERT); Key information is extracted through segmented pooling using an attention mechanism, and then multi-view vector representations are obtained through domain adaptive calibration.

[0008] Optionally, constructing the keyword inverted index includes: Built on the BM25 algorithm, it assigns different weights to the title, abstract, and claim fields, and supports technical term phrase matching and synonym expansion.

[0009] Optionally, the cross-domain name disambiguation of paper authors and patent inventors, merging them into a unified expert entity, includes: Canopy clustering was used for pre-screening, and the similarity of names, institutions, research topics, and time trajectories between entities was calculated. Accurate grouping is achieved through hierarchical clustering, and unified expert entities are obtained by merging. The name similarity is calculated by combining edit distance and pinyin similarity, and the comprehensive similarity formula is as follows: ,in , For entities and The overall similarity between them For the two entities to be compared, Weighting for name similarity. For institutional similarity weights, As a weight for topic similarity, For time similarity weight, The score represents the similarity between the names. For institutional similarity scores, The theme similarity score, This represents the time similarity score.

[0010] Optionally, the learnable gating function dynamically outputs weights based on the resulting features, wherein the weights satisfy the following conditions: The formula for the fusion fraction is: ,in The combined score is the final score after merging. For semantic retrieval weights based on query q, To determine the keyword retrieval weight based on query q, For graph retrieval weights based on query q, For semantic retrieval score, Keyword search score, The score is the knowledge graph retrieval score, and q represents the user query.

[0011] Optionally, the step of aggregating the merged and ranked hit documents into the corresponding unified expert entity, calculating the expert comprehensive score, and completing the ranking includes: The expert comprehensive score is calculated based on a weighted average of six indicators: maximum semantic score, number of documents covered, recent activity level, citation impact, patent claim matching strength, and cross-domain consistency. The expert comprehensive score formula is as follows: , , Based on the comprehensive score from experts, Let i be the weight of the i-th indicator. Let i be the normalization function for the i-th indicator, where i is the indicator index, and 1-6 correspond to the maximum semantic score, the number of documents covered, the recent activity level, the citation impact, the patent claim matching strength, and the cross-domain consistency, respectively. The LambdaMART learning sorting algorithm was used to complete the final sorting.

[0012] Optionally, in the process of solving the team composition optimization problem containing institutional constraints and conflict of interest constraints, the objective function of the team composition optimization is: ,in, For capability coverage weight, As a weight for the strength of cooperation, Weighting by team size Weighting for communication costs, The score represents the team's capability coverage. The score represents the intensity of teamwork. Penalty based on team size The team communication cost score is subject to the following constraints. , Let be a binary decision variable, representing whether expert i is selected, and n be the total number of candidate experts. To limit the maximum team size, 0 and 1 represent binary constraints. Take 0 or 1.

[0013] Optionally, the relevance of the evidence fragment to the demand element is calculated using a vector dot product, wherein the formula for evidence relevance is: For evidence fragments With query elements The correlation score Let be the vector representation of the i-th piece of evidence. Let be the vector representation of the j-th query element, where the explanation quality score is expressed as . , where n is the total number of statements in the explanation. This indicates whether the i-th statement contains evidence references (1 indicates it contains, 0 indicates it does not). This represents the total number of statements that include evidence citations.

[0014] On the other hand, a technology-demand-oriented intelligent matching system for implementing the above-described method is provided, the system comprising: The data preprocessing module is used to acquire paper and patent data and perform preprocessing operations such as text segmentation, word segmentation, and cleaning. The vectorization and indexing module is used to perform segmented vectorization and domain adaptive calibration on the preprocessed text, and to build a keyword inverted index. The knowledge graph construction module is used to extract entities and relationships, and to build and maintain heterogeneous knowledge graphs. The name disambiguation module is used to perform cross-domain name disambiguation between paper authors and patent inventors, and output a unified expert entity. The three-modal retrieval and fusion module is used to analyze technical requirements, execute three retrieval methods in parallel, and fuse and sort them through a gating function. The expert ranking module is used to aggregate the hit documents into expert entities, calculate the comprehensive score, and rank them. The team synthesis module is used to solve multi-objective team optimization problems and generate the optimal technical team. The explanation generation module is used to extract evidence fragments and generate recommended explanations containing evidence numbers using a large language model.

[0015] On the other hand, a computer-readable storage medium is also provided, which stores a computer program that, when executed by a processor, implements the aforementioned intelligent matching method for experts and teams based on technical needs. Attached Figure Description

[0016] Figure 1 This is a flowchart of the overall system of the present invention; Figure 2 This is a flowchart of the three-modal fusion process of the present invention; Figure 3 This is a flowchart illustrating the synthesis and optimization process of the invention team. Detailed Implementation

[0017] To make the objectives, technical solutions, and advantages of this application clearer, the embodiments of this application will be described in further detail below with reference to the accompanying drawings.

[0018] In this article, "multiple" refers to two or more. "And / or" describes the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A alone, A and B simultaneously, or B alone. The character " / " generally indicates that the preceding and following related objects have an "or" relationship.

[0019] The intelligent matching method and system for experts and teams based on technical needs described in this application will be explained in detail below through specific embodiments, wherein... Figure 1 This is a flowchart of the overall system of the present invention; Figure 2 This is a flowchart of the three-modal fusion process of the present invention; Figure 3 This is a flowchart illustrating the synthesis and optimization process of the invention team.

[0020] Example 1 On the one hand, a method for intelligently matching experts and teams based on technical needs, the method comprising: S1: Obtain paper and patent data, perform segmented vectorization of the data, and construct a keyword inverted index.

[0021] A multi-perspective encoding strategy is employed to vectorize different types of text content (titles, abstracts, and claims) separately. Then, segmented pooling is used to extract key information, and finally, domain-adaptive calibration is performed to ensure the comparability of vector representations from different sources within the same semantic space. This multi-perspective processing approach better captures the hierarchical semantic information of the text, providing high-quality vector representations for subsequent semantic retrieval.

[0022] Optionally, acquire paper and patent data, and perform segmented vectorization processing on the data, including: The paper and patent texts were divided into different text segments according to title, abstract and claims, and each text segment was encoded using a domain pre-trained model (SciBERT / PatentBERT); Key information is extracted through segmented pooling using an attention mechanism, and then multi-view vector representations are obtained through domain adaptive calibration.

[0023] Specifically, the algorithm is implemented as follows: 1 defmulti_view_vectorization(text_segments,domain_model): 2 """ 3. Segment and encode the paper / patent text. 4 Args: 5. text_segments: Text segmentation [title, abstract, claims] 6. domain_model: Domain model (SciBERT / PatentBERT) 7 Returns: 8. multi_view_vectors: Multi-view vector representation 9 """ 10 vectors={} 11 12 # Segmentation Coding 13 forsegment_type, textintext_segments.items(): 14 # Encoding using a domain model 15 encoded=domain_model.encode(text) 16 # Segmented Pooling 17 pooled=segment_pooling(encoded) 18 vectors[segment_type]=pooled 19 20 # Domain Adaptive Calibration 21 calibrated_vectors=domain_adaptation(vectors) twenty two 23 return calibrated_vectors twenty four 25 defsegment_pooling(encoded_text): 26 """Segmented Pooling Operation""" 27 # Using attention mechanisms for pooling 28 attention_weights=softmax(linear_layer(encoded_text)) 29 pooled=torch.sum(encoded_text*attention_weights,dim=1) 30 returnpooled Segmented pooling: , in , : The vector representation after piecewise pooling n: Number of segments Attention weights for the i-th segment. : The vector representation of the i-th segment W: Linear transformation weight matrix, Domain adaptive calibration: , in, : The calibrated vector representation : Primitive vector representation Calibration intensity parameters, : The reference vector of the target domain : The reference vector of the source domain.

[0024] Optionally, construct a keyword inverted index, including: Built on the BM25 algorithm, it assigns different weights to the title, abstract, and claim fields, and supports technical term phrase matching and synonym expansion.

[0025] Specifically, the keyword index uses the BM25 algorithm to build a high-efficiency inverted index, supporting traditional keyword retrieval. This module first segments and preprocesses documents, then assigns different weights to different fields (title, abstract, claims), creating field-level inverted indexes. The BM25 algorithm effectively handles factors such as term frequency, document frequency, and document length, providing more accurate retrieval results than traditional TF-IDF. This module also maintains a technical terminology dictionary and a classification number dictionary, supporting phrase matching and synonym expansion to ensure high recall and precision in keyword retrieval.

[0026] 1 defbuild_bm25_index(documents,field_weights): 2 """ 3. Construct the BM25 inverted index 4 Args: 5 documents: a collection of documents 6. field_weights: Field weights {'title': 2.0, 'abstract': 1.5, 'claims': 1.0} 7 Returns: 8. inverted_index: inverted index 9 """ 10 inverted_index={} 11 doc_lengths={} 12 13 fordoc_id,docindocuments.items(): 14 doc_lengths[doc_id]=0 15 16 forfield,textindoc.items(): 17 #Word segmentation and preprocessing 18 terms=tokenize_and_preprocess(text) 19 weight=field_weights.get(field,1.0) 20 21 forterminterms: 22 iftermnotininverted_index: 23 inverted_index[term]={} twenty four 25 if doc_id not in inverted_index[term]: 26 inverted_index[term][doc_id] = 0 27 28 inverted_index[term][doc_id] += weight 29 doc_lengths[doc_id] += weight 30 31 return inverted_index, doc_lengths 32 33 def bm25_score(query_terms, doc_id, inverted_index, doc_lengths, k1 = 1.2, b = 0.75): 34 """Calculate BM25 score""" 35 score = 0 36 avg_doc_length = sum(doc_lengths.values()) / len(doc_lengths) 37 38 for term in query_terms: 39 if term in inverted_index and doc_id in inverted_index[term]: 40 tf = inverted_index[term][doc_id] 41 df = len(inverted_index[term]) 42 idf = math.log(len(doc_lengths) / df) 43 44 # BM25 formula 45 score += idf * (tf * (k1 + 1)) / (tf + k1 * (1 - b + b * doc_lengths[doc_id] / avg_doc_length)) 46 47 return score BM25 score: , where : Query the BM25 score of document D for Q. n: Number of query terms Inverse document frequency of the i-th query term. The frequency of word $q_i$ in document D. K1: Term frequency saturation parameter (usually set to 1.2-2.0). b: Document length normalization parameter (usually set to 0.75). |D|: The length of document D, avgdl: The average length of all documents in the corpus. Inverse document frequency: , in: : word q i Inverse document frequency, N: Total number of documents in the corpus : Contains word q i The number of documents.

[0027] S2 extracts entities and relationships from paper and patent data to construct a heterogeneous knowledge graph containing nodes of experts, papers, patents, institutions, and classification numbers.

[0028] The knowledge graph construction module is responsible for extracting entities and relationships from paper and patent data to build a heterogeneous knowledge graph. This graph contains various types of entity nodes (experts, papers, patents, institutions, classification numbers, etc.) and various types of relationship edges (author relationships, citation relationships, institution relationships, etc.). The module employs entity recognition and relationship extraction technologies to automatically extract structured information from unstructured text, and then organizes this information into a knowledge graph using graph construction algorithms. This graph supports semantically expanded subgraph walks and path matching, enabling the discovery of implicit connections between entities and providing rich semantic information for graph retrieval.

[0029] 1 defbuild_heterogeneous_kg(papers,patents): 2 """ 3. Constructing Heterogeneous Knowledge Graphs 4 Args: 5 papers: Paper data 6 patents: Patent data 7 Returns: 8 kg: Knowledge Graph Objects 9 """ 10 kg = HeterogeneousGraph() 11 12 # Add entity nodes 13 for paper in papers: 14 kg.add_node('Paper', paper['id'], paper['attributes']) 15 for author in paper['authors']: 16 kg.add_node('Expert', author['id'], author['attributes']) 17 kg.add_edge('Expert', 'Paper', 'Authored', {'weight': 1.0}) 18 19 for patent in patents:[[ID=2|1]] 20 kg.add_node('Patent', patent['id'], patent['attributes']) 21 for inventor in patent['inventors']: 22 kg.add_node('Expert', inventor['id'], inventor['attributes']) 23 kg.add_edge('Expert', 'Patent', 'Invented', {'weight': 1.0}) 24[[ID=|31]] 25 # Add citation relationships 26 add_citation_relationships(kg, papers, patents) 27 28 # Add affiliation relationships 29 add_affiliation_relationships(kg, papers, patents) 30 31 return kg 32 33 defgraph_walk_search(query_elements,kg,max_depth=3): 34 """Graph Walking Search""" 35 relevant_nodes=set() 36 37 forelementinquery_elements: 38 # Found relevant nodes 39 element_nodes=kg.find_nodes_by_semantic(element) 40 41 fornodeinelement_nodes: 42 # Perform a random walk 43 walk_paths=random_walk(node,kg,max_depth) 44 relevant_nodes.update(extract_documents_from_paths(walk_paths)) 45 returnlist(relevant_nodes) S3 performs cross-domain name disambiguation on paper authors and patent inventors, merging them to obtain a unified expert entity.

[0030] Optionally, cross-domain name disambiguation can be performed on the authors of the paper and the inventors of the patent, merging them into a unified expert entity, including: Canopy clustering was used for pre-screening, and the similarity of names, institutions, research topics, and time trajectories between entities was calculated. Accurate grouping is achieved through hierarchical clustering, and unified expert entities are obtained by merging. Name similarity is calculated by combining edit distance and pinyin similarity; the comprehensive similarity formula is as follows: ,in , For entities and The overall similarity between them For the two entities to be compared, Weighting for name similarity. For institutional similarity weights, As a weight for topic similarity, For time similarity weight, The score represents the similarity between the names. For institutional similarity scores, The theme similarity score, This represents the time similarity score.

[0031] Specifically, the name disambiguation and expert entity unification module is responsible for merging author and inventor information from two different fields—papers and patents—into a unified expert entity. This module employs a multi-stage disambiguation strategy: first, Canopy clustering is used for rapid pre-screening, grouping entities with high similarity together; then, multimodal feature similarity between entities is calculated, including name similarity, institutional similarity, research topic similarity, and time trajectory similarity; next, hierarchical clustering is used for precise grouping; finally, a small amount of manual verification ensures the quality of disambiguation. This cross-domain disambiguation method effectively solves the problems of different people with the same name and different names for the same person, providing accurate expert identity information for subsequent expert ranking and team synthesis.

[0032] 1 defcross_domain_name_disambiguation(authors,inventors): 2 """ 3. Cross-domain name disambiguation 4 Args: 5 authors: List of authors of the paper 6 inventors: List of patent inventors 7 Returns: 8 unified_experts: Unified expert entities 9 """ 10 #Step 1: Canopy Clustering Pre-screening 11 canopies=canopy_clustering(authors+inventors,threshold=0.8) 12 13 unified_experts=[] 14 15 forcanopyincanopies: 16 # Step 2: Feature Similarity Calculation 17 similarity_matrix=compute_similarity_matrix(canopy) 18 19 #Step 3: Hierarchical Clustering 20 clusters=hierarchical_clustering(similarity_matrix,threshold=0.7) twenty one 22 # Step 4: Merging of Expert Entities 23 for clusterinclusters: 24 expert_entity=merge_expert_entities(cluster) 25 unified_experts.append(expert_entity) 26 27 returnunified_experts 28 29 defcompute_similarity_matrix(entities): 30 """Calculate the entity similarity matrix""" 31 n = len(entities) 32 similarity_matrix=np.zeros((n,n)) 33 34 foriinrange(n): 35 forjinrange(i+1,n): 36 # Multimodal feature similarity 37 name_sim=name_similarity(entities[i]['name'],entities[j]['name']) 38 org_sim=organization_similarity(entities[i]['org'],entities[j]['org']) 39 topic_sim=topic_similarity(entities[i]['topics'],entities[j]['topics']) 40 time_sim=temporal_similarity(entities[i]['timeline'],entities[j]['timeline']) 41 42 # Weighted Fusion 43 similarity=0.4*name_sim+0.3*org_sim+0.2*topic_sim+0.1*time_sim 44 similarity_matrix[i][j]=similarity_matrix[j][i]=similarity 45 46 returnsimilarity_matrix 47 48 defname_similarity(name1,name2): 49 """Name Similarity Calculation""" 50 # Using edit distance and pinyin similarity 51 edit_dist=levenshtein_distance(name1,name2) 52 pinyin_sim=pinyin_similarity(name1,name2) 53 54 return0.7*(1-edit_dist / max(len(name1),len(name2)))+0.3*pinyin_sim S4 receives user technical requirements, parses and extracts elements from the requirements, and then performs semantic retrieval, keyword retrieval, and knowledge graph retrieval in parallel.

[0033] S5 extracts query features and retrieval result features, dynamically adjusts the weights of the three retrieval results through a learnable gating function, and merges and sorts the retrieval scores.

[0034] Optionally, the learnable gating function can dynamically output weights based on the resulting features, where the weights satisfy the following conditions: The formula for the fusion fraction is: ,in The combined score is the final score after merging. For semantic retrieval weights based on query q, To determine the keyword retrieval weight based on query q, For graph retrieval weights based on query q, For semantic retrieval score, Keyword search score, The score is the knowledge graph retrieval score, and q represents the user query.

[0035] Gated networks: W: Weight matrix of the gated network f(q): The feature vector of query q b: Bias vector of the gated network (): softmax activation function Specifically, the trimodal parallel retrieval and fusion ranking module is the core retrieval engine of the system. It utilizes three different retrieval methods—semantic retrieval, keyword retrieval, and knowledge graph retrieval—and then adaptively fuses them through a learnable gating network. This module first identifies the user query's intent and extracts elements, then executes the three retrieval methods in parallel: semantic retrieval uses vector similarity calculation to find semantically relevant documents; keyword retrieval uses the BM25 algorithm to find documents containing the query keywords; and knowledge graph retrieval uses subgraph walks to find documents related to the query elements. Finally, the gating network dynamically adjusts the weights of the three retrieval methods based on query features (length, proper noun density, ambiguity, etc.) and result features (paragraph matching confidence, neighborhood distance, graph path confidence, etc.) to achieve adaptive fusion ranking.

[0036] 55 defthree_modal_parallel_search(query,vector_index,keyword_index,kg): 56 """ 57. Trimodal Parallel Search 58 Args: 59 query: User query 60 vector_index: vector index 61 keyword_index: Keyword index 62 kg: Knowledge Graph 63 Returns: 64 semantic_results: semantic search results 65 keyword_results: Keyword search results 66 graph_results: Graph search results 67 """ 68 # Semantic Search 69 query_vector=encode_query(query) 70 semantic_results=vector_index.search(query_vector,top_k=100) 71 72 #Keyword Search 73 query_terms=extract_keywords(query) 74 keyword_results=keyword_index.search(query_terms,top_k=100) 75 76 #Graphic Retrieval 77 query_elements=extract_query_elements(query) 78 graph_results=graph_walk_search(query_elements,kg) 79 80 returnsemantic_results,keyword_results,graph_results 81 82 defadaptive_fusion_scoring(semantic_results,keyword_results,graph_results,query_features): 83 """ 84 Adaptive Fusion Scoring 85 Args: 86 semantic_results: semantic search results 87 keyword_results: Keyword search results 88 graph_results: Graph search results 89 query_features: query features 90 Returns: 91 fused_scores: the scores after fusion 92 """ 93 #Gated Network Prediction Weights 94 gate_network=GateNetwork(input_dim=len(query_features)) 95 alpha,beta,gamma=gate_network(query_features) 96 97 # Ensure the weight sum is 1 98 total_weight=alpha+beta+gamma 99 alpha = alpha / total_weight 100 beta = beta / total_weight 101 gamma = gamma / total_weight 102 103 # Fusion Score 104 fused_scores={} 105 all_docs=set(semantic_results.keys())|set(keyword_results.keys())|set(graph_results.keys()) 106 107 fordoc_idinall_docs: 108 sem_score=semantic_results.get(doc_id,0) 109 kw_score=keyword_results.get(doc_id,0) 110 kg_score=graph_results.get(doc_id,0) 111 112 fused_score=alpha*sem_score+beta*kw_score+gamma*kg_score 113 fused_scores[doc_id]=fused_score 114 115 returnfused_scores S6 aggregates the merged and ranked hit documents into the corresponding unified expert entity, calculates the expert comprehensive score, and completes the ranking.

[0037] Optionally, the merged and ranked hit documents are aggregated to the corresponding unified expert entity, and an expert comprehensive score is calculated and ranked, including: The expert comprehensive score is calculated based on a weighted average of six indicators: maximum semantic score, number of documents covered, recent activity level, citation impact, patent claim matching strength, and cross-domain consistency. The expert comprehensive score formula is as follows: , , Based on the comprehensive score from experts, Let i be the weight of the i-th indicator. Let be the normalization function for the i-th indicator, where i is the indicator index, and 1-6 correspond to the maximum semantic score, number of documents covered, recent activity, citation impact, patent claim matching strength, and cross-domain consistency, respectively. The LambdaMART learning sorting algorithm was used to complete the final sorting.

[0038] Specifically, the expert extraction and ranking module is responsible for aggregating the retrieved documents to corresponding expert entities and calculating the experts' comprehensive scores. This module first aggregates the matched documents according to expert entities, then calculates multiple indicators for each expert: maximum semantic score reflects the expert's highest match degree on the query topic; document coverage reflects the expert's activity level in the field; recent activity reflects the expert's timeliness; citation impact reflects the influence of the expert's research results; patent claim matching strength reflects the practicality of the expert's technical solutions; and cross-domain consistency reflects the consistency of the expert's performance in both the paper and patent fields. Finally, a learning-based ranking algorithm (such as LambdaMART) is used to comprehensively score and rank these indicators, resulting in the final expert recommendation list.

[0039] 1 defexpert_comprehensive_scoring(hit_documents,expert_entities): 2 """ 3. Expert Overall Score 4 Args: 5 hit_documents: hit documents 6. expert_entities: expert entities 7 Returns: 8 expert_scores: expert scores 9 """ 10 expert_scores={} 11 12 forexpert_id,expertinexpert_entities.items(): 13 # Calculate various indicators 14 max_semantic_score=max([doc['semantic_score']fordocinexpert['documents']]) 15 document_coverage=len(expert['documents']) 16 recent_activity = calculate_recent_activity(expert['timeline']) 17 citation_impact = calculate_citation_impact(expert['documents']) 18 patent_claim_match = calculate_patent_match(expert['patents']) 19 cross_domain_consistency = calculate_cross_domain_consistency(expert) 20 21 # Comprehensive scoring function 22 expert_score = g_function( 23 max_semantic_score = max_semantic_score, 24 document_coverage = document_coverage, 25 recent_activity = recent_activity, 26 citation_impact = citation_impact, 27 patent_claim_match = patent_claim_match, 28 cross_domain_consistency = cross_domain_consistency 29 ) 30 31 expert_scores[expert_id] = expert_score 32 33 return expert_scores 34 35 def g_function(**kwargs): 36 """Comprehensive function for expert scoring""" 37 weights = { 38'max_semantic_score': 0.25, 39 'document_coverage':0.20, 40 'recent_activity':0.15, 41 'citation_impact':0.15, 42 'patent_claim_match':0.15, 43 'cross_domain_consistency':0.10 44} 45 46 score=0 47 forkey,valueinkwargs.items(): 48 normalized_value=normalize_score(value,key) 49 score+=weights[key]*normalized_value 50 51 returnscore 52 53 deflearning_to_rank_training(expert_features,relevance_labels): 54 """Learning to sort""" 55 # Using the LambdaMART algorithm 56 ranker=LambdaMART() 57 ranker.fit(expert_features,relevance_labels) 58 returnranker S7 solves the team composition optimization problem with institutional constraints and conflict of interest constraints based on the capability coverage requirements of technical needs and the historical collaboration relationships among experts, and obtains the optimal technical team.

[0040] Optionally, in solving the team composition optimization problem with institutional constraints and conflict of interest constraints, the objective function of team composition optimization is: ,in, This is the capability coverage weight (usually set to 0.4). This is the weight for the cooperation strength (usually taken as 0.3). The team size is weighted (usually set to 0.2). The communication cost is weighted (usually set to 0.1). The score represents the team's capability coverage. The score represents the intensity of teamwork. Penalty based on team size (team size * 0.1). The team communication cost score is subject to the following constraints. , Let be a binary decision variable, representing whether expert i is selected, and n be the total number of candidate experts. To limit the maximum team size, 0 and 1 represent binary constraints. Take 0 or 1.

[0041] The team synthesis module is one of the system's innovative highlights. Based on expert ranking, it automatically synthesizes the optimal technical team according to technical requirements. This module first converts the user's technical requirements into a capability vector and a coverage list, then solves a multi-objective combinatorial optimization problem on the expert candidate set. Optimization objectives include: maximizing capability coverage to ensure the team can meet all technical requirements; maximizing historical collaboration strength by prioritizing expert combinations with collaborative experience; minimizing team size and controlling team costs; and minimizing communication costs, considering geographical distance and language barriers. Constraints include: requirements for institutional homogeneity or heterogeneity, geographical distribution requirements, expert availability, and conflict of interest avoidance. This module uses optimization algorithms such as Integer Linear Programming (ILP) or Large-Scale Neighborhood Search (LNS) to solve the problem and can incorporate graph neural networks such as GraphSAGE to predict new collaborations.

[0042] 1 defteam_synthesis_optimization(expert_candidates,requirements,constraints): 2 """ 3. Team Synthesis Optimization 4 Args: 5 expert_candidates: Expert candidate set 6 requirements: demand elements 7. Constraints: Conditions 8 Returns: 9 optimal_team: the best team 10 """ 11 # Constructing Capability Vectors 12 capability_vector=build_capability_vector(requirements) 13 14 # Define the optimization objective 15 def objective_function(team): 16 coverage_score = calculate_capability_coverage(team, capability_vector) 17 cohesion_score = calculate_team_cohesion(team) 18 size_penalty = len(team) * 0.1 19 comm_cost = calculate_communication_cost(team) 20 21 return lambda1 * coverage_score + lambda2 * cohesion_score - lambda3 * size_penalty - lambda4 * comm_cost 22 23 # Constraints 24 def constraint_function(team): 25 constraints_satisfied = 1 26 27 # Organization constraints 28 if not check_organization_constraints(team, constraints['org_constraints']): 29 constraints_satisfied = 0 30 31 # Geographic constraints 32 if not check_geographic_constraints(team, constraints['geo_constraints']): 33 constraints_satisfied = 0 34 35 # Conflict avoidance constraints 36 if not check_conflict_constraints(team, constraints['conflict_constraints']): 37 constraints_satisfied=0 38 39 returnconstraints_satisfied 40 41 # Solve using integer linear programming 42 optimal_team=solve_ilp_optimization( 43 expert_candidates, 44 objective_function, 45 constraint_function, 46 max_team_size=constraints['max_size'] 47) 48 49 returnoptimal_team 50 51 defsolve_ilp_optimization(candidates,objective,constraints,max_team_size): 52 """Solving Integer Linear Programming""" 53 frompulpimport* 54 55 #Creating a problem 56 prob=LpProblem("Team_Optimization",LpMaximize) 57 58 # Decision Variable 59 x={} 60 fori,expertinenumerate(candidates): 61 x[i]=LpVariable(f"expert_{i}",cat='Binary') 62 63 #Objective Function 64 prob+=lpSum([objective([candidates[i]])*x[i]foriinrange(len(candidates))]) 65 66 #Constraints 67 prob+=lpSum([x[i]foriinrange(len(candidates))])<=max_team_size 68 69 #Solve 70 prob.solve() 71 72 # Extraction Results 73 selected_team=[] 74 foriinrange(len(candidates)): 75 ifx[i].varValue==1: 76 selected_team.append(candidates[i]) 77 78 returnselected_team S8 extracts evidence fragments aligned with the required elements from the hit literature and assigns them unique numbers. It then generates recommended explanations containing the evidence numbers using a large language model and outputs expert ranking results, the best technical team, and the recommended explanations.

[0043] Optionally, the relevance between the evidence fragment and the demand element is calculated using the vector dot product, where the formula for evidence relevance is: For evidence fragments With query elements The correlation score Let be the vector representation of the i-th piece of evidence. Let be the vector representation of the j-th query element, where the explanation quality score is expressed as . , where n is the total number of statements in the explanation. This indicates whether the i-th statement contains evidence references (1 indicates it contains, 0 indicates it does not). This represents the total number of statements that include evidence citations.

[0044] Specifically, the evidence-aligned recommendation explanation generation module is a key innovation of the system, responsible for generating traceable and explainable recommendation reasons for expert and team recommendations. This module employs a two-stage processing strategy: the first stage is evidence extraction, selecting segments from relevant literature that align with user needs, assigning a unique number to each evidence segment, and generating an evidence table; the second stage is LLM generation, using a large language model as its core and a "needs element → evidence segment → expert / team mapping" as the RAG context to generate natural language explanations. The key innovation of this module lies in the evidence alignment mechanism, requiring all recommendation reasons generated by the LLM to be based on specific evidence segments and automatically referencing evidence numbers (e.g., [Ev#3, Ev#7]), thereby reducing the risk of illusion and improving the credibility and traceability of the explanations. This evidence-based explanation generation method helps users understand the basis for recommendations and enhances their trust in the recommendation results.

[0045] 1 defevidence_aligned_explanation_generation(query,hit_documents,expert_team): 2 """ 3. Evidence Alignment and Interpretation Generation 4 Args: 5. Query: User query 6 hit_documents: hit documents 7 expert_team: expert team 8 Returns: 9 explanations: Explanation of evidence alignment 10 """ 11 #Step 1: Evidence Extraction 12 evidence_table=extract_evidence_segments(query,hit_documents) 13 14 # Step 2: LLM Generate Interpretation 15 explanations=generate_llm_explanations(query,evidence_table,expert_team) 16 17 returnexplanations 18 19 defextract_evidence_segments(query,documents): 20 """Evidence Fragment Extraction""" 21 evidence_table={} 22 evidence_id=1 twenty three 24 query_elements=extract_query_elements(query) 25 26 fordoc_id,docindocuments.items(): 27 # Find the paragraph that aligns with the query element 28 aligned_segments=find_aligned_segments(doc['content'],query_elements) 29 30 forsegmentinaligned_segments: 31 evidence_table[f"Ev#{evidence_id}"]={ 32 'content':segment['text'], 33 'source_doc':doc_id, 34 'relevance_score':segment['score'], 35 'query_element':segment['matched_element'] 36} 37 evidence_id+=1 38 39 returnevidence_table 40 41 defgenerate_llm_explanations(query,evidence_table,expert_team): 42 """LLM Generation Interpretation""" 43 # Building the RAG Context 44 rag_context=build_rag_context(query,evidence_table,expert_team) 45 46 #LLM prompt template 47 prompt_template=""" 48. Based on the following evidence, explain why this team of experts was recommended to address the technical requirements: 49 50. Technical Requirements: {query} 51 52. Evidence fragments: 53 {evidence_list} 54 55 Recommended Teams: {team_info} 56 57. Please generate an explanation and ensure that: 58 1. Each reason should cite a specific evidence number (e.g., [Ev#3, Ev#7]). 59 2. Explanations should be specific and traceable. 60 3. Avoid fabricating information 61 """ 62 63 # Generate Explanation 64 explanations=llm_generate(prompt_template.format( 65 query=query, 66 evidence_list=format_evidence_list(evidence_table), 67 team_info=format_team_info(expert_team) 68 )) 69 70 returnexplanations 71 72 defbuild_rag_context(query,evidence_table,expert_team): 73 """Constructing the RAG Context""" 74 context={ 75 'query':query, 76 'evidence_count':len(evidence_table), 77 'evidence_summary':summarize_evidence(evidence_table), 78 'team_capabilities':extract_team_capabilities(expert_team), 79 'max_tokens':2000 80} 81 returncontext Example 2 On the other hand, a technology-demand-oriented intelligent matching system for experts and teams is provided to implement the above method. The system includes: The data preprocessing module is used to acquire paper and patent data and perform preprocessing operations such as text segmentation, word segmentation, and cleaning. The vectorization and indexing module is used to perform segmented vectorization and domain adaptive calibration on the preprocessed text, and to build a keyword inverted index. The knowledge graph construction module is used to extract entities and relationships, and to build and maintain heterogeneous knowledge graphs. The name disambiguation module is used to perform cross-domain name disambiguation between paper authors and patent inventors, and output a unified expert entity. The three-modal retrieval and fusion module is used to analyze technical requirements, execute three retrieval methods in parallel, and fuse and sort them through a gating function. The expert ranking module is used to aggregate the hit documents into expert entities, calculate the comprehensive score, and rank them. The team synthesis module is used to solve multi-objective team optimization problems and generate the optimal technical team. The explanation generation module is used to extract evidence fragments and generate recommended explanations containing evidence numbers using a large language model.

[0046] On the other hand, a computer-readable storage medium is also provided, which stores a computer program that, when executed by a processor, implements the aforementioned expert and team intelligent matching method oriented towards technical needs.

[0047] The above description is merely an optional embodiment of this application and is not intended to limit this application. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the protection scope of this application.

Claims

1. A method for intelligent matching of experts and teams based on technical needs, characterized in that, The method includes: S1. Obtain paper and patent data, perform segmented vectorization processing on the data, and construct a keyword inverted index. S2 extracts entities and relationships from paper and patent data to construct a heterogeneous knowledge graph containing nodes of experts, papers, patents, institutions, and classification numbers. S3 performs cross-domain name disambiguation on paper authors and patent inventors, merging them to obtain a unified expert entity; S4 receives user technical requirements, parses and extracts elements from the requirements, and then performs semantic retrieval, keyword retrieval, and knowledge graph retrieval in parallel. S5 extracts query features and retrieval result features, dynamically adjusts the weights of the three retrieval results through a learnable gating function, and merges and sorts the retrieval scores; S6: Aggregate the hit documents after fusion and ranking to the corresponding unified expert entity, calculate the expert comprehensive score and complete the ranking; S7, based on the capability coverage requirements of technical needs and the historical collaboration relationships among experts, solves the team composition optimization problem with institutional constraints and conflict of interest constraints to obtain the optimal technical team; S8 extracts evidence fragments aligned with the required elements from the hit literature and assigns them unique numbers. It then generates recommended explanations containing the evidence numbers using a large language model and outputs expert ranking results, the best technical team, and the recommended explanations.

2. The intelligent matching method for experts and teams based on technical needs as described in claim 1, characterized in that, The process of acquiring paper and patent data and performing segmented vectorization on the data includes: The paper and patent texts were divided into different text segments according to title, abstract and claims, and each text segment was encoded using a domain pre-trained model (SciBERT / PatentBERT); Key information is extracted through segmented pooling using an attention mechanism, and then multi-view vector representations are obtained through domain adaptive calibration.

3. The intelligent matching method for experts and teams based on technical needs as described in claim 1, characterized in that, The construction of the keyword inverted index includes: Built on the BM25 algorithm, it assigns different weights to the title, abstract, and claim fields, and supports technical term phrase matching and synonym expansion.

4. The intelligent matching method for experts and teams based on technical needs according to claim 1, characterized in that, The process of performing cross-domain name disambiguation on paper authors and patent inventors, merging them into a unified expert entity, includes: Canopy clustering was used for pre-screening, and the similarity of names, institutions, research topics, and time trajectories between entities was calculated. Accurate grouping is achieved through hierarchical clustering, and unified expert entities are obtained by merging. The name similarity is calculated by combining edit distance and pinyin similarity, and the comprehensive similarity formula is as follows: ,in , For entities and The overall similarity between them For the two entities to be compared, Weighting for name similarity. For institutional similarity weights, As a weight for topic similarity, For time similarity weight, The score represents the similarity between the names. For institutional similarity scores, The theme similarity score, This represents the time similarity score.

5. The intelligent matching method for experts and teams based on technical needs according to claim 1, characterized in that, The learnable gating function dynamically outputs weights based on the resulting features, wherein the weights satisfy the following conditions: The formula for the fusion fraction is: ,in The combined score is the final score after merging. For semantic retrieval weights based on query q, To determine the keyword retrieval weight based on query q, For graph retrieval weights based on query q, For semantic retrieval score, Keyword search score, The score is the knowledge graph retrieval score, and q represents the user query.

6. The intelligent matching method for experts and teams based on technical needs according to claim 1, characterized in that, The process of aggregating the merged and ranked hit documents into the corresponding unified expert entity, calculating the expert comprehensive score, and completing the ranking includes: The expert comprehensive score is calculated based on a weighted average of six indicators: maximum semantic score, number of documents covered, recent activity level, citation impact, patent claim matching strength, and cross-domain consistency. The expert comprehensive score formula is as follows: , , Based on the comprehensive score from experts, Let i be the weight of the i-th indicator. Let i be the normalization function for the i-th indicator, where i is the indicator index, and 1-6 correspond to the maximum semantic score, the number of documents covered, the recent activity level, the citation impact, the patent claim matching strength, and the cross-domain consistency, respectively. The LambdaMART learning sorting algorithm was used to complete the final sorting.

7. The intelligent matching method for experts and teams based on technical needs according to claim 1, characterized in that, In solving the team composition optimization problem containing institutional constraints and conflict of interest constraints, the objective function of the team composition optimization is: ,in, For capability coverage weight, As a weight for the strength of cooperation, Weighting by team size Weighting for communication costs, The score represents the team's capability coverage. The score represents the intensity of teamwork. Penalty based on team size The team communication cost score is subject to the following constraints. , Let be a binary decision variable, representing whether expert i is selected, and n be the total number of candidate experts. To limit the maximum team size, 0 and 1 represent binary constraints. Take 0 or 1.

8. The intelligent matching method for experts and teams based on technical needs according to claim 1, characterized in that, The relevance between the evidence fragments and the demand elements is calculated using the vector dot product, where the formula for evidence relevance is: For evidence fragments With query elements The correlation score Let be the vector representation of the i-th piece of evidence. Let be the vector representation of the j-th query element, where the explanation quality score is expressed as . , where n is the total number of statements in the explanation. This indicates whether the i-th statement contains evidence references (1 indicates it contains, 0 indicates it does not). This represents the total number of statements that include evidence citations.

9. An expert and team intelligent matching system for implementing the method of any one of claims 1-8, characterized in that, The system includes: The data preprocessing module is used to acquire paper and patent data and perform preprocessing operations such as text segmentation, word segmentation, and cleaning. The vectorization and indexing module is used to perform segmented vectorization and domain adaptive calibration on the preprocessed text, and to build a keyword inverted index. The knowledge graph construction module is used to extract entities and relationships, and to build and maintain heterogeneous knowledge graphs. The name disambiguation module is used to perform cross-domain name disambiguation between paper authors and patent inventors, and output a unified expert entity. The three-modal retrieval and fusion module is used to analyze technical requirements, execute three retrieval methods in parallel, and fuse and sort them through a gating function. The expert ranking module is used to aggregate the hit documents into expert entities, calculate the comprehensive score, and rank them. The team synthesis module is used to solve multi-objective team optimization problems and generate the optimal technical team. The explanation generation module is used to extract evidence fragments and generate recommended explanations containing evidence numbers using a large language model.

10. A computer-readable storage medium, characterized in that, The storage medium stores a computer program that, when executed by a processor, implements the expert and team intelligent matching method based on technical needs as described in any one of claims 1-8.

Images