Short episode generation method and system

Abstract

The invention relates to the technical field of artificial intelligence assisted content creation, in particular to a short play outline generation method and system, comprising: calling a large language model to generate candidate outlines based on a plurality of policy instruction vectors, each outline being associated with a corresponding policy instruction; carrying out multiple rounds of independent and randomly sorted automatic evaluation on the candidate outline, and calculating a quantitative value score of each outline by adopting a pruning mean value algorithm; and screening a high-score outline according to the score and a preset condition, and inputting the high-score outline and an original strategy instruction into a model together to generate an optimized outline. According to the method, through oriented content generation, multi-round randomization depolarization evaluation and trimming mean value robust scoring guided by the strategy instruction, and in combination with a path dependence optimization mechanism, the quality stability, evaluation objectivity and optimization reliability of outline generation are remarkably improved, and efficient, controllable and traceable industrial episode outline production is realized.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of artificial intelligence assisted content creation, and in particular to a short play outline generation method and system. BACKGROUND

[0002] The current short play outline generation method based on large language model (LLM) usually relies on a single prompt word for content creation, which has obvious technical limitations: to pursue creative diversity and improve model randomness, the quality of generated content is extremely unstable, the effective output rate is low, and the evaluation process is easily disturbed by position bias and sequence effect, causing subjective and unreliable scoring, and it is difficult to maintain the quality core of the original content in subsequent optimization, often resulting in value decay, and the overall process lacks traceability between strategies and results, which seriously hinders the application of AI in efficient and large-scale content production.

[0003] Therefore, there is an urgent need to provide a technical solution to solve the above problems. SUMMARY

[0004] To solve the above technical problems, the present application provides a short play outline generation method and system.

[0005] In a first aspect, the present application provides a short play outline generation method, and the technical scheme of the method is as follows: Based on a plurality of preset strategy instruction vectors, a large language model is called to generate a plurality of candidate outlines; wherein each candidate outline is associated with a strategy instruction vector used when it is generated, and the strategy instruction vector is the original strategy instruction vector of the candidate outline; The plurality of candidate outlines are subjected to multi-round independent and randomly ordered automated evaluation before each round of evaluation, to obtain a score for each round, and the scores for each round are processed using a pruning mean algorithm to calculate a quantitative value score for each candidate outline; Based on the quantitative value score of each candidate outline and a preset optimization condition, a high-score candidate outline is selected, and the selected high-score candidate outline and its associated original strategy instruction vector are input into the large language model to generate an optimized outline, thereby completing the generation of the outline.

[0006] The short play outline generation method of the present application has the following beneficial effects: The method of the present application significantly improves the quality stability, evaluation objectivity and optimization reliability of the generated outline by using strategy instruction guided directional content generation, multi-round randomized unbiased evaluation and pruning mean robust scoring, and combining with a path-dependent optimization mechanism, thereby realizing efficient, controllable and traceable industrial short play outline production.

[0007] On the basis of the above-mentioned scheme, the short play outline generation method of the present application can also be improved as follows.

[0008] In an optional manner, based on a plurality of preset strategy instruction vectors, the step of calling a large language model to generate a plurality of candidate outlines includes: According to a preset random degree interval, set the temperature parameter of the large language model; Obtain a plurality of user-defined generation strategies; wherein each strategy contains a business confidence weight and a strategy instruction vector in text form; Based on the greatest common divisor method, according to the weight of each strategy, the total number of preset tasks is allocated to each strategy instruction vector; For each allocated generation task, the corresponding strategy instruction vector is injected into the unified prompt word template to form the final prompt word, and the large language model is called using the final prompt word to generate a candidate outline.

[0009] In the above optional manner, by setting the temperature parameter to encourage creative exploration, and using the greatest common divisor method combined with strategy weight to realize the optimal allocation of computing resources, both the diversity of generated content and the sufficient generation tasks for high-value strategies are ensured, significantly improving the efficiency and output quality of the generation process.

[0010] In an optional manner, based on the greatest common divisor method, according to the weight of each strategy, the total number of preset tasks is allocated to each strategy instruction vector, including: According to the weight of all strategies, determine the total weight representing the sum of the weights; For each strategy, calculate the theoretical task quota based on the proportion of its weight and the total weight; Allocate a basic task number equal to the integer part of the theoretical quota to each strategy; Determine the remaining task number according to the difference between the sum of the basic task numbers of all strategies and the total task number; Determine the decimal remainder according to the difference between the theoretical quota of each strategy and its basic task number; Sort all strategies in descending order according to the size of their decimal remainder values, and allocate the multiple tasks represented by the remaining task number to the strategies in the front of the order in turn.

[0011] In the above optional manner, the implementation steps of the greatest common divisor method include calculating the theoretical quota, allocating the basic task number, processing the decimal remainder, and allocating the remaining tasks, which ensures that the total number of tasks is accurately allocated according to the weight, avoids resource waste or insufficient allocation caused by rounding errors, and realizes the fair and efficient use of computing budget.

[0012] In an optional manner, in the step of allocating multiple tasks in turn, if the decimal remainders of multiple strategies are the same, the tasks are preferentially allocated to strategies with higher weights.

[0013] In the optional manner described above, by setting a conflict resolution rule that gives priority to allocating weights to the higher ones when the remainders of multiple strategies are the same, the resource allocation strategy is further optimized, ensuring that strategies with higher business confidence can obtain more computing resources, thereby increasing the probability of high-value content output.

[0014] In an optional manner, the method further comprises: when the candidate outline generated by the large language model is structured data and there is a syntax error, automatically repairing the syntax of the structured data; If the repair fails, perform heuristic reconstruction based on a preset template; If the reconstruction fails, trigger a request for re-generation with enhanced format requirements.

[0015] In the optional manner described above, by introducing a hierarchical structured data error handling mechanism, including automatic repair, heuristic reconstruction, and retry request, the problem of process interruption caused by common syntax errors in LLM output is effectively solved, greatly improving the robustness and automation of the system when processing complex structured output.

[0016] In an optional manner, the step of performing multiple rounds of independent and randomly ordered automated evaluation of the multiple candidate outlines to obtain scores for each round comprises: performing a preset number of independent evaluation processes; Before starting each evaluation process, randomly sort all candidate outlines to eliminate position bias; Submit the randomly sorted candidate outlines in batches to the large language model as the evaluator for scoring, and collect the scores for each round.

[0017] In the optional manner described above, by using the strategy of random sorting and batch submission in each round of evaluation, the position bias and order effect that may be caused by fixed candidate order are completely eliminated, ensuring the objectivity of the evaluation process and the reliability of the scores.

[0018] In an optional manner, the scores for each round are processed using the pruning mean algorithm to calculate the quantitative value score of each candidate outline, comprising: For each candidate outline, analyze the collected multiple scores to obtain a score set in multiple preset scoring dimensions; For each scoring dimension, determine whether the number of scores in the score set is greater than or equal to a preset pruning threshold; If less than the pruning threshold, calculate the average of all scores in the score set as the quantitative value score of the candidate outline in this dimension; If greater than or equal to the pruning threshold, discard one highest score and one lowest score in the score set, and calculate the average value of the remaining scores as the quantitative value score of the candidate outline in this dimension.

[0019] In the above optional manner, by implementing the pruning mean algorithm, different sample sizes are flexibly processed, abnormal values and random noise in the evaluation are effectively filtered, more stable and reliable quantitative score results are obtained than simple average value, and the confidence of the decision data is improved.

[0020] In an optional manner, further comprising: If it is detected that the score of a certain scoring dimension in a certain round of evaluation deviates from the median of the collected scores by more than a preset statistical threshold, the round of evaluation is marked as abnormal, and a supplementary evaluation is triggered.

[0021] In the above optional manner, by introducing the abnormal evaluation detection and supplementary evaluation mechanism based on the statistical threshold (such as median deviation), invalid scores generated due to temporary malfunction of the model can be intelligently identified and processed, further enhancing the robustness and result accuracy of the evaluation system.

[0022] In an optional manner, based on the quantitative value score of each candidate outline and a preset optimization condition, high-score candidate outlines are screened, and the screened high-score candidate outlines and their associated original strategy instruction vectors are input into the large language model to generate optimized outlines, comprising: Based on the quantitative value score and the preset optimization condition, the to-be-optimized outlines are selected from all candidate outlines; For each to-be-optimized outline, the strategy instruction vector used when the to-be-optimized outline is generated is extracted from the metadata of the to-be-optimized outline, and an optimization prompt word is constructed. The optimization prompt word integrates the text content of the to-be-optimized outline, the automated modification suggestions for the to-be-optimized outline, and the extracted strategy instruction vector used when the to-be-optimized outline is generated. The optimization prompt word is submitted to the large language model for processing, and the text returned by the large language model is received as the optimized version of the to-be-optimized outline to complete the generation of the outline.

[0023] In the above optional manner, by forcibly re-injecting the original strategy instruction (successful gene) during optimization and constructing the multi-element integrated optimization prompt word, it is ensured that the optimization process always revolves around the core value of the initial draft, effectively preventing the common value decay problem in conventional optimization, and achieving stable enhancement of the value.

[0024] In a second aspect, the present application provides a short play outline generation system, and the technical scheme of the system is as follows: The short play outline generation system comprises: The guiding divergence module is used for calling a large language model to generate a plurality of candidate outlines based on a plurality of preset strategy instruction vectors; wherein each candidate outline is associated with a strategy instruction vector used when the candidate outline is generated, and the strategy instruction vector is an original strategy instruction vector of the candidate outline. The quantification convergence module is used for performing a plurality of rounds of independent and randomly ordered automatic evaluations on the plurality of candidate outlines to obtain scores of each round, and processing the scores of each round by using a pruning mean algorithm to calculate a quantification value score of each candidate outline. The constraint and value enhancement module is used for screening high-score candidate outlines based on the quantification value score of each candidate outline and a preset optimization condition, and inputting the screened high-score candidate outlines and their associated original strategy instruction vectors into the large language model to generate optimized outlines.

[0025] The short play outline generation system of the present application has the following beneficial effects: The system of the present application significantly improves the quality stability, evaluation objectivity and optimization reliability of the generated outlines by using the strategy instruction guided directional content generation, the multi-round randomized and unbiased evaluation and the pruning mean robust scoring, and combining the path-dependent optimization mechanism, and realizes efficient, controllable and traceable industrialized short play outline production.

[0026] In a third aspect, the technical solution of an electronic device of the present application is as follows: The processor executes the program to realize the steps of the short play outline generation method of the present application.

[0027] In a fourth aspect, the technical solution of a computer readable storage medium provided by the present application is as follows: The computer readable storage medium stores instructions, and when the computer readable storage medium reads the instructions, the computer readable storage medium executes the steps of the short play outline generation method of the present application.

[0028] The above description is only a summary of the technical solutions of the present application, in order to more clearly understand the technical means of the present application, the specific embodiments of the present application can be implemented according to the content of the specification, and in order to make the above and other purposes, features and advantages of the present application more obvious and easy to understand, the following specific embodiments of the present application are described. BRIEF DESCRIPTION OF DRAWINGS

[0029] The accompanying drawings are only used to illustrate the embodiments and are not considered as limiting the present application. Moreover, the same reference signs are used to represent the same components throughout the drawings. In the drawings: Figure 1 The flowchart of an embodiment of the short play outline generation method of the present application is shown in the figure; Figure 2 A guided divergence-convergence (GDC) three-stage core flowchart in the present application; Figure 3 A task allocation algorithm flowchart based on the maximum remainder method in the present application; Figure 4 A debiasing evaluation flowchart based on the multi-round randomization and pruning mean algorithm in the present application; Figure 5 A closed-loop optimization workflow based on path dependence in the present application; Figure 6 A structural schematic diagram of an embodiment of a short play outline generation system of the present application; Figure 7 A structural schematic diagram of an embodiment of an electronic device of the present application. DETAILED DESCRIPTION

[0030] Exemplary embodiments of the present application will be described in greater detail below with reference to the accompanying drawings. Although exemplary embodiments of the present application are shown in the drawings, it should be understood that the present application can be implemented in various forms and should not be limited by the embodiments set forth herein.

[0031] Figure 1 A flowchart of an embodiment of a short play outline generation method provided by the present application is shown, as shown in Figure 1 includes the following steps: S1, based on a plurality of preset strategy instruction vectors, calling a large language model to generate a plurality of candidate outlines; wherein each candidate outline is associated with a strategy instruction vector used when it is generated, and the strategy instruction vector is the original strategy instruction vector of the candidate outline. In S1: 1) The strategy instruction vector refers to a text instruction defined by the user in advance to guide the generation direction, which functions to form an "attractive center" in the high-dimensional semantic space of the large language model, so that the generated content maintains diversity while not deviating from the preset commercial value orientation.

[0032] 2) The association relationship refers to binding each generated outline with its corresponding strategy instruction vector through a metadata recording mechanism, which functions to ensure that the subsequent process can trace back and reuse the core strategy during generation, providing a basis for path-dependent optimization.

[0033] Specifically, the user first defines a set of policy instruction vectors with different orientations and their weights in the configuration file. The maximum remainder method is used to calculate the specific number of tasks that each policy should allocate according to the total number of generated tasks, and then each policy instruction vector is injected into a unified prompt template, and a large language model under high temperature parameter setting is called to generate content with high randomness. Each generated outline records its corresponding policy instruction identifier, and finally a large-scale candidate outline pool with diversity and directionality is formed.

[0034] S2, a plurality of candidate outlines are subjected to multi-round independent and randomly ordered automated evaluation, a score for each round is obtained, and a pruning mean algorithm is used to process the score for each round to calculate a quantitative value score of each candidate outline. In S2: 1) Multi-round independent evaluation means that the same evaluation model scores the candidate outlines multiple times in different sessions, which eliminates accidental errors in single evaluation and obtains more stable score data.

[0035] 2) Random ordering means that the order of all candidate outlines is randomly rearranged before each round of evaluation, which eliminates positional bias that may be caused by fixed order and ensures the objectivity of evaluation.

[0036] 3) The pruning mean algorithm is a robust statistical processing method that calculates the average value by removing extreme values at both ends of the data, which effectively filters noise and outliers generated during the evaluation process due to temporary model abnormalities, thereby obtaining more reliable scores.

[0037] Specifically, the total number of evaluation rounds (e.g., 3 rounds) is set, and all candidate outlines are randomly shuffled and submitted in batches to the large language model as the evaluator for scoring before each round begins. After collecting all round scores, the pruning mean algorithm (e.g., removing one highest score and one lowest score when the sample size is ≥3) is applied to each outline's score set in each scoring dimension to calculate its final robust score, thereby obtaining the quantitative value score of each candidate outline.

[0038] S3, based on the quantitative value score of each candidate outline and the preset optimization condition, high-score candidate outlines are screened, and the screened high-score candidate outlines and their associated original policy instruction vectors are input into the large language model to generate optimized outlines, thereby completing the generation of outlines. In S3: 1) The preset optimization condition refers to the score threshold rule set by the user, which automatically determines which outlines need to enter the optimization process, for example, outlines below a certain threshold are optimized, while high-score outlines are directly output.

[0039] 2) The original strategy instruction vector is the strategy instruction text used when generating the outline in S1. It is re-injected in this stage to serve as a "success gene" to constrain the optimization direction and prevent the optimization process from deviating from the original advantages.

[0040] Specifically, first, the target to be optimized is selected from all candidate outlines according to a preset threshold. For each outline to be optimized, the original strategy instruction vector is extracted from its metadata, and an optimized prompt word with enhanced constraints is constructed by combining the automatically generated modification suggestions and the original outline text. The prompt word is submitted to the large language model for processing, and the model generates an optimized outline version under the guidance of the original strategy, thereby preserving the core advantages while enhancing the value. Finally, the generation process of all outlines is completed.

[0041] Figure 2 The guided divergent-convergent (GDC) three-stage core process followed by the method of the application is shown. The process starts with guided divergence in stage one, generates a large-scale candidate pool by defining multiple strategies, allocating budgets, and high-temperature injection instructions; then enters the quantitative convergence in stage two, selects high-potential candidates through randomized sorting, multi-round evaluation, and pruning mean calculation; finally enters the constraint optimization in stage three, enhances the value of the selected candidates through threshold judgment, extraction of success genes, and path-dependent optimization, and outputs the final results. The flowchart fully embodies the core idea of the application of converting the uncontrollable generation process into a controllable and measurable industrial process.

[0042] The technical solution of the embodiment significantly improves the quality stability, evaluation objectivity, and optimization reliability of the outline generation through strategy instruction guided directional content generation, multi-round randomized debiasing evaluation and pruning mean robust scoring, and combined with the path-dependent optimization mechanism, realizes efficient, controllable, and traceable industrial short script outline production.

[0043] In an optional manner, based on a plurality of preset strategy instruction vectors, the step of calling the large language model to generate a plurality of candidate outlines comprises: According to a preset randomness interval, set the temperature parameter of the large language model; Obtain a plurality of generation strategies defined by the user; wherein each strategy includes a business confidence weight and a strategy instruction vector in text form; Based on the maximum remainder method, according to the weight of each strategy, the total number of preset tasks is allocated to each strategy instruction vector; For each allocated generation task, the corresponding strategy instruction vector is injected into a unified prompt word template to form a final prompt word, and the large language model is called using the final prompt word to generate a candidate outline.

[0044] In an alternative manner, the step of allocating the preset total number of tasks to the strategy instruction vectors according to the weights of the strategies based on the maximum remainder method comprises: determining a total weight representing the sum of the weights according to the weights of all the strategies; calculating a theoretical task quota for each strategy based on the proportion of its weight to the total weight; allocating a basic number of tasks to each strategy equal to the floor of its theoretical quota; determining a remaining number of tasks according to the difference between the sum of the basic numbers of tasks of all the strategies and the total number of tasks; determining a decimal remainder according to the difference between the theoretical quota of each strategy and its basic number of tasks; sorting all the strategies in descending order according to the values of their decimal remainders, and allocating the multiple tasks to be allocated represented by the remaining number of tasks to the strategies in the front of the order in turn.

[0045] In an alternative manner, in the step of allocating the multiple tasks to be allocated in turn, if the decimal remainders of the multiple strategies are the same, the tasks are preferentially allocated to the strategies with higher weights.

[0046] It should be noted that for the activation and parameter setting of the high-randomness generation mode, in order to encourage the model to conduct creative exploration, the temperature hyperparameter (temperature) of the large language model is first set in a relatively high preset interval. A higher temperature coefficient increases the entropy value of the sampling process by smoothing the probability distribution output by the softmax function, thereby macroscopically representing high-randomness and diversified text output.

[0047] For the strategy instruction vector D i , the user defines a generation strategy in the configuration file, each strategy including a business confidence weight w i and a strategy instruction vector D i in text form. In the prompt word construction stage, D i is injected into the input of the LLM. Therefore, the key lies in that D i not only serves as an ordinary text constraint, but also forms an “attraction center” in the high-dimensional semantic space (Latent Space) of the model. This “attraction center” mechanism is equivalent to applying a “weighted centroid” to the high-business-value region in the latent space, which can make the sampling distribution converge to the target semantic region, thereby significantly improving the generation hit rate and effectively reducing the proportion of invalid output in the high-randomness exploration process.

[0048] For the calculation budget optimization distribution based on the maximum remainder method, in order to ensure that the total generated task number T can be accurately distributed according to the preset weight w of each strategy i The distribution is carried out by using the largest remainder method (Largest Remainder Method). The use of this method can perfectly distribute the task number, avoiding the waste of computing resources or the systematic deviation of insufficient distribution (i.e. the total of the distributed tasks is not equal to T) caused by simple proportional rounding.

[0049] For guided generation, for each distributed task, the corresponding strategy instruction vector directive is injected into the unified prompt template, and the LLM is called to generate a candidate outline. The instruction vector plays the role of "gravitational center" in the semantic space of the LLM, constraining its high-entropy exploration process and ensuring that the final large-scale candidate outline pool meets the expected commercial orientation, with diversity and directionality.

[0050] In this embodiment, first, according to the preset randomness interval, the temperature parameter δ of the large language model is set, where δ ∈ [0.6, 1.0]. The temperature parameter δ is used to adjust the smoothing degree of the softmax function output probability distribution. The higher the value, the greater the entropy value of the sampling process, and the generated text shows higher randomness and diversity, thereby encouraging the model to conduct creative exploration.

[0051] Secondly, N generation strategies defined by the user are obtained, each strategy P i contains a business confidence weight w i and a strategy instruction vector D i in text form. The strategy instruction vector D i not only serves as a text constraint after being injected into the large language model input, but also constructs an "attractive center" in the high-dimensional semantic space of the model to guide the generation process towards the preset commercial value direction. Assuming that the original sampling distribution of the LLM is When the strategy instruction vector D i is injected, the distribution is modified to: ; Wherein, represents the modified generation probability distribution guided by the strategy instruction; represents the original generation probability distribution of the LLM; represents a potential generated content (such as a short play outline); D i represents the text content of the i-th strategy instruction vector; is a semantic encoding function responsible for mapping text into high-dimensional semantic vectors. This function is implemented by calling the encoder of a large language model itself, for example, directly extracting the average pooling vector of the hidden state of the last layer of the transformer or the vector of the [CLS] token after the text input, as its semantic representation; represents vector similarity calculation, preferably cosine similarity, used to calculate the degree of alignment between the generated content and the policy instructions in the semantic space; is a positive real hyperparameter that adjusts the strength of the gravitational force of the "attractive center". The larger the value of a, the more the generated content tends to be semantically close to the policy instructions. This parameter can be optimized on the validation set through methods such as grid search, for example, testing in an interval of to find the best balance point. This is beneficial to make the random sampling process of the model gather towards these high-value target regions, thereby significantly improving the hit rate of "blockbuster" content and effectively reducing the overhead of invalid calculations.

[0052] Next, based on the maximum remainder method, the total number of preset generation tasks T is allocated to each policy instruction vector according to the weight of each policy. The specific execution steps of the maximum remainder method are as follows: Input: total number of tasks T, N policies {P¹,…,Pⁿ} and their weights {w¹,…,wⁿ}; Output: the final number of tasks T i allocated to each policy P final,i .

[0053] Calculate the total weight: ; where W total represents the sum of all weights, i.e., the total weight; j is the summation index, representing the first policy to the Nth policy; w j represents the weight of the jth policy.

[0054] For each policy P i , calculate its theoretical quota: ; where q i represents the theoretical number of tasks that the policy P i should be allocated according to the weight ratio; w i represents the weight of the ith policy.

[0055] Allocate the base number of tasks: ; where T base,i represents the actual number of base tasks allocated after rounding down; represents the rounding down operation on q i , i.e., taking the value not greater than qi The largest integer.

[0056] Calculate the remainder: ; Where, r i This represents the decimal remainder between the theoretical quota and the basic task number.

[0057] Calculate the number of remaining tasks to be assigned: ; Among them, T rem This indicates the number of remaining tasks after all strategies have assigned basic tasks; This represents the summation of the number of basic tasks for all strategies from i=1 to i=N.

[0058] All strategies modulo r i Sort in descending order. (The last part, "T", appears to be a typo and can be left as is.) rem One task at a time, assigned sequentially to the first T sorted groups. rem One strategy; The final number of tasks for each strategy is: ; Among them, T final,i Representing strategy P i The final total number of tasks assigned.

[0059] When assigning remaining tasks to policies, if multiple policies have a remainder r... i In the same case, tasks will be assigned to those with higher business confidence weights. i The strategy.

[0060] Finally, for each assigned generation task, the corresponding policy instruction vector D is... i The final prompts are injected into a unified prompt template and then used to generate candidate outlines using a large language model. Through this method, the system can maintain directionality during the highly randomized generation process, significantly improving the proportion of effective content produced.

[0061] Figure 3 The algorithm for optimizing the allocation of computational resources based on the maximum remainder method is specifically illustrated. This algorithm takes the total number of tasks and the weights of each strategy as input. It calculates the theoretical quota, allocates the basic number of tasks, calculates the decimal remainder and the remaining number of tasks, and finally allocates the total number of tasks precisely to each strategy instruction vector according to their weights by distributing them in descending order of the remainders. This process ensures the optimal allocation of computational resources, avoiding the systematic bias of wasted or insufficient allocation that may result from simple proportional rounding, and is consistent with the description and claims.

[0062] In one alternative approach, it also includes: When the candidate outlines generated by the large language model are structured data and contain grammatical errors, the structured data is automatically repaired. If the repair fails, a heuristic reconstruction will be performed based on the preset template; If the reconstruction fails, a regeneration request with enhanced formatting requirements will be triggered.

[0063] In this embodiment, to address the common grammatical errors encountered when generating structured data from large language models, and thus ensure the automation and robustness of the entire process, a hierarchical, progressive processing strategy is adopted, as follows: First-level processing: Performs lightweight syntax auto-correction. This layer of logic is triggered when the system catches a JSON parsing exception. This logic includes a series of correction rules for common errors, specifically: Missing or extra commas: Detect and correct comma errors at the end of lines or between object / array members using regular expressions; Parentheses or quotation marks mismatch: Use the stack data structure to check the pairing of parentheses {}, [] and quotation marks "", and complete or delete them at the most likely inferenced position; Illegal escape characters: Remove or correct escape characters that do not conform to the JSON specification.

[0064] Second-level processing: If parsing still fails after the first-level repair, context-based heuristic refactoring is initiated. This level uses regular expressions to forcibly extract the text content of core fields (such as "plot", "characters", etc.) that conform to a predefined format. Based on a standard, correct JSON template, the extracted field content is then re-filled in, thereby reconstructing a syntactically correct JSON object. This process can be formally represented as: ; Among them, JSON correct A template represents a syntactically correct JSON object after refactoring. standard This represents a standard, correct JSON template; Extract regex This represents a field extraction function based on regular expressions; Content raw This represents the original question text content returned by the model.

[0065] Third-layer processing: If the first two layers of repair and reconstruction both fail, it indicates that the structural damage to the original generated content is very severe. In this case, the generation task is marked as failed, and a retry is automatically triggered. An additional reinforcement instruction is added to the retry prompt, requiring the model to "strictly adhere to the JSON format for output" to increase the probability of success on the next attempt. The maximum number of retries, R, is configurable.max (e.g. R) max =2), where R =2), max This indicates the maximum number of allowed retries. After exceeding this number, the task will be completely abandoned and an error log will be logged to prevent an infinite loop.

[0066] By employing the aforementioned hierarchical and progressive processing strategies, common grammatical errors in generating structured data from large language models can be effectively addressed, ensuring automation and robustness throughout the entire process.

[0067] In one alternative approach, the steps of performing multiple independent rounds of automated evaluation on multiple candidate outlines, with randomized ordering before each round, to obtain a score for each round include: Conduct a pre-set series of independent evaluation processes; Before each round of evaluation begins, all candidate outlines are randomly sorted to eliminate positional bias. The randomized and sorted candidate outlines are submitted in batches to the large language model, which acts as the evaluator, for scoring, and the scores for each round are collected.

[0068] In one alternative approach, the steps of processing the scores for each round using a trimmed mean algorithm and calculating the quantitative value score for each candidate outline include: For each candidate outline, the collected multiple rounds of scores are analyzed to obtain a set of scores across multiple preset scoring dimensions; For each rating dimension, determine whether the number of scores in its score set is greater than or equal to a preset pruning threshold; If the score is less than the pruning threshold, the average of all scores in the score set is calculated as the quantitative value score of the candidate outline in this dimension. If the score is greater than or equal to the pruning threshold, then the highest and lowest scores in the score set are discarded, and the average of the remaining scores is calculated as the quantitative value score of the candidate outline in this dimension.

[0069] In one alternative approach, it also includes: If a score for a certain rating dimension in a round of evaluation is detected to deviate from the median of the collected scores and exceed a preset statistical threshold, the round of evaluation will be marked as abnormal and a supplementary evaluation will be triggered.

[0070] In this embodiment, firstly, a preset number of independent evaluation rounds are performed, with the total number of evaluation rounds set to K (e.g., K=3). Multi-round independent evaluation refers to the same evaluation model scoring the candidate outline multiple times in different independent sessions. Its purpose is to eliminate the random errors of a single evaluation and obtain multiple sets of stable scoring data.

[0071] Before each round of evaluation begins, a random sorting algorithm (such as random.sample) is used to randomize all candidate outlines. The purpose of random sorting is to eliminate positional bias (such as preference for earlier-listed options) and order effects that may arise from a fixed order of candidate outlines, thus ensuring the objectivity of the evaluation.

[0072] The randomly sorted candidate outlines are submitted in batches to a large language model acting as the evaluator for scoring, and the scores for each round are collected. The temperature parameter δ of the large language model is usually set to a low value (e.g., δ=0.2) to ensure the consistency and objectivity of the evaluation scores.

[0073] In this embodiment, for each candidate outline C, the collected K rounds of ratings are parsed to obtain its score set on multiple preset rating dimensions j (such as plot, characters, commercial value, etc.): ; in This represents the score of outline C in the Kth round on dimension j.

[0074] For each rating dimension j, determine its score set. The score is determined by whether the number of scores, K, is greater than or equal to a preset pruning threshold (usually set to 3). The final score is calculated as follows: ; in, This represents the final robust score of candidate outline C on dimension j; This represents the original score for the k-th round; Indicates will The k-th element in the ordered set obtained after sorting by numerical ascending order, where... For an ordered set, The lowest score, It is the highest score.

[0075] When K ≥ 3, the algorithm discards the highest and lowest scores and calculates the average of the remaining K-2 scores. This effectively filters out outliers and random noise in the evaluation process, resulting in a more stable and reliable quantitative value score than a simple average. This calculation process can be formally represented as: ; in, This indicates removing p% of the data points from both ends of the sorted data. Ideally, when K ≥ 3, the highest and lowest values ​​are discarded. When K is the number of samples, the pruning ratio p can be set to... For example, when K=5, p=0.2 means removing 20% ​​of the data points at both ends (i.e., the highest and lowest scores).

[0076] In this embodiment, after summarizing the K rounds of scores and before calculating the trimmed mean, an anomaly assessment and detection step is included. This step calculates the score set for each scoring dimension j. The interquartile range (IQR). If the score value of k in a certain round... If a data point deviates from the median of the score set for that dimension by more than a preset statistical threshold (e.g., greater than 1.5 times the IQR), then that round of evaluation is marked as an anomaly, and a supplementary evaluation is automatically triggered to replace the outlier with new, more reliable data points, thereby ensuring the quality of data entering subsequent calculations. This anomaly detection process can be formally represented as: ; in, Represents the set of ratings the median; Represents the set of ratings Interquartile range; This is a preset statistical threshold (usually 1.5).

[0077] When an anomaly is detected, a supplementary assessment is automatically triggered to ensure the reliability and integrity of the scoring data. Furthermore, if anomaly data is pre-configured to be automatically discarded, or if the number of anomaly dimensions in the same assessment round exceeds a preset proportion, the entire dataset for that anomaly round is automatically discarded.

[0078] Figure 4 This paper details the debiased evaluation process in the quantization convergence module. The process includes setting up multiple rounds of evaluation, randomizing the ranking before each round to eliminate positional bias, submitting evaluations in batches and collecting scores, and finally applying a pruning mean algorithm (e.g., discarding the highest and lowest scores when the sample size K ≥ 3) to each scoring dimension of each outline to calculate the final robust score. This flowchart visually illustrates how this invention obtains objective, debiased quantization evaluation results through a double randomization experimental design and robust statistical methods, thereby solving the evaluation inaccuracy problem described in the background art.

[0079] As another optional implementation, to further differentiate the confidence levels of different rounds of evaluation, a quantile-weighted mean can be used. For example, for the ranked five-round scores [s] 1 ,s 2 ,s 3 ,s 4 ,s 5 We apply a weight vector [0.1, 0.2, 0.4, 0.2, 0.1] and perform a weighted summation to highlight the central trend while preserving boundary information.

[0080] In one alternative approach, the steps of selecting high-scoring candidate outlines based on the quantitative value score of each candidate outline and preset optimization conditions, and then inputting the selected high-scoring candidate outlines and their associated original strategy instruction vectors into the large language model to generate optimized outlines include: Based on the quantitative value score and preset optimization conditions, the outlines to be optimized are selected from all candidate outlines; For each outline to be optimized, the strategy instruction vector used during its generation is extracted from the metadata of the outline to be optimized, and optimization prompt words are constructed. The optimization prompt words integrate the text content of the outline to be optimized, the automated modification suggestions for the outline to be optimized, and the extracted strategy instruction vector used during its generation. The optimized prompts are submitted to the large language model for processing, and the text returned by the large language model is received and used as the optimized version of the outline to complete the outline generation.

[0081] It should be noted that, to address the common technical pain point of "getting worse with each improvement" in conventional optimization, this invention proposes and implements a path-dependent optimization mechanism, aiming to enhance the value of selected high-scoring candidate outlines. This mechanism ensures that the optimization process is a precise enhancement while preserving the original manuscript's "success genes" (i.e., the most effective strategy instructions when the outline was initially generated).

[0082] In this embodiment, firstly, based on the quantified value score and preset optimization conditions, the outlines to be optimized are selected from all candidate outlines. The preset optimization conditions are: setting a modification skip threshold T. skip (e.g., T) skip =9.0), when the quantitative value score of a candidate outline is higher than this threshold, the optimization process for that outline is skipped; otherwise, it is included in the outline queue to be optimized.

[0083] For each outline to be optimized, perform the following optimization process: From the outline that needs optimization O orig Extract the original strategy instruction vector D used during its generation from the metadata. orig This D orig This is the "success gene" of the outline, a key constraint that ensures optimization does not deviate from the correct direction and retains its core value.

[0084] Get modification suggestions M for the text format generated from the quantization convergence part. eval .

[0085] By optimizing the prompt word template function P opt(·) Construct prompt words for constraint optimization optThis function combines the three core text inputs according to a preset structured template: ; Among them, O orig This represents the original high-scoring outline text content to be optimized; M eval This indicates text-formatted modification suggestions generated by the quantization convergence module; D orig This represents the extracted original policy instruction vector (text).

[0086] This step constructs a constrained closed loop, D. orig Re-injection is key to ensuring that optimization does not deviate from the correct direction and retains core value.

[0087] In a preferred embodiment, the original policy instruction vector D orig The injection intensity is dynamically weighted. The injection weighting coefficient ω is based on the original manuscript O. orig Quantitative score S orig Adaptive adjustment can be expressed in general form as follows: ; in, The dynamic weight coefficients of the instruction vector are represented by β; β is the base weight; γ is the gain coefficient of the score; S orig S represents the quantitative value score of the original outline. max This represents the maximum score for a rating dimension (e.g., 10 points). and These are the upper and lower limits of the weights (e.g., 0.2 and 1.0); clip(x,min,max) is the clipping function, which means restricting x to the range [min,max].

[0088] A specific example of a linear mapping is as follows: ; If S orig =5 (out of 10), then =0.6; if Sorig=9, then =0.92.

[0089] This mechanism ensures that higher-scoring drafts have stronger constraints on their "success genes," maximizing the preservation of their advantages; while lower-scoring drafts grant the large language model greater freedom of modification. This weight can be introduced into the D language model when constructing prompt words. orig To emphasize.

[0090] The constructed optimization prompt opt Submitted to a large language model for processing: ; Where LLM(·) represents the operation of calling a large language model to generate text; O opt This represents the text returned by the large language model, i.e., the final optimized outline.

[0091] Finally, the text returned by the large language model is received and used as the optimized version of the outline to complete the outline generation. This path-dependent optimization mechanism ensures that the optimization process is a precise enhancement while preserving the "successful genes" of the original, effectively solving the technical problem of the text getting worse with each revision.

[0092] Figure 5 The diagram illustrates the path-dependency-based closed-loop optimization workflow within the constraint and value enhancement section. This process begins with inputting high-scoring candidate outlines and their suggested modifications. The key lies in extracting the original policy instruction vector (i.e., the "success gene") from the outline's metadata and constructing it, along with the original outline content and modification suggestions, into optimization prompts. These prompts are then submitted to the LLM (Limited Learning Model) to generate the optimized outline. This process, by re-injecting the "success gene" to form a constraint loop, ensures that the optimization process is a precise enhancement while preserving the original core value, effectively addressing the technical pain point of "getting worse with each modification."

[0093] It should be noted that, in the implementation of this invention, the Large Language Model (LLM) invoked in guided divergence, quantization convergence, and constraint and value enhancement can be different independent models, selected according to the characteristics of each step. This design embodies the modular concept of this invention, aiming to select the most suitable model for each specific task stage to maximize the overall system performance.

[0094] Specifically, guided divergence prefers to use generative models with high creativity and divergence to encourage diverse content exploration; quantitative convergence prefers to use large models with strong logical reasoning and stable evaluation capabilities, and usually sets their temperature parameters to low values ​​to ensure the consistency and objectivity of the scoring results; constraint and value enhancement prefers to use models that perform well in terms of following instructions and fine-tuning to achieve constrained value enhancement.

[0095] This model-separated configuration strategy is centrally managed through project configuration files (such as YAML format). Users can flexibly specify the models used in each stage according to actual needs, thereby achieving optimal production results and resource utilization efficiency while ensuring process automation and industrialization.

[0096] Figure 6 A schematic diagram of an embodiment of a short drama outline generation system 200 provided by the present invention is shown. Figure 6 As shown, the system 200 includes: The guided divergence module 210 is used to call a large language model to generate multiple candidate outlines based on multiple preset policy instruction vectors; wherein each candidate outline is associated with the policy instruction vector used when it is generated, and the policy instruction vector is the original policy instruction vector of the candidate outline. The quantization convergence module 220 is used to perform multiple independent rounds of automated evaluation of multiple candidate outlines, with random sorting before each round of evaluation, to obtain the score for each round, and to process the score of each round using a trimmed mean algorithm to calculate the quantization value score of each candidate outline. The constraint and value enhancement module 230 is used to filter high-scoring candidate outlines based on the quantitative value score of each candidate outline and preset optimization conditions, and input the filtered high-scoring candidate outlines and their associated original strategy instruction vectors into the large language model to generate optimized outlines.

[0097] In one alternative approach, the guided divergence module is specifically used for: Set the temperature parameters of the large language model according to the preset randomness range; Obtain multiple user-defined generation strategies; each strategy contains a business confidence weight and a strategy instruction vector in text form. Based on the maximum remainder method, the preset total number of tasks is allocated to the instruction vectors of each strategy according to the weight of each strategy. For each assigned generation task, the corresponding strategy instruction vector is injected into a unified prompt word template to form the final prompt word, and the final prompt word is used to call the large language model to generate candidate outlines.

[0098] In one alternative approach, the guided divergence module is also specifically used for: Based on the weights of all strategies, determine the total weight representing the sum of the weights; For each strategy, the theoretical task quota is calculated based on the ratio of its weight to the total weight; For each strategy, allocate a base number of tasks equal to the floor of its theoretical quota. The remaining number of tasks is determined by the difference between the sum of the base task counts for all strategies and the total number of tasks. The decimal remainder is determined based on the difference between the theoretical quota of each strategy and its basic number of tasks. Sort all strategies in descending order of their decimal remainders, and then assign the remaining tasks to the strategies ranked first.

[0099] In one alternative approach, during the step of sequentially assigning multiple tasks to be assigned, if the decimal remainders of multiple strategies are the same, the task is assigned to the strategy with the higher weight.

[0100] In one alternative approach, it further includes: an auxiliary support module, which is used for: When the candidate outlines generated by the large language model are structured data and contain grammatical errors, the structured data is automatically repaired. If the repair fails, a heuristic reconstruction will be performed based on the preset template; If the reconstruction fails, a regeneration request with enhanced formatting requirements will be triggered.

[0101] In one alternative approach, the quantization convergence module is specifically used for: Conduct a pre-set series of independent evaluation processes; Before each round of evaluation begins, all candidate outlines are randomly sorted to eliminate positional bias. The randomized and sorted candidate outlines are submitted in batches to the large language model, which acts as the evaluator, for scoring, and the scores for each round are collected.

[0102] In one alternative approach, the quantization convergence module is also specifically used for: For each candidate outline, the collected multiple rounds of scores are analyzed to obtain a set of scores across multiple preset scoring dimensions; For each rating dimension, determine whether the number of scores in its score set is greater than or equal to a preset pruning threshold; If the score is less than the pruning threshold, the average of all scores in the score set is calculated as the quantitative value score of the candidate outline in this dimension. If the score is greater than or equal to the pruning threshold, then the highest and lowest scores in the score set are discarded, and the average of the remaining scores is calculated as the quantitative value score of the candidate outline in this dimension.

[0103] In an alternative approach, a supplementary evaluation module is also included, which is used for: If a score for a certain rating dimension in a round of evaluation is detected to deviate from the median of the collected scores and exceed a preset statistical threshold, the round of evaluation will be marked as abnormal and a supplementary evaluation will be triggered.

[0104] In one alternative approach, the constraint and value enhancement module is specifically used for: Based on the quantitative value score and preset optimization conditions, the outlines to be optimized are selected from all candidate outlines; For each outline to be optimized, the strategy instruction vector used during its generation is extracted from the metadata of the outline to be optimized, and optimization prompt words are constructed. The optimization prompt words integrate the text content of the outline to be optimized, the automated modification suggestions for the outline to be optimized, and the extracted strategy instruction vector used during its generation. The optimized prompts are submitted to the large language model for processing, and the text returned by the large language model is received and used as the optimized version of the outline to complete the outline generation.

[0105] The technical solution of this embodiment significantly improves the quality stability, evaluation objectivity and optimization reliability of outline generation by using strategy-guided targeted content generation, multi-round randomized debiased evaluation and pruning mean robust scoring, and combining path-dependent optimization mechanisms, thereby achieving efficient, controllable and traceable industrialized short drama outline production.

[0106] The steps for implementing the corresponding functions of each parameter and module in the short drama outline generation system 200 of this embodiment can be referred to the parameters and steps in the embodiments of the short drama outline generation method above, and will not be repeated here.

[0107] To further illustrate the details of the configuration file and system output, an example configuration file used to drive the system of this invention is shown here: The system of this invention is driven by a structured text configuration file (preferably in YAML format), which centrally manages all variable parameters, making the entire generation process highly flexible and reproducible. Below is a sample fragment of a configuration file used to guide a batch generation task of short drama outlines with "rebirth and revenge" as its core theme: <yaml> # ================================================================ # GDC System - Project Configuration File Example # (Format: YAML, for Patent Specification) # ================================================================ # --- Project & API Configuration --- project_name: "revenge_drama_series_01" api_config: provider_url: "https: / / api.example-llm-provider.com / v1" api_key: env("SECRET_API_KEY") # Preferred practice: Load securely from environment variable # --- Model Selection Configuration --- # Specify optimal models for different stages, embodying the modular design philosophy of the invention model_selection: generation_model: "advanced_creative_model_v4" # For divergent generation, pursuing creativity modification_model: "balanced_refinement_model_v2" # For constrained optimization, pursuing balance arbitration_model: "strict_evaluation_model_v3" # For quantitative convergence, pursuing objective stability # --- Core Workflow Parameters --- workflow_control: total_generations: 30 # Total number of tasks in the guided divergent stage arbitration_runs: 3 # Number of independent evaluation rounds in the quantitative convergence stage, corresponding to claim 3 modification_skip_threshold: 9.0 # score above this threshold skips optimization, corresponds to claim 4 word_output_threshold: 9.2 # final score above this threshold outputs additional formatted results # --- Technical Details Parameters --- technical_params: # Temperature coefficients configuration, key to regulate LLM behavior patterns temperatures: generation: 0.9 # high randomness, encourages divergent exploration modification: 0.5 # medium randomness, conducts micro-innovation under constraints arbitration: 0.2 # low randomness, ensures consistency and objectivity of evaluation scores # Concurrent and timeout control, reflects industrial production capacity max_concurrent_workers: 5 timeout_seconds: 300 # --- Guided Divergence Strategy Combination (Core of the Invention) --- # Define multiple "Strategy Directive Vectors D_i", each being an "Attractor Center" in the latent space generation_strategies: - name:"Plot Complexity Priority" weight: 10 directive:"Core Requirement: Specific Instruction Text for This Strategy, Omitted Here"# De-sensitization Processing - name:"Emotional Fluency Priority" weight: 20 directive:"Core Requirement: Specific Instruction Text for This Strategy, Omitted Here" ... (and so on) In order to visually demonstrate the complete execution flow and data traceability of the method provided by the invention, this shows the running log example of the invention system. Further, the following provides a de-sensitized and simplified system log (System Log) fragment generated by a typical task run: <log> --- System Initialization and Configuration Loading --- [INFO] System GDC-Engine v2.1 Activated. [INFO] Loading configurations... [INFO] 5 generation strategies successfully loaded. [INFO] Knowledge base loaded: universal_principles.txt, writer_requirements.txt, avoid_pitfalls.txt [INFO] Prompt templates loaded: generation.txt, arbitration.txt,modification.txt [INFO] Model separation enabled: [Generation: advanced_creative_model_v4][Modification: balanced_refinement_model_v2] [Arbitration: strict_evaluation_model_v3] [INFO] All configurations loaded successfully. --- Stage One: Guided Divergence --- [INFO] Applying Largest Remainder Method to allocate 30 tasks... [INFO] Generation plan determined: - Strategy 'Plot Complexity Priority' (Weight: 1.0) -> Tasks: 3 - Strategy 'Creative Novelty Priority' (Weight: 3.0) -> Tasks: 7 - Strategy 'Emotional Flow Priority' (Weight: 2.0) -> Tasks: 5 - Strategy 'Character Depth First' (Weight: 4.0) -> Tasks: 10 - Strategy 'Market Fit First' (Weight: 2.0) -> Tasks: 5 [INFO] Starting concurrent generation for 30 outlines (Max Workers:6)... [API_CALL] Task 1 (Strategy: Character Depth First) -> Sent to 'advanced_creative_model_v4' (Temp: 0.7) [API_CALL] Task 2 (Strategy: Character Depth First) -> Sent to 'advanced_creative_model_v4' (Temp: 0.7) ... (concurrent request logs omitted)... [SUCCESS] Progress 1 / 30. Outline 'id_A001' generated (Source Strategy: Character Depth First). [SUCCESS] Progress 2 / 30. Outline 'id_B002' generated (Source Strategy: Creative Novelty First). ... [SUCCESS] Progress 30 / 30. Outline 'id_C030' generated (Source Strategy: Plot Complexity First). [INFO] Generation phase complete. 30 / 30 outlines created successfully. --- Phase Two: Quantitative Convergence --- [INFO] Starting multi-run evaluation. Total runs: 3. Batch size: 2. [INFO] Run 1 / 3 - Shuffling 30 candidates to eliminate position bias... [API_CALL] Evaluating Batch 1 / 15 ['id_X218','id_Y102'] ->Sent to'strict_evaluation_model_v3'(Temp: 0.2) ... (concurrent evaluation request logs omitted)... [INFO] Run 1 / 3 complete. [INFO] Run 2 / 3 - Re-shuffling 30 candidates for independent arbitration... [API_CALL] Evaluating Batch 1 / 15 ['id_Z007','id_W015'] ->Sent to'strict_evaluation_model_v3'(Temp: 0.2) ... [INFO] All 3 evaluation runs complete. Aggregating scores... [CALC] Processing scores for outline'id_A001': - Raw Scores (Plot): [9, 7, 9] - Raw Scores (Character): [8, 8, 6] - Raw Scores (Commercial): [9, 7, 8] [CALC] Applying Trimmed Mean algorithm... - Robust Score (Plot): 8.0 (after discarding 7 and 9) - Robust Score (Character): 8.0 (after discarding 6 and 8) - Robust Score (Commercial): 8.0 (after discarding 7 and 9) [INFO] Final robust score for'id_A001'calculated: {Plot: 8.0,Character: 8.0, Commercial: 8.0, Average: 8.0} ... (The rest of the syllabus's score calculation log is omitted here)... [INFO] Evaluation and scoring phase complete. --- Phase Three: Constrained Value Enhancement --- [INFO] Starting modification phase. High-score skip threshold: 9.2. [CHECK] Outline'id_K011'(Avg Score: 9.3) ->Skipped modification due to high score. [CHECK] Outline'id_A001'(Avg Score: 8.0) ->Queued for modification. ... [INFO] Preparing to modify 29 outlines (Max Workers: 6)... [INFO] Modifying 'id_A001'... Retrieving its original successful gene (Strategy: Character Depth Priority). [API_CALL] Task'id_A001-mod'->Sent to'balanced_refinement_model_v2'(Temp: 0.5) with [Original Outline + Suggestions + Original Directive]. ... (Concurrency optimization request logs, omitted here) ... [SUCCESS] Outline'id_A001-mod'(Optimized Version) created. [INFO] Modification phase complete. --- Final results generation and saving --- [SAVE] Saving all 30 original and 29 modified outlines as detailedJSON files. [SAVE] Generating comprehensive report:'scoring_summary.xlsx'. [SAVE] Generating formatted Word documents for a_scripts with finalscore>= 9.0... [SAVE] 12 high-quality Word documents created. [INFO] Task complete. All results saved to output directory. It should be noted that the generation of the "short drama outline" is used as an example to illustrate the technical solutions of the present application, but this is not a limitation on the scope of protection of the present application. The core of the present application is to provide an industrialized content generation method and system based on policy instruction guidance, quantitative convergence and path dependence optimization. The method and system are also applicable to other series short content (Short-Form Series Content) fields that require efficient, batch, controllable generation of episodic outlines, including but not limited to the generation of episodic outlines or shot scripts for animated series, motion comics, interactive dramas, micro short dramas, etc. Based on the disclosure of the present application, those skilled in the art can apply it to the above similar scenarios without creative labor, which should fall within the scope of protection of the present application.

[0108] As shown in Figure 7 An electronic device 300 according to an embodiment of the present application, the electronic device 300 includes a processor 320, the processor 320 is coupled with a memory 310, the memory 310 stores at least one computer program 330, the at least one computer program 330 is loaded and executed by the processor 320, so that the electronic device 300 realizes any one of the above short drama outline generation methods, specifically: The electronic device 300 can be quite different in configuration or performance, and can include one or more processors 320 (Central Processing Units, CPUs) and one or more memories 310, where the one or more memories 310 store at least one computer program 330, which is loaded and executed by the one or more processors 320, so that the electronic device 300 implements any of the short play outline generation methods provided by the above embodiments. Of course, the electronic device 300 can also have a wired or wireless network interface, a keyboard, and an input and output interface, and the like, so as to perform input and output, and the electronic device 300 can also include other components for implementing device functions, which are not described here.

[0109] The computer readable storage medium of an embodiment of the present application stores at least one computer program, and the at least one computer program is loaded and executed by a processor, so that the computer implements any of the short play outline generation methods described above.

[0110] Optionally, the computer readable storage medium can be a read-only memory (Read-Only Memory, ROM), a random access memory (Random Access Memory, RAM), a compact disc read-only memory (Compact Disc Read-Only Memory, CD-ROM), a magnetic tape, a floppy disk, and an optical data storage device, etc.

[0111] In an exemplary embodiment, a computer program product or computer program is also provided, which includes computer instructions stored in a computer readable storage medium. The processor of the electronic device reads the computer instructions from the computer readable storage medium, and the processor executes the computer instructions, so that the electronic device executes any of the short play outline generation methods described above.

[0112] Those skilled in the art know that the present application can be implemented as a system, a method or a computer program product, so the present disclosure can be specifically implemented as follows: it can be a complete hardware, a complete software (including firmware, resident software, microcode, etc.), or a combination of hardware and software, which is generally referred to as "circuit", "module" or "system" in this paper. In addition, in some embodiments, the present application can also be implemented as a computer program product in one or more computer readable media, which includes computer readable program code.

[0113] Although the embodiments of the present application have been shown and described above, it is understood that the above-described embodiments are exemplary and are not to be construed as limiting the present application, and that variations, modifications, substitutions and changes can be made by those skilled in the art without departing from the scope of the present application.< / log> < / yaml>

Claims

1. A method for generating a short drama outline, characterized in that, include: Based on multiple preset policy instruction vectors, a large language model is invoked to generate multiple candidate outlines; each candidate outline is associated with the policy instruction vector used during its generation, which is the original policy instruction vector of the candidate outline. Multiple candidate outlines are evaluated independently in multiple rounds with random sorting before each round. A score is obtained for each round, and the score for each round is processed using a trimmed mean algorithm to calculate the quantitative value score of each candidate outline. Based on the quantitative value score of each candidate outline and the preset optimization conditions, high-scoring candidate outlines are selected, and the selected high-scoring candidate outlines and their associated original strategy instruction vectors are input into the large language model to generate optimized outlines, thus completing the outline generation.

2. The method for generating short drama outlines according to claim 1, characterized in that, The steps of generating multiple candidate outlines by calling a large language model based on multiple preset policy instruction vectors include: Set the temperature parameters of the large language model according to the preset randomness range; Obtain multiple user-defined generation strategies; each strategy contains a business confidence weight and a strategy instruction vector in text form. Based on the maximum remainder method, the preset total number of tasks is allocated to the instruction vectors of each strategy according to the weight of each strategy. For each assigned generation task, the corresponding strategy instruction vector is injected into a unified prompt word template to form the final prompt word, and the final prompt word is used to call the large language model to generate candidate outlines.

3. The method for generating short drama outlines according to claim 2, characterized in that, Based on the maximum remainder method, the steps of allocating the preset total number of tasks to the instruction vectors of each strategy according to the weight of each strategy include: Based on the weights of all strategies, determine the total weight representing the sum of the weights; For each strategy, the theoretical task quota is calculated based on the ratio of its weight to the total weight; For each strategy, allocate a base number of tasks equal to the floor of its theoretical quota. The remaining number of tasks is determined by the difference between the sum of the base task counts for all strategies and the total number of tasks. The decimal remainder is determined based on the difference between the theoretical quota of each strategy and its basic number of tasks. Sort all strategies in descending order of their decimal remainders, and then assign the remaining tasks to the strategies ranked first.

4. The method for generating short drama outlines according to claim 3, characterized in that, In the step of sequentially assigning multiple tasks to be assigned, if the decimal remainders of multiple strategies are the same, the task is assigned to the strategy with the higher weight first.

5. The method for generating short drama outlines according to claim 1, characterized in that, Also includes: When the candidate outlines generated by the large language model are structured data and contain grammatical errors, the structured data is automatically repaired. If the repair fails, a heuristic reconstruction will be performed based on the preset template; If the reconstruction fails, a regeneration request with enhanced formatting requirements will be triggered.

6. The method for generating short drama outlines according to claim 1, characterized in that, The steps for automating the evaluation of multiple candidate outlines through multiple independent rounds, with random sorting before each round, to obtain a score for each round include: Conduct a pre-set series of independent evaluation processes; Before each round of evaluation begins, all candidate outlines are randomly sorted to eliminate positional bias. The randomized and sorted candidate outlines are submitted in batches to the large language model, which acts as the evaluator, for scoring, and the scores for each round are collected.

7. The method for generating short drama outlines according to claim 6, characterized in that, The scoring for each round is processed using a trimmed mean algorithm. The steps for calculating the quantitative value score for each candidate outline include: For each candidate outline, the collected multiple rounds of scores are analyzed to obtain a set of scores across multiple preset scoring dimensions; For each rating dimension, determine whether the number of scores in its score set is greater than or equal to a preset pruning threshold; If the score is less than the pruning threshold, the average of all scores in the score set is calculated as the quantitative value score of the candidate outline in this dimension. If the score is greater than or equal to the pruning threshold, then the highest and lowest scores in the score set are discarded, and the average of the remaining scores is calculated as the quantitative value score of the candidate outline in this dimension.

8. The method for generating short drama outlines according to claim 7, characterized in that, Also includes: If a score for a certain rating dimension in a round of evaluation is detected to deviate from the median of the collected scores and exceed a preset statistical threshold, the round of evaluation will be marked as abnormal and a supplementary evaluation will be triggered.

9. The method for generating short drama outlines according to claim 1, characterized in that, Based on the quantitative value score of each candidate outline and preset optimization conditions, the process of selecting high-scoring candidate outlines and inputting the selected high-scoring candidate outlines and their associated original strategy instruction vectors into the large language model to generate optimized outlines includes: Based on the quantitative value score and preset optimization conditions, the outlines to be optimized are selected from all candidate outlines; For each outline to be optimized, the strategy instruction vector used during its generation is extracted from the metadata of the outline to be optimized, and optimization prompt words are constructed. The optimization prompt words integrate the text content of the outline to be optimized, the automated modification suggestions for the outline to be optimized, and the extracted strategy instruction vector used during its generation. The optimized prompts are submitted to the large language model for processing, and the text returned by the large language model is received and used as the optimized version of the outline to complete the outline generation.

10. A short drama outline generation system, characterized in that, include: The guided divergence module is used to call the large language model to generate multiple candidate outlines based on multiple preset policy instruction vectors. Each candidate outline is associated with the policy instruction vector used during its generation, which is the original policy instruction vector of the candidate outline. The quantization convergence module is used to perform multiple independent rounds of automated evaluation on multiple candidate outlines, with random sorting before each round of evaluation, to obtain a score for each round. The score for each round is then processed using a trimmed mean algorithm to calculate the quantization value score for each candidate outline. The constraint and value enhancement module is used to filter high-scoring candidate outlines based on the quantitative value score of each candidate outline and preset optimization conditions, and input the filtered high-scoring candidate outlines and their associated original strategy instruction vectors into the large language model to generate optimized outlines.

Images