Structured query language processing method and device for intelligently screening resumes

Abstract

The invention provides a structured query language processing method and device for resume intelligent screening, and relates to the technical field of computers.The method comprises the steps that a natural language query statement corresponding to resume screening input by a user is received, entity information in the natural language query statement is extracted, the entity information is converted into an entity triad, and the entity triad is sent to the user; wherein the entity triad comprises an entity type, a relation value and an entity relation; based on the logic conjunctions in the natural language query statements, a logic tree representing the logic relation between the screening conditions is constructed, non-leaf nodes in the logic tree represent the logic relation, and leaf nodes are the entity triples; and performing conversion according to the logic relationship represented by the logic tree to obtain a logic expression, converting the logic expression and the entity triad into SQL statements, and performing intelligent resume screening by executing the SQL statements to obtain a resume screening result.

Description

Technical Field

[0001] This invention relates to the field of computer technology, and more particularly to a structured query language processing method and apparatus for intelligent resume screening. Background Technology

[0002] In the field of human resource management, targeted screening of candidates based on resume content is a crucial component of the work. However, the complexity and diversity of resume information and the numerous combinations of screening criteria present many challenges to this process. Traditional manual screening methods are inefficient, easily influenced by subjective factors, and fail to meet the demands for rapid, efficient, and accurate screening.

[0003] The types of personal information in a resume include, but are not limited to: basic information (e.g., name, gender, age, contact information), personal information (e.g., hobbies, personality traits), language skills (e.g., foreign languages ​​spoken, certificates held), educational background (e.g., degree, university, major), work / internship experience (e.g., position, company name, job duties, work period), and project experience (e.g., project name, role, technology used, results demonstrated). These information types are further refined into several specific indicators, and the values ​​for these indicators may include structured data (e.g., dates, numbers), unstructured data (e.g., text descriptions), and semi-structured data (e.g., form information). Furthermore, the amount and level of detail of information in different resumes can vary significantly. For example, some job seekers may list the achievements of each internship in detail, while others may only provide the job title and dates.

[0004] The traditional method of manually constructing screening criteria, which relies heavily on complex and diverse content in resumes, is gradually becoming obsolete. Compared to traditional methods, modern technologies can automatically extract and understand resume information through deep learning, natural language processing, and other techniques, identifying core elements that match job requirements, thereby significantly improving the accuracy and efficiency of screening. Currently, traditional Text2SQL solutions mainly fall into two categories: the first method directly converts natural language into SQL using a model; the second method converts natural language into an intermediate expression, and then converts the intermediate expression back into SQL. The first method is simpler but less accurate. In real-world business scenarios, the second method is generally used because SQL requires extremely high syntactic precision. However, the second method currently only handles simple logical relationships and lacks specific methods for handling complex logical relationships.

[0005] In summary, there is an urgent need for a technical solution that can overcome the above-mentioned shortcomings, handle complex logical relationships, and ensure conversion quality. Summary of the Invention

[0006] To address the problems existing in the prior art, this invention proposes a structured query language processing method and apparatus for intelligent resume screening.

[0007] In a first aspect of this invention, a structured query language processing method for intelligent resume screening is proposed, the method comprising:

[0008] The system receives a natural language query statement corresponding to the resume screening input by the user, extracts entity information from the natural language query statement, and converts the entity information into entity triples, wherein the entity triples include entity type, relation value and entity relation;

[0009] Based on the logical connectors in the natural language query statement, a logic tree is constructed to represent the logical relationships between the filtering conditions, wherein the non-leaf nodes in the logic tree represent logical relationships, and the leaf nodes are the entity triples;

[0010] Logical expressions are derived from the logical relationships represented by the logic tree, and the logical expressions and entity triples are converted into SQL statements. The SQL statements are then executed to perform intelligent resume screening and obtain the resume screening results.

[0011] In a second aspect of the present invention, a structured query language processing apparatus for intelligent resume screening is provided, the apparatus comprising:

[0012] The triple extraction module is used to receive the natural language query statement corresponding to the resume screening input by the user, extract the entity information in the natural language query statement, and convert the entity information into entity triples, wherein the entity triples include entity type, relation value and entity relation.

[0013] The logic tree construction module is used to construct a logic tree representing the logical relationship between the filtering conditions based on the logical connectors in the natural language query statement, wherein the non-leaf nodes in the logic tree represent logical relationships, and the leaf nodes are the entity triples;

[0014] The SQL generation module is used to convert logical expressions based on the logical relationships represented by the logic tree, and to convert the logical expressions and entity triples into SQL statements. The SQL statements are then executed to perform intelligent resume screening and obtain resume screening results.

[0015] In a third aspect of the present invention, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement a structured query language processing method for intelligent resume screening.

[0016] In a fourth aspect of the present invention, a computer-readable storage medium is provided, the computer-readable storage medium storing a computer program, which, when executed by a processor, implements a structured query language processing method for intelligent resume screening.

[0017] In a fifth aspect of the present invention, a computer program product is proposed, the computer program product comprising a computer program, wherein when the computer program is executed by a processor, a structured query language processing method for intelligent resume screening is implemented.

[0018] The structured query language processing method and device for intelligent resume screening proposed in this invention effectively solves the shortcomings of traditional methods in expressing complex logical relationships, entity recognition accuracy, and handling nested logic by extracting entity triples, constructing logic trees, and converting SQL, combined with large model fine-tuning and logical self-correction mechanisms. It effectively improves the accuracy and efficiency of automatic conversion from natural language to SQL, significantly enhances the efficiency and accuracy of enterprise resume screening, and provides strong technical support for enterprise resume screening. Attached Figure Description

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

[0020] Figure 1 This is a schematic diagram of a structured query language processing method for intelligent resume screening according to an embodiment of the present invention.

[0021] Figure 2 This is a schematic diagram of the process for extracting entity triples according to a specific embodiment of the present invention.

[0022] Figure 3 This is a schematic diagram of the process of constructing a logic tree according to a specific embodiment of the present invention.

[0023] Figure 4 This is a schematic diagram of the logic tree processing flow according to a specific embodiment of the present invention.

[0024] Figure 5 This is a flowchart illustrating the logical expression to SQL conversion process according to a specific embodiment of the present invention.

[0025] Figure 6 This is a schematic diagram of the structured query language processing device architecture for intelligent resume screening according to an embodiment of the present invention.

[0026] Figure 7 This is a schematic diagram of a computer device structure according to an embodiment of the present invention. Detailed Implementation

[0027] The principles and spirit of the invention will now be described with reference to several exemplary embodiments. It should be understood that these embodiments are given merely to enable those skilled in the art to better understand and implement the invention, and are not intended to limit the scope of the invention in any way. Rather, these embodiments are provided to make this disclosure more thorough and complete, and to fully convey the scope of this disclosure to those skilled in the art.

[0028] Those skilled in the art will recognize that embodiments of the present invention can be implemented as a system, apparatus, device, method, or computer program product. Therefore, this disclosure can be specifically implemented in the following forms: entirely hardware, entirely software (including firmware, resident software, microcode, etc.), or a combination of hardware and software.

[0029] According to an embodiment of the present invention, a structured query language processing method and apparatus for intelligent resume screening are proposed, relating to the field of computer technology.

[0030] The principles and spirit of the present invention will be explained in detail below with reference to several representative embodiments.

[0031] Figure 1 This is a schematic flowchart of a structured query language processing method for intelligent resume screening according to an embodiment of the present invention. Figure 1 As shown, the method includes:

[0032] S101, receive the natural language query statement corresponding to the resume screening input by the user, extract the entity information in the natural language query statement, and convert the entity information into entity triples, wherein the entity triples include entity type, relation value and entity relation;

[0033] S102, Based on the logical connectors in the natural language query statement, construct a logic tree representing the logical relationship between the filtering conditions, wherein the non-leaf nodes in the logic tree represent logical relationships, and the leaf nodes are the entity triples;

[0034] S103, a logical expression is obtained by transforming the logical relationship represented by the logic tree, and the logical expression and entity triples are converted into SQL statements. The SQL statements are then executed to perform intelligent resume screening and obtain resume screening results.

[0035] This invention establishes an architecture for entity triple extraction, logic tree construction, and SQL transformation, converting natural language into structured, executable SQL statements. This achieves efficient and accurate integration from user intent to filtering results, with a clear overall logical relationship that can effectively improve conversion accuracy.

[0036] To provide a clearer explanation of the structured query language processing method for intelligent resume screening described above, each step will be explained in detail below.

[0037] In one embodiment, for S101, a natural language query statement corresponding to resume screening input by the user is received, entity information is extracted from the natural language query statement, and the entity information is converted into entity triples. (See reference...) Figure 2 This is a schematic diagram of the process for extracting entity triples according to a specific embodiment of the present invention. Figure 2 As shown, the specific methods include:

[0038] S201, Entity recognition is performed on natural language query statements using a large language model to generate entity triples;

[0039] S202, construct a fine-tuned dataset of natural language query statements and corresponding entity triple lists;

[0040] S203, Use the fine-tuning dataset to fine-tune the large language model.

[0041] This invention introduces an entity recognition method based on fine-tuning of a large language model, which significantly improves the accuracy and generalization ability of entity triple extraction. Compared with methods that rely on fixed rules or small-scale labeled data, this method can better understand and adapt to the varied entity representations in the human resources field, effectively reducing entity type misjudgments, value omissions, or relationship errors, and providing a high-quality, standardized data foundation for subsequent processes.

[0042] Furthermore, for S202, a fine-tuning dataset is constructed by matching natural language query statements with corresponding entity triple lists. The specific process includes:

[0043] Training data is generated in batches using a script program based on preset language templates, entity type flags, and entity value lists.

[0044] We use a large language model to rewrite the query sample without changing its semantics, thereby expanding the training data sample.

[0045] This invention constructs a fine-tuning dataset by combining script-based batch generation with large-scale model semantic rewriting. Its technical advantage lies in efficiently and cost-effectively solving the bottleneck problem of large-scale, high-quality labeled data required for model training. This method can automatically generate training samples covering a wide range of language variants, ensuring data diversity to enhance model robustness while significantly reducing the cost of manual data collection and labeling, thus automating and intelligentizing the data preparation process.

[0046] Extracting entity triples primarily focuses on accurately converting the entity information of a short sentence into a specific triple format, namely, (entity type, entity, entity range). Taking a typical sentence in a resume search scenario, "I want a male master's degree holder," as an example, the processing flow accurately extracts the entities and converts them into a list of triple expressions: [('gender', 'male', '='), ('educational level', 'master', '=')].

[0047] A short sentence can contain a maximum of two entities. Entity types include background appearance, marital status, poverty status, gender, age, place of origin, college entrance examination admission batch, CET-4, CET-6, IELTS, TOEFL, height, weight, educational level, and major. Entity values ​​are the values ​​corresponding to the types, and can be character, string, or number. Entity ranges include '=', '>', '<', '>=', '<=', 'in', 'between', and 'not in', corresponding to a single entity, greater than a certain threshold, less than a certain threshold, greater than or equal to a certain threshold, less than or equal to a certain threshold, within a certain entity list, between two thresholds, and not within a certain entity list, respectively.

[0048] The 'not in' field represents the "not" logic, and its keyword list is ["don't", "remove", "reject", "remove"].

[0049] This invention employs a technical approach combining large-scale model prompting engineering with fine-tuning to achieve the task of extracting entity information from sentences. The prompting engineering content defines the translation function role (i.e., explicitly tells the generative large language model what needs to be done), entity type, entity value, entity range (mainly involving the entity type, entity value, entity range list and description), and triple extraction steps (mainly telling the large model how to extract triples step by step).

[0050] The key to fine-tuning the large model lies in constructing a high-quality fine-tuning dataset. This invention rigorously defines the fine-tuning dataset format as <natural language query statement, entity list>. To reduce workload, this invention designs a script-based method for automatically constructing the fine-tuning dataset. The script includes language templates (for enriching language expression), entity type flags, and expanded value lists (entity value lists). This script allows for the automatic batch generation of fine-tuning data.

[0051] To further expand the model's semantic understanding and expressive capabilities, this invention also rewrites the natural language query statements input by users using a large-scale model. While strictly adhering to the principle of not altering the original semantics, this rewrites the statements in a richer and more diverse manner, effectively enhancing the model's compatibility and adaptability to different expression forms.

[0052] In practical applications, over 100,000 fine-tuning datasets were successfully constructed through the collaborative operation of script programs and a large model. To train the large model's ability to respond to rejected queries, a batch of rejected queries was also prepared, leading to the design of a targeted rejected query training mechanism. This involves constructing unrelated questions for a given database table and preparing corresponding rejected responses such as "cannot answer." This approach guides the model to deeply analyze the inherent relationships between questions and entities, enabling it to accurately judge and provide reasonable responses to various inputs. During fine-tuning training, this invention sets a series of key parameters, such as learning rate, batch size, and number of training epochs, and employs techniques like LoRA and QLoRA for fine-tuning. Simultaneously, to effectively monitor model training progress and preserve high-quality model states, a checkpoint model saving operation is performed every 100 iterations.

[0053] In one embodiment, for S102, a logic tree representing the logical relationship between filtering conditions is constructed based on the logical connectors in the natural language query statement, wherein the non-leaf nodes in the logic tree represent logical relationships, and the leaf nodes are the entity triples.

[0054] The logic tree includes at least: a complete sentence logic tree and a clause logic tree.

[0055] refer to Figure 3 The specific process includes:

[0056] S301, determine the logical relationship between clauses based on punctuation marks and logical keywords between sentences, and construct the entire sentence logic tree.

[0057] S302, through recursion, determines the root node of the logic tree based on the position weight and type weight of the logical words in the clause, and constructs the clause logic tree by splitting it layer by layer.

[0058] By constructing sentence-level and clause-level logic trees, this method can accurately parse and represent complex, nested logical semantics in natural language. It hierarchically models the logical relationships at the sentence and clause levels, using positional and type weights to scientifically determine the root of the logic tree. This accurately transforms colloquial queries with multiple related conditions into unambiguous tree-like logical structures, providing crucial support for the correct expression of complex filtering conditions.

[0059] Further reference Figure 4 The logic tree processing flow also includes:

[0060] S401, when the entity types of adjacent leaf nodes in the logic tree are found to be consistent, the logic tree is structurally adjusted; among them, entity conditions of the same entity type are preferentially connected by OR logic.

[0061] By introducing a logical self-correction mechanism, the logic tree is structurally adjusted when adjacent entities of the same type are detected, making the logical relationships constructed by the system more consistent with human common sense and true semantic intent. It can automatically optimize suboptimal logical structures that may be caused by natural language expression habits (e.g., listing similar conditions side by side), prioritizing the aggregation of similar entities using "OR" logic, thereby generating more reasonable and accurate filtering condition expressions and improving the semantic fidelity of logical representation.

[0062] S402, detect whether there are conflicting or redundant logical relationships in the logic tree; if so, reselect the root node of the logic tree and reconstruct the logic tree.

[0063] By introducing a logical self-checking mechanism, the completed logic tree is checked for conflicts and redundancy, enhancing the system's fault tolerance and reliability. This mechanism can automatically identify contradictory logic or invalid repetitions, such as logic originating from one region and another, and trigger a refactoring process. This ensures that the final generated logical expression is logically consistent, concise, and effective, avoiding subsequent erroneous SQL generated due to early parsing deviations and guaranteeing the quality of system output.

[0064] The specific construction method for the entire sentence logic tree is as follows:

[0065] This invention collects descriptive information corresponding to the resumes the user inputs for filtering. This descriptive information typically involves multiple filtering conditions. From a linguistic perspective, it presents itself as a natural language statement containing multiple filtering conditions. These natural language statements generally use logical connectors such as AND, OR, and NOT to construct semantic logical relationships. For example, consider the sentence: "I want master's students whose place of origin is the first region, and they all have a preset background." The core function of this invention is to construct the semantic logical relationships inherent in long sentences. Specifically, it meticulously divides the logical relationships of sentences into two main parts: one part is the logic within clauses, and the other part is the logic between clauses. The clauses mentioned here are mainly defined based on commas in the natural language input by the user.

[0066] This invention uses a binary tree structure to construct the logical relationships of sentences. Specifically, the non-leaf nodes of the tree represent "AND" or "OR" logical relationships, and the leaf nodes represent entity triples. First, the logical relationships between sentences are constructed. The construction of inter-sentence logic is based on the keywords preceding the clauses. For example, in the long sentence, "I want students whose place of origin is the first region, (and / or) whose academic level is master's degree," the logical relationship between the two short clauses depends on the keywords after the punctuation marks. That is, the logical relationship between the two sentences is "AND" or "OR." The list of keywords representing "AND" logic is ["simultaneously," "moreover," "and," "and"], and the list of keywords representing "OR" logic is ["or," "or," "and," "in addition"].

[0067] The specific construction method for the clause logic tree is as follows:

[0068] Construct logical relationships within clauses. For example, the sentence "I want someone from Region 1 with a Master's degree or someone from Region 2 with a PhD" contains the logical relationship "(('place of origin', 'Region 1', '=')&&('educational level', 'Master', '='))||(('place of origin', 'Region 2', '=')&&('educational level', 'PhD', '='))".

[0069] The clause logic tree is constructed by using logical word type weighting, logical word position weighting, logical self-detection, and logical self-correction.

[0070] Specifically, the processing methods for logic trees also include: 1) determining the root of the logic tree, 2) logic tree self-correction, and 3) logic tree self-testing.

[0071] 1) Determine the root of the logic tree:

[0072] Complex natural language queries contain multiple logical terms. First, the scores of logical terms in the clauses that can be used as the root of a logical tree are calculated, and the logical term with the highest score is selected as the root of the logical tree. Typically, the logical term representing the root of the logical tree in a clause is placed in the middle of the sentence. This invention uses a quadratic function to calculate the positional weight of logical terms in the sentence. The quadratic function is F(x) = -4x^2 + 4x, where "x" represents the relative position of the logical term in the sentence, and the range of F(x) is 0-1. For example, in the above example sentence, the sentence length is 27, and the position of "or" is 16, then x = 16 / 27. F(16 / 27) = 0.9657. Through continuous testing, the weight of the keyword representing "AND" logic is set to 1, and the weight of the keyword representing "OR" logic is set to 0.9. Multiplying the logical word weight by the logical word position weight yields the probability that a logical word in the clause is the root of the logic tree, i.e., G(x) = F(x) × Para(x), where Para(x) represents the logical word weight. After obtaining the root of the logic tree, the clause is split into two clauses based on the position of the logical word. For example, the sentence above can be split into "I want to be from region 1 and have a master's degree" and "from region 2 and have a doctorate." The logical relationship is "I want to be from region 1 and have a master's degree" || "from region 2 and have a doctorate." A recursive algorithm is used to determine the root of the logic tree for each clause until no more logical words are contained in the clause. For the example sentence above, it can be constructed as ("I want to be from region 1" && "have a master's degree") || ("from region 2" && "have a doctorate"). For clauses that do not contain logical operators, after entity extraction, they are transformed into entity triples, resulting in the final logical relation "(('place of origin', 'first region', '=')&&('educational level', 'master', '='))||(('place of origin', 'second region', '=')&&('educational level', 'doctor', '='))".

[0073] 2) Logic tree self-correction:

[0074] Complex natural language queries often involve entities of the same type, typically connected by the logical operator "OR". For example, in the query "I want students whose place of origin is either Region 1 or Region 3 and whose educational background is a PhD", the logical operator "OR" scores 0.897 as the root of the logic tree, and 0.864 as the root. Therefore, "OR" should be the root of the logic tree. However, generally, entities of the same type are located adjacently, making the logical relationship of this statement more likely to be "I want students whose place of origin is either Region 1 or Region 3 &&" and whose educational background is a PhD". Therefore, this invention sets a condition: when the entity type of a non-leaf node in the logic tree is the same as that of its adjacent non-leaf node, a logic tree rotation is performed.

[0075] 3) Logic tree self-testing:

[0076] After constructing the logic tree, it's necessary to perform a self-check on its logic. Logical errors generally occur in the following situations: 1. Two or more entities of the same type have an "AND" logical relationship, for example, "from region 1 and from region 3". 2. Entities of the same type have an "OR" logical relationship, for example, "from region 1 or from region 1". If any of these situations occur, it indicates that the root of the logic tree has been chosen incorrectly, and a new root needs to be selected, requiring a reconstructed logic tree. Finally, the logical expression is obtained by traversing the tree structure using an inorder traversal method.

[0077] In one embodiment, for S103, a logical expression is obtained by converting the logical relationship represented by the logic tree, and the logical expression and entity triples are converted into SQL statements. The SQL statements are then executed to perform intelligent resume screening and obtain resume screening results.

[0078] refer to Figure 5 The specific process for converting logical expressions into SQL is as follows:

[0079] S501 constructs a triplet fine-tuning dataset, which includes a positive and negative sample ratio control mechanism.

[0080] S502, the large language model is fine-tuned using the triplet fine-tuning dataset, and the rejection conversion capability of the model is trained using negative samples.

[0081] S503, based on the multi-dimensional template library, input the logical expression and entity triples into the large language model to obtain an SQL statement; including a basic transformation template and an exception handling template, the basic transformation template converts the logical expression into an SQL statement for screening resumes; the exception handling template is used to return an empty result when an abnormal scenario is detected.

[0082] After obtaining the logical expression, it needs to be converted into an SQL statement. In practical applications, hint engineering can be used to convert the logical expression into SQL. For example, the large model used is the QWEN7B model. The QWEN7B model is fine-tuned and trained, with training data prepared in the form of <question, logical expression, executable SQL> triples. Additionally, some non-convertible training examples need to be added to allow the model to learn to recognize conversions. Fine-tuning techniques such as QLoRA are used for further fine-tuning, and finally, the model is checked and saved every 1000 iterations.

[0083] This invention achieves a balance between accuracy and controllability in SQL generation by employing a fine-tuning dataset containing both positive and negative samples and a template-driven large-model transformation method during the SQL generation phase. Negative sample training endows the model with the ability to "reject" inputs, safely handling untransformable or invalid inputs; the multi-dimensional template library ensures that the generated SQL syntax is standardized and conforms to business scenarios. In particular, the exception handling templates guarantee that the system can reliably return empty results rather than errors in abnormal situations, greatly improving the practicality and robustness of the entire solution in production environments.

[0084] This invention provides a natural language to SQL conversion solution for the field of intelligent resume screening. The overall solution mainly focuses on entity conversion and complex logic construction, including: 1. This invention uses a prompting engineering + large model fine-tuning approach to convert entities in short sentences into entity triples. By constructing fine-tuning data through scripts and rewriting data, a training set can be created without manually writing example sentences, effectively reducing workload. 2. This invention uses a logic tree method to construct complex logic. Combined with the entity triple construction in the previous part, it achieves the conversion of natural language to complex logical expressions. Through logic self-detection and logic self-correction, it can automatically correct logic when errors are constructed, preparing for the next step of converting complex logical expressions to SQL. 3. This invention constructs a <question, logical expression, executable SQL> fine-tuning dataset and uses a large model fine-tuning method to achieve logical expression to SQL conversion.

[0085] In this embodiment of the invention, an entity triple refers to the normalized representation of a single filtering condition, and its basic format is: (entity type, relation value, entity relation). For example, "employees with a bachelor's degree or above" can be represented as: (educational level, [bachelor's, master's, doctoral], in).

[0086] Logical triple expressions are based on entity triples and use "AND (&)," "OR (||)," and "NOT (!)" to represent the relationship between two or more filtering conditions. The combined expression is a logical triple expression. For example, "female employees with a bachelor's degree" can be represented as: (education level, bachelor's, =) & (gender, female, =).

[0087] Complex Nested Relationships: In the process of describing filtering conditions in natural language processing, multiple filtering conditions may have hierarchical nested relationships. For example: undergraduate students who have passed CET-4, or graduate students who have passed CET-6, and whose place of origin is a certain region. The logical expression for the above conditions is: (((language level, CET4, =) & (language score, 425, >) & (academic level, undergraduate, =)) || ((language level, CET6, =) & (language score, 425, >) & (academic level, [master's, doctoral], in))) & (place of origin, a certain region, =). In the above logical triple expression, multiple "AND" and "OR" relationships form multiple nested relationships, which have a certain degree of complexity. The logical relationships in this expression are called complex nested relationships.

[0088] Compared with existing technologies, the structured query language processing method for intelligent resume screening proposed in this invention has at least the following technical advantages:

[0089] 1. Precise Expression of Logical Relationships: This invention defines filtering conditions as entity triples and constructs logical triple expressions by connecting them with specific logical terms. This effectively solves the problem of low accuracy in constructing logical relationships in existing large language model Text2SQL methods, enabling precise expression of complex logical relationships and thus improving the accuracy of filtering results. For example, when handling multi-condition filtering, the "AND," "OR," and "NOT" relationships can be clearly defined, avoiding filtering errors caused by logical confusion.

[0090] 2. Accurate Entity Triple Extraction: This method combines targeted fine-tuning of a large language model with post-processing of extraction results. Compared to traditional named entity recognition methods based on rules and dictionaries, machine learning, and deep learning, it overcomes limitations such as limited generalization ability in open scenarios, reliance on large-scale labeled data, and low adaptability to new domains. It significantly improves the accuracy of entity triple extraction, reduces errors and omissions in entity type and relation values, and provides a reliable foundation for subsequent accurate screening.

[0091] 3. Highly Efficient in Handling Complex Nested Logic: By breaking down continuous filtering conditions into individual conditions, representing hierarchical relationships in a tree structure, and reconstructing the logical structure using traversal methods, the problem of difficulty in identifying and representing complex nested logical relationships is effectively solved. Compared to previous technologies that struggled to handle such complex logic, this invention can efficiently process complex nested logic and adapt to more complex and diverse filtering needs. For example, when processing filtering statements containing multiple levels and intertwined logical relationships, it can accurately construct logical relationships and convert them into SQL statements for filtering.

[0092] It should be noted that although the operation of the method of the present invention has been described in a specific order in the above embodiments and figures, this does not require or imply that the operations must be performed in that specific order, or that all the operations shown must be performed to achieve the desired result. Additionally or alternatively, certain steps may be omitted, multiple steps may be combined into one step, and / or one step may be broken down into multiple steps.

[0093] After introducing the method of exemplary embodiments of the present invention, the following references are made. Figure 6 The structured query language processing apparatus for intelligent resume screening according to an exemplary embodiment of the present invention will be introduced.

[0094] The implementation of the structured query language processing device for intelligent resume screening can refer to the implementation of the above method, and repeated details will not be elaborated further. The term "module" or "unit" used below can refer to a combination of software and / or hardware that implements a predetermined function. Although the device described in the following embodiments is preferably implemented in software, hardware implementation, or a combination of software and hardware, is also possible and contemplated.

[0095] Based on the same inventive concept, this invention also proposes a structured query language processing device for intelligent resume screening, such as... Figure 6 As shown, the device includes:

[0096] The triple extraction module 610 is used to receive a natural language query statement corresponding to the resume screening input by the user, extract entity information from the natural language query statement, and convert the entity information into entity triples, wherein the entity triples include entity type, relation value and entity relation.

[0097] The logic tree construction module 620 is used to construct a logic tree representing the logical relationship between the filtering conditions based on the logical connectors in the natural language query statement, wherein the non-leaf nodes in the logic tree represent logical relationships, and the leaf nodes are the entity triples;

[0098] The SQL generation module 630 is used to convert logical expressions based on the logical relationships represented by the logic tree, and to convert the logical expressions and entity triples into SQL statements. The SQL statements are then executed to perform intelligent resume screening and obtain resume screening results.

[0099] In one embodiment, the triplet extraction module 610 is specifically used for:

[0100] Entity recognition is performed on natural language query statements using a large language model to generate entity triples;

[0101] Construct a fine-tuned dataset of natural language query statements and corresponding entity triple lists;

[0102] The large language model was fine-tuned using the fine-tuning dataset.

[0103] In one embodiment, the triple extraction module 610 is further configured to:

[0104] Training data is generated in batches using a script program based on preset language templates, entity type flags, and entity value lists.

[0105] We use a large language model to rewrite the query sample without changing its semantics, thereby expanding the training data sample.

[0106] In one embodiment, the logic tree includes at least: a complete sentence logic tree and a clause logic tree.

[0107] The logic tree construction module 620 is specifically used for:

[0108] Determine the logical relationships between clauses based on punctuation marks and logical keywords between sentences, and construct the entire sentence logic tree;

[0109] By recursively determining the root node of the logic tree based on the positional and type weights of the logical words within the clauses, the clause logic tree is constructed by splitting it layer by layer.

[0110] In one embodiment, the logic tree construction module 610 is specifically used for:

[0111] When the entity types of adjacent leaf nodes in the logic tree are found to be consistent, the logic tree structure is adjusted; among them, entity conditions of the same entity type are preferentially connected by OR logic.

[0112] In one embodiment, the logic tree construction module 610 is specifically used for:

[0113] Detect whether there are conflicting or redundant logical relationships in the logic tree; if so, reselect the root node of the logic tree and reconstruct the logic tree.

[0114] In one embodiment, the SQL generation module 630 is specifically used for:

[0115] Construct a triplet fine-tuning dataset, including a positive and negative sample ratio control mechanism;

[0116] The large language model was fine-tuned using the triplet fine-tuning dataset, and the rejection conversion ability of the model was trained using negative samples.

[0117] Based on the multi-dimensional template library, the logical expression and entity triples are input into the large language model to obtain an SQL statement; this includes a basic transformation template and an exception handling template. The basic transformation template converts the logical expression into an SQL statement for screening resumes; the exception handling template is used to return an empty result when an abnormal scenario is detected.

[0118] It should be noted that although several modules of the structured query language processing device for intelligent resume screening have been mentioned in the detailed description above, this division is merely exemplary and not mandatory. In fact, according to embodiments of the present invention, the features and functions of two or more modules described above can be embodied in one module. Conversely, the features and functions of one module described above can be further divided and embodied by multiple modules.

[0119] Based on the aforementioned inventive concept, such as Figure 7 As shown, the present invention also proposes a computer device 700, including a memory 710, a processor 720, and a computer program 730 stored in the memory 710 and executable on the processor 720. When the processor 720 executes the computer program 730, it implements the aforementioned structured query language processing method for intelligent resume screening.

[0120] Based on the aforementioned inventive concept, this invention proposes a computer-readable storage medium storing a computer program that, when executed by a processor, implements the aforementioned structured query language processing method for intelligent resume screening.

[0121] Based on the aforementioned inventive concept, this invention proposes a computer program product, which includes a computer program that, when executed by a processor, implements a structured query language processing method for intelligent resume screening.

[0122] The structured query language processing method and device for intelligent resume screening proposed in this invention effectively solves the shortcomings of traditional methods in expressing complex logical relationships, entity recognition accuracy, and handling nested logic by extracting entity triples, constructing logic trees, and converting SQL, combined with large model fine-tuning and logical self-correction mechanisms. It effectively improves the accuracy and efficiency of automatic conversion from natural language to SQL, significantly enhances the efficiency and accuracy of enterprise resume screening, and provides strong technical support for enterprise resume screening.

[0123] The acquisition, storage, use, and processing of data in this application comply with relevant laws and regulations.

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

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

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

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

[0128] Finally, it should be noted that the above-described embodiments are merely specific implementations of the present invention, used to illustrate the technical solutions of the present invention, and not to limit it. The scope of protection of the present invention is not limited thereto. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that any person skilled in the art can still modify or easily conceive of changes to the technical solutions described in the foregoing embodiments within the technical scope disclosed in the present invention, or make equivalent substitutions for some of the technical features; and these modifications, changes, or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be covered within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A structured query language processing method for intelligent resume screening, characterized in that, The method includes: The system receives a natural language query statement corresponding to the resume screening input by the user, extracts entity information from the natural language query statement, and converts the entity information into entity triples, wherein the entity triples include entity type, relation value and entity relation; Based on the logical connectors in the natural language query statement, a logic tree is constructed to represent the logical relationships between the filtering conditions, wherein the non-leaf nodes in the logic tree represent logical relationships, and the leaf nodes are the entity triples; Logical expressions are derived from the logical relationships represented by the logic tree, and the logical expressions and entity triples are converted into SQL statements. The SQL statements are then executed to perform intelligent resume screening and obtain the resume screening results.

2. The structured query language processing method for intelligent resume screening according to claim 1, characterized in that, The system receives a natural language query statement corresponding to a resume screening input from a user, extracts entity information from the natural language query statement, and converts the entity information into entity triples, including: Entity recognition is performed on natural language query statements using a large language model to generate entity triples; Construct a fine-tuned dataset of natural language query statements and corresponding entity triple lists; The large language model was fine-tuned using the fine-tuning dataset.

3. The structured query language processing method for intelligent resume screening according to claim 2, characterized in that, A fine-tuned dataset is constructed, consisting of natural language query statements and corresponding entity triple lists, including: Training data is generated in batches using a script program based on preset language templates, entity type flags, and entity value lists. We use a large language model to rewrite the query sample without changing its semantics, thereby expanding the training data sample.

4. The structured query language processing method for intelligent resume screening according to claim 1, characterized in that, The logic tree includes at least: a complete sentence logic tree and a clause logic tree. Based on the logical connectors in the natural language query statement, a logic tree representing the logical relationships between the filtering conditions is constructed, including: Determine the logical relationships between clauses based on punctuation marks and logical keywords between sentences, and construct the entire sentence logic tree; By recursively determining the root node of the logic tree based on the positional and type weights of the logical words within the clauses, the clause logic tree is constructed by splitting it layer by layer.

5. The structured query language processing method for intelligent resume screening according to claim 4, characterized in that, The method also includes: When the entity types of adjacent leaf nodes in the logic tree are found to be consistent, the logic tree structure is adjusted; among them, entity conditions of the same entity type are preferentially connected by OR logic.

6. The structured query language processing method for intelligent resume screening according to claim 4 or 5, characterized in that, The method also includes: Detect whether there are conflicting or redundant logical relationships in the logic tree; if so, reselect the root node of the logic tree and reconstruct the logic tree.

7. The structured query language processing method for intelligent resume screening according to claim 1, characterized in that, Logical expressions are derived from the logical relationships represented by the logic tree, and these logical expressions and entity triples are converted into SQL statements. The SQL statements are then executed to perform intelligent resume screening, yielding the resume screening results, including: Construct a triplet fine-tuning dataset, including a positive and negative sample ratio control mechanism; The large language model was fine-tuned using the triplet fine-tuning dataset, and the rejection conversion ability of the model was trained using negative samples. Based on the multi-dimensional template library, the logical expression and entity triples are input into the large language model to obtain an SQL statement; this includes a basic transformation template and an exception handling template. The basic transformation template converts the logical expression into an SQL statement for screening resumes; the exception handling template is used to return an empty result when an abnormal scenario is detected.

8. A structured query language processing device for intelligent resume screening, characterized in that, The device includes: The triple extraction module is used to receive the natural language query statement corresponding to the resume screening input by the user, extract the entity information in the natural language query statement, and convert the entity information into entity triples, wherein the entity triples include entity type, relation value and entity relation. The logic tree construction module is used to construct a logic tree representing the logical relationship between the filtering conditions based on the logical connectors in the natural language query statement, wherein the non-leaf nodes in the logic tree represent logical relationships, and the leaf nodes are the entity triples; The SQL generation module is used to convert logical expressions based on the logical relationships represented by the logic tree, and to convert the logical expressions and entity triples into SQL statements. The SQL statements are then executed to perform intelligent resume screening and obtain resume screening results.

9. The structured query language processing device for intelligent resume screening according to claim 8, characterized in that, The triplet extraction module is specifically used for: Entity recognition is performed on natural language query statements using a large language model to generate entity triples; Construct a fine-tuned dataset of natural language query statements and corresponding entity triple lists; The large language model was fine-tuned using the fine-tuning dataset.

10. The structured query language processing device for intelligent resume screening according to claim 9, characterized in that, The triplet extraction module is also specifically used for: Training data is generated in batches using a script program based on preset language templates, entity type flags, and entity value lists. We use a large language model to rewrite the query sample without changing its semantics, thereby expanding the training data sample.

11. The structured query language processing device for intelligent resume screening according to claim 8, characterized in that, The logic tree includes at least: a complete sentence logic tree and a clause logic tree. The logic tree construction module is specifically used for: Determine the logical relationships between clauses based on punctuation marks and logical keywords between sentences, and construct the entire sentence logic tree; By recursively determining the root node of the logic tree based on the positional and type weights of the logical words within the clauses, the clause logic tree is constructed by splitting it layer by layer.

12. The structured query language processing device for intelligent resume screening according to claim 11, characterized in that, The logic tree construction module is specifically used for: When the entity types of adjacent leaf nodes in the logic tree are found to be consistent, the logic tree structure is adjusted; among them, entity conditions of the same entity type are preferentially connected by OR logic.

13. The structured query language processing device for intelligent resume screening according to claim 11 or 12, characterized in that, The logic tree construction module is specifically used for: Detect whether there are conflicting or redundant logical relationships in the logic tree; if so, reselect the root node of the logic tree and reconstruct the logic tree.

14. The structured query language processing device for intelligent resume screening according to claim 8, characterized in that, The SQL generation module is specifically used for: Construct a triplet fine-tuning dataset, including a positive and negative sample ratio control mechanism; The large language model was fine-tuned using the triplet fine-tuning dataset, and the rejection conversion ability of the model was trained using negative samples. Based on the multi-dimensional template library, the logical expression and entity triples are input into the large language model to obtain an SQL statement; this includes a basic transformation template and an exception handling template. The basic transformation template converts the logical expression into an SQL statement for screening resumes; the exception handling template is used to return an empty result when an abnormal scenario is detected.

15. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the method of any one of claims 1 to 7.

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

17. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, implements the method of any one of claims 1 to 7.

Images