A resource-oriented academic paper technical solution automatic reproduction method

Abstract

This invention discloses a resource-oriented method for automatically reproducing technical solutions from academic papers, comprising: acquiring the text content of the target academic paper and generating a resource requirement list; searching and filtering technical resources on an open-source platform to construct a resource support library; combining the resource support library and the text content to generate a comprehensive reproduction blueprint; formulating resource usage guidelines; coordinating multiple large language models to perform logical analysis on each module in dependency order to obtain an initial technical implementation; iteratively repairing the initial technical implementation to obtain a repaired technical implementation; using a reinforcement learning algorithm to fine-tune the quality assessment model to maximize the matching degree between the model output and the key technical points of the paper; and using the fine-tuned model to perform quality assessment and optimization on the repaired technical implementation to complete the reproduction of the target academic paper. The reproduction method proposed in this invention can effectively utilize resources and improve the success rate of reproducing complex papers.

Description

Technical Field

[0001] This invention belongs to the field of academic paper technical solution reproduction technology, and in particular relates to a resource-oriented method for automatic reproduction of academic paper technical solutions. Background Technology

[0002] With the exponential growth in the volume of academic research on artificial intelligence, experimental reproducibility has become a key engineering issue in collaborative innovation between industry, academia, and research. Universities, research institutions, and industrial laboratories often need to fully implement the methods, experiments, and evaluation processes outlined in academic papers when verifying conclusions, reusing baseline systems, or conducting technology transfer. This need constitutes an application scenario for the automatic reproduction of technical solutions from academic papers.

[0003] In existing technologies, researchers mainly rely on large language models to automate certain parts of the reproduction process, such as automatically configuring the runtime environment, restoring training hyperparameters, retrieving public datasets, or generating end-to-end program scripts. While these approaches can reduce manual operations at discrete technical points, they remain "segmented" tools at the system level. They lack a unified screening and consolidation mechanism for open-source technical resources, leading to repeated development of reusable modules for the same algorithm and persistently high hardware and time costs.

[0004] Furthermore, existing frameworks often employ a single linear process of "planning-analysis-generation," which can easily lead to logical breaks or loss of details when dealing with complex papers that involve cross-module dependencies or require multiple rounds of reasoning. Although some studies have proposed multi-model collaboration, there is still a lack of "consultative" cross-validation and result aggregation strategies when facing key modules with high reasoning complexity, making it difficult to guarantee the integrity and consistency of the reproducibility path.

[0005] In the quality assessment stage, existing technologies mainly rely on general code specifications or manual review. The evaluation indicators are not closely coupled with the technical points of the paper itself, making it impossible to adaptively generate a quantifiable reproducibility measurement system. Furthermore, a closed-loop improvement mechanism of "evaluation-feedback-correction" has not been formed, resulting in unpredictable deviations between the reproduction results and the technical solutions of the original paper.

[0006] In summary, existing automated reproduction systems have significant shortcomings in terms of efficient resource reuse, complex reasoning collaboration, and closed-loop quality control, which restricts the stable implementation of academic paper technical solutions in high-fidelity and high-coverage scenarios. Summary of the Invention

[0007] To address the aforementioned technical problems, this invention proposes a resource-oriented method for automatically reproducing technical solutions from academic papers, comprising the following steps:

[0008] Obtain the text content of the target academic paper and generate a resource requirement list to reproduce the text content;

[0009] Based on the resource requirements list, technical resources are retrieved and filtered from the open-source platform to build a resource support library;

[0010] Based on the resource support library and the text content, a comprehensive reproduction blueprint is generated, and a repository-level architecture design is performed in the execution environment to determine module division, interface specifications and dependencies.

[0011] Based on the resource support library, the comprehensive reproduction blueprint, and the repository-level architecture design, a resource usage guideline is formulated, and several large language models are coordinated to perform logical analysis on each module according to the dependency relationship order to obtain the initial technical implementation.

[0012] The initial technical implementation is subjected to executability iterative repair based on error feedback to obtain the repaired technical implementation;

[0013] A reinforcement learning algorithm is used to fine-tune the quality assessment model to maximize the matching degree between the model output and the key technical points of the paper. The fine-tuned model is then used to assess the quality of the repaired technical implementation. Based on the assessment results, the model is optimized to achieve the reproduction of the target academic paper.

[0014] Optionally, the process of generating a resource requirement list to reproduce the text content of the target academic paper includes:

[0015] The text content of the target academic paper is formatted to obtain formatted text; model elements, library dependencies, and dataset requirements are extracted from the formatted text to generate a resource requirements list covering the basic model, baseline implementation, dataset, and dedicated library documentation.

[0016] Optionally, the process of retrieving and filtering technical resources on the open-source platform and constructing a resource support library based on the resource requirements list includes:

[0017] For each resource in the resource requirement list, parallel retrieval is performed on the open-source platform to construct a candidate resource set. Heuristic filtering based on lexical relevance and repository structure features is performed on the candidate resource set to obtain filtered candidate resources. A large language model is used to evaluate the semantic relevance and implementation quality of the filtered candidate resources to obtain semantic evaluation scores and quality evaluation scores. The semantic evaluation scores and heuristic filtering scores are multiplied and fused to determine the target repository. The target repository is then archived after file parsing and semantic compression to construct a resource support library.

[0018] Optionally, the process of generating a comprehensive reproduction blueprint based on the resource support library and the text content, and designing a repository-level architecture in the execution environment, includes:

[0019] Based on the resource support library and text content, a multi-expert solution aggregation strategy is adopted to generate a comprehensive reproduction blueprint, which clarifies the stage goals, key points and resource mapping relationships. According to the comprehensive reproduction blueprint, a warehouse-level architecture design is carried out to determine the module division, interface specifications and dependencies, and generate class diagrams and sequence diagrams to standardize object relationships and runtime interaction processes.

[0020] Optionally, based on the resource support library, the comprehensive reproduction blueprint, and the repository-level architecture design, a resource usage guideline is formulated, and multiple large language models are coordinated to perform logical analysis on each module according to the dependency order to obtain the initial technical implementation. This process includes:

[0021] Based on the resource support library, comprehensive reproduction blueprint, and repository-level architecture design, we develop customized resource usage guidelines for each module; we coordinate multiple large language models according to their dependency order, perform logical analysis on each module based on the resource usage guidelines, identify core modules, trigger a multi-perspective reasoning fusion mechanism, and generate the initial technical implementation.

[0022] Optionally, the specific process of performing executability iterative repair on the initial technical implementation based on error feedback to obtain the repaired technical implementation includes:

[0023] The system automatically debugs the initial technical implementation. When errors occur, it parses the error context and locates the problematic interface. It retrieves relevant library usage documents or data metadata from the resource support library to guide developers in implementing targeted corrections until a fixed technical implementation is achieved.

[0024] Optionally, a reinforcement learning algorithm is used to fine-tune the quality assessment model to maximize the matching degree between the model output and the key technical points of the paper. The fine-tuned model is then used to assess the quality of the repaired technical implementation. The optimization process based on the assessment results includes:

[0025] A quality assessment model finely tuned by a reinforcement learning algorithm is used to adaptively construct a technical solution evaluation scale based on the paper content. The technical solution evaluation scale is used to check the corrected technical implementation item by item to identify missing and non-compliant items and form targeted modification suggestions. The corrected technical implementation is then locally optimized based on the modification suggestions to obtain the final technical implementation.

[0026] The present invention also proposes a computer device, including a memory, a processor, and a computer program stored in the memory, wherein the processor executes the computer program to implement the steps of the method.

[0027] The present invention also proposes a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the method.

[0028] The present invention also proposes a computer program product, including a computer program that, when executed by a processor, implements the steps of the method.

[0029] Compared with the prior art, the present invention has the following advantages and technical effects:

[0030] This invention effectively integrates existing technical resources from the open-source community by constructing a resource support library, a multi-model collaborative reasoning and fusion mechanism, and a reinforcement learning quality assessment model. This enables technology reuse, avoids redundant development, and reduces the difficulty and cost of reproduction. Simultaneously, the core technology analysis of adaptive reasoning fusion is introduced. Through a multi-model consultative collaborative mechanism, the system can efficiently complete routine reproduction tasks and tackle high-complexity problems through multi-perspective reasoning, effectively improving the success rate of reproducing complex tasks. Furthermore, the reinforcement learning-based quality assessment and automatic repair mechanism ensures the correctness and completeness of the generated technical solution, closely resembling the technical implementation in the paper, and ensuring the rigor and reliability of the reproduction results. Attached Figure Description

[0031] The accompanying drawings, which form part of this application, are used to provide a further understanding of this application. The illustrative embodiments and descriptions of this application are used to explain this application and do not constitute an undue limitation of this application. In the drawings:

[0032] Figure 1 This is a schematic diagram of the overall process of the reproduction method of this invention.

[0033] Figure 2 This is a schematic diagram of the resource construction phase process according to an embodiment of the present invention;

[0034] Figure 3 This is a schematic diagram of the integrated adaptive warehouse selection algorithm according to an embodiment of the present invention;

[0035] Figure 4 This is a schematic diagram of the quality control stage process based on enhanced fine-tuning according to an embodiment of the present invention;

[0036] Figure 5 This is a schematic diagram of the composition of the reproduction device according to an embodiment of the present invention;

[0037] Figure 6 This is a schematic diagram of the composition of an electronic device according to an embodiment of the present invention. Detailed Implementation

[0038] It should be noted that, unless otherwise specified, the embodiments and features described in this application can be combined with each other. This application will now be described in detail with reference to the accompanying drawings and embodiments.

[0039] It should be noted that the steps shown in the flowchart in the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions, and although a logical order is shown in the flowchart, in some cases the steps shown or described may be executed in a different order than that shown here.

[0040] Example 1

[0041] This embodiment provides a method for automatically reproducing resource-oriented academic paper technical solutions, including the following steps:

[0042] Obtain the text content of the target academic paper and generate a resource requirement list to reproduce the text content;

[0043] Based on the resource requirements list, technical resources are retrieved and filtered from the open-source platform to build a resource support library;

[0044] Based on the resource support library and the text content, a comprehensive reproduction blueprint is generated, and a repository-level architecture design is performed in the execution environment to determine module division, interface specifications and dependencies.

[0045] Based on the resource support library, the comprehensive reproduction blueprint, and the repository-level architecture design, a resource usage guideline is formulated, and several large language models are coordinated to perform logical analysis on each module according to the dependency relationship order to obtain the initial technical implementation.

[0046] The initial technical implementation is subjected to executability iterative repair based on error feedback to obtain the repaired technical implementation;

[0047] A reinforcement learning algorithm is used to fine-tune the quality assessment model to maximize the matching degree between the model output and the key technical points of the paper. The fine-tuned model is then used to assess the quality of the repaired technical implementation. Based on the assessment results, the model is optimized to achieve the reproduction of the target academic paper.

[0048] An feasible process for generating a list of resource requirements to reproduce the text content of a target academic paper includes:

[0049] The text content of the target academic paper is formatted to obtain a formatted text; model elements, library dependencies, and dataset requirements are extracted from the formatted text to generate a resource requirements list covering the basic model, baseline implementation, dataset, and dedicated library documentation.

[0050] The feasible process of retrieving and filtering technical resources on the open-source platform and constructing a resource support library based on the aforementioned resource requirements list includes:

[0051] For each resource in the resource requirement list, parallel retrieval is performed on the open-source platform to construct a candidate resource set. Heuristic filtering based on lexical relevance and repository structure features is performed on the candidate resource set to obtain filtered candidate resources. The semantic relevance and implementation quality of the filtered candidate resources are evaluated using a Large Language Model (LLM) or a neural network model to obtain semantic evaluation scores and quality evaluation scores. The semantic evaluation scores and heuristic filtering scores are multiplied and fused to determine the target repository. The target repository is then archived after file parsing and semantic compression to construct a resource support library.

[0052] The feasible process of generating a comprehensive reproduction blueprint based on the resource support library and the text content, and designing a repository-level architecture in the execution environment, includes:

[0053] Based on the resource support library and text content, a multi-expert solution aggregation strategy is adopted to generate a comprehensive reproduction blueprint, which clarifies the stage goals, key points and resource mapping relationships. According to the comprehensive reproduction blueprint, a warehouse-level architecture design is carried out to determine the module division, interface specifications and dependencies, and generate class diagrams and sequence diagrams to standardize object relationships and runtime interaction processes.

[0054] The feasible process, based on the resource support library, the comprehensive reproduction blueprint, and the repository-level architecture design, involves developing resource usage guidelines and coordinating multiple large language models to perform logical analysis on each module according to the dependency order, resulting in the initial technical implementation.

[0055] Based on the resource support library, comprehensive reproduction blueprint, and repository-level architecture design, we develop customized resource usage guidelines for each module; we coordinate multiple large language models according to their dependency order, perform logical analysis on each module based on the resource usage guidelines, identify core modules, trigger a multi-perspective reasoning fusion mechanism, and generate the initial technical implementation.

[0056] The feasible process of performing iterative repairs on the initial technical implementation based on error feedback to obtain the repaired technical implementation includes:

[0057] The system automatically debugs the initial technical implementation. When errors occur, it parses the error context and locates the problematic interface. It retrieves relevant library usage documents or data metadata from the resource support library to guide developers in implementing targeted corrections until a fixed technical implementation is achieved.

[0058] The feasible approach involves fine-tuning the quality assessment model using reinforcement learning algorithms to maximize the match between the model output and the key technical points of the paper. The fine-tuned model is then used to assess the quality of the reworked technology. The optimization process based on the assessment results includes:

[0059] A quality assessment model finely tuned by a reinforcement learning algorithm is used to adaptively construct a technical solution evaluation scale based on the paper content. The technical solution evaluation scale is used to check the corrected technical implementation item by item to identify missing and non-compliant items and form targeted modification suggestions. The corrected technical implementation is then locally optimized based on the modification suggestions to obtain the final technical implementation.

[0060] Furthermore, the plurality of LLMs include:

[0061] The system comprises a Managerial LLM for task decomposition and scheduling, a Resource Curator LLM for cross-platform retrieval, filtering, and archiving of external resources, a Developer LLM for modular code logic analysis and generation based on the architecture, a Think Tank LLM for multi-perspective reasoning and conclusion fusion in tasks with high reasoning complexity, and a Quality Assurance LLM for performing quality assessments and generating optimization suggestions. The tasks are accomplished through the core LLMs and the tools involved in applying for code reproduction methods.

[0062] Furthermore, the retrieval and filtering of open-source code resources employs a fusion-based adaptive repository selection algorithm, including:

[0063] Candidate repositories are initially filtered using heuristic metrics to determine up to k candidates; semantic relevance and quality are evaluated on the k candidates based on a large language model; the semantic evaluation scores are multiplied and fused with the heuristic metrics to determine the target repository, which is then archived along with metadata into the resource support library after file parsing and semantic compression.

[0064] Furthermore, the integrated reproduction blueprint includes:

[0065] In response to the text content, the method and experimental content of the paper are reproduced; all third-party library usage and hyperparameters are collected and organized; in response to the resource support library, an overall resource mapping is established for the basic model, baseline implementation, dataset, and dedicated library documentation. The final reproduction blueprint is obtained by combining template and candidate solutions through expert selection and aggregation strategies.

[0066] Furthermore, coordinating multiple LLMs includes employing an adaptive inference fusion mechanism. Specifically, in response to determining that a code file is a core file with high inference complexity for the target task, a consultative collaboration mode is triggered to perform multiple rounds of inference, and the intermediate results of the multiple LLMs are fused to generate an aggregated code logic analysis file for the initial technical implementation of the core file.

[0067] Furthermore, the quality assessment is driven by an assessment model fine-tuned based on the GRPO algorithm. This assessment model is used to adaptively construct a code assessment scale based on the paper content, identify defects or omissions that do not conform to the scale, and generate targeted modification suggestions to instruct developers to perform single-round or limited-round code refinement.

[0068] Furthermore, this embodiment can trigger consultative collaboration among multiple LLMs, discussing and aggregating candidate implementation paths to form implementation suggestions; the initial technical implementation is generated in the order of dependencies, and when an error occurs during execution, the error context is parsed and document-driven targeted repair is implemented based on the library documents in the resource support library;

[0069] Furthermore, to adapt to different task scales and constraints, one or more parameters can be configured, including the number of experts, screening threshold, evaluation threshold, and iteration upper limit. The parameter values ​​do not constitute a limitation on this application.

[0070] Example 2

[0071] In related technologies, automated reproduction of academic papers is gradually shifting towards workflow orchestration centered on large-scale language models, aiming to reduce manual intervention, shorten reproduction cycles, and improve consistency. Although explorations surrounding environment construction, parameter restoration, and data localization have shown that LLM can effectively solve local and discrete technical challenges, it still struggles to achieve high-fidelity coverage of the paper's key points at the system level. On the one hand, insufficient structured reuse of readily available community implementations and open-source assets leads to redundant construction and resource waste. On the other hand, facing cross-module dependencies and long-chain inference, existing solutions lack scalable collaboration and decision-making mechanisms, as well as a quantifiable quality loop centered on task semantics, making it difficult to stably deliver verifiable and reproducible results.

[0072] In current technological practices, the planning-analysis-generative framework has achieved some success in medium-sized paper code reproduction tasks, but its resource utilization and artifact accumulation are insufficient, and duplication of development is prominent. While multi-LLM collaboration introduces diverse task decomposition and reasoning fusion, its "consultative collaboration," conflict resolution, and evidence aggregation for high-reasoning complexity scenarios remain weak. Regarding quality control, evaluation and remediation largely rely on general benchmarks or manual review, lacking adaptively constructed scales and automatic correction loops tailored to the key points of the paper. These limitations collectively result in insufficient stability, reliability, and scalability of current automated reproduction systems under complex paper and heterogeneous dependency conditions.

[0073] Therefore, this embodiment proposes a resource-oriented method for automatically reproducing technical solutions in academic papers, which combines core code analysis with adaptive inference fusion and a quality detection optimization mechanism based on reinforcement fine-tuning. For example... Figure 1As shown, this method includes key stages such as resource construction, hierarchical planning, execution, and quality assessment. First, in the resource construction stage, the resource curator LLM acquires and parses the target paper, generating a resource requirement list covering categories such as basic model code, baseline implementation code, dataset information, and dedicated library documentation. It also retrieves and filters relevant code and data resources from the open-source community to build a centralized resource support library. Next, in the hierarchical planning stage, the manager LLM generates a reproduction blueprint based on the aforementioned resource support library and the paper content, and further conducts repository-level architecture design to determine module division, interface specifications, and dependencies. Then, in the execution stage, the manager LLM generates resource usage guidelines, and the developer LLM generates code logic analysis in parallel based on the planning results and existing information such as the guidelines, thereby generating the initial technical implementation. For key documents containing the paper's innovative points, a multi-perspective think tank LLM collaborative analysis is triggered to solve implementation difficulties. Finally, in the quality assessment stage, the quality assurance LLM calls an assessment model fine-tuned using Group Relative Policy Optimization (GRPO) to automatically generate a quantitative scoring scale for the paper's key points, checking the initial technical implementation and proposing modification suggestions, thus iteratively generating the final technical implementation that meets the paper's requirements. The aforementioned resource construction-planning-execution-evaluation framework strengthens the collaboration logic among multiple LLMs, enabling the system to effectively integrate community resources, avoid redundant development, improve the success rate of reproducibility in high-complexity tasks through adaptive collaboration, and ensure the correctness and completeness of generated code through a reinforcement learning-driven quality control mechanism.

[0074] The specific implementation steps of this embodiment will be further described in detail below with reference to the accompanying drawings.

[0075] Figure 1 A flowchart illustrating the overall process of this embodiment is shown. The method is divided into multiple stages, including the following steps:

[0076] S100, Configuring and Orchestrating Multiple LLM Roles, Parameters and Communication Protocols:

[0077] In some embodiments, before the execution process begins, this application performs unified configuration and orchestration on multiple LLMs participating in the collaboration, as the basic environment for subsequent steps S101–S110.

[0078] In some embodiments, S100 can be specifically implemented as S1001-S1004 as follows:

[0079] S1001, Define roles and abilities.

[0080] In some embodiments, the plurality of LLMs includes at least: a manager LLM for task decomposition and scheduling; a resource curator LLM for cross-platform retrieval, filtering, and archiving of external resources; a developer LLM for modular code logic analysis and generation based on repository-level architecture; a think tank LLM for multi-perspective reasoning and conclusion fusion in high-complexity reasoning tasks; and a quality assurance LLM for performing quality assessments and generating modification suggestions. Based on the functional design of each LLM, its core is constructed, including prompt word engineering, model parameter settings, etc. Tool usage modules (such as code retrieval), memory modules (such as repository-level coding phase execution processes), planning modules, and execution modules are designed according to specific functional requirements. It should be noted that the above roles can be added, deleted, or merged according to the task scale, and the specific role names do not constitute a limitation of this application.

[0081] Optionally, the LLM skeleton uses Gemini-2.5-pro to meet the method's requirement for a long context window.

[0082] S1002, Set instantiation and parameters.

[0083] Specifically, the number of LLMs, parallelism, context length, temperature / sampling strategy, and timeout / budget thresholds can be set through configuration files or startup parameters; for example, the number of think tank LLMs k can be 5–9, and the upper limit of quality assessment iterations N can be 1–3 rounds. To avoid unnecessary restrictions, the above value ranges are only examples.

[0084] S1003, Select LLM and route the task.

[0085] In some embodiments, in response to the determination that the target task has high reasoning complexity, a consultative collaboration mode is triggered: the manager LLM selects participants from the candidate LLM pool based on an expert selection and aggregation strategy, and outputs the intermediate conclusions after consistent aggregation for use in subsequent steps. It should be noted that routine tasks can use a single LLM direct route to reduce overhead.

[0086] S1004, Management communication protocol and status.

[0087] In some embodiments, the system uses structured JSON as the message carrier between multiple LLMs and each execution stage, transmits intermediate results according to a predefined pattern, and performs fault-tolerant parsing on the JSON generated by the LLMs to avoid process interruptions caused by escaping errors. Simultaneously, it maintains a session / task-level cache, including GitHub repository parsing results, code refining artifacts, dataset directory trees, and HuggingFace search results, to support idempotent reruns and breakpoint continuation. Environment parameters are uniformly set through a parameter file. When necessary, the stack context of an execution error will trigger a targeted retrieval and repair process based on the Resource Support Library (RSRHub).

[0088] It should be noted that if LLM is used to complete the corresponding task in subsequent steps without additional detailed explanation, it means that the large language model is used to design targeted prompt words for direct analysis or to obtain the results with the help of tools. According to literature review and experimental analysis, this method performs well in most tasks.

[0089] S101. Obtain papers from multiple academic platforms, convert their formats, and perform structured analysis of the content.

[0090] In this embodiment, the Resource Curator LLM receives identification information (such as title or link) of the target paper, retrieves the target paper to be reproduced from multiple academic sources, and obtains the full text of the paper. To ensure the accuracy of subsequent analysis, the Resource Curator LLM uses a dedicated PDF parsing tool to convert the paper into a machine-readable Markdown text format to fully preserve the paper's structure and key information such as formulas and tables for subsequent processing. When the paper contains complex formulas or special formats, the above-mentioned dedicated parsing method can avoid information loss or extraction errors, ensuring the completeness and accuracy of the paper content analysis.

[0091] Optionally, the aforementioned academic sources include, but are not limited to, the Arxiv preprint server and conference proceedings repositories.

[0092] Optionally, parsing and acquisition tools may include, but are not limited to: PDF→Markdown / structured conversion tools (such as MinerU), document aggregation and metadata services (such as arXiv / OpenReview / Crossref / DOI parsing), academic search interfaces (such as the search endpoint provided by PaperswithCode), etc.; the above tools are only optional examples and do not constitute the only limitation.

[0093] S102. Generate a resource requirement list covering the basic model, baseline implementation, dataset, and dedicated library based on the extraction of elements from the paper.

[0094] In some embodiments, this step automatically generates a "resource requirements list" for the target paper using a resource curator LLM, specifying the subsequent retrieval and screening targets in the form of an "executable data contract." The list covers four common resource categories: basic models, baseline implementations, datasets, and dedicated library documentation. It should be understood that the output of S102 serves as both the input to S103 and is materialized and stored in a fixed path for easy idempotent reuse and traceability.

[0095] In this embodiment, "base model" refers to reusable standard algorithms and framework implementations, which constitute the core of the reproducibility workflow; "baseline implementation" refers to authoritative reference models used to ensure the consistency and comparability of experimental evaluations; "dataset" refers to standardized data sources, accompanied by scripts and metadata, to ensure reproducibility and prevent data drift; and "dedicated library documentation" refers to providing usage guidelines and application examples for third-party libraries to support accurate and reliable LLM code generation.

[0096] like Figure 2 As shown, specifically, this resource requirements analysis can be divided into the following steps:

[0097] S1021. Extract the elements of the paper model and represent them in a structured manner.

[0098] In some embodiments, a formatted paper is used as input, and the resource curator LLM is used to trigger extraction prompts for "related / basic models" and "baseline models" respectively. The results are returned uniformly with JSON keys and saved as files for subsequent S103 to populate the corresponding preferred repository links.

[0099] S1022. Extract and filter special library dependencies.

[0100] In some embodiments, library dependency fields are returned synchronously during the model feature extraction phase, and the following filtering is performed:

[0101] Exclude common general-purpose libraries (such as tensor / numerical / visualization general dependencies) to avoid unnecessary expansion; retain third-party libraries that are strongly related to the implementation of the target paper and have complex API usage (such as special operators, specific sequence modeling / optimizer implementations, etc.).

[0102] The selected libraries, base models, and baseline implementation information are written into the same JSON file.

[0103] S1023, Requirement to generate and persist datasets.

[0104] In some embodiments, for the data involved in the paper, a dataset requirement list is generated and the data is stored in a JSON file according to the agreed directory. Subsequently, in S103, preferably, HuggingFace is used to retrieve the data, only the Parquet file is downloaded, the original hierarchy is maintained, and the local path and statistical information are recorded, which is convenient for direct use in reproducing experiments and for enumerating the directory tree.

[0105] It's important to note that Parquet is a column-oriented, open-source data format designed for large-scale data analysis and efficient compression. Compared to traditional row-oriented storage, it significantly reduces I / O overhead when reading specific columns and supports better compression ratios and faster parallel processing. Choosing Parquet can reduce storage costs and improve query performance while maintaining data accuracy, making it suitable for big data processing and machine learning training scenarios.

[0106] S1024. Capture and archive dedicated library documents.

[0107] In some embodiments, for the dedicated libraries reserved in S1022, the system calls the Python built-in documentation interface (such as pydoc / inspect.getdoc) to extract and save the module / class / function signatures and key example information containing the library in the local environment, and refines and archives the useful information in subsequent stages. Then, in the subsequent code refinement and bug fixing stages, it is directly referenced as the retrieval corpus of the Resource Support Library (RSRHub).

[0108] Optionally, in some embodiments, the resource curator LLM maps the extracted elements to four types of resources and sets source channels: base model: GitHub, PaperswithCode; baseline implementation: GitHub, PaperswithCode; dataset: Google, HuggingFace; dedicated library documentation: official documentation of various third-party Python libraries.

[0109] It should be understood that the above sources are priority channels, not the only ones.

[0110] S103. Perform cross-platform parallel retrieval based on the resource requirement list, and use a fusion adaptive warehouse selection algorithm for resource filtering and archiving.

[0111] In some embodiments, this step, based on the resource requirement list generated in S102, completes cross-platform resource collection and candidate screening, and determines the primary and secondary results in the base model and extreme implementation through a fusion-based adaptive repository selector (FARS) algorithm. It should be understood that the goal of S103 is to keep high-cost evaluations within an acceptable range while ensuring screening accuracy.

[0112] In some embodiments, this can be achieved through the following steps:

[0113] S1031. Parallel retrieval and construction of candidate sets.

[0114] In some embodiments, the resource curator LLM may optionally perform parallel searches on platforms such as GitHub, PaperswithCode, and HuggingFace for each resource in the inventory.

[0115] Specifically, to improve recall and avoid ranking bias, the top k candidates for each resource category are retrieved by default (for example, k=5), and merged into an initial candidate set C for that list item. It should be understood that selecting only a single highest-ranking repository can easily introduce noisy repositories irrelevant to the target; even official repositories often contain a large number of irrelevant files, so further filtering is required to improve usability.

[0116] S1032. In response to the candidate resource set, execute the Fusion Adaptive Repository Selection (FARS) algorithm.

[0117] like Figure 3 As shown, in some embodiments, S1032 can be specifically implemented as the following steps:

[0118] S1032a, Perform lightweight heuristic filtering on the candidate resource set based on lexical relevance and repository structure features.

[0119] In some embodiments, to significantly reduce the computational overhead of high-cost evaluation, a fast lexical and structural filtering is first performed on the candidate set C, retaining only the most promising repositories for the next stage.

[0120] Specifically, it includes the following metrics and judgments:

[0121] Lexical relevance score Based on the matching results of "title term - initials - alias", the weight parameters are... , , Control the three separately in The relative importance of [the data]; structured filtering (based on document size) Judgment): Based on the number of code files in the repository. , , Adaptive thresholding to eliminate candidates with abnormal volume;

[0122] It should be understood that the above filtering stage does not call LLM and sets an upper limit for subsequent stages. To ensure that the overall LLM call complexity is the same as Linear correlation.

[0123] S1032b: Use a large language model to perform an in-depth evaluation of the semantic relevance and implementation quality of the filtered candidate resources.

[0124] In some embodiments, two types of evaluations are performed on candidate LLM calls that have been heuristically filtered: LLM semantic relevance. : Measuring the semantic match between the repository and the key methods / experiments in the paper; LLM quality assessment The evaluation is based on the completeness of the readme.md file, its reproducibility (scripts / configuration / instructions), and its implementation quality, and is normalized to [0,1].

[0125] Specifically, the number of candidates entering this stage is... Limitations are imposed to control high-cost assessments. Within the scope of this LLM call.

[0126] S1032c: Multiplication fusion scoring, sorting warehouse score.

[0127] In some embodiments, multiplication fusion is used to uniformly score the heuristic signal and the LLM signal, denoted as:

[0128] ;

[0129] in Depend on , , Weighted average , , Normalize to [0,1]

[0130] Specifically:

[0131] First, the minimum acceptable fusion threshold If all candidate F < This triggers the rollback mechanism;

[0132] Secondly, set a tie boundary. .by The corresponding warehouse is used as the main result; satisfying The warehouse is returned as a secondary candidate.

[0133] It should be understood that , , It can be learned from labeled "paper-repository pairing" data; and It can be configured by task domain to balance efficiency and accuracy.

[0134] S1032d: Compare thresholds and determine rollback.

[0135] In some embodiments, in response to no candidates reaching the threshold When this happens, the system triggers a rollback mechanism to ensure robustness; the specific execution of this mechanism follows a preset process, which will not be elaborated here.

[0136] S1033, Refine repository files and library documentation content, and compress semantics.

[0137] In some embodiments, file analysis and semantic compression are performed on the primary / secondary repositories selected by FARS and the help documentation of the aforementioned repositories. Irrelevant material is removed, and key implementation components and necessary descriptions are retained to reduce the computational burden caused by irrelevant files and improve the usability of subsequent reproducibility. This process serves as a pre-repository step.

[0138] S1034. Unify the archiving of resources to the resource support library (RSRHub).

[0139] In some embodiments, the filtered and refined code repositories, datasets and library documents, along with complete metadata (source, version or tag and necessary descriptions), are archived together to form a resource support library (RSRHub) to support source tracing and version management, and to serve as a basic resource pool for subsequent planning and implementation phases.

[0140] S104. Combining the paper content with the resource support library, a comprehensive reproduction blueprint is generated through a multi-expert solution aggregation strategy.

[0141] In some embodiments, such as Figure 3 As shown, in the hierarchical planning phase, the manager's LLM, combining the paper content and the resource support library (RSRHub), generates a comprehensive reproduction blueprint to guide subsequent implementation. To ensure faithful reproduction of the original paper's method and coverage of implementation details, this step organizes think tank experts' LLM to form candidate solutions based on predefined templated schemes, and uses an aggregation strategy to obtain a consistent blueprint.

[0142] Specifically, regarding the selection and aggregation of expert LLMs:

[0143] In some embodiments, expert selection may be performed by the BrainTrust selection algorithm: mapping cue words to a sentence encoder to obtain an embedding matrix R=[ ,…, The selection is based on maximizing semantic volume, and its objective function can be expressed as:

[0144] ;

[0145] To strike a balance between accuracy and diversity, R can be adjusted by exponential scaling based on the performance evaluation function u(⋅), and a greedy solution can be used to obtain an approximate solution.

[0146] ;

[0147] The parameters (e.g., number of experts k, adjustment coefficient) It can be set according to the task size and performance requirements.

[0148] After candidate solutions are generated, the LLM (Local Language Management) administrator employs a large-scale language model aggregation strategy, using templated solutions as a framework for element alignment and conflict detection, integrating them into a unified comprehensive reproducibility blueprint. This blueprint clearly defines phase goals, key milestones, resource mappings, and key points for subsequent evaluation, driving the subsequent repository-level architecture design.

[0149] Optionally, to adapt to different task scales and constraints, one or more parameters can be configured, including the number of experts, screening threshold, evaluation threshold, and iteration limit. The parameter values ​​do not constitute a limitation on this application.

[0150] S105. Design a warehouse-level architecture based on a comprehensive reproduction blueprint, defining module division, dependencies, and interface specifications.

[0151] In some embodiments, based on the comprehensive reproduction blueprint obtained in step S104, the manager LLM is used to transform the abstract plan into the implementation architecture specification of the code repository, determine the module boundaries, dependencies and interface conventions, thereby providing a stable skeleton for parallel development and debugging.

[0152] Specifically, this step can generate the following complementary deliverables: Module partitioning and dependency management: Layering and decomposing the codebase, clarifying module responsibilities and establishing an explicit dependency graph, recording the calling relationships and data flow patterns between modules; Object-oriented architecture specifications: Generating class diagrams to define class hierarchies, interfaces and method signatures, as well as composition / aggregation relationships between objects, ensuring interface contract consistency and reducing integration complexity; Runtime interaction modeling: Drawing sequence diagrams to describe the dynamic behavior during execution, including message passing order, conditional branches and exception handling, clarifying the complete collaborative process from input to output.

[0153] The above three types of outputs together constitute the output of the repository-level architecture design, providing structured guidance for subsequent file-level development, avoiding integration conflicts and ensuring clear execution semantics.

[0154] S106. For each file in the repository architecture, analyze and generate a customized resource usage guide selected from the resource support library.

[0155] In some embodiments, the administrator LLM performs targeted resource usage analysis for each file to be implemented based on existing information such as the repository-level architecture design, paper text, and blueprints defined in step S105. This analysis filters a subset of resources directly related to the target file from the Resource Support Library (RSRHub), records the matching relationships so that subsequent steps can selectively input the required resources, thereby avoiding interference from irrelevant resources and improving the efficiency and accuracy of subsequent analysis.

[0156] For each reusable code resource, based on the analysis of the paper and blueprint, the following different strategies are implemented according to the actual usage of the file: Adaptive modification strategy: Adjust the parameters or configuration level of the basic matching implementation to better adapt it to the needs of the current task; Functional expansion strategy: Add modules or functions on the basis of existing available implementations to meet the specific needs or requirements of the paper; Reference implementation strategy: Borrow the design principles of approximate methods, complete the missing components, and ensure the conceptual consistency of the implementation.

[0157] These strategies, by aligning with the "dependency footprint-coverage matrix" of the files, ensure that each target file can be reused to the maximum extent from existing resources during actual development, and avoid reimplementation or unnecessary development work.

[0158] Finally, this step outputs customized resource usage guidelines for the target file, supporting code analysis and generation in subsequent step S107. These customized resource guidelines ensure that the resources used during code implementation are the most relevant and effective, avoiding redundant development and improving development efficiency.

[0159] S107. Perform implementation logic analysis on each target file, and trigger an adaptive reasoning fusion mechanism for the difficult points marked as core files to execute multi-LLM consultative collaborative solution.

[0160] In some embodiments, based on the existing product of the above steps, the following steps are performed:

[0161] S1071, File-level implementation analysis.

[0162] First, for each target file, an actionable logical analysis file is generated, including the following: function / class definitions; cross-module dependencies and interface calls; locations of directly reusable code / configuration / scripts; and a list of logic that needs to be rewritten or extended. The analysis results provide a development-oriented implementation plan, precisely explaining the implementation strategy and code structure, directly reusable existing components and calling methods, or necessary modifications and adaptations, ensuring that development can be implemented directly step by step. Furthermore, during the analysis, the developer's LLM, in conjunction with the paper and the differences between the resource implementation and the target implementation plan corresponding to the file, analyzes whether the file is a "core file" containing innovative elements. For files with high complexity and containing innovative components, the developer's LLM adds "Innovation Implementation Description" and "Innovation Mark" to the end of the generated analysis file for subsequent additional multi-reasoning perspective analysis and integration.

[0163] S1072. Perform multi-perspective reasoning on multiple LLMs for core files, and use an aggregation strategy to fuse the conclusions to form an executable path.

[0164] In some embodiments, in response to the "innovation marker" at the end of a partial analysis document, objects marked as "core documents" employ a multi-LLM consultative collaboration consistent with the blueprint planning phase: managers dynamically select heterogeneous experts from a pool of candidate experts, conduct multiple rounds of discussions around the implementation plan, and aggregate consensus conclusions. Specifically, the "semantic volume maximization" strategy used for expert selection in the planning phase can be adopted to ensure a balance between diversity and accuracy of viewpoints, and then an aggregation strategy is used to unify conflicts and output an executable path. Managers use the same think tank collaboration method as in the planning phase to solve key issues, enabling the system to achieve iterative reasoning from multiple perspectives around these innovations. This diverse reasoning can be viewed as unique insights and hypotheses provided by experts from different domains on the same problem, thereby reducing the illusion of a single path and the loss of details in subsequent code reproduction.

[0165] S108. Based on the architecture design and logic analysis documents, generate code in the order of dependencies, and perform targeted debugging and repair based on the resource support library.

[0166] In some embodiments, the developer LLM is used to receive matching support resources based on the architecture design in step S105 and the logic analysis file in step S107, and generate code sequentially according to a predetermined file order and dependency relationship to ensure consistency between interfaces and data structures in the generation order, thereby reducing the cost of subsequent modifications. After the initial code generation, the developer LLM automatically debugs and improves the repository: when syntax or library call errors occur during runtime, the error stack is parsed to locate the problematic interface, and the administrator LLM retrieves relevant library usage documents or data metadata from RSRHub to guide developers in implementing targeted corrections to avoid inefficient blind retries.

[0167] In some embodiments, to prevent infinite loops, a maximum number of iterations N can be set for the automatic debugging-repair process; for example, N can be set to 15 to control the overall overhead while ensuring sufficient repair. After completing this step, an executable code repository is obtained, and the method and experimental process of the target paper are initially implemented.

[0168] S109. The basic language model is fine-tuned using a group relative strategy optimization algorithm to obtain a dedicated quality assessment model that can automatically generate hierarchical assessment scales.

[0169] In some embodiments, this step fine-tunes the dedicated language model used for reproducibility quality assessment so that it can automatically extract “reproducibility key points” from the paper and generate a hierarchical assessment scale, providing an objective benchmark for subsequent quality checks and code refinement.

[0170] It should be noted that model fine-tuning refers to the process of further training an already trained basic model for a specific task or domain, so that the model can better adapt to specific needs.

[0171] like Figure 4 As shown, in some embodiments, S109 can be specifically implemented as S1091-S1095 as follows:

[0172] S1091. Construct annotations and create training corpus:

[0173] In some embodiments, a baseline corpus containing 23 ICML / NeurIPS papers and corresponding stratified assessment scales are used as the basis for fine-tuning. The scale for each paper is drafted by research engineers and repeatedly confirmed with the original authors. It is in a tree structure, refined from the root node "reproducing the core contribution of the paper" to operational assessment dimensions to ensure coverage of key points and determinability.

[0174] S1092. Determine the elements of the fine-tuning algorithm and design the reward signal:

[0175] In some embodiments, Group Relative Policy Optimization (GRPO) is used to fine-tune the evaluation model using reinforcement learning, including the following elements: Policy model: based on a general LLM model; Training objective: maximizing the expected value of the relative reward per group; Optimization method: stable training within groups using the average reward as a baseline. The core capability objective is "automatic extraction and reproduction of key points – generation of scales".

[0176] The coverage rate of the "model-generated keypoint set scale" over the "expert annotation scale" is used as a reward signal (which can be weighted). It is calculated using another general LLM evaluation (optionally, Gemini 2.5pro is used in this embodiment), combining three metrics: Token-level Jaccard similarity (60%), FastText embedding similarity (30%), and exact numerical matching (10%), with a coverage threshold of 0.35. This coverage rate measures the comprehensiveness and accuracy of the evaluation and is derived from the hierarchical tree-structured scale of the aforementioned benchmark corpus.

[0177] S1093, Progressively expand the context and perform two-stage fine-tuning:

[0178] In order to alleviate the instability of long context training, a progressive context expansion strategy is designed in some embodiments, and a two-stage fine-tuning scheme is adopted.

[0179] Specifically, firstly, while preserving the key structure and semantics of the paper, the content was refined, removing redundant information. Then, following the paper's reproduction workflow, the refined text was divided into four parts: methods and implementation, dataset and baseline, experimental design and execution, and evaluation and visualization. In the first stage, each part was independently input into the language model for policy sampling, generating a corresponding list of key reproduction points. In the second stage, the complete refined text was used for global fine-tuning to improve the model's ability to comprehensively and accurately extract key reproduction points.

[0180] S1094. Train the model and save the model parameters:

[0181] After training, the parameters of the quality assessment model converged via GRPO are obtained. This model is used in S110 to automatically generate a hierarchical evaluation scale for the current code repository, and based on this, identify missing and non-compliant items, thereby providing modification suggestions for developers.

[0182] Preferably, the refining process is designed to be executed in a single round to avoid overfitting the score tree.

[0183] Optionally, in this embodiment, Qwen3-8B is used as the base model, and a LoRA adapter (r=32) is used. =16) and NF4 four-bit quantization. The reward signal was evaluated using Gemini-2.5-Pro ​​to assess the coverage between the generated scale and expert annotations, and was calculated using three metrics: Token-level Jaccard similarity (60%), FastText embedding similarity (30%), and exact numerical matching (10%), with a coverage threshold of 0.35 set.

[0184] S110. The fine-tuned quality assessment model is called to generate a key point scale for the paper, and the code repository is evaluated and iteratively optimized accordingly.

[0185] In some embodiments, a quality assurance engineer (LLM) is built based on a quality assessment model. The paper is input to obtain an implementation key assessment scale. Then, a fine-grained quality check is performed on the code repository generated in step S108 to obtain assessment results and modification suggestions to drive the developer LLM to complete the final code optimization.

[0186] Specifically, the Quality Assurance Engineer (LLM) first analyzes the target paper's content using a trained evaluation model, generating a tiered evaluation scale corresponding to the paper. Then, according to the scale, they compare each item with the files and modules in the current code repository, identifying missing items or areas that do not meet the paper's requirements, and generating targeted modification suggestions (e.g., supplementing missing data preprocessing steps, improving core algorithm logic, correcting interface inconsistencies, etc.). Subsequently, the developer LLM implements local optimizations based on these suggestions, making the updated code implementation extremely close to the implementation described in the target paper, ensuring the fidelity and coverage of code reproducibility.

[0187] Preferably, to avoid overfitting of the evaluation model to a limited number of indicators, the evaluation and refinement process is designed to be executed in a single round. That is, after generating and implementing a modification suggestion, the quality assurance process ends, resulting in the final reproducible code repository after quality verification and targeted correction.

[0188] This embodiment effectively integrates existing code implementations from the open-source community by constructing a resource support library, enabling code reuse and avoiding redundant development, thereby reducing the difficulty and cost of reproduction. Secondly, it introduces adaptive inference fusion into the core code analysis, employing a multi-LLM consultative collaboration mechanism. This allows the system to efficiently complete routine reproduction tasks and tackle high-complexity inference problems through multi-perspective reasoning, effectively improving the success rate of reproducing complex tasks. Thirdly, a reinforcement learning-based quality assessment and automatic repair mechanism ensures the correctness and completeness of the generated code, making it closer to the implementation in the paper and ensuring the rigor and reliability of the reproduction results. Experimental results show that the average reproduction accuracy of this method reaches 79.1%, an improvement of approximately 13.3% compared to existing methods. Furthermore, the adaptive multi-inference fusion mechanism and code quality assurance system adopted in this invention have good versatility and can be applied to paper reproduction tasks in different fields, further improving the efficiency of scientific research.

[0189] Example 3

[0190] Based on the same general inventive concept, the present invention also provides a training device.

[0191] refer to Figure 5The training device includes: a resource construction module 510, a planning module 520, an implementation module 530, and a quality control module 540; as well as a resource support library 550 (RSRHub). These modules work collaboratively to support the entire process of paper reproduction, with the resource support library 550 providing unified support resource management.

[0192] Specifically, it includes:

[0193] The resource building module 510 is configured to generate a resource requirement list based on the target academic paper text, retrieve and filter external resources, and build a resource support library.

[0194] Planning module 520 is configured to generate a reproduction blueprint and perform warehouse-level architecture design based on the resource support library and the text content;

[0195] Implementation module 530 is configured to coordinate multiple LLMs to develop support resource usage guidelines, and to analyze and generate initial technical implementations in the order of the said dependencies;

[0196] The quality control module 540 is configured to perform a quality assessment on the initial technical implementation and optimize it based on the assessment results to obtain the final reproducible code repository.

[0197] Supports 550 resource libraries, which are configured to contain refined resources such as basic models, baseline implementations, datasets, and dedicated library documentation, and provide unified support resource management.

[0198] The resource construction module 510 is used to: acquire the text content and metadata of the target academic paper; perform structured transformation on the text content to form a format conducive to model parsing; generate a resource requirement list for reproduction based on the text content; perform cross-platform retrieval and screening of basic models, baseline implementations, datasets, and third-party library documents; perform content refinement and semantic compression on candidate resources, remove irrelevant materials and retain key implementation components and necessary descriptions; archive and record metadata for the selected resources in a versioned manner; construct a resource support library 550; and provide a traceable and reusable resource entry point for subsequent modules.

[0199] In some embodiments, the resource construction module 510 is further configured to perform heuristic and semantic joint evaluation of candidate repositories according to a preset fusion adaptive selection strategy to ensure resource quality and relevance.

[0200] The planning module 520 is used to generate a reproduction blueprint based on the resource support library and the paper content, clarify the stage goals, key points and resource mapping relationships; perform warehouse-level architecture design to determine module division, interface specifications and dependency relationships, and output structured specifications to guide implementation; in scenarios with complex dependencies or containing innovative points, adopt a multi-expert solution aggregation strategy to integrate candidate plans in a consistent manner, thereby improving the integrity and executability of the blueprint.

[0201] In some embodiments, the planning module 520 is also used to generate abstract artifacts such as class diagrams and sequence diagrams to standardize object relationships and runtime interaction processes, thereby reducing integration complexity.

[0202] The implementation module 530 is used to, based on the reproduction blueprint and architecture specifications, and the required resources of the support resource library 550, use the administrator LLM to formulate a file-oriented resource usage guide, generate code logic analysis according to the dependency order, and perform initial technical implementation; during the code generation and debugging process, call the code snippets, datasets and library documents in the resource support library for targeted referencing and adaptation;

[0203] The implementation module 530 is further configured to, when an error occurs or an interface inconsistency occurs, parse the error context and perform document-driven targeted repair based on the library documentation; in response to files containing innovative elements of a paper or high reasoning complexity, trigger consultative collaboration to perform multi-perspective reasoning and conclusion aggregation, thereby forming an executable implementation path. In some embodiments, an upper limit for automatic debugging-repair iterations is set to control overall overhead while ensuring sufficient repair.

[0204] The quality control module 540 is used to perform quality assessment and targeted optimization on the initial technical implementation generated by the implementation module 530; specifically, it includes: calling the evaluation model fine-tuned by reinforcement learning to adaptively generate a hierarchical evaluation scale from the paper content; checking the code repository item by item according to the scale, identifying missing items and non-compliant items, and forming targeted modification suggestions; and feeding back the modification suggestions to the implementation module 630 to drive local optimization until a final implementation that meets the requirements of the paper is generated.

[0205] In some embodiments, the quality control module 540 preferably completes the evaluation and correction in a single round or a limited number of rounds to avoid overfitting to a limited set of indicators and to improve evaluation efficiency.

[0206] In some embodiments, the resource support library 550 serves as a centralized storage and retrieval component that interacts with the resource construction module 510, planning module 520, implementation module 530, and quality control module 540. It is used to uniformly store the filtered and refined basic model / baseline implementation code repository, library documents, datasets, and their metadata, and to provide consistent traceability, version management, and efficient retrieval capabilities for the above modules.

[0207] For ease of description, the above devices are divided into different modules according to their functions. In actual implementation, the functions of the modules can be implemented in the same or multiple software and / or hardware, or they can be completed by one or more processing units by executing computer programs. The training device is used to implement the corresponding method steps in any of the foregoing embodiments and can obtain the same beneficial effects as the method embodiments, and will not be described again here.

[0208] Example 4

[0209] Based on the same inventive concept, this application also provides an electronic device 1000. For example... Figure 6 As shown, the electronic device may include: a processor 1010, a memory 1020, an input / output interface 1030, a communication interface 1040, and a bus 1050. Wherein:

[0210] Processor 1010 is used to execute computer programs stored in memory 1020;

[0211] The memory 1020 is used to store the computer program and data related to the operation of the method;

[0212] The input / output interface 1030 is used for interaction with the user or peripherals;

[0213] Communication interface 1040 is used for data communication with external devices or networks;

[0214] Bus 1050 is used to realize the communication connection between the above components.

[0215] When the computer program is executed by the processor 1010, the processor performs the steps (S101-S110) described in any method embodiment of this application, including: acquiring and converting the target paper text, generating a resource requirement list and building a resource support library, generating a reproduction blueprint and completing a repository-level architecture design, forming a resource usage guide to coordinate the order of multiple LLM dependencies to generate an initial technical implementation, calling an evaluation LLM fine-tuned by the GRPO algorithm for quality assessment and modifying it accordingly, until the final code implementation for reproducing the target academic paper is output, thereby obtaining the same technical effect as in the method embodiment.

[0216] In some embodiments, the electronic device may be a server, personal computer, workstation, edge computing device, or embedded device; it may also be implemented in a standalone or distributed / cluster configuration; the above configurations do not constitute a limitation of this application.

[0217] Example 5

[0218] Based on the same inventive concept, this application also provides a non-transitory computer-readable storage medium. The storage medium stores computer instructions, which, when executed by a processor, cause the processor to perform the steps (S101-S110) described in any method embodiment of this application, thereby achieving the same technical effect as the method embodiment.

[0219] In some embodiments, the computer-readable storage medium may be a read-only memory (ROM), random access memory (RAM), flash memory, solid-state drive, magnetic disk, optical disk, or any combination thereof; it may also be programs and data stored in a network server or cloud storage. The above-mentioned media types and deployment methods are all implementations that can be conceived by those skilled in the art.

[0220] Example 6

[0221] Based on the same inventive concept, this application also provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the method described in Embodiment 1.

[0222] The above are merely preferred embodiments of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A resource-oriented academic paper technical solution automatic reproduction method, characterized in that, Includes the following steps: Obtain the text content of the target academic paper and generate a resource requirement list to reproduce the text content; Based on the resource requirements list, technical resources are retrieved and filtered from the open-source platform to build a resource support library; Based on the resource support library and the text content, a comprehensive reproduction blueprint is generated, and a repository-level architecture design is performed in the execution environment to determine module division, interface specifications and dependencies. Based on the resource support library, the comprehensive reproduction blueprint, and the repository-level architecture design, a resource usage guideline is formulated, and several large language models are coordinated to perform logical analysis on each module according to the dependency relationship order to obtain the initial technical implementation. The initial technical implementation is subjected to executability iterative repair based on error feedback to obtain the repaired technical implementation; A reinforcement learning algorithm is used to fine-tune the quality assessment model to maximize the matching degree between the model output and the key technical points of the paper. The fine-tuned model is then used to assess the quality of the repaired technical implementation. Based on the assessment results, the model is optimized to achieve the reproduction of the target academic paper. The quality assessment model is fine-tuned using a reinforcement learning algorithm to maximize the match between the model output and the key technical points of the paper. The fine-tuned model is then used to assess the quality of the repaired technical implementation. The optimization process based on the assessment results includes: A quality assessment model finely tuned by a reinforcement learning algorithm is used to adaptively construct a technical solution evaluation scale based on the paper content. The technical implementation after repair was checked item by item according to the technical solution evaluation scale to identify missing and non-compliant items and formulate targeted modification suggestions; the technical implementation after repair was optimized locally according to the modification suggestions to obtain the final technical implementation.

2. The method according to claim 1, characterized in that, The process of generating a resource requirement list to reproduce the text content of a target academic paper includes: The text content of the target academic paper is formatted to obtain a formatted text; model elements, library dependencies, and dataset requirements are extracted from the formatted text to generate a resource requirements list covering the basic model, baseline implementation, dataset, and dedicated library documentation.

3. The method according to claim 1, characterized in that, The process of retrieving and filtering technical resources on the open-source platform and building a resource support library based on the aforementioned resource requirements list includes: For each resource in the resource requirement list, parallel retrieval is performed on the open-source platform to construct a candidate resource set. Heuristic filtering based on lexical relevance and repository structure features is performed on the candidate resource set to obtain filtered candidate resources. A large language model is used to evaluate the semantic relevance and implementation quality of the filtered candidate resources to obtain semantic evaluation scores and quality evaluation scores. The semantic evaluation scores and heuristic filtering scores are multiplied and fused to determine the target repository. The target repository is then archived after file parsing and semantic compression to construct a resource support library.

4. The method according to claim 1, characterized in that, The process of generating a comprehensive reproduction blueprint based on the resource support library and the text content, and designing a repository-level architecture in the execution environment, includes: Based on the resource support library and text content, a multi-expert solution aggregation strategy is adopted to generate a comprehensive reproduction blueprint, which clarifies the stage goals, key points and resource mapping relationships. According to the comprehensive reproduction blueprint, a warehouse-level architecture design is carried out to determine the module division, interface specifications and dependencies, and generate class diagrams and sequence diagrams to standardize object relationships and runtime interaction processes.

5. The method according to claim 1, characterized in that, Based on the resource support library, the comprehensive reproduction blueprint, and the repository-level architecture design, a resource usage guideline is formulated, and multiple large language models are coordinated to perform logical analysis on each module according to the dependency relationship order. The process of obtaining the initial technical implementation includes: Based on the resource support library, comprehensive reproduction blueprint, and repository-level architecture design, we develop customized resource usage guidelines for each module; we coordinate multiple large language models according to their dependency order, perform logical analysis on each module based on the resource usage guidelines, identify core modules, trigger a multi-perspective reasoning fusion mechanism, and generate the initial technical implementation.

6. The method according to claim 1, characterized in that, The specific process of performing executability iterative repair based on error feedback on the initial technical implementation to obtain the repaired technical implementation includes: The system automatically debugs the initial technical implementation. When errors occur, it parses the error context and locates the problematic interface. It retrieves relevant library usage documents or data metadata from the resource support library to guide developers in implementing targeted corrections until a fixed technical implementation is achieved.

7. A computer apparatus comprising a memory, a processor, and a computer program stored on the memory, wherein the computer program, when executed by the processor, causes the processor to perform the method of any one of claims 1 to 6. The processor executes the computer program to implement the steps of the method according to any one of claims 1-6.

8. A computer-readable storage medium having stored thereon a computer program, characterized in that, When executed by a processor, the computer program implements the steps of the method according to any one of claims 1-6.

9. A computer program product comprising a computer program, characterized in that, When executed by a processor, the computer program implements the steps of the method according to any one of claims 1-6.

Images