Technical consultation question and answer processing method and device based on AI self-adaptive tuning and medium

Abstract

The invention provides a technical consultation question and answer processing method and device based on AI adaptive tuning and a medium, and belongs to the technical field of artificial intelligence and natural language processing. According to the method, multiple candidate question and answer engine configurations are set in a question and answer system, each engine comprises different model versions, knowledge retrieval strategies and reasoning parameter combinations, and an initial configuration weight is set for each engine; the system receives a technical consultation question and answer request in the operation process, performs analysis and type marking on a question, and divides the request into a common consultation request and a reference question triggering request. Aiming at a common consultation request, the system selects a target question and answer engine according to the configuration weight to generate an answer result; and for a reference question triggering request, calling all candidate engines by the system to generate candidate answer results in parallel. According to the method, automatic calibration and continuous optimization of the question-answering system can be realized in a real service flow, and the question-answering accuracy, the response speed and the long-term stability of the system are remarkably improved.

Description

Technical Field

[0001] This invention relates to the fields of artificial intelligence and natural language technology, and in particular to a method, device and medium for processing technical consultation questions and answers based on AI adaptive optimization. Background Technology

[0002] In recent years, with the rapid development of artificial intelligence (AI) and natural language processing (NLP) technologies, intelligent question-answering systems based on large models have been widely used in fields such as technical support, customer consultation, operation and maintenance guidance, and knowledge services. Existing technical consultation question-answering systems typically rely on a single model or fixed parameter settings, generating answers through keyword retrieval or semantic matching, which has the following shortcomings: First, existing question-answering systems mostly use statically configured model parameters and retrieval strategies, lacking a self-learning mechanism to adapt to changes in the operating environment. This leads to a decline in the quality of model output over time. For example, when the knowledge base content is updated or the user's inquiry direction changes, the system cannot adjust parameters or optimize model weights in a timely manner, which can easily result in delayed answers or a decrease in accuracy. Secondly, the performance evaluation of existing question-answering systems usually relies on manually labeled data or offline test sets for model verification, which cannot continuously monitor model performance in real business processes. This offline evaluation method has a lag in response and is difficult to reflect the accuracy and robustness of the system in multiple domains and scenarios in a timely manner.

[0003] Furthermore, in technical consulting systems, it is often necessary to combine different models or inference strategies to deal with diverse problems. However, existing solutions mostly use fixed priorities or manual weight configurations, which makes it difficult to dynamically allocate computing resources based on real-time feedback. This results in some engines being overloaded or idle for a long time, making it difficult to optimize the overall system performance.

[0004] Therefore, we propose a technical consultation question-and-answer processing method, device, and medium based on AI adaptive optimization. The information disclosed in the background section is only for enhancing understanding of the background of this disclosure and therefore may include information that does not constitute prior art known to those skilled in the art. Summary of the Invention

[0005] The purpose of this invention is to address the shortcomings of existing technologies by providing a technical consultation question-and-answer processing method, device, and medium based on AI adaptive optimization, thereby resolving the technical problems mentioned in the background section.

[0006] To achieve the above objectives, the present invention provides the following technical solution: The AI-adaptive optimization-based technical consultation question-and-answer processing method includes the following steps: S1. Initialize candidate question answering engine configurations, pre-set multiple candidate question answering engine configurations including model versions, knowledge retrieval strategies and inference parameter combinations, assign initial configuration weights to each candidate question answering engine configuration, and establish a benchmark question set including benchmark questions, benchmark reference answers and scoring rules; S2. Collect user-input technical consultation and Q&A requests, parse the question text, extract topic tags and complexity indicators, and determine whether the request matches the benchmark question set based on semantic similarity. Mark successfully matched questions as benchmark question trigger requests and unmatched questions as ordinary consultation requests. S3. For ordinary consultation requests, the target question-answering engine configuration is determined by weighted sampling based on the configuration weights of each candidate question-answering engine. The corresponding model is then invoked to perform question-answering reasoning, generate the target answer result, and return it to the terminal. S4. When a baseline question triggers a request, all candidate question answering engines are called to generate candidate answer results. Multidimensional evaluation scores are calculated based on preset semantic similarity, structural consistency and keyword matching rate. The average scores of each engine configuration are then combined to form a comprehensive evaluation dataset. S5. Calculate the reward value configured for each candidate question answering engine based on the comprehensive evaluation dataset, input the reward value into the online learning algorithm module to perform weight update, adjust the configured weights using a multi-armed slot machine or Softmax strategy and perform normalization processing, and write the updated weights into the configured weight storage unit. S6. In subsequent question-and-answer processing, the updated configuration weights are called to select the target question-and-answer engine configuration, continuously triggering the benchmark question evaluation and weight learning loop, monitoring the performance indicators of each engine to achieve self-calibration and stability maintenance, forming an adaptive optimization closed loop of initialization, question-and-answer execution, benchmark evaluation, weight update and application feedback.

[0007] S1 includes: in the technical consultation question-and-answer processing system, pre-setting multiple candidate question-and-answer engine configurations, each candidate question-and-answer engine configuration including model version, knowledge retrieval strategy and inference parameter combination; assigning initial configuration weights to each candidate question-and-answer engine configuration and storing the initial configuration weights in the configuration weight storage unit; constructing a benchmark question set including multiple benchmark questions, corresponding benchmark reference answers and scoring rules, and associating and binding it with the technical consultation question-and-answer processing system; setting trigger conditions and trigger frequencies for each benchmark question in the benchmark question set to ensure that it can be periodically triggered and executed during system operation; completing the synchronous initialization of the candidate question-and-answer engine configurations and the benchmark question set, so that the subsequent question-and-answer process can be dynamically optimized based on a unified configuration weight system.

[0008] S2 includes: receiving a technical consultation Q&A request submitted by a user from a terminal device and parsing it to obtain the question text; identifying the subject area and complexity level of the question text based on a preset question parsing model; determining whether the question text matches a benchmark question in a benchmark question set according to a triggering strategy; if the match is successful, marking the question as a benchmark question trigger request; if the match is not successful, marking it as a normal consultation request; and storing the question type marking information and the question text together in a session data cache to provide input basis for subsequent Q&A processing.

[0009] S3 includes: reading the configuration weights of each candidate question-answering engine from the configuration weight storage unit; determining the target question-answering engine configuration for processing the current general inquiry request based on the configuration weights using a weighted sampling method; calling the model version, knowledge retrieval strategy, and inference parameters corresponding to the target question-answering engine configuration to perform question-answering inference on the general inquiry request; generating the target answer result and returning it to the corresponding terminal device to form user-visible output; and recording the target question-answering engine configuration, the general inquiry request text, and the target answer result to the question-answering log for subsequent performance statistics and weight update reference.

[0010] S4 includes: when a benchmark question trigger request is detected, extracting the benchmark question, benchmark reference answer, and scoring rules corresponding to the request from the benchmark question set; for the benchmark question, calling all candidate question-answering engine configurations to perform question-answering processing respectively, generating multiple sets of candidate answer results; calculating the evaluation score of each candidate answer result relative to the benchmark reference answer according to the scoring rules; establishing an association between the evaluation score and the corresponding candidate question-answering engine configuration and writing it into the evaluation result storage unit; periodically summarizing the evaluation scores in the evaluation result storage unit to form a comprehensive evaluation dataset for the current period.

[0011] S5 includes: calculating the average evaluation score of each candidate question-answering engine configuration in the current period based on the comprehensive evaluation dataset; generating a corresponding reward value using the average evaluation score to characterize the performance of each candidate question-answering engine configuration; inputting the reward value into the online learning algorithm module to perform a weight update calculation based on a multi-armed slot machine strategy; dynamically adjusting the configuration weights of each candidate question-answering engine configuration according to the output results of the online learning algorithm; and writing the updated configuration weights into the configuration weight storage unit so that the target question-answering engine configuration for subsequent ordinary consultation requests can be selected based on the latest weights.

[0012] S6 includes: after completing the configuration weight update, reading the updated configuration weight; for subsequent received ordinary consultation requests, calling the process in step S3, and using the updated configuration weight to determine the target question-answering engine configuration; in the new round of question-answering processing, continuing to evaluate the benchmark question triggering requests in parallel according to the mechanism in step S4; continuously triggering the online weight update in step S5 based on the accumulated evaluation scores, realizing continuous adaptive optimization of the system; forming a closed loop of online evaluation, weight update, and performance improvement with the benchmark question set as the core, enabling the technical consultation question-answering processing system to maintain stable question-answering quality and self-calibration capability during long-term operation.

[0013] The beneficial effects of this invention are as follows: This invention periodically triggers a benchmark question set during system operation, enabling the question-answering system to continuously collect evaluation data in real-world interaction flows. Combined with online learning algorithms, the engine weights are automatically updated, thus forming a sustainable self-learning capability. Unlike traditional solutions that rely on manual testing or static parameter tuning, this invention achieves "service-while-optimizing" without manual intervention. That is, the system completes a self-calibration process while maintaining real-time responses to user requests, allowing question-answering accuracy and response stability to gradually improve over time, avoiding the "aging drift" problem of the model, and possessing long-term self-evolutionary characteristics.

[0014] The weighted sampling engine selection strategy proposed in this invention enables different model versions, retrieval strategies, and inference parameters to operate collaboratively under a unified scheduling system. The system can dynamically allocate request probabilities based on the historical scores and real-time reward values ​​of each engine, achieving evolutionary optimization of "using stronger engines more and weaker engines less." This dynamic scheduling based on feedback signals breaks through the limitations of fixed priority strategies, allowing question-answering task allocation to no longer rely on human experience, but rather be automatically made by the system to achieve optimal performance decisions. This significantly improves resource utilization efficiency and average response speed, and has the dual effects of intelligent load balancing and optimal performance configuration.

[0015] This invention establishes a quantitative scoring system through joint modeling of four dimensions: semantic similarity, structural consistency, keyword coverage, and response latency. The scoring process is fully automated and can measure the deviation between the model output and the standard answer in real time. This multi-dimensional, time-decaying dynamic scoring mechanism can objectively reflect model performance in different technical fields and task types, providing measurable feedback signals for weight learning. This makes system tuning mathematically interpretable and results traceable, overcoming the technical shortcomings of traditional question-answering optimization, which is "empirical" and "unverifiable."

[0016] This invention introduces a performance monitoring and stability detection module after weight updates to continuously track the accuracy, latency, and availability metrics of each engine. When performance degradation or excessive fluctuations are detected, the system automatically adjusts the learning rate and confidence coefficient, and can perform weight decay and replacement operations on poorly performing engines. Through this closed-loop control mechanism, the system can automatically prevent overfitting or oscillations during long-term operation, causing the weight distribution to converge, thus forming an adaptive control system with "steady-state learning" characteristics. This feature has significant non-obviousness and inventiveness in the field of dynamic fusion of AI models.

[0017] This invention achieves adaptive optimization without retraining the model, making it suitable for various practical scenarios, including equipment maintenance and diagnostics, engineering consulting, software development technical support, and professional question-and-answer fields such as healthcare and energy. The system supports hot-switching of multiple models and online version management, and can dynamically expand the number of engines according to business scale, enabling intelligent collaboration in large-scale distributed question-and-answer. This online evaluation, self-learning, and hot-optimization architecture combines real-time performance with scalability, transforming the AI ​​question-and-answer system from a static tool into an intelligent decision-making entity with continuous evolution capabilities, significantly enhancing the system's practical value and industry applicability in complex business environments. Attached Figure Description

[0018] Figure 1 This is a schematic diagram of the technical consultation question-and-answer processing method based on AI adaptive optimization according to the present invention. Detailed Implementation

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

[0020] Example 1: As Figure 1 As shown, this embodiment provides a technical consultation question-and-answer processing method based on AI adaptive optimization, including the following steps: S1. Initialize candidate question answering engine configurations, pre-set multiple candidate question answering engine configurations including model versions, knowledge retrieval strategies and inference parameter combinations, assign initial configuration weights to each candidate question answering engine configuration, and establish a benchmark question set including benchmark questions, benchmark reference answers and scoring rules; S2. Collect user-input technical consultation and Q&A requests, parse the question text, extract topic tags and complexity indicators, and determine whether the request matches the benchmark question set based on semantic similarity. Mark successfully matched questions as benchmark question trigger requests and unmatched questions as ordinary consultation requests. S3. For ordinary consultation requests, the target question-answering engine configuration is determined by weighted sampling based on the configuration weights of each candidate question-answering engine. The corresponding model is then invoked to perform question-answering reasoning, generate the target answer result, and return it to the terminal. S4. When a baseline question triggers a request, all candidate question answering engines are called to generate candidate answer results. Multidimensional evaluation scores are calculated based on preset semantic similarity, structural consistency and keyword matching rate. The average scores of each engine configuration are then combined to form a comprehensive evaluation dataset. S5. Calculate the reward value configured for each candidate question answering engine based on the comprehensive evaluation dataset, input the reward value into the online learning algorithm module to perform weight update, adjust the configured weights using a multi-armed slot machine or Softmax strategy and perform normalization processing, and write the updated weights into the configured weight storage unit. S6. In subsequent question-and-answer processing, the updated configuration weights are called to select the target question-and-answer engine configuration, continuously triggering the benchmark question evaluation and weight learning loop, monitoring the performance indicators of each engine to achieve self-calibration and stability maintenance, forming an adaptive optimization closed loop of initialization, question-and-answer execution, benchmark evaluation, weight update and application feedback.

[0021] S1 specifically includes the following sub-steps: S110. Multiple candidate question-answering engine configurations are preset in the technical consultation question-answering system. Each candidate question-answering engine configuration consists of a model version, knowledge retrieval strategy, and inference parameters. The candidate question-answering engine configurations are stored in the system as structured records. The data structure includes fields: Model ID, Retrieval Strategy ID, Inference Param Set, and Configuration Weight. These records can be stored as database tables or JSON objects for loading and invocation during system initialization.

[0022] S120. Assign initial configuration weights to each candidate question-answering engine. Its value ranges from 0 to 1. If the system is being deployed for the first time, the equal-weight allocation rule will be executed. If historical performance data exists for the system, then the historical average score will be used. The initial weights are generated using the following formula: ; And perform normalization constraints. This ensures that the weight distribution of all candidate question-answering engine configurations is repeatable and verifiable; among which... This represents the initial weight value configured for the i-th candidate question-answering engine; represents the average question-answering score of the engine during its historical operation phase; n represents the number of candidate question-answering engine configurations; the superscript (0) indicates the weight version during the initialization phase.

[0023] S130. Construct a set of benchmark questions, which contains multiple benchmark questions. Each benchmark problem corresponds to a benchmark reference answer. The system provides each pair Preset scoring rules and weighting coefficients The scoring rules include semantic similarity. Keyword matching degree and structural consistency Three dimensions, with scores ranging from 0 to 1; weighting coefficients satisfy This is used to balance the importance of the scores across different dimensions.

[0024] The benchmark question set is stored in association with the system database to ensure consistency of scoring criteria in subsequent evaluation phases; among which, Let j represent the j-th benchmark problem. This represents the standard reference answer corresponding to the benchmark question. This represents the weighting coefficients used for each scoring dimension.

[0025] S140, Define trigger parameters for each benchmark problem The parameters are used to control the time interval or call frequency of the baseline question trigger; the triggering strategy can adopt a time window mechanism (e.g., triggering at least once per hour) or a request counting mechanism (e.g., the system triggers a baseline question once for every 100 ordinary consultation requests processed) to ensure that all candidate question answering engine configurations are covered and evaluated during the system's operating cycle.

[0026] in The trigger parameter for the j-th benchmark question can be expressed in seconds, minutes, or the number of requests. It is used to limit the minimum interval between two consecutive triggers. The trigger frequency can be adaptively adjusted according to the system load and sample distribution to ensure the balance and representativeness of the evaluation task.

[0027] S150. After completing the configuration of the candidate question-answering engine, the initial configuration weights, and the loading of the benchmark question set, the system registers the above objects to the configuration database through the API (Application Programming Interface) of the scheduling module and automatically executes the initialization verification process.

[0028] The verification process includes the following steps: checking whether the number n of candidate question-answering engines is consistent with the system's preset value; and verifying whether the configuration weights meet the normalization constraints. Confirm that the entire baseline query set has been successfully loaded. If all the above checks pass, the system generates an initialization completion flag E_init_complete and switches the running status to RUNNING. The verification results are output through the log module, recording fields including timestamp, check item identifier (Check_ID), and execution result (Result_Code) to ensure that subsequent question-and-answer processing and online optimization processes have unified basic data support and traceability.

[0029] S2 specifically includes the following sub-steps: S210. During system operation, the system receives technical consultation / question requests from users on the terminal device and parses the question text. The system is configured with a request receiving module on the receiving end. This module supports multiple input channels, including web, mobile and API (Application Programming Interface) inputs. The received data is encapsulated in JSON format.

[0030] The system will parse the obtained question text Stored in the input buffer for subsequent unified parsing processing; where This represents the text of the technical inquiry submitted by the user; Request_ID, User_ID, Timestamp, and Question_Text are the fields for request identifier, user identifier, time record, and question content, respectively.

[0031] S220. Invoke the question parsing model to process the user-inputted question text. By performing word segmentation, named entity recognition, and keyword extraction, a set of topic tags for the question is obtained: ; in This represents the i-th topic tag, which can be a technical term, entity name, or high-frequency keyword. The system calculates the problem complexity index based on the parsing results. Its definition is as follows: ; In the formula Indicates the number of technical terms detected (unit: items); Indicates the syntactic dependency depth (calculated from the dependency syntax tree, reflecting syntactic complexity); Indicates the length of the question text (unit: word count or character count); The weight coefficients of the above three items are respectively, satisfying... Furthermore, each coefficient can be set based on experience or training data; the system is based on... The value of classifies the problem complexity into three levels: "basic," "advanced," and "high complexity," and the results are written to the problem parsing result table for subsequent use by the question-answering scheduling module. The larger the value, the more complex the problem.

[0032] S230. Call the benchmark problem matching module to extract all benchmark problems from the benchmark problem set. Calculate user problems Semantic similarity with each benchmark problem: ; in The semantic vectorized representation of question Q is generated by a word vector model (such as BERT, Word2Vec, or TF-IDF) with a dimension of d (typically d=768).

[0033] By iterating through all The system calculates the maximum similarity. ,like If the current request triggers the corresponding baseline issue event, then the threshold is determined. The semantic similarity threshold is preset for the system or learned from historical samples, with a value range of 0.7-0.9. The matching results are recorded in JSON format, where the closer the semantic similarity is to 1, the more similar the semantics are. The system writes the matching results into the database for subsequent weight updates and performance evaluation.

[0034] S240, Perform problem type marking based on the matching result of S230. If Then mark the issue as a "baseline issue trigger request"; if If so, it will be marked as a "normal consultation request".

[0035] The marking results are written to the question type table in a structured format. The data structure is defined as follows: { "Request_ID": "String, representing a unique identifier for the current request", "Question_Type":"ENUM, with values ​​{Reference,Normal}, representing a reference question trigger request and a regular consultation request, respectively". "Complexity_Level": "ENUM, with values ​​{Basic, Intermediate, Advanced}, corresponding to the basic, intermediate, and advanced levels of problem complexity, respectively." } Question_Type is determined based on the similarity result of S230, and Complexity_Level is determined based on the complexity index of S220. Automatic assignment: After generating the labeling results, the system writes them into the question type table (Question_Type_Table) and synchronizes them to the input cache of the weight update module for adaptive tuning of the candidate question answering engine configuration.

[0036] Question text Collection of topic tags Complexity metrics The question type and matching information are stored together in the session data cache.

[0037] The session data cache is a temporary storage module of the system, which can be implemented using an in-memory database (such as Redis) or a circular cache queue, and is used to maintain context consistency in the question-and-answer process.

[0038] After the write operation is completed, the system performs a data integrity check to verify the field integrity rate, data type correctness, and format validity, ensuring that all questions have a unique identifier and type tag. When the check passes, the system triggers the event signal E_data_ready, which is generated by the data write thread, indicating that the buffer is ready. After receiving the E_data_ready signal, the question and answer execution module starts subsequent question and answer processing, including the specific execution flow of ordinary consultation requests or benchmark evaluation requests.

[0039] S3 specifically includes the following sub-steps: S310, Configuration Weight Reading and Engine Set Loading: The system reads the weight set configured for all current candidate question-answering engines from the configuration weight storage unit. And load the candidate question answering engine configuration set. Where t represents the iteration time step or weight update time sequence number of the system operation.

[0040] The data structure definition for the weighted storage unit is as follows: Table: Engine_Weight_Config ├Engine_ID: String (primary key), used to uniquely identify the candidate question-answering engine; ├Weight_Value: Floating-point type (range 0–1), representing the current weight configured by the engine; └Last_Update_Time: Timestamp (ISO 8601 format), recording the time of the last weight update; the system performs normalization verification on all weight values ​​to ensure that the following constraints are met:

[0041] If the normalization bias detected exceeds the threshold The system triggers a weight reset process: recalculates the weight vector and performs a normalization update to maintain probability consistency and model convergence stability; after verification, the system outputs a loading success event signal E_weight_ready, notifying subsequent modules to perform question-answering inference or weight optimization operations.

[0042] S320, Target Question Answering Engine Configuration Selection: Based on the read weight set The system uses a weighted random sampling algorithm to determine the target question-answering engine configuration for the current ordinary consultation request. ;in This represents the target question-answering engine configuration instance selected in this round of sampling; the system uses a roulette-weighted sampling algorithm to calculate the selection probability of each candidate engine configuration, defined as follows: ; In the formula Let be the configuration weight of the i-th candidate question answering engine at the current time step t. This is a minor disturbance term used to prevent configurations that have not been selected for a long time from being completely eliminated; its value range is [value range missing]. The system applies to all Perform normalization processing to ensure The probability of selecting the sampling result is proportional to the configuration weight. The algorithm has a time complexity of O(n) and is suitable for real-time scheduling tasks.

[0043] The sampling results are recorded in a structured format as follows: { "Request_ID": "String, a unique identifier for the current request", "Selected_Engine_ID": "String, representing the selected engine configuration number", "Selection_Weight": "Floating-point type, representing the actual sampling probability value of this engine", "Timestamp": "Timestamp (ISO 8601 format)" } After the system finishes recording, it will It is passed to the question-and-answer execution module to generate the final answer to this round of consultation requests.

[0044] S330, Problem Handling and Inference Execution: System Calls and Configuration of the Selected Target Question Answering Engine The corresponding model version, knowledge retrieval strategy, and inference parameter combination for the question text Conduct question-and-answer reasoning.

[0045] The execution process includes the following stages: Retrieval Phase: Based on the knowledge retrieval strategy, relevant entries are retrieved from the knowledge base using a two-layer retrieval structure of "vector recall + keyword filtering".

[0046] The first layer calculates semantic similarity and recalls candidate documents using a semantic vector model (such as Embedding-Retrieval); the second layer performs fine-grained ranking using keyword matching or the BM25 algorithm to obtain a knowledge retrieval result set; in the generation stage, the system inputs the retrieval results into a database... The corresponding inference model version (Model_ID) is used to generate the response text based on the inference parameter set (e.g., temperature, top_p, max_tokens, etc.). Model calls are made through a unified model interface layer (Model_API) to ensure pluggable switching between different model versions.

[0047] Post-processing stage: processing the generated response text Perform deduplication, redundancy removal, and terminology normalization; terminology normalization is based on a standard glossary to ensure consistent output style and semantic accuracy; Response time measurement phase: The system calculates the time delay from invoking the inference model to the generation of a complete answer. The unit is milliseconds (ms), used to evaluate the model's real-time response performance and as a basis for subsequent optimization. After the above processing, the system outputs the final answer result. And record the corresponding model version identifier and response latency metric.

[0048] S340. Response Return and Security Review: The system will return the target response result. Before returning to the user terminal, content verification is performed through the security audit module; the security audit includes the following three checks: Sensitive content detection: Based on a two-layer structure of keyword rule base matching and semantic judgment model, it detects whether the content contains sensitive words or prohibited expressions; Response length constraint detection: Verifies the length of the response text. Does it exceed the system's maximum allowed number of characters? (Typical value: 2048 characters, configurable); Technical field consistency check: Verify whether the semantic topic of the answer matches the question's topic tag set. If the detection results show any violations, the system will trigger an automatic regeneration mechanism, calling the backup question-and-answer engine configuration to regenerate the answer text. Until the security review is passed or the regeneration limit (2 times) is reached.

[0049] After the security review is passed, the system generates a security pass signal E_safe_pass and returns the final answer to the user terminal.

[0050] The final output structure is as follows: { "Request_ID": "String, a unique identifier for the current request", "Answer_Text": "A string representing the final generated answer content", "Response_Time": "Floating-point type (unit: ms), representing the model generation delay", "Engine_ID": "String, the model version identifier that generated this answer", "Safety_Status":"ENUM{Pass,ReGen}, representing whether the pass was successful or a regeneration was triggered, respectively." } The value "Safety_Status=ReGen" indicates that the answer has undergone a security regeneration process. If it fails the review more than twice, it will be recorded as "ReGen-Fail" and a security warning log will be output.

[0051] S350. Result Recording and Performance Log Storage: The system records the complete information of this ordinary consultation request to the question-and-answer log database for subsequent performance evaluation and adaptive tuning; the question-and-answer log database table structure is defined as follows: Table:QnA_Log ├Request_ID: A string representing a unique identifier for the current request; ├Engine_ID: String, representing the configuration number of the question-answering engine executed in this round; ├Question_Text: A string representing the text of the input question; ├Answer_Text: A string representing the generated answer text; ├Response_Time: Floating-point type (unit: ms), representing the delay from when the model receives a request to when it outputs a result; ├Safety_Status:ENUM{Pass,ReGen,Fail} represents the security audit result; └Timestamp: Timestamp (ISO 8601 format).

[0052] At the same time, the system calculates the real-time performance metrics for this round of question-and-answer: ; in Indicates the actual response time of the model (in milliseconds); This represents the security review score, ranging from [0,1]. The user feedback score is calculated by linearly normalizing the satisfaction rating (1–5). These are weighting coefficients, typically taking values ​​of 0.4, 0.3, and 0.3; after the system completes the calculation, it will... As input variables for the next round of evaluation and weight update algorithm, and triggering the event signal E_perf_ready to notify the weight optimization module to perform the update operation; if an anomaly is detected during the log writing process, the system automatically triggers the retry event E_log_retry to ensure the integrity and traceability of performance data.

[0053] S4 specifically includes the following sub-steps: S410, Benchmark Problem Extraction and Task Distribution: When a benchmark problem trigger request is detected, the system extracts the benchmark problem that matches the request from the benchmark problem set. And simultaneously read the corresponding benchmark answer. and its set of scoring weight coefficients . The system generates a unique task ID, EvalTask_ID, based on a timestamp and a random seed hash, ensuring global uniqueness. The system then distributes the task to all candidate question-answering engine configurations based on this ID. In order to perform a standardized conformity assessment.

[0054] The data packet structure is defined as follows: { "EvalTask_ID": "String, unique task number", "Question_Text": "String, the text of the benchmark question that triggered it", "Reference_Answer": "String, the text of the benchmark answer", "Score_Weights":" , respectively corresponding to semantic similarity, keyword matching degree, and structural consistency weight", "Dispatch_Time": "Timestamp, task dispatch time (ISO 8601 format)" } The system asynchronously broadcasts tasks through message queue modules (such as Kafka and RabbitMQ) and ensures the parallelism and consistency of task distribution through a distributed lock mechanism. If any node fails to respond within the specified time limit... If no result is returned within 5 seconds (typical value), the timeout flag Timeout_Flag=True is recorded, and the task reassignment mechanism is triggered. All task status, response time, and abnormal events are written to the Eval_Task_Log table to provide complete traceability data for subsequent performance analysis and weight updates.

[0055] S420, Parallel Inference and Result Collection of Candidate Engines: After receiving the evaluation task, the system configures all candidate question-answering engines. Task packages are distributed in parallel. Each task includes a baseline question text, a reference answer, and evaluation parameters. Each engine independently performs question-answering reasoning and generates corresponding candidate question-answer results. . The system maintains an asynchronous result queue through a scheduling module. The queue element structure is defined as follows: { "EvalTask_ID": "String, evaluation task number", "Engine_ID": "String, question answering engine configuration number", "Generated_Answer": "String, the answer content generated by the candidate engine", "Response_Time": "Floating-point type, unit ms, response time", "Status": "ENUM{Success,Timeout,Error,Retry}" } The system employs a thread pool parallel execution model to initiate asynchronous calls to each engine and continuously monitors the task return status through a Future listener mechanism; if any engine reaches its maximum waiting time... If no result is returned within 5 seconds (typical value), Status=Timeout will be automatically recorded and a timeout event E_timeout_flag will be triggered; when all engine results are returned or the timeout period is reached... When the result collection module closes the current evaluation channel, it automatically triggers the score calculation event E_score_calc, and sends all result data to the evaluation module for unified scoring and weight updates. If an anomaly or error is detected, the system performs an automatic reassignment operation and writes the anomaly details to the Error_Log table. Finally, all candidate results and execution logs are synchronously stored in the cache table QnA_Engine_Result for subsequent performance analysis and adaptive optimization.

[0056] S430, Evaluation Score Calculation and Multidimensional Quantization: The system outputs results for each candidate engine based on preset multidimensional scoring rules. Quantitative evaluation is conducted to generate a comprehensive score. The formula for the comprehensive evaluation model is: ; in To represent semantic similarity, the cosine similarity is calculated after extracting sentence vectors using the Sentence-BERT model. To represent structural consistency, the edit distance normalization result of the dependency parsing tree is used. The keyword matching rate is represented by the keyword co-occurrence ratio between candidate answers and the benchmark answer. The system is configured based on application domain experience. To balance the impact of response latency on model performance, the system introduces time correction weights:

[0057] in The time decay coefficient, For response time (ms). The final corrected score is calculated as follows: ; The score ranges from [0,1] and reflects the overall quality of the candidate engine in terms of semantics, structure, and response performance. The system writes the calculation results into the multidimensional scoring database table Engine_Score_Record, whose structure is as follows: Table: Engine_Score_Record ├EvalTask_ID: String, the evaluation task number ├Engine_ID: String, question-answering engine configuration number ├Semantic_Score: Floating-point number, semantic similarity score ├Structural_Score: Floating-point value, structural consistency score ├Keyword_Score: Floating-point number, keyword matching score ├Time_Weight: Floating-point type, time-adjusted weight ├Total_Score: Floating-point number, weighted average score └Timestamp: Timestamp (ISO 8601 format) The multidimensional evaluation results serve as the input for the next step (S440) "weight update and adaptive tuning" to achieve dynamic optimal configuration of multiple engines.

[0058] S440, Evaluation Result Archiving and Weight Mapping: The system configures each candidate question-answering engine. Evaluation score Establish a one-to-one mapping relationship with its engine identifier: ; in It is a two-dimensional matrix, where the i-th row represents the candidate question answering engine and the j-th column represents the evaluation score of the corresponding benchmark question. The matrix dimension is m×n, where m is the number of engines and n is the number of benchmark questions.

[0059] The system writes the mapping result to the evaluation result storage unit Engine_Score_Matrix_Storage, and performs an integrity check on the data after each round of evaluation to verify whether all candidate question-answering engines have returned valid results or missing indicators; if a missing record or abnormal return (such as Status=Timeout or Error) is detected, the system automatically fills in the default score. And fill the Error_Flag=True flag to ensure that the matrix dimensions are consistent with the number configured in the engine.

[0060] The system performs hash verification and dimension verification on Engine_Score_Matrix through the verification module. After confirming the consistency of the matrix, the results are synchronously written to the cache Score_Cache_Unit and the log table Score_Update_Log as the input data source for subsequent weight adaptive tuning (S450).

[0061] S450, Periodic Summary and Comprehensive Evaluation Dataset Generation: The system generates datasets during preset evaluation periods. Within the system, the historical evaluation scores of each candidate question-answering engine are automatically aggregated, and their average score and performance stability indicators are calculated.

[0062] The formulas for calculating the average score and variance are as follows:

[0063] Where m represents the total number of baseline tasks within the evaluation period, the system automatically removes outliers (such as samples with Error_Flag=True) and uses an exponentially moving weighted average to correct the mean, thereby enhancing data representativeness and real-time performance. To improve the stability of the system's self-learning, the system will... and The combined features are input as feature vectors for engine performance evaluation into the comprehensive evaluation database Engine_Performance_Summary, with the following table structure: Table:Engine_Performance_Summary ├Engine_ID: String, identifier of the candidate question-answering engine ├Avg_Score: Floating-point type, average score over the period (normalized range 0–1) ├Variance: Floating-point type, score variance, used to reflect performance fluctuations. ├Sample_Count: Integer type, the number of tasks m that participated in within the period. ├Last_Update_Time: Timestamp (ISO 8601 format) The system uses this comprehensive performance dataset as the input source for the subsequent online learning and weight adaptation module (S460), combining reinforcement learning algorithms to dynamically configure weight updates, enabling the model to automatically tend towards optimal scheduling balance during multi-cycle operation; when the variance is detected to exceed the tolerance threshold... When an abnormal event occurs, the system records the abnormal event E_var_alert and triggers policy fine-tuning to maintain the stability of the evaluation process.

[0064] S5 specifically includes the following sub-steps: S510, Reward Value Calculation and Performance Normalization: The system obtains the configuration of each candidate question-answering engine based on the comprehensive evaluation dataset generated in stage S450. average score With stability coefficient Calculate its reward value . The reward function is defined as follows:

[0065] in The weighting coefficients for performance and stability satisfy... ; This indicates the average performance of the engine; This is a volatility penalty term used to suppress unstable engines; typical system settings. This prioritizes encouraging high-performance and stable engine configurations.

[0066] To avoid extreme reward values ​​causing oscillations in the learning strategy, the system performs linear normalization on all reward values: ; in These represent the maximum and minimum engine reward values ​​for the current period, respectively. After normalization, This is used as a standardized reward signal input to the reinforcement learning module; if an outlier is detected... The system automatically sets And record the warning flag Warning_Flag=True.

[0067] Finally, the system writes the calculation results into the Engine_Reward_Record table, with the following structure definition: Table: Engine_Reward_Record ├Engine_ID: String, identifier of the candidate question-answering engine ├Raw_Reward: Floating-point type, unnormalized reward value

[0068] ├Normalized_Reward: Floating-point value, normalized reward value

[0069] ├Timestamp: Timestamp (ISO 8601 format) └Warning_Flag: Boolean, flag for abnormal input. The reward record table serves as the input for the online learning weight update module in the next step (S520). The system dynamically adjusts the configuration weights of each engine based on the reward signals to achieve adaptive optimization based on real-time performance feedback.

[0070] S520, Online Learning Algorithm Selection and Weight Update Calculation: The system normalizes the reward value from S510. The online learning algorithm module is used to calculate the weights for the next round of question-answering engine configuration. The online learning module supports two types of weight update algorithms: The Upper Confidence Bound (UCB) algorithm (suitable for stable environments) uses the following weight update formula:

[0071] in It is the learning rate (0.01–0.1); It is a confidence coefficient (0.5–2.0), used to balance exploration and exploitation; It's an engine. The number of times it is scheduled in the current cycle; It is the average reward for the current cycle; the algorithm promotes exploration in the early stage through confidence intervals, and gradually converges in the stable stage, so that the high-performance engine can be given higher weight.

[0072] The Softmax policy update algorithm (suitable for highly dynamic environments) uses a probability distribution to smoothly adjust weights.

[0073] in This is a temperature coefficient (0.1–1.0), used to control the balance between exploration and utilization. The system will set the weight for the next round as follows:

[0074] And automatically select the algorithm type according to the system configuration parameter Learning_Mode: if evaluating the variance mean If the system fluctuates significantly, then the UCB mode is adopted; if the system fluctuates significantly... If so, then the Softmax mode is used.

[0075] After each update, the system performs normalization constraints to ensure that:

[0076] The final weight results are then written to the database table Engine_Weight_Record. Table: Engine_Weight_Record ├Engine_ID: String, question-answering engine configuration number ├Learning_Mode:ENUM{UCB, Softmax} ├Weight_Value: Floating-point type, the weight of the current iteration. ├Confidence_Coefficient: Floating-point type

[0077] ├Update_Time: Timestamp (ISO 8601 format) The system continuously monitors during periodic iterations. and By analyzing the changing trends, a dynamic balance between exploratory and convergent approaches is achieved, enabling the entire question-answering system to possess self-learning and adaptive optimization capabilities.

[0078] Weight normalization and constraint verification: the set of weights output by the algorithm After normalization, the constraints are met to ensure that the sum of all engine weights is always 1; the normalization formula is as follows:

[0079] The system then performs constraint checks to confirm that the normalized weights meet the following conditions:

[0080] If the system detects an anomaly (including negative weights or errors exceeding the threshold), it will trigger an automatic smoothing reset mechanism:

[0081] in This is a random perturbation compensation term, used to prevent convergence stagnation caused by identical distributions, and is randomly generated in the interval [0, 1]. The system is renormalized after a smooth reset to ensure that all weights satisfy the conservation condition.

[0082] The final normalized weight vector is written to the database table Weight_Normalization_Log for subsequent performance analysis and training tracking.

[0083] Table:Weight_Normalization_Log ├Iteration_ID: Integer, the current iteration number. ├Engine_ID: String, identifier of the question-answering engine ├Normalized_Weight: Floating-point type, normalized weight ├Deviation_Error: Floating-point type, deviation value

[0084] ├Epsilon_Value: Floating-point type, perturbation term

[0085] ├Validation_Flag: Boolean (whether validation passed) ├Timestamp: Timestamp (ISO 8601 format) If the system detects a deviation error in three consecutive iterations If this happens, the weight retraining module S540 will be automatically triggered to ensure the learning process remains stable.

[0086] S540, Update Writing and Version Management: The system will verify the set of weights. The configuration weights are written to the storage unit, and a version control mechanism is established. Each write operation generates a unique version number (Version_ID) and records the update timestamp to achieve traceable management of weight evolution. The version number can be generated by combining timestamps and hashes.

[0087] The data writing structure is as follows: Table: Engine_Weight_History ├Version_ID: String, unique version number (generated by SHA256) ├Engine_ID: String, question-answering engine configuration number ├Weight_Value: Floating-point type, current normalized weight ├Learning_Mode: ENUM{UCB,Softmax} ├Algorithm_Params: JSON, records the algorithm parameters for this round.

[0088] ├Update_Time: Timestamp (ISO 8601 format) The system retains the most recent N version records (N=20) by default and automatically discards the oldest version to control storage resource consumption; if model drift or abnormal weight fluctuations are detected... The system will trigger historical version backtracking and parameter comparison analysis to optimize the initial weights for the next round of the algorithm; simultaneously, the system can use the difference index... Generate visual reports to assist engineers in reviewing model performance and adjusting strategies.

[0089] S550, Triggering subsequent learning loops and self-calibration signals: After successfully writing new weights, the system generates an event signal E_weight_updated to notify the scheduling module and the question-answering engine module to execute the next round of tasks using the updated weights.

[0090] This signal is an internal event-triggered signal with non-blocking properties, capable of activating reinforcement learning loops in an asynchronous environment, avoiding system waiting or resource idleness; Self-calibration detection module: After receiving the event signal, the system performs self-calibration detection to dynamically adjust learning parameters: If the average reward growth rate over three consecutive cycles meets the following:

[0091] The learning rate will be automatically halved. To prevent excessive oscillation; if performance is significantly improved Then, the confidence coefficient c is increased to enhance the exploration intensity; where Reward growth threshold (range of values) ); Performance improvement threshold (range of values) The system can automatically adjust two thresholds based on the volatility of the last ten rounds to maintain balance.

[0092] Self-feedback loop mechanism: Through the above threshold detection, the system forms a self-feedback closed loop, so that the configuration weights automatically tend to the optimal distribution in long-term operation; when a stable trend is detected (i.e., After three consecutive rounds, the system enters "balanced mode," performing only fine-tuning operations; conversely, when performance degrades (i.e., ... When the system automatically triggers the restart signal E_retrain, it resamples the historical best version weights to restore stable performance. Ultimately, through this self-looping and self-calibration mechanism, the system achieves continuous self-evolution, enabling the question-answering module to have long-term adaptive optimization capabilities and maintain performance convergence and stable growth.

[0093] S6 specifically includes the following sub-steps: S610, Weight Result Loading and Synchronization Activation: After detecting the event signal E_weight_updated, the system reads the latest weight set from the configuration weight storage unit. The corresponding version number (Version_ID) is then loaded into the runtime cache for subsequent use by the scheduling module and the question-answering engine module.

[0094] The data reading structure is as follows: Table: Engine_Weight_Config ├Version_ID: String, the currently loaded version number ├Engine_ID: String, engine configuration number ├Weight_Value: Floating-point value, engine weight value ├Update_Time: Timestamp (ISO 8601 format) After loading, the system performs a version consistency check to verify that the number of all candidate question-answering engine configurations corresponds one-to-one with the weight entries. If the check passes, the system marks the version as the currently active version. If inconsistencies in fields, missing data, or version number conflicts are detected, the system automatically reverts to the previous valid version Version_ID_(t) and triggers a warning log.

[0095] The log structure is defined as follows: Table:Weight_Load_Log ├Event_ID: Integer type, event number ├Current_Version: String, the currently loaded version ├Rollback_Version: String, the target version to roll back to. ├Error_Type:ENUM{Mismatch, Missing, Conflict} ├Recovery_Status:ENUM{Success, Fail} ├Timestamp: timestamp Through this mechanism, the system can complete the loading of new weights and version activation in milliseconds, ensuring that the question-answering engine module has the latest performance immediately after the weight update, and automatically rolls back in case of anomalies to maintain the stability of system operation.

[0096] S620, Weight-Driven Dynamic Engine Scheduling Execution: After receiving a new general consultation request, the system calls the same engine selection module as S3, using the updated weight set. Select the target question-answering engine configuration.

[0097] The scheduling probability is defined as:

[0098] The system performs random sampling with this probability and maintains a sliding buffer mechanism, storing the K most recent tasks in a dynamic buffer. The buffer structure is defined as follows: Cache:Engine_Selection_History ├Request_ID: String, request number ├Engine_ID: String, the selected engine number ├Applied_Weight: Floating-point type, the actual weight used in this application. ├Response_Time: Floating-point type, response time (seconds) ├Timestamp: Timestamp (ISO 8601 format) The system analyzes response latency and accuracy fluctuations within the sliding window and calculates load skew in real time.

[0099] When detected At that time, the system dynamically adjusts the sampling probability:

[0100] The system then updates the corrected actual sampling results in the cache. Simultaneously, it performs debouncing detection within a sliding window: if a single engine is called more than K / 2 consecutively, its weight is softly decayed.

[0101] in To avoid single-point overload, the system synchronously writes the actual response latency and the difference between the application weights into the performance feedback cache Perf_Eval_Buffer, which serves as the input for the next online learning cycle. Through this dynamic scheduling and feedback mechanism, the system ensures that weight updates are reflected in the business flow in real time, achieving real-time adaptive optimization and performance balancing of the question-answering engine's resource allocation.

[0102] S630, Continuous Evaluation of Benchmark Problems and Online Learning Loop: The system continuously detects the benchmark problem triggering conditions (see S140). When the triggering conditions are met, a new round of benchmark problem triggering requests is periodically generated.

[0103] When a new task is initiated, the system automatically invokes the evaluation mechanism in steps S410–S450 to perform parallel evaluation of the configurations of each candidate question-answering engine, generating a new round of scoring matrices. This matrix includes multi-dimensional scores such as semantic similarity, structural consistency, and keyword matching rate. The evaluation results are pushed to the online learning algorithm module (corresponding to S520) via the event signal E_score_update. After receiving the signal, the online learning module performs the following based on the mapping relationship:

[0104] The score matrix is ​​transformed into reward input, triggering the S520 weight update process to achieve continuous adaptive adjustment of the weights. The system monitors and evaluates the rate of score change.

[0105] If the rate of change is less than [a certain value] in three consecutive rounds of evaluation. Then it enters a stable mode, maintaining only sampling evaluation, reducing computational overhead, and ultimately forming a continuously running "weight application – benchmark evaluation – weight relearning" cycle, enabling the system to automatically achieve dynamic convergence that balances model accuracy and performance during long-term operation.

[0106] S640, Operational Performance Monitoring and Parameter Self-Calibration: During long-term operation, the system periodically calculates the set of operational performance indicators for each engine configuration.

[0107] in The average accuracy is based on user feedback or standard comparison results. The average response time (seconds) is given, and Uptime is the engine availability ratio (average over the past 7 days). For empirical weighting coefficients, satisfying . When the performance metric of any engine configuration is detected to be below the threshold When this happens, the system triggers the self-calibration module and performs the following operations: temporarily reduce the weight of this engine. Add the engine to the Observation_Pool for continuous monitoring.

[0108] The system continues to calculate performance metrics in subsequent cycles. If performance recovers within M consecutive cycles (e.g., M=3), the system will be considered successful. If the performance continues to decline, the corresponding model version will be automatically removed from the observation pool and its original weights restored. If the performance continues to decline, the corresponding model version will be automatically replaced and the record will be marked. This mechanism realizes a closed loop of self-monitoring, self-decay and self-repair of running parameters, ensuring that the system maintains stable performance and optimal learning efficiency in long-term operation.

[0109] S650, System-wide Closed-Loop Verification and Stability Maintenance: After each complete tuning cycle (including three phases: weight update, scheduling execution, and benchmark evaluation), the system performs a global closed-loop verification.

[0110] First, a data consistency check is performed to confirm that the engine number and version number in the weight table, log table, and evaluation table are completely consistent. Then, a convergence check is performed to calculate the average reward difference over three consecutive periods.

[0111] When satisfied When this happens, the system will mark the status as "Stable" and generate a periodic tuning report file. File:Adaptive_Tuning_Report_{Version_ID}.log ├Version_ID: string ├ Avg_Reward: Floating-point type ├Delta_Reward: Floating-point type ├Stability_Flag:ENUM{Stable,Unstable} ├Timestamp: timestamp The report records the average reward growth rate and the number of anomalies in the performance fluctuation curve for the current period; if stability is maintained for more than the set period... The system triggers the signal E_stable_confirmed, freezing the current weight set and entering "stable mode"; in frozen mode, the system suspends weight updates and only maintains performance monitoring; if detected... The system automatically unfreezes and re-enters the online learning cycle. Through this mechanism, the system achieves full lifecycle adaptive closed-loop optimization from the initial stage (S1) to the continuous operation stage (S6), ensuring that the technical consultation and Q&A processing system maintains stable performance and continuous improvement capabilities during long-term operation.

[0112] Example 2: This example provides an electronic device, which includes a processor, a storage medium, and a computer program. The computer program is stored in the storage medium, and when the computer program is executed by the processor, it implements the AI-based adaptive optimization technical consultation question-and-answer processing method of Example 1.

[0113] Example 3: This example provides a computer-readable storage medium storing a computer program thereon. When the computer program is executed by a processor, it implements the AI-based adaptive tuning technical consultation question-and-answer processing method of Example 1.

[0114] The above formulas are all dimensionless calculations. The formulas are derived from software simulations based on a large amount of collected data to obtain the most recent real-world results. The preset parameters and thresholds in the formulas are set by those skilled in the art according to the actual situation.

[0115] Those skilled in the art will recognize that the modules and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0116] In conclusion, the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A technical consultation question-and-answer processing method based on AI adaptive optimization, characterized in that, Includes the following steps: S1. Initialize candidate question answering engine configurations, pre-set multiple candidate question answering engine configurations including model versions, knowledge retrieval strategies and inference parameter combinations, assign initial configuration weights to each candidate question answering engine configuration, and establish a benchmark question set including benchmark questions, benchmark reference answers and scoring rules; S2. Collect user-input technical consultation and Q&A requests, parse the question text, extract topic tags and complexity indicators, and determine whether the request matches the benchmark question set based on semantic similarity. Mark successfully matched questions as benchmark question trigger requests and unmatched questions as ordinary consultation requests. S3. For ordinary consultation requests, the target question-answering engine configuration is determined by weighted sampling based on the configuration weights of each candidate question-answering engine. The corresponding model is then invoked to perform question-answering reasoning, generate the target answer result, and return it to the terminal. S4. When a baseline question triggers a request, all candidate question answering engines are called to generate candidate answer results. Multidimensional evaluation scores are calculated based on preset semantic similarity, structural consistency and keyword matching rate. The average scores of each engine configuration are then combined to form a comprehensive evaluation dataset. S5. Calculate the reward value configured for each candidate question answering engine based on the comprehensive evaluation dataset, input the reward value into the online learning algorithm module to perform weight update, adjust the configured weights using a multi-armed slot machine or Softmax strategy and perform normalization processing, and write the updated weights into the configured weight storage unit.

2. The technical consultation question-and-answer processing method based on AI adaptive optimization according to claim 1, characterized in that, It also includes S6, which calls the updated configuration weights to select the target question-answering engine configuration in subsequent question-answering processing, continuously triggers the benchmark question evaluation and weight learning loop, monitors the performance indicators of each engine to achieve self-calibration and stability maintenance, and forms an adaptive optimization closed loop of initialization, question-answering execution, benchmark evaluation, weight update and application feedback.

3. The technical consultation question-and-answer processing method based on AI adaptive optimization according to claim 1, characterized in that, S1 includes: In the technical consultation question and answer processing system, multiple candidate question and answer engine configurations are preset, and each candidate question and answer engine configuration includes a model version, knowledge retrieval strategy and inference parameter combination; Assign initial configuration weights to each candidate question answering engine and store the initial configuration weights in the configuration weight storage unit; Construct a benchmark question set containing multiple benchmark questions, corresponding benchmark reference answers, and scoring rules, and associate and bind it with the technical consultation question and answer processing system; Triggering conditions and triggering frequencies are set for each benchmark question in the benchmark question set to ensure that it can be periodically triggered and executed during system operation; The candidate question-answering engine configuration and the benchmark question set are synchronized and initialized, so that the subsequent question-answering process can be dynamically optimized based on a unified configuration weight system.

4. The technical consultation question-and-answer processing method based on AI adaptive optimization according to claim 1, characterized in that, S2 includes: Receive technical consultation and Q&A requests submitted by users from terminal devices, and parse the question text; The topic domain and complexity level of the question text are identified based on a pre-defined question analysis model; The triggering strategy determines whether the question text matches a benchmark question in the benchmark question set. If a match is found, the issue will be marked as a baseline issue to trigger a request; If there is no match, it will be marked as a regular consultation request; The question type tag information and the question text are stored together in the session data cache to provide input basis for subsequent question and answer processing.

5. The technical consultation question-and-answer processing method based on AI adaptive optimization according to claim 1, characterized in that, S3 includes: Read the configuration weights of each candidate question answering engine from the configuration weight storage unit; Based on the configuration weights, the target question-answering engine configuration for processing the current ordinary consultation request is determined by weighted sampling. The model version, knowledge retrieval strategy, and inference parameters corresponding to the target question-answering engine configuration are invoked to perform question-answering inference on the ordinary consultation request. Generate the target answer and return it to the corresponding terminal device, forming a user-visible output; Record the target question-answering engine configuration, ordinary consultation request text, and target answer results to the question-answering log for subsequent performance statistics and weight update reference.

6. The technical consultation question-and-answer processing method based on AI adaptive optimization according to claim 1, characterized in that, S4 includes: When a benchmark question trigger request is detected, the benchmark question, benchmark reference answer, and scoring rules corresponding to the request are extracted from the benchmark question set. For this benchmark question, all candidate question-answering engine configurations are invoked to perform question-answering processing and generate multiple sets of candidate answer results; The evaluation score of each candidate answer relative to the benchmark answer is calculated according to the scoring rules. The evaluation score is associated with the corresponding candidate question-answering engine configuration and written into the evaluation result storage unit; The evaluation scores in the evaluation result storage unit are periodically aggregated to form a comprehensive evaluation dataset for the current period.

7. The technical consultation question-and-answer processing method based on AI adaptive optimization according to claim 1, characterized in that, S5 include: Calculate the average evaluation score of each candidate question-answering engine configuration in the current period based on the comprehensive evaluation dataset; The average evaluation score is used to generate a corresponding reward value, which is used to characterize the performance of each candidate question answering engine configuration; The reward value is input into the online learning algorithm module to perform a weight update calculation based on the multi-armed slot machine strategy; Based on the output of the online learning algorithm, the configuration weights of each candidate question-answering engine are dynamically adjusted. The updated configuration weights are written to the configuration weight storage unit so that the target question answering engine configuration selection for subsequent ordinary consultation requests is based on the latest weights.

8. The technical consultation question-and-answer processing method based on AI adaptive optimization according to claim 2, characterized in that, S6 include: After completing the configuration weight update, read the updated configuration weight; For subsequent ordinary consultation requests, step S3 is invoked to determine the target question-answering engine configuration using the updated configuration weights; In the new round of question-and-answer processing, the baseline question trigger requests will continue to be evaluated in parallel according to the mechanism in step S4; The weights in step S5 are continuously updated online based on the accumulated evaluation scores, thereby enabling continuous adaptive optimization of the system. This forms a closed loop of online evaluation, weight update, and performance improvement centered on a benchmark question set, enabling the technical consultation question-and-answer processing system to maintain stable question-and-answer quality and self-calibration capability during long-term operation.

9. An electronic device comprising a processor, a storage medium, and a computer program, wherein the computer program is stored in the storage medium, characterized in that, When the computer program is executed by the processor, it implements the AI-based adaptive tuning technical consultation question-and-answer processing method according to any one of claims 1 to 8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the AI-based adaptive tuning technical consultation question-and-answer processing method according to any one of claims 1 to 8.

Images