Business execution method and device based on large model, medium and equipment

Abstract

The embodiment of the invention discloses a business execution method based on a large model, and the method comprises the steps: taking data inputted into the large model as initial data, reversely determining a final step which needs to be executed to obtain an output target, forwardly determining an inference boundary condition which can be deduced by the initial data, and according to the inference boundary condition and the final step, carrying out the business execution according to the inference boundary condition and the final step. And constructing a reasoning process to obtain an output result, and executing a service according to the output result. According to the method, a global solution direction is determined through independent reverse planning, blindness and local traps caused by only forward reasoning are avoided, better robustness and adaptability are embodied in a complex problem scene through butt joint of forward derivation verification and reverse planning, computing resources can be saved, and meaningless search overhead is reduced.

Description

Technical Field

[0001] This specification relates to the field of computer technology, and in particular to a business execution method, apparatus, storage medium and device based on a large model. Background Technology

[0002] In recent years, Large Language Models (LLMs) have been widely applied in various fields such as natural language processing, intelligent question answering, and decision support. With technological advancements, complex reasoning tasks—such as mathematical proofs, logical derivations, and complex problem-solving—have become important application scenarios. These tasks typically require models to perform multi-step reasoning, contextual understanding, and error correction, placing higher demands on the models' cognitive and reasoning abilities. Although LLMs excel in generating coherent text, their performance in complex structured reasoning still needs improvement.

[0003] In existing technologies, LLM mainly employs a forward reasoning approach from input to output target to generate output results, such as the common Chain-of-Thought (CoT) or Tree-of-Thought (ToT) reasoning methods. The CoT method solves the problem by guiding LLM to generate a series of consecutive intermediate reasoning steps, while methods such as ToT introduce a limited exploration mechanism on the basis of CoT, evaluating multiple possibilities by constructing a tree-like reasoning path.

[0004] However, existing technical solutions are essentially forward reasoning starting from the problem's origin, which exposes inherent limitations when dealing with complex problem scenarios. Specifically, they lack a holistic consideration of the ultimate goal; the reasoning process resembles a "blind search," easily leading to the selection of seemingly reasonable but ultimately unsuccessful local paths in the early stages, thus causing reasoning failure.

[0005] Based on this, this specification provides a business execution method based on a large model to partially solve the problems existing in the prior art. Summary of the Invention

[0006] This specification provides a business execution method, apparatus, storage medium, and electronic device based on a large model to partially solve the problems existing in the prior art.

[0007] The embodiments in this specification adopt the following technical solutions: This specification provides a business execution method based on a large model, the method comprising: Obtain the business data to be processed as the initial data for inputting the large model; Based on the initial data, the output target is determined through the large model, and according to the output target, the final steps required to obtain the output target are generated; With the goal of obtaining the prerequisites for executing the final step, the initial data is subjected to reasoning analysis to deduce the reasoning boundary conditions that can be obtained based on the initial data. Based on the final step and the inference boundary conditions, a reasoning process from the initial data to the output target is constructed, and the output result of the large model is determined based on the reasoning process. Based on the output results, execute the business corresponding to the business data to be processed.

[0008] This specification provides a business execution device based on a large model, the device comprising: The acquisition module is used to acquire the business data to be processed, which serves as the initial data for inputting the large model; The reverse analysis module is used to determine the output target based on the initial data through the large model, and to generate the final steps required to obtain the output target according to the output target; The forward reasoning module is used to perform reasoning analysis on the initial data with the goal of obtaining the preconditions for executing the final step, and to deduce the reasoning boundary conditions that can be obtained based on the initial data. The docking and reconstruction module is used to construct the reasoning process from the initial data to the output target based on the final step and the reasoning boundary conditions, and to determine the output result of the large model based on the reasoning process. The execution module is used to execute the business corresponding to the business data to be processed based on the output result.

[0009] This specification provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the aforementioned business execution method based on a large model.

[0010] This specification provides an electronic device including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the program, it implements the aforementioned business execution method based on a large model.

[0011] The above-described at least one technical solution adopted in the embodiments of this specification can achieve the following beneficial effects: This specification discloses a business execution method based on a large model. The method uses the input data of the large model as initial data, reversely determines the final steps required to obtain the output target, and then forward determines the inference boundary conditions that can be derived from the initial data. Based on the inference boundary conditions and the final steps, the inference process is constructed to obtain the output result, which is then used to execute the business. First, independent backward programming establishes the global solution direction, avoiding the blindness and local traps caused by forward reasoning alone. Second, forward derivation verifies the connection between backward programming and forward derivation, demonstrating better robustness and adaptability in complex problem scenarios, while also saving computational resources and reducing meaningless search overhead. Attached Figure Description

[0012] The accompanying drawings, which are included to provide a further understanding of this specification and form part of this specification, illustrate exemplary embodiments and are used to explain this specification, but do not constitute an undue limitation thereof. In the drawings: Figure 1 A business execution flowchart based on a large model is provided for the embodiments of this specification; Figure 2 A schematic diagram of the inference boundary conditions provided for the embodiments of this specification; Figure 3 A business execution flowchart based on a large model is provided for the embodiments of this specification; Figure 4 A flowchart for redetermining inference boundary conditions provided in the embodiments of this specification; Figure 5 A business execution flowchart based on a large model is provided for the embodiments of this specification; Figure 6 A business execution flowchart based on a large model is provided for the embodiments of this specification; Figure 7 A business execution flowchart based on a large model is provided for the embodiments of this specification; Figure 8 A schematic diagram of a business execution device based on a large model provided in the embodiments of this specification; Figure 9 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this specification. Detailed Implementation

[0013] To make the objectives, technical solutions, and advantages of this specification clearer, the technical solutions of this specification will be clearly and completely described below in conjunction with specific embodiments and corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of this specification, and not all of them. Based on the embodiments in this specification, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this specification.

[0014] Traditional LLM currently relies primarily on unidirectional stepwise reasoning to obtain the output. Common methods include Chain-of-Thought (CoT) to guide LLM in generating continuous reasoning steps, and Tree-of-Thought (ToT) to explore finite branching reasoning directions based on CoT. However, these methods are essentially still strategies that start from the initial input data and reason forward towards the answer.

[0015] Because of the lack of reverse learning from the output target, traditional LLM consistently lacks global path planning during the reasoning process. This makes LLM prone to getting stuck in locally reasonable reasoning paths or wasting significant computational resources in a vast search space. This is especially problematic when dealing with business scenarios requiring complex reasoning processes, leading to inaccurate reasoning direction selection, low reasoning efficiency, and poor robustness. For example, consider the logic puzzle "A says B is lying, B says C is lying, C says A and B are both lying, who is telling the truth?". A traditional LLM's unidirectional reasoning might start with "A says B is lying," assuming A is true, then B is lying, and so on down to C... If this path is incorrect, LLM may get stuck in contradictions or require a complete backtracking and retrying, making the entire process inefficient and prone to failure.

[0016] Based on this, this specification provides a business execution method based on a large model to partially solve the defects existing in the above-mentioned application of LLM to execute business. The technical solutions provided by the various embodiments of this specification are described in detail below with reference to the accompanying drawings.

[0017] Figure 1 A business execution flowchart based on a large model, provided for embodiments of this specification, specifically includes the following steps: S100: Obtain the business data to be processed as the initial data for inputting the large model.

[0018] In the embodiments described in this specification, the following are employed: Figure 1 The device used to perform the business operations as shown can be any electronic device, such as a computer, a server, or a server cluster consisting of multiple servers. For ease of description, the following explanation uses a server as an example only.

[0019] To address the issue that simple forward step-by-step reasoning based on Large Language Models (LLMs) is prone to getting stuck in local solutions or initial reasoning errors in complex reasoning scenarios, this specification proposes a method that uses both forward and backward reasoning. Specifically, backward analysis first determines the solution direction for the global solution before proceeding with forward reasoning. This planned two-way reasoning approach determines the complete reasoning process and provides the output results, thereby improving the efficiency and accuracy of LLM execution in complex reasoning scenarios.

[0020] Specifically, due to the aforementioned technical problems in LLM, which mainly arise when facing complex inference tasks rather than in business scenarios involving the generation of coherent text, the server in this embodiment can only be executed for business scenarios requiring complex inference tasks. Figure 1 The business process shown improves the efficiency and accuracy of LLM output results.

[0021] Therefore, the server can acquire the business data to be processed in the business scenario as input data for the LLM. Generally, this business data is user input, the server calls the LLM to determine the corresponding output result, and then returns it to the user. Furthermore, since the LLM determines the complete reasoning process in this embodiment, it needs to proceed in stages from both the forward and reverse directions. Therefore, the input data in this embodiment is referred to as initial data. Initial data refers to the original information or data set input into the LLM for reasoning. Since this information constitutes the starting point or initial state of the reasoning process, it is called initial data. Initial data is the basis for the LLM to begin processing and typically includes a problem statement, known conditions, contextual information, or other forms of processable data. Similar to the "input end" in end-to-end input, the initial data in this specification is the starting point for forward reasoning and the verification benchmark for reverse reasoning. Specifically, this embodiment does not limit the specific content of the initial data. For example, initial data may include text, numbers, symbols, or combinations thereof, but essentially, the initial data may contain all the information available at the start of LLM reasoning.

[0022] S102: Based on the initial data, determine the output target through the large model, and generate the final steps required to obtain the output target according to the output target.

[0023] After acquiring the initial data, the server can input the initial data into the pre-trained LLM, enabling the LLM to perform inference analysis based on the initial data and determine the output target. Then, based on the determined output target, it analyzes and determines the final steps required to obtain the output target. Here, the output target is not the output result, because in this step, the LLM is not inferring and determining the output result based on the initial data, but rather determining what kind of data the LLM should output based on the initial data. That is, in the embodiments of this specification, the output target refers to an abstract description or requirement of the expected output result of the LLM, defining at least one of the conditions, format, type, or functional characteristics that the output result should meet, rather than the specific output content. Therefore, the output target is used to guide the direction of the inference process, especially as a target point in reverse inference.

[0024] For example, if the initial data is "There are 3 tables in a room. Each table has 4 legs. There are also 6 chairs in the room, each with 3 legs. How many legs do all the furniture in the room have in total?", then the output target is a description of the answer that LLM needs to generate, not the answer itself. For example, the output target could be: output the numerical value of the number of legs for all the furniture, which is a positive integer. In contrast, the output could be: First, calculate the total number of table legs: 3 tables × 4 legs / table = 12 legs. Then, calculate the total number of chair legs: 6 chairs × 3 legs / chair = 18 legs. Finally, calculate the sum: 12 + 18 = 30 legs. Therefore, the total number of legs for all the furniture in the room is 30.

[0025] Specifically, the server can input initial data into a large model to obtain the corresponding output target. Since the initial data necessarily contains information about the desired output of the LLM, the inference and analysis capabilities of the LLM can be utilized to extract the desired output from the initial data, serving as the output target. As described above regarding the output target, the LLM can extract an abstract description or requirement for its expected output from the initial data. It should be noted that since the goal is not to derive the result, but rather to extract the required "specification" of the result, the LLM does not need to infer the process from the initial data to the output result; it only needs to mine the initial data. Therefore, the requirements for the LLM and the computational load are relatively low, resulting in faster response times and less need for high computing power.

[0026] For example, if the initial data includes the question "How many furniture legs are there in total?", then the output target is "Output the total number of furniture legs, which is a positive integer." Conversely, if the initial data includes the question "How many types of furniture are there in a room?", then the output target is "Output the total number of furniture types, which is a positive integer." As you can see, the output target can generally be determined based on the initial data.

[0027] Secondly, we continue to use the large model to start with the output target and analyze and deduce the candidate reasoning steps for the output target.

[0028] After identifying the output target, LLM can continue to use this output target as the starting point for reasoning, deriving the reasoning steps that may be required to achieve the output target. This process is similar to the forward reasoning process of LLM. LLM can also identify multiple candidate reasoning processes, but it does not need to reason the entire path; it only needs to reason the steps that will achieve the output target after execution. For example, continuing with the output target in the previous example, if the output target is "output the value of all furniture legs, which is a positive integer," then the identified candidate reasoning steps might include A: "Calculate the sum of the legs of the two types of furniture: X + Y = ? legs," or B: "Calculate the sum of the legs of the furniture in the two rooms: X + Y = ? legs," and so on.

[0029] Since this embodiment only requires obtaining the final step to be executed for the output target, the reasoning process does not need to proceed further. It only needs to obtain the "final step" from multiple possible reasoning processes as candidate reasoning steps, and then determine one of them. This reasoning process, working backward from the output target, if completed, deduces what the "necessary conditions" are needed to obtain the output target. That is, what known data is required to deduce the output target. However, this specification aims to provide direction for the reasoning process, and therefore does not require a complete deduction to the "necessary conditions."

[0030] Finally, select the final step from all candidate reasoning steps.

[0031] In other words, based on its training ability to select the output from multiple candidate results, the LLM determines the final step of the inference process that it is "most likely" to achieve with the initial data from among the candidate inference steps. For example, using the previous example, the LLM selects A as the final step from candidate inference steps A and B.

[0032] In constructing the final step derived from the output target, the embodiments of this specification cleverly introduce and reconstruct a core native capability of LLM—the ability to select the most reasonable subsequent text from multiple candidate contents based on probability distribution. However, unlike traditional LLMs where this capability is used to directly generate the final answer, the embodiments of this specification strategically apply it to a higher-level reasoning planning stage. Specifically, LLM generates multiple possible "final step" candidates, i.e., candidate reasoning steps. Subsequently, LLM uses the "initial data" and these candidate reasoning steps as the basis for analysis. At this point, LLM no longer acts as a solver, but as a "path planner" that evaluates the probability based on existing information. Based on its implicit understanding of the logic and causal relationships of the world, trained on massive amounts of data, LLM judges the probability and rationality of executing each candidate reasoning step starting from the "initial data," and selects a "final step" from among the candidate reasoning steps accordingly.

[0033] The brilliance of this design lies in its deep integration of LLM's powerful, association-based "intuitive judgment" capabilities at the micro level with the macro-level "logical planning" framework of bidirectional reasoning. For example, after LLM back-plans candidate reasoning steps A and B, by allowing LLM to choose based on the initial data, it tends to select path A, which best aligns with the tone of the initial data. This essentially transforms the statistical power of LLM into a heuristic guide, establishing a dynamic and adaptive connection between the global blueprint of back-planning and the local reality of forward reasoning, bridged by probability. This not only ensures the feasibility of the planned path but also significantly improves the efficiency of pruning the vast search space.

[0034] It should be noted that, in the embodiments of this specification, the output target can also be "generating a logical proof," "producing a classification decision," or "outputting a summary." The examples above illustrate this using a mathematical logic process for easier understanding. Regardless of the output target, it is not necessary to determine the specific steps of the proof, the specific category of the decision, or the specific text of the summary when determining the output target. The output target can serve as a standardized representation of the inference endpoint, ensuring that the output meets the expected requirements without pre-defining the details of the result.

[0035] S104: With the goal of obtaining the prerequisites for executing the final step, perform reasoning analysis on the initial data to deduce the reasoning boundary conditions that can be obtained based on the initial data.

[0036] In the embodiments of this specification, after receiving the final step given by the LLM, the server aims to obtain the preconditions for executing the final step. Based on the initial data, it performs reasoning analysis to derive the reasoning boundary conditions that can be obtained based on the initial data. These reasoning boundary conditions refer to the outer edge of the set of all possible conclusions that the LLM can directly or indirectly reach through forward logical deduction from the initial data during the problem-solving process. Therefore, with the initial data as the initial state, the reasoning boundary conditions mark the boundary between a series of reachable states and a series of unreachable states. In this specification, the LLM determines the reasoning boundary conditions based on the potential conditions of the final step. Therefore, the reasoning boundary conditions represent several "reachable states" that are close to the preconditions set by the backward programming on the forward reasoning path. Of course, in different situations, the reasoning boundary conditions may exactly match the preconditions, or they may fail to meet the preconditions, or they may exceed the preconditions. Therefore, subsequent steps are needed to "connect" and determine the most important reasoning process to be executed.

[0037] Specifically, in this specification, the server can determine the preconditions required to execute the final step through LLM. The server can use the determined final step as input and, through LLM, first determine the preconditions for executing that final step. Preconditions are one or more pieces of data that must first be established or obtained to execute and complete the final step. This data can be specific content such as intermediate states of inference, key facts, or core arguments. Preconditions are not the final answer itself, but rather the necessary path and logical threshold to the final answer, constituting the "sub-goals" that forward reasoning from the initial data aims to achieve. Therefore, the final step determined by backward reasoning belongs to the macro-planning of the reasoning process, i.e., the general direction. Forward reasoning, on the other hand, focuses on the specific execution, i.e., the specific reasoning steps.

[0038] In this process, LLM's task is to perform a logical reverse decomposition, taking the final output goal as the origin, and explicitly answer the question, "What prerequisites must be met first to achieve this goal?" Therefore, the corresponding prompts can be set in a similar format. This allows LLM to analyze the inherent logical structure of the output goal and parse out one or more prerequisites indispensable for executing the final step. These prerequisites constitute the adjacent and necessary logical thresholds to be crossed when looking back from the goal endpoint. For example, assuming the output goal is "to prove geometric theorem C," then through reverse derivation, the prerequisite might be "it is necessary to first prove that theorems B1 and B2 are both true." Theorems B1 and B2 are not the final answer, but rather the necessary path defined by reverse programming leading to the final answer.

[0039] Secondly, LLM can use initial data as the current state and preconditions as the target state, deriving the reasoning process from the current state to the target state through a large model. Once the preconditions are clear, LLM can perform forward reasoning based on the initial data. The complete initial data is used as the current state of reasoning, while the preconditions determined in the previous step are used as the target state to be reached. The task of LLM is to simulate a reasoning sequence that gradually approaches the target state from the current state based on its internal knowledge and logical rules. By attempting to construct one or more logical paths, it explores how to utilize the information in the initial data, through reasonable inference, calculation, or association, to gradually approach or satisfy the requirements of the preconditions. This process is essentially a comprehensive exploration of "what can be deduced from the known," which may generate multiple reasoning chains with different confidence levels or perspectives—that is, multiple reasoning processes. It should be noted that because the reasoning has a clear final goal, it can greatly reduce the possibility of errors in the initial reasoning steps or "getting lost" in the middle of the reasoning process.

[0040] Finally, the LLM can determine the inference boundary conditions based on the initial data from the inference process. Since at least one inference process has been identified, the inference boundary conditions can be determined based on the final results obtained from each inference process. Furthermore, since the inference process takes the preconditions as the target state, the results obtained are generally close to the preconditions. Figure 2 This diagram illustrates the reasoning boundary conditions provided in this specification. The left side represents the initial data, and the right side represents the preconditions determined by the final step. It can be seen that multiple reasoning processes may "contact" the preconditions, that is, match the preconditions, while multiple reasoning processes may not satisfy the preconditions, and different reasoning processes may also reach the same reasoning boundary conditions.

[0041] Furthermore, in the embodiments described in this specification, the results provided by each reasoning policy can be filtered, rather than simply accepting all generated reasoning processes. Specifically, LLM can comprehensively analyze the conclusions that can be steadily reached by all reasoning paths, and select the intermediate state that is logically closest to the target preconditions and can be supported by the initial data, as the "reasoning boundary".

[0042] It should be noted that the inference boundary conditions in this specification represent the limits of the LLM's capabilities. These boundary conditions clearly characterize how far the LLM can reason given the current, finite initial data. Therefore, the inference boundary conditions are not the goals the LLM "should" achieve—that is, not the output target—but rather the "actual" limit of the LLM's reasoning ability. We use the term "actual" because even with the same input, the LLM may produce different outputs. Therefore, "actual" here refers to the inference boundary conditions given by the LLM at the current step. This is not necessarily the upper limit of the LLM's capabilities, but rather the result of this particular inference.

[0043] In this specification, the backward planning in step S102 defines the necessary preconditions from the output target of the endpoint, while forward reasoning starts from the initial data and explores the reasoning boundary conditions of the initial data, that is, what the LLM "has" and "can reach". The success of subsequent bidirectional reasoning depends on whether the output target and the initial data can be successfully matched on the reasoning boundary conditions. Therefore, the reasoning boundary conditions can also be regarded as the "dating surface" of bidirectional reasoning.

[0044] S106: Based on the final step and the inference boundary conditions, construct the inference process from the initial data to the output target, and determine the output result of the large model based on the inference process.

[0045] S108: Execute the business corresponding to the business data to be processed based on the output result.

[0046] Finally, based on step S104, the reasoning boundary conditions for forward reasoning and the final steps to be executed obtained from backward reasoning have been obtained. It can be determined whether the reasoning boundary conditions satisfy the preconditions for the execution of the final steps. If they are satisfied, it means that a complete reasoning process has been obtained. If they are not satisfied, it means that there is a problem with the reasoning in at least one direction. It can be redefined and, through multiple iterations, the reasoning boundary conditions that satisfy the preconditions can be obtained.

[0047] Specifically, the server can determine whether the inference boundary conditions satisfy the preconditions for executing the final step. This determination step verifies whether the inference boundary conditions derived from forward inference are logically sufficient to support the preconditions defined by backward programming. Therefore, the determination process is a logical validity check, rather than a simple string matching. The server can evaluate whether the facts or states corresponding to the inference boundary conditions can necessarily, or with high confidence, initiate the final step.

[0048] In the embodiments of this specification, the server can use a combination of rule-based and semantic understanding methods for judgment, that is, checking whether the inference boundary conditions logically directly imply the preconditions. For example, if the inference boundary condition is "the figure is an equilateral triangle" and the precondition is "the figure is an equiangular triangle", the system can determine that the two are equivalent based on geometric knowledge, thus satisfying the condition. This process can be performed through a semantic analysis model to determine whether the similarity between the inference boundary conditions and the preconditions is higher than a preset threshold, or it can be performed through a large model to determine whether the inference boundary conditions and the preconditions satisfy a logical inclusion relationship.

[0049] Alternatively, the server can leverage the semantic understanding capabilities of LLM to determine whether two statements that differ in wording but have the same meaning are equivalent. For example, if the inference boundary is "the company's current assets are sufficient to cover its short-term liabilities," and the precondition is "the company's short-term solvency is secure," LLM should be able to identify their semantic consistency.

[0050] Alternatively, in the embodiments of this specification, if the inference boundary conditions are identified as a set of multiple conditions, and the preconditions are also identified as one or more conditions, then the server needs to determine whether the preconditions are an element or subset of that set. If so, it means that each of the preconditions required to execute the final step has a logically corresponding satisfying item found in the set of inference boundary conditions. Only when the set of inference boundary conditions is a superset or equivalent set of the set of preconditions can it be determined that the inference boundary conditions satisfy the preconditions for executing the final step. For example, if the preconditions include [condition A, condition B], and the inference boundary conditions include [conclusion A, conclusion B, conclusion C, conclusion D, conclusion E, conclusion F], then it is determined whether condition A is satisfied by conclusion A (or other conclusions), and whether condition B is satisfied by conclusion B (or other conclusions). If both are yes, then the preconditions are determined to be satisfied.

[0051] If the inference boundary conditions satisfy the preconditions for executing the final step, then based on the inference process that yields the inference boundary conditions and the final step, the inference process from the initial data to the output target is determined.

[0052] Specifically, when the inference boundary conditions satisfy the preconditions, the server can integrate the forward and backward inference paths into a complete inference process. The server can determine the inference boundary conditions that satisfy the preconditions and their corresponding inference process, which is a forward inference process from the initial data to the "satisfied" inference boundary. Then, based on this inference process and the final steps of the output target, a coherent inference chain is generated, and the final result is output.

[0053] In the embodiments of this specification, since the reasoning boundary conditions have been determined in step S104, the result obtained from the reasoning boundary conditions can also be determined. Therefore, the result corresponding to the reasoning boundary conditions can be directly used as input to execute the final step and generate the output result. For example, in mathematical proof, if forward reasoning yields the reasoning boundary condition "the sum of the interior angles of a triangle is 180 degrees", and the final step is "prove that the triangle is a right triangle" with the precondition "the property of the sum of interior angles is known", then the system directly uses the reasoning boundary to execute the final step and complete the proof.

[0054] Finally, after obtaining the output, the server can execute the business operations corresponding to the pending business data based on the output. For example, suppose an international logistics company needs to plan a multimodal transport route from Shanghai to Berlin for a batch of goods, with the goal of minimizing total cost while meeting delivery time requirements. The available options involve various combinations of sea freight, air freight, rail freight, and last-mile land transport, each with different costs, times, and reliability. The server can input this complex problem into the LLM (Logistic Management System), and through the aforementioned steps, the LLM will output a result, such as a sea freight route from Shanghai Port to Hamburg Port, then a rail route to Berlin. Based on the output, the server can create this transport order in the logistics management system, lock in the corresponding cargo space and wagons, and write the freight cost into the financial system as a budget basis.

[0055] based on Figure 1 The business execution method based on a large model, as shown, uses the input data of the large model as initial data. It then reverse-engineers the final steps required to obtain the output target, and forward-engineers the inference boundary conditions that can be derived from the initial data. Based on the inference boundary conditions and the final steps, it constructs the inference process to obtain the output result, and executes the business based on the output result. First, independent backward programming establishes the global solution direction, avoiding the blindness and local traps caused by forward reasoning alone. Second, forward derivation verifies the connection between backward programming and forward derivation, demonstrating better robustness and adaptability in complex problem scenarios, while also saving computational resources and reducing meaningless search overhead.

[0056] This specification describes a novel inference architecture employing phased serial processing and deterministic planning, which differs significantly from existing bidirectional inference technologies. This approach achieves precise control over the inference process by first independently completing goal-oriented global path planning, followed by local verification based on initial data. A complete inference blueprint, including the output goal, final steps, and preconditions, is generated during the backward planning phase, and rigorous path matching is performed during the forward verification phase. This planning-then-execution mechanism effectively avoids decision oscillations and resource coordination problems common in bidirectional parallel inference. Because each inference stage is clearly defined and performed sequentially, it exhibits better stability and predictability, with a clearly directional computational path that avoids uncertainty caused by real-time interaction. In solving complex problems, inference can be completed through a single, precise path connection, demonstrating higher decision-making and resource utilization efficiency, providing a new technical implementation path for knowledge reasoning systems.

[0057] It should be noted that in one or more embodiments of this specification, the business data can be text data, image data, audio data, video data, etc. Generally, the type of data is not limited, and it can also be a combination of multiple data types. For example, business data includes images and text; any data that can be used as input to a large model can be used as business data in the embodiments of this specification. The output result can also include text data, image data, video data, or audio data, etc. The specific type of data output can be set as needed, and this specification does not impose any restrictions.

[0058] Furthermore, in step S106, when the inference boundary condition satisfies the precondition, that is, when the inference boundary condition and the precondition are logically consistent, it does not mean that the two conditions are identical. In some complex inference scenarios, there may be a logical equivalence between the inference boundary condition and the precondition, but formal transformation is required.

[0059] Therefore, in the embodiments of this specification, the server can construct a logical bridge connecting two conditions. By analyzing the logical relationship between the boundary conditions and preconditions of the LLM analysis, it generates the necessary transformation steps, ensuring that the endpoint of the forward reasoning can seamlessly connect to the starting point of the final step. Taking investment analysis as an example, if the forward reasoning yields the boundary condition that "the company's price-to-earnings ratio is 20% lower than the industry average and its dividend yield is higher than the government bond yield," and the final step "generating a buy recommendation" requires the precondition that "the value is undervalued," the LLM can construct a logical bridge, transforming specific data indicators into a qualitative judgment of "the value is undervalued" through a value assessment model, thereby completing the complete reasoning chain from data analysis to investment decision-making.

[0060] For example, suppose the final step requires proving that "quadrilateral ABCD is a rectangle," with the precondition set as "the diagonals of quadrilateral ABCD are equal and bisect each other." However, the reasoning boundary obtained through forward reasoning is "quadrilateral ABCD is a parallelogram with equal diagonals." At this point, by automatically inserting the key theorems from a geometry theorem library—"a quadrilateral whose diagonals bisect each other is a parallelogram" and "a parallelogram with equal diagonals is a rectangle"—a rigorous logical bridge is constructed. This bridging process matches and connects the explicit "parallelogram with equal diagonals" and the implicit "diagonals are equal and bisect each other," two formally different but logically equivalent conditions, ultimately achieving a smooth transition from preconditions to the output target through theorem transformation.

[0061] Furthermore, in step S106 of this embodiment, the inference boundary marks the furthest frontier that forward inference can reach under the current information. The relationship between the boundary condition and the preconditions set by backward programming directly determines the subsequent path. If they match, it means the bidirectional path has successfully "connected," the output result can be determined, and step S108 can be executed. However, if a discrepancy exists, the server will redetermine the inference boundary conditions with the goal of obtaining the preconditions for executing the final step, until the inference boundary conditions satisfy the preconditions for executing the final step.

[0062] Figure 3 This is a schematic diagram illustrating the business execution process based on a large model, provided as an embodiment of this specification. Figure 3 The process is in Figure 1 Based on this, an iterative loop process was added, in which: S200: Obtain the business data to be processed as the initial data for inputting the large model; S202: Based on the initial data, determine the output target through the large model, and generate the final steps required to obtain the output target according to the output target; S204: With the goal of obtaining the prerequisites for executing the final step, perform reasoning analysis on the initial data to deduce the reasoning boundary conditions that can be obtained based on the initial data; S206: Determine whether the reasoning boundary conditions satisfy the preconditions for executing the final step. If yes, execute step S208; otherwise, execute step S210. S208: Based on the reasoning process that obtains the reasoning boundary conditions and the final step, determine the reasoning process from the initial data to the output target; S210: With the goal of obtaining the preconditions for executing the final step, redetermine the inference boundary conditions until the inference boundary conditions satisfy the preconditions for executing the final step; S212: Execute the business corresponding to the business data to be processed based on the output result.

[0063] Specifically, upon determining that the conditions are not met, the server can execute the following basic iterative process: randomly adjusting or changing the strategy parameters and search direction of forward inference, and re-performing the inference analysis to derive new inference boundary conditions. This process does not rely on intelligent diagnosis of the gap, but rather involves multiple rounds of attempts by introducing randomness, expanding the search range, or changing the inference heuristic rules; essentially, it is a probability-based Monte Carlo exploration. For example, in a logic proof scenario, if the initial inference boundary fails to match the preconditions, LLM can randomly select another set of theorems or try different auxiliary line construction methods to re-derive the condition. In decision analysis, it can randomly switch the weight coefficients or feature combinations of the evaluation model to generate new intermediate conclusions. This iterative process of trial and error ensures the possibility of finding a feasible path with a sufficient number of attempts, providing the most basic robustness guarantee for solving complex problems and forming the underlying foundation for all more advanced iterative strategies.

[0064] Furthermore, when redefining the inference boundary conditions, the server can first determine the gap between the inference boundary conditions and the preconditions. This gap provides a clear diagnostic basis and direction for iterative optimization. For example, backward programming requires proving that a function is monotonically increasing, while forward inference, based on existing data, can at most conclusively prove that the derivative of the function is non-negative. This subtle difference constitutes the core problem that needs to be solved in the next inference loop.

[0065] Specifically, when redefining the inference boundary conditions, the server first performs a gap analysis between the boundary conditions and the preconditions, identifying specific differences in their logical structure, semantic connotation, or strength of evidence. Based on this gap analysis, targeted iterative optimization is performed. For example, in mathematical proof scenarios, if the gap is the strength difference between "non-negative derivative" and "strictly monotonically increasing," the mean value theorem or auxiliary functions can be introduced to strengthen the proof. In decision analysis, if the gap lies in the distance between qualitative judgment and quantitative requirements, the depth of data mining will be automatically enhanced or a more accurate econometric model will be introduced. This iterative strategy based on gap diagnosis, through establishing a closed-loop mechanism from gap identification to strategy selection and finally targeted optimization, can improve the efficiency of inference path correction, reduce the number of iterations, and achieve reliable connection from initial data to the output target.

[0066] Furthermore, in the embodiments of this specification, besides positive correction based on differences to improve the accuracy of the exploration path, there are also cases where the exploration path has fundamental errors, causing the inference process to fail even with difference correction. Therefore, to reduce limitations on the exploration scope and avoid exploring invalid inference paths, the server can also set up an LLM inference blacklist, adding currently determined invalid paths to the blacklist. This reduces the probability of LLM exploring invalid paths under the current circumstances, improves exploration efficiency, and consequently reduces the number of iterations.

[0067] Specifically, the server can write inference boundary conditions that do not meet the preconditions for executing the final step, and their corresponding inference processes, into the LLM inference blacklist to establish a complete path exclusion mechanism.

[0068] The server can first extract features or digitally identify the inference boundary conditions and their corresponding complete inference process to generate a unique path fingerprint. In mathematical proof scenarios, when an auxiliary line construction scheme is proven unable to derive the target conclusion, the server can record the key features of the scheme, such as the auxiliary line type, the coordinates of the connection points, and the combination of theorems used, as part of the inference blacklist. In business decision-making scenarios, if a data analysis method, such as a regression model with specific weight settings, produces intermediate results that fail to meet the decision-making conditions, the core parameters and calculation process of that method will be added to the inference blacklist.

[0069] Furthermore, this inference blacklist can employ a hierarchical storage architecture, comprising three dimensions: a logical rule layer, a semantic feature layer, and an instance pattern layer. During subsequent inference processes, the LLM can perform real-time matching and comparison with the blacklist when generating each inference step. When the similarity between a newly created inference path and an entry in the blacklist exceeds a preset threshold, the LLM can terminate the inference for that path and select another inference direction not listed in the blacklist. This mechanism effectively prevents the LLM from repeatedly consuming computational resources on already identified invalid paths, and significantly improves the efficiency and success rate of solving complex problems through continuously accumulated path elimination experience.

[0070] Furthermore, when the server determines that the inference boundary conditions need to be redefined, it can achieve this through the same operation in step S104 of the LLM. However, in order to avoid invalid iterations due to errors in the final step determination, in this embodiment of the specification, the server may also first determine the number of times the inference boundary conditions need to be redefined with the preconditions of the current final step as the target.

[0071] Next, it is determined whether the number of times has reached the preset value. If so, steps S102 to S104 are repeated, that is, the final step is redefined using the large model, and the inference boundary conditions are redefined with the preconditions of the redefined final step as the target. If not, the inference boundary conditions are redefined using the preconditions of the current final step as the target. The preset value can be set as needed, such as 5 times, 10 times, or 50 times, etc.

[0072] In the embodiments of this specification, since the final step is determined from several candidate inference steps in step S102, when re-determining the final step, the server can also directly re-determine the final step from the unselected candidate inference steps. Alternatively, step S102 can be repeated.

[0073] This specification provides the following for this embodiment: Figure 4 . Figure 4 A schematic diagram illustrating the process of redetermining inference boundary conditions provided in the embodiments of this specification, wherein: S300: Determine the number of times the reasoning boundary conditions are redefined with the preconditions of the current final step as the target. S302: Determine whether the number of times has reached a preset value. If yes, proceed to step S304; otherwise, proceed to step S306. S304: Redetermine the final step using the large model, and redetermine the inference boundary conditions with the goal of obtaining the preconditions for executing the redetermined final step; S306: Using the large model, redetermine the inference boundary conditions with the preconditions of the current final step as the target.

[0074] Furthermore, since the final step is determined based on the output target, the server can redetermine the final step using a large model based on the already determined output target, or redetermine the output target using a large model based on the initial data, and determine the final step required to obtain the redefined output target. Of course, referring to the aforementioned inference blacklist, relevant content that cannot be inferred to produce an output result can be recorded in the inference blacklist to avoid selecting the same final step.

[0075] As can be seen from the embodiments in this specification, during the iteration process, the server can redetermine the output target, keep it unchanged and redetermine the final step, or even only change the preconditions.

[0076] Through this iterative strategy of tiered processing and progressively increasing adjustment intensity, the server can select different levels of adjustment strategies based on the depth of the current inference dilemma during the iteration process. When the inference boundary conditions do not match the preconditions, the server first attempts to keep the output target unchanged and only redefine the final step or its preconditions; this is a low-intensity "tactical fine-tuning." If this strategy still cannot solve the problem within a preset number of iterations, it indicates that there may be a fundamental deviation in the current understanding of the problem or the setting of the target. At this point, a high-intensity "strategic reconstruction" needs to be initiated, that is, redefining the output target itself.

[0077] This strategy stems from the inherent characteristics of problem-solving: the same goal can be achieved through different paths, and the same path can serve different goals. For example, in numerical computation scenarios, to obtain the final result, the prerequisites can be obtained either by adding several intermediate quantities or by multiplying them. These two paths are mathematically equivalent but have different forms of expression. The server, through a progressively enhancing adjustment mechanism, avoids the solution deviating from its original intent due to premature changes to high-level goals, and effectively overcomes the inference bottleneck caused by rigid lower-level paths. This hierarchical iterative architecture produces three technical effects: first, it significantly improves the convergence efficiency of the inference process, avoiding unnecessary waste of computational resources by adjusting paths from shallow to deep; second, it enhances the method's adaptability, enabling it to flexibly cope with problem challenges at different levels, from path selection to goal reconstruction; and third, by maintaining a dynamic balance between goal constraints and releasing the exploration space, it maximizes the possibility of solving the problem while maintaining the relevance of the solution.

[0078] Furthermore, since the server can add records to the recommended blacklist for LLM, it can also manage the recommended blacklist when redefining conditions. A reasoning process that is blacklisted in a failed inference may not be erroneous; it may be correct given the redefined output target, final step, or preconditions. Therefore, when handling the recommended blacklist lifecycle, the server can follow the principle that the scope of blacklist release strictly depends on the position of the redefined content within the inference hierarchy.

[0079] Specifically, when only the final step or its preconditions are redefined, the server manages the blacklist more finely by comparing the two sets of preconditions. Only paths that were banned due to conflicts with specific subconditions that have been modified or removed are released, while paths that conflict with the core conditions that remain unchanged are retained.

[0080] When the output objective is redefined, it signifies a top-level task reset. The server will clear the entire blacklist. Because of the entirely new output objective, a completely new reasoning framework is established. For example, changing from "write a market analysis report" to "generate a technical feasibility report," all paths deemed invalid under the previous objective may be fully applicable or must be re-evaluated under the new framework.

[0081] This ensures that the recommended blacklist is always highly relevant to the current inference task, effectively avoiding repeated errors within the task framework while completely liberating the model's exploration capabilities when the nature of the task changes, thus achieving a balance between constraints and flexibility.

[0082] In one or more embodiments of this specification, when facing complex business scenarios, steps S100-108 yield more accurate output results, reducing the need for rework in business operations based on these output results, thus resulting in relatively higher business efficiency. However, when facing non-complex business scenarios, the accuracy advantage of steps S100-108 is no longer significant, leading to no substantial improvement in business execution efficiency. Therefore, the server can also first determine in step S100 whether the business to be executed belongs to a complex business scenario; if so, then proceed to step S102.

[0083] Specifically, after acquiring business data, the server can determine whether the business scenario corresponding to the business data is a business scenario that requires a complex reasoning process, i.e., a complex business scenario. If so, it will execute subsequent steps S102~S108; otherwise, it will transfer to the traditional LLM output result business processing flow for processing.

[0084] The server can use regular expression matching to determine whether a business scenario involves complex reasoning. It can also determine whether a task requires complex reasoning based on keyword matching. For example, if the user input includes words like "briefly describe," "what is," "summarize," or "translate," which clearly indicate simple induction or factual questions, the server can classify it as a simple task and directly call traditional LLM values ​​to perform the business. However, if the user input includes words requiring logical deduction such as "prove," "why," "derive," "calculate," "analyze," "analyze the root cause," or "if...then...", the server can classify it as a complex reasoning task. Figure 1 The corresponding business process executes the business.

[0085] Alternatively, the server can determine whether a task involves complex reasoning based on a pre-defined blacklist or whitelist of service types. For example, known non-complex reasoning tasks such as text polishing, summary generation, simple customer service Q&A, and entity recognition are classified as simple tasks, while tasks like solving math problems, logic puzzles, code debugging, causal analysis, and complex planning are classified as complex reasoning tasks. Therefore, when business data originates from requests in specific business scenarios, such as math problem-solving platforms or legal case analysis platforms, it can be determined that the business data requires LLM's complex reasoning capabilities and falls under the category of business scenarios involving complex reasoning processes.

[0086] Alternatively, the server can determine whether a task involves complex reasoning based on the length of the user's input text, which represents the amount of business data. If the user's input is very short, such as less than 20 words, it usually does not involve multi-step reasoning and can be classified as a simple task; otherwise, it is considered a business scenario involving complex reasoning.

[0087] Similarly, in the embodiments of this specification, the server may also determine whether the initial step belongs to a complex problem, that is, whether it belongs to a business scenario of complex reasoning process, before step S104. If so, step S104 is executed.

[0088] Specifically, the server can input initial data into a pre-trained detection model, which then determines whether the initial data constitutes a complex problem. If so, it performs reasoning analysis on the initial data with the goal of obtaining the preconditions for executing the final step, deriving the reasoning boundary conditions based on the initial data.

[0089] The detection model can be a large language model that uses pre-set prompts to infer whether the initial data belongs to a complex problem. Alternatively, it can be a pre-trained classifier. Specifically, the detection model can be trained by finding business data of different types of business and determining the corresponding labels based on the business type. For example, using a pre-set black / white list based on the business type in the previous example, the label of the business data can be determined as a complex problem or a simple problem. The detection model can be trained using supervised training.

[0090] Furthermore, in one or more embodiments of this specification, when it is determined that the business data does not belong to a complex problem, the server may use a simplified LLM bidirectional reasoning strategy to execute the business.

[0091] Specifically, when the server determines that the initial data does not belong to a complex problem, it can use a large model to determine several sub-goals that need to be achieved to reach the output goal. This large model can be the same as the large model in steps S100 to S108.

[0092] Since reasoning paths for non-complex problems are typically more linear and structured, LLM has the ability to directly decompose them. Therefore, by decomposing the output target, a task requiring multi-step comprehensive reasoning can be transformed into a series of simple tasks that can be "solved" one by one, greatly reducing the cognitive load of a single reasoning session.

[0093] Therefore, the server can invoke LLM to decompose the output target determined in step S102, breaking down the single, complex overall target into several sub-targets. These sub-targets together constitute the logical ladder to achieve the final target. Of course, the sub-targets can be parallel or sequential; this specification does not restrict this. For example, if the output target is to demonstrate that the shared bicycle business has entered a mature market stage in city A, then the sequential sub-targets might include: confirming market penetration rate indicators, analyzing growth rate changes, assessing the stability of the competitive landscape, and drawing a stage-based judgment conclusion. If the output target is to design a product optimization plan for a smart home voice assistant, parallel sub-targets might include: improving wake-up rate and recognition accuracy, increasing supported home appliance brands and categories, designing a more human-like dialogue interaction experience, and optimizing privacy protection settings and instructions.

[0094] By breaking down the sub-goals, relatively macroscopic and vague output objectives can be transformed into clearer and more specific sub-goals, providing a clear roadmap for subsequent reasoning. While still constraining the direction of reasoning from the source, this approach is more specific and avoids the divergent thinking or step-by-step jumps that can occur with LLM in simple tasks, laying the foundation for generating logically rigorous and step-by-step answers.

[0095] Secondly, taking several sub-goals as objectives, we perform reasoning analysis on the initial data to deduce the achievable objectives based on the initial data.

[0096] Specifically, the server can use this LLM (Limited Learning Model) to perform forward reasoning, starting from the initial data, with each sub-goal as an independent inference endpoint. It determines which goals the LLM can reliably deduce based on the currently known information; these are the achievable goals. The achievable goals here are similar to the inference boundary conditions mentioned earlier. However, since the goal is not based on preconditions but on sub-goals, the result obtained through reasoning is referred to as the achievable goal in this example, not the inference boundary condition. Nevertheless, it is understood that the definitions and explanations of the inference boundary conditions above can be applied to achievable goals; this specification will not elaborate further, but please refer to the previous descriptions for details.

[0097] Since the problem to be reasoned about is simple, the logical path between the initial data and the output target is usually clear and direct. Breaking down the target into sub-targets further reduces the difficulty of the reasoning. Therefore, by focusing the reasoning analysis on each sub-target, it is possible to find the reasoning boundary conditions that are "satisfied" for all sub-targets with a high probability.

[0098] It enables rapid exploration of the problem space with minimal computational cost. Through efficient batch processing, all reasoning fragments required to construct the final answer can be obtained, improving efficiency in handling simple problems and reducing computational requirements compared to steps S100~S108.

[0099] Then, based on the sub-goals and achievable goals, a reasoning process from the initial data to the output goal is constructed, and the output of the large model is determined based on the reasoning process.

[0100] After completing the reasoning for each sub-objective, the server can enter the integration phase. Based on the sub-objectives and reachable targets, it determines that each sub-objective has a pair of reachable targets, meaning they can all be derived from the initial data. Then, the sub-objectives are linked and combined according to their inherent logical order, thus constructing a complete reasoning chain from the initial data to the output target. Finally, the LLM can generate the output result based on this reasoning chain.

[0101] By breaking down the problem into sub-goals, the issue has been simplified and made more concrete. Therefore, even if the reasoning boundary conditions of individual sub-goals are not perfectly matched, all the reasoning fragments obtained in this exploration are sufficient to be combined with high confidence into a logically coherent and reliable final answer.

[0102] Finally, the business operations corresponding to the pending business data are executed based on the output results. This step is similar to step S108 and will not be described again in this specification.

[0103] This specification provides the following for this embodiment: Figure 5 . Figure 5 This is a schematic diagram of business execution based on a large model provided in the embodiments of this specification, wherein: S400: Using the large model, determine several sub-goals that need to be achieved to reach the output goal; S402: Taking the aforementioned sub-targets as objectives, perform reasoning analysis on the initial data to deduce the achievable objectives based on the initial data; S404: Based on the sub-goals and the achievable goals, construct a reasoning process from the initial data to the output goal, and determine the output result of the large model based on the reasoning process; S406: Execute the service corresponding to the business data to be processed based on the output result.

[0104] Combination Figure 1 The corresponding execution process can be summarized as follows: Figure 6 ,in: S500: Obtain the business data to be processed as the initial data for inputting the large model; S502: Based on the initial data, determine the output target through the large model, and generate the final steps required to obtain the output target according to the output target; S504: Using the pre-trained detection model, determine whether the initial data belongs to a complex problem. If so, proceed to step S506; otherwise, proceed to step S510. S506: With the goal of obtaining the preconditions for executing the final step, perform reasoning analysis on the initial data to deduce the reasoning boundary conditions that can be obtained based on the initial data; S508: Based on the final step and the inference boundary conditions, construct the inference process from the initial data to the output target, and determine the output result of the large model based on the inference process, and execute step S516; S510: Using the large model, determine several sub-goals that need to be achieved to reach the output goal; S512: Taking the aforementioned sub-targets as objectives, perform reasoning analysis on the initial data to deduce the achievable objectives based on the initial data; S514: Based on the sub-goals and the achievable goals, construct a reasoning process from the initial data to the output goal, and determine the output result of the large model based on the reasoning process, and execute step S516; S516: Execute the business corresponding to the business data to be processed based on the output result.

[0105] As can be seen, for simple problems, the server can obtain the output results with a small response latency through bidirectional reasoning, namely reverse splitting and forward reasoning. Therefore, for a large number of simple reasoning requests, it achieves a balance between efficiency and quality, and improves the throughput and practical value of the business system.

[0106] For example, suppose the initial data is: "The meeting room booking system shows that meeting room A is booked this Wednesday afternoon from 3-4 pm." The output objective is determined as: "Determine whether I can use meeting room A for a meeting this Wednesday afternoon, and give a reason." Based on the output objective, two sub-objectives are determined: Sub-objective 1: Determine the meeting room occupancy status during the target time period. Sub-objective 2: Draw an availability conclusion based on the occupancy status. Using LLM, with sub-objective 1 and sub-objective 2 as the reasoning objectives, inference analysis is performed on the initial data.

[0107] Suppose that the inference boundary condition 1 derived from sub-goal 1 is "Meeting Room A is 'occupied' this Wednesday afternoon from 3-4 pm.", and the inference boundary condition 2 derived from sub-goal 2 is "I cannot use the meeting room because this time slot is already occupied." Then both sub-goals are reachable. Integrating the two inference processes yields the complete inference process from the initial data to the output goal: According to the meeting room booking system, Meeting Room A is booked this Wednesday afternoon from 3-4 pm, therefore this time slot is "occupied." Since the target time slot is occupied, a meeting cannot be held in that meeting room.

[0108] The LLM output will then read: "You are unable to use Meeting Room A this Wednesday afternoon from 3 to 4 p.m. because that time slot is already booked." Furthermore, in one or more embodiments of this specification, during the reasoning process from the initial data to the output target based on the sub-targets and reachable targets, although for simple problems, the result can likely be determined through a single analysis, there may be cases where reachable targets do not cover all sub-targets. Therefore, the server may first determine whether all sub-targets are reachable targets. If so, the corresponding steps in the above embodiments are executed.

[0109] If not, that is, if there is a sub-goal that is not a reachable goal obtained from the initial data inference, the reachable goal can be used as the input data of the large model to update the initial data.

[0110] Then, using the remaining sub-goals as the target, the updated initial data is used for reasoning and analysis to derive new achievable targets. That is, sub-goals that are not achievable targets are taken as the current targets to be reasoned and analyzed, based on the updated initial data. For each sub-goal that is not achievable, a new achievable target is reasoned. This judgment process is repeated until all sub-goals are achievable, thus determining the reasoning process for obtaining the output target.

[0111] Figure 7 This is a schematic diagram of business execution based on a large model provided in the embodiments of this specification, wherein: S600: Using the large model, determine several sub-goals that need to be achieved to reach the output goal; S602: Taking the aforementioned sub-targets as objectives, perform reasoning analysis on the initial data to deduce the achievable objectives based on the initial data; S604: Determine whether each sub-goal is a reachable goal. If yes, proceed to step S606; otherwise, proceed to step S608. S606: Based on the reasoning process of each reachable goal, determine the reasoning process for obtaining the output goal, and determine the output result of the large model according to the reasoning process; S608: Using the reachable target as input data to the large model, update the initial data, take the remaining sub-targets as targets, perform reasoning analysis on the updated initial data, re-derive the reachable targets, and repeat the above process until all sub-targets are reachable targets, determine the reasoning process for obtaining the output target, and determine the output result of the large model based on the reasoning process. S610: Execute the service corresponding to the business data to be processed based on the output result.

[0112] Specifically, the server checks whether all sub-goals have found corresponding inference boundary conditions after the previous round of inference. If not, the server can use the obtained inference boundary conditions as new valid information and integrate them into the initial data to form updated initial data. Then, the remaining sub-goals that have not yet been achieved are used as new directions to initiate inference analysis again on this enhanced initial data. This process is repeated until all sub-goals are achieved.

[0113] Since the reasoning boundary conditions, i.e., intermediate conclusions, obtained for each sub-goal are valuable information in themselves, they can serve as prerequisites for solving other sub-goals. This cyclical mechanism enables step-by-step reasoning, knowledge accumulation, and the thought process of using the known to solve the unknown, gradually overcoming difficulties by continuously enriching the contextual information.

[0114] It achieves dynamic evolution and problem-solving, enabling the reasoning process to overcome the limitations of business data through data iteration and automatically handle implicit dependencies between sub-goals. It enhances the ability to solve problems with inherent logical chains by decomposing relatively complex output goals into multiple simpler sub-goals based on stronger data foundations, ensuring the robustness and completeness of the final reasoning process.

[0115] Finally, after multiple iterations, once it is determined that all sub-goals are reachable, i.e., all have obtained the corresponding reasoning boundary conditions, the loop terminates. The server takes the reasoning process generated in each iteration, from the initial data of the corresponding iteration to each sub-goal, as the reasoning fragments that lead to the output goal. These fragments are then integrated and linked according to the logical order of the sub-goals to construct a complete and traceable reasoning chain, and the output result is generated based on this chain.

[0116] For example, suppose the initial data is: Our company's product A achieved sales of 1 million yuan in East China last quarter, but the customer repurchase rate was only 15%. The defined output objective is to develop a market optimization strategy for this product in the next quarter. The server breaks this objective down into three sub-objectives: accurately assess the current sales situation; identify the core issues affecting development; and propose specific improvement measures.

[0117] In the first round of inference, the server successfully found the inference boundary conditions for the first two sub-objectives. By analyzing sales data, it concluded that the market demand base was solid; at the same time, based on the low repurchase rate, it identified insufficient customer loyalty as the main problem. However, for the sub-objective of proposing specific improvement measures, due to limited initial data, it failed to form reliable inference boundary conditions.

[0118] The process continues iterating, with the server using the two obtained inference boundary conditions as new valid information, merging them with the original initial data to form updated initial data. This enhanced dataset not only includes the original sales figures and repurchase rate, but also the important diagnostic conclusion that market demand is solid but customer loyalty is insufficient.

[0119] Based on this updated dataset containing richer information, the server performs further reasoning analysis on the remaining sub-objectives. This time, LLM is able to derive targeted improvement solutions based on the explicit problem of insufficient customer loyalty, including measures such as establishing a customer points reward system and optimizing the after-sales service system. At this point, all sub-objectives have found their corresponding reasoning boundary conditions, and the server, by integrating the entire reasoning process, ultimately outputs a complete market optimization strategy.

[0120] Furthermore, during any round of reasoning on the remaining sub-goals, the server can also designate sub-goals that are not part of the reachable goals as unreachable goals. That is, the remaining sub-goals are called unreachable goals, and new sub-goals that need to be achieved to reach these unreachable goals are determined. In other words, the unreachable goals are broken down to determine more detailed and specific new sub-goals. This process is similar to the aforementioned process of determining several sub-goals from the output goal, and will not be elaborated upon in this specification.

[0121] When reasoning about reachable targets based on updated initial data, the new sub-targets are used as the reasoning targets. The updated initial data are then used for reasoning analysis to deduce the reachable targets.

[0122] Since sub-goals cannot be derived from the initial data, it's possible that the sub-goal itself is flawed, or that its complexity exceeds the capabilities of a single-round iterative LLM reasoning. Therefore, the sub-goal might also be a macro-level objective. Decomposing unachieved goals into more specific new sub-goals essentially constructs a more operational reasoning ladder. This allows LLM to focus on smaller, more defined reasoning tasks, reducing the cognitive load of a single reasoning iteration. Simultaneously, building new rounds of reasoning on updated data containing historical conclusions ensures the continuity and accumulation of the knowledge system.

[0123] This process enables dynamic problem decomposition, allowing the server to autonomously adjust its solution strategy based on actual reasoning difficulties, thus enhancing the method's adaptability and intelligence. Furthermore, by optimizing the granularity of the objective, relatively difficult reasoning tasks are transformed into a series of simpler tasks, improving both the success rate of single-round iterative reasoning and ensuring the logical rigor of the solution path. This progressive objective refinement strategy, combined with data augmentation mechanisms, allows for the accurate determination of the reasoning process even for problems requiring multi-level reasoning, resulting in more accurate outputs.

[0124] For example, suppose the initial data shows a slowdown in user growth for smart home devices, and the customer service system receives numerous complaints about the complexity of device operation. The output objective is to design and develop solutions for the next generation of smart home products. The server breaks this down into three sub-objectives: analyzing the reasons for the slowdown in market growth, assessing potential for technological improvements, and proposing new product feature plans.

[0125] In the first round of inference, the server completed the first two sub-objectives, confirming that the main reason for the slowdown in growth was the excessive complexity of device operation, and that there was a technical feasibility to simplify the user interface. However, in the sub-objective of proposing new product feature planning, the inference failed to achieve satisfactory boundary conditions.

[0126] Continuing the iteration process, the server did not simply update the data; instead, it initiated a goal refinement mechanism. The unmet sub-goals were broken down into two more specific new sub-goals: to conduct in-depth research into the specific operational pain points of different user groups, and to design new features based on technical feasibility to minimize user learning costs.

[0127] Based on an updated dataset containing the original data and existing conclusions, the server then conducts a new round of reasoning targeting these more granular sub-objectives. By analyzing the usage habits of different user groups, it was found that middle-aged and elderly users generally have difficulty operating touchscreens, while younger users expect more intelligent voice interaction. Based on these findings, the server further deduced specific solutions for new products that should simultaneously provide simplified physical buttons and enhanced voice assistant functionality.

[0128] Finally, after multiple rounds of such goal refinement and reasoning iterations, the server built a product development solution that deeply meets market demands, solving the core pain points of existing products and providing personalized user experiences for different user groups.

[0129] Furthermore, in one or more embodiments of this specification, during the iteration process, the server uses the achievable target as input data to the large model to update the initial data. This is essentially a process of information accumulation, which can optimize iteration efficiency. However, it also increases the complexity of the iteration. Therefore, in some embodiments, to save resources, the server may not update the initial data. Instead, based on the original initial data, it may again use the unachievable target as the objective to infer and determine the achievable target. Due to the characteristics of LLM, even the same problem may produce different results in two iterations. That is, LLM itself has a certain ability to explore differences. Therefore, it can also achieve the effect that the previous iteration process could not achieve, namely, inferring achievable targets that include unachievable targets.

[0130] Furthermore, after a certain number of iterations, the server can initiate updates to the initial data, further refine sub-goals, or a combination of both, depending on the specific requirements; this manual does not impose any restrictions. For example, if a complete inference cannot be completed in 5 rounds, the initial data is updated, and sub-goals are refined starting from the 10th round. Or, if a complete inference cannot be completed in the 7th round, the initial data is updated, and sub-goals that could not be completed are also refined, and so on. In other words, updating the initial data and further refining sub-goals are both optional "tools" that can be used according to actual needs.

[0131] Of course, using these "tools" requires a certain cost, so in scenarios where cost is a priority or computing power is limited, it is also possible to choose not to use these tools.

[0132] It should be noted that the sub-goals derived from the decomposition of the output goal are usually quite clear and direct, without a large number of invalid or misleading reasoning branches. Therefore, all the "reachable goals" obtained in the forward reasoning process, that is, the intermediate conclusions derived for each sub-goal, are essentially valid logical products based on the initial data. These reachable goals may not be used to construct the final reasoning chain yet, but they are not erroneous or paths that need to be eliminated; rather, they are organic components of the problem-solving space and potentially useful pieces of information. Figure 1 Compared to the corresponding implementation, because the problems it deals with are relatively simple and the structure is clear, there is no need to introduce defensive mechanisms such as blacklists used for pruning and avoidance. Its core lies in gradually approaching the answer in a constructive way through the decomposition of sub-goals and the accumulation of achievable goals, rather than filtering and eliminating from many possibilities. This makes it more efficient and concise when dealing with specific types of problems.

[0133] It should be noted that common bidirectional reasoning schemes aim to improve the limitations of traditional LLM unidirectional reasoning by introducing reverse reasoning. The core of this scheme is to allow reverse thinking starting from the answer goal and to interact and integrate with forward reasoning starting from the problem in real time and dynamically, so as to find solutions in a bidirectional approximation manner.

[0134] However, this real-time interactive parallel mode introduces instability and decision oscillations in the inference process. Because the forward and backward inference threads need to continuously evaluate and influence each other, the entire system is in a highly dynamic equilibrium, making it susceptible to decision fluctuations due to changes in local information. This makes it difficult for the inference path to converge stably, increasing the system's uncertainty. Furthermore, this complex interaction places higher demands on the coordinated allocation of computational resources, affecting the overall efficiency and stability of the solution.

[0135] Taking a logic puzzle as an example, a two-way reasoning solution might reason from both ends simultaneously: the forward reasoning starts from "A says B is lying," and the reverse reasoning starts from "C is telling the truth." However, when the forward reasoning leads to "A might be true" while the reverse reasoning leads to "A must be lying if C is true," the information from the two directions will immediately conflict. The model may need to frequently switch between different assumptions, causing the reasoning state to fluctuate and making it impossible to proceed along a single path.

[0136] The above is an example of a business execution method based on a large model provided in this specification. Based on the same idea, this specification also provides corresponding devices, storage media and electronic devices.

[0137] Figure 8 This specification provides a schematic diagram of a business execution device based on a large model, the device comprising: The acquisition module 701 is used to acquire the business data to be processed as the initial data for inputting the large model; The reverse analysis module 702 is used to determine the output target based on the initial data through the large model, and generate the final steps required to obtain the output target according to the output target; The forward reasoning module 703 is used to perform reasoning analysis on the initial data with the goal of obtaining the preconditions for executing the final step, and to deduce the reasoning boundary conditions that can be obtained based on the initial data. The docking and reconstruction module 704 is used to construct an inference process from the initial data to the output target based on the final step and the inference boundary conditions, and to determine the output result of the large model based on the inference process; The execution module 706 is used to execute the business corresponding to the business data to be processed based on the output result.

[0138] Optionally, the forward reasoning module 703 is used to input the initial data into the large model to obtain the output target corresponding to the initial data; continue to analyze and deduce each candidate reasoning step of the output target using the large model, starting from the output target; and select the final step from each candidate reasoning step.

[0139] Optionally, the forward reasoning module 703 is used to determine the preconditions required to execute the final step through the large model; take the initial data as the current state and the preconditions as the target state, and derive the reasoning process of obtaining the target state from the current state through the large model; and determine the reasoning boundary conditions that can be obtained based on the initial data from the reasoning process.

[0140] Optionally, the docking reconstruction module 704 is used to determine whether the inference boundary conditions satisfy the preconditions for executing the final step; if so, it determines the inference process from the initial data to the output target based on the inference process of obtaining the inference boundary conditions and the final step.

[0141] Optionally, the device further includes: The loop iteration module 706 is used to redetermine the inference boundary conditions when the inference boundary conditions do not meet the preconditions for executing the final step, with the goal of obtaining the preconditions for executing the final step, until the inference boundary conditions meet the preconditions for executing the final step.

[0142] Optionally, the iterative loop module 706 is used to determine the number of times the inference boundary conditions are redefined with the preconditions of the current final step as the target; determine whether the number of times reaches a preset value; if so, the final step is redefined through the large model, and the inference boundary conditions are redefined with the preconditions of the redefined final step as the target; if not, the inference boundary conditions are redefined through the large model with the preconditions of the current final step as the target.

[0143] Optionally, the loop iteration module 706 is used to redetermine the final steps based on the determined output target through the large model, or to redetermine the output target based on the initial data through the large model, and determine the final steps required to obtain the redetermined output target.

[0144] Optionally, the loop iteration module 706 is further configured to write the reasoning boundary conditions that do not meet the preconditions for executing the final step and the corresponding reasoning process into the reasoning blacklist of the large model before reasoning through the large model, so that the large model can avoid the reasoning blacklist in subsequent reasoning processes.

[0145] Optionally, the forward reasoning module 703 is further configured to determine whether the initial data belongs to a complex problem using a pre-trained detection model; if so, it performs reasoning analysis on the initial data with the goal of obtaining the preconditions for executing the final step, and derives the reasoning boundary conditions that can be obtained based on the initial data.

[0146] Optionally, the device further includes: The information accumulation module 707 is used to determine, through the large model, several sub-goals that need to be achieved to reach the output goal; to perform reasoning analysis on the initial data with the several sub-goals as targets, and to derive the achievable goals based on the initial data; to construct a reasoning process from the initial data to the output goal based on the sub-goals and the achievable goals, and to determine the output result of the large model based on the reasoning process; and to execute the business corresponding to the business data to be processed based on the output result.

[0147] Optionally, the information accumulation module 707 is used to determine whether each sub-target belongs to an reachable target; if so, the reasoning process of the output target is determined based on the reasoning process of each reachable target; if not, the reachable target is used as the input data of the large model, the initial data is updated, the remaining sub-targets are used as targets, the updated initial data is reasoned and analyzed, and the reachable targets that can be obtained are re-derived. The above process is repeated until all sub-targets belong to reachable targets, and the reasoning process of the output target is determined.

[0148] Optionally, the information accumulation module 707 is used to identify sub-goals that are not attainable as unattainable goals, determine new sub-goals that need to be achieved to reach the unattainable goals, and use the new sub-goals as targets to perform reasoning analysis on the updated initial data to deduce attainable goals.

[0149] This specification also provides a computer-readable storage medium storing a computer program that, when executed by a processor, can be used to perform the above-described business execution method based on a large model.

[0150] based on Figure 1 The business execution method based on the large model shown in this specification also provides the embodiments. Figure 9 The diagram shows the structure of the electronic device. Figure 9 At the hardware level, the electronic device includes a processor, internal bus, network interface, memory, and non-volatile storage, and may also include other hardware required for business operations. The processor reads the corresponding computer program from the non-volatile storage into memory and then runs it to implement the aforementioned business execution method based on a large model.

[0151] The above description is merely an embodiment of this specification and is not intended to limit this specification. Various modifications and variations can be made to this specification by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this specification should be included within the scope of the claims of this specification.

Claims

1. A business execution method based on a large model, the method comprising: Obtain the business data to be processed as the initial data for inputting the large model; Based on the initial data, the output target is determined through the large model, and according to the output target, the final steps required to obtain the output target are generated; With the goal of obtaining the prerequisites for executing the final step, the initial data is subjected to reasoning analysis to deduce the reasoning boundary conditions that can be obtained based on the initial data. Based on the final step and the inference boundary conditions, a reasoning process from the initial data to the output target is constructed, and the output result of the large model is determined based on the reasoning process. Based on the output results, execute the business corresponding to the business data to be processed.

2. The method as described in claim 1, wherein the output target is determined based on the initial data using the large model, and the final steps required to obtain the output target are generated according to the output target, specifically including: The initial data is input into the large model to obtain the output target corresponding to the initial data; Continuing with the large model, starting with the output target, we analyze and deduce each candidate reasoning step for the output target; Select the final step from the candidate reasoning steps.

3. The method as described in claim 1, with the goal of obtaining the preconditions for executing the final step, involves performing reasoning analysis on the initial data to derive reasoning boundary conditions based on the initial data, specifically including: The preconditions required to perform the final step are determined using the large model. The initial data is taken as the current state, and the preconditions are taken as the target state. The reasoning process of obtaining the target state from the current state is derived through the large model. From the reasoning process, it is determined that the reasoning boundary conditions can be obtained based on the initial data.

4. The method as described in claim 1, wherein the reasoning process from the initial data to the output target is constructed based on the final step and the reasoning boundary conditions, specifically including: Determine whether the inference boundary conditions satisfy the preconditions for executing the final step; If so, then based on the reasoning process that obtains the reasoning boundary conditions and the final step, the reasoning process from the initial data to the output target is determined.

5. The method of claim 4, further comprising: When the inference boundary conditions do not meet the preconditions for executing the final step, the inference boundary conditions are redefined with the goal of obtaining the preconditions for executing the final step, until the inference boundary conditions meet the preconditions for executing the final step.

6. The method as described in claim 5, further comprising redetermining the inference boundary conditions, specifically including: Determine the number of times the inference boundary conditions are redefined, with the preconditions of the current final step as the target. Determine whether the number of times has reached a preset value; If so, the final step is redefined using the large model, and the reasoning boundary conditions are redefined with the goal of obtaining the preconditions for executing the redefined final step. If not, then the inference boundary conditions are redefined using the large model with the preconditions of the current final step as the target.

7. The method of claim 6, further comprising redetermining the final step, specifically including: The large model redetermines the final steps based on the determined output target, or redetermines the output target based on the initial data, and determines the final steps required to obtain the redetermined output target.

8. The method of claim 6 or 7, wherein before inference is performed through the large model, the method further comprises: For inference boundary conditions that do not meet the preconditions for executing the final step, and the corresponding inference process, they are written into the inference blacklist of the large model, so that the large model can avoid the inference blacklist in subsequent inference processes.

9. The method of claim 1, further comprising, before performing inference analysis on the initial data to deduce the inference boundary conditions based on the initial data, with the goal of obtaining the preconditions for performing the final step, the method further comprising: The pre-trained detection model is used to determine whether the initial data constitutes a complex problem. If so, then with the goal of obtaining the prerequisites for executing the final step, the initial data is subjected to reasoning analysis to deduce the reasoning boundary conditions that can be obtained based on the initial data.

10. The method of claim 9, wherein when the initial data does not pertain to a complex problem, the method further comprises: Using the large model, several sub-goals that need to be achieved to reach the output goal are determined; Using the aforementioned sub-objectives as targets, the initial data is analyzed and reasoned to derive the achievable targets based on the initial data. Based on the sub-goals and the achievable goals, a reasoning process from the initial data to the output goal is constructed, and the output result of the large model is determined based on the reasoning process; Based on the output results, execute the business corresponding to the business data to be processed.

11. The method of claim 10, wherein constructing a reasoning process from the initial data to the output target based on the sub-target and the reachable target specifically includes: Determine whether each sub-objective is an attainable objective; If so, then based on the reasoning process of each reachable target, determine the reasoning process for obtaining the output target; If not, the reachable target is used as the input data of the large model to update the initial data. The remaining sub-targets are used as targets. The updated initial data is used for reasoning analysis to derive the reachable targets again. The above process is repeated until all sub-targets are reachable targets, and the reasoning process of obtaining the output target is determined.

12. The method as described in claim 11, taking the remaining sub-objectives as the target, performing reasoning analysis on the updated initial data, and re-deriving the achievable targets, specifically includes: Sub-goals that are not attainable goals are designated as unattainable goals, and new sub-goals that need to be achieved to reach these unattainable goals are determined. Using the new sub-goal as the objective, the updated initial data is analyzed to deduce the attainable objective.

13. A business execution apparatus based on a large model, the apparatus comprising: The acquisition module is used to acquire the business data to be processed, which serves as the initial data for inputting the large model; The reverse analysis module is used to determine the output target based on the initial data through the large model, and to generate the final steps required to obtain the output target according to the output target; The forward reasoning module is used to perform reasoning analysis on the initial data with the goal of obtaining the preconditions for executing the final step, and to deduce the reasoning boundary conditions that can be obtained based on the initial data. The docking and reconstruction module is used to construct the reasoning process from the initial data to the output target based on the final step and the reasoning boundary conditions, and to determine the output result of the large model based on the reasoning process. The execution module is used to execute the business corresponding to the business data to be processed based on the output result.

14. A computer-readable storage medium storing a computer program that, when executed by a processor, implements the method described in any one of claims 1-12.

15. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor, when executing the program, implements the method according to any one of claims 1-12.

Images