A proxy training method, system, device, and medium for autonomous data science
By constructing an interactive data analysis environment and curriculum learning strategies, adaptive training of the intelligent agent's large language model is carried out, which solves the problems of poor autonomy and insufficient environmental adaptability of existing systems and realizes end-to-end autonomous data analysis.
Patent Information
- Application Number
- CN202611332017.6
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-31
- Publication Date
- 2026-11-17
AI Technical Summary
Existing data analysis systems lack autonomous orchestration capabilities and environmental adaptability, making it difficult to generate high-quality analysis reports in real-world data environments.
An interactive data analysis environment is constructed, employing a course learning strategy and data base trajectory synthesis technology to adaptively optimize and train the large language model of the intelligent agent. Through a closed-loop process of autonomous iterative execution of orchestration analysis-encoding-execution-feedback, a data science report is generated.
It achieves full-process autonomy and environmental adaptability. The intelligent agent's large language model can autonomously interact, experiment, and optimize in real-world environments, generating high-quality data science reports.
Smart Images

Figure CN123117243A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the fields of artificial intelligence and data science, and in particular to a proxy training method, system, device, and medium for autonomous data science that enables end-to-end autonomous data analysis. Background Technology
[0002] In data science and business analytics, end-to-end automation from raw data to analytical reports has significant industrial value. With the development of large language models, automated data analysis has become possible. However, existing technical solutions mainly suffer from two types of problems: First, existing code-generated data analysis systems can typically only write single code snippets and lack the ability to autonomously orchestrate the entire data science process (such as data cleaning, exploratory analysis, modeling, and visualization).
[0003] Second, existing data analysis systems often rely on manually hard-coded workflows or cue word engineering, lacking adaptability to real-world data environments. When faced with open-ended data exploration tasks, models often fail to generate high-quality analysis reports due to a lack of high-quality training data (trajectory scarcity) and feedback in long-chain tasks (reward sparsity).
[0004] Therefore, there is an urgent need for a training method and system that can enable large language models to autonomously interact, experiment, and optimize in real-world environments through systematic course training. Summary of the Invention
[0005] To address the aforementioned problems, the present invention aims to provide a proxy training method, system, device, and medium for autonomous data science. By employing a course-based training paradigm and data-based trajectory synthesis technology, it solves the problems of poor autonomy and lack of training data in existing large language models for complex data science tasks.
[0006] To achieve the above objectives, the present invention adopts the following technical solution: In a first aspect, the present invention provides a surrogate training method for autonomous data science, comprising: Build an interactive data analysis environment; Based on an interactive data analysis environment, a course learning strategy is used to adaptively optimize and train the user-initialized intelligent agent large language model. The trained intelligent agent large language model is loaded, receives the raw data source input by the user and the requirements of a certain open data research task, and generates a data science report through a closed-loop process of orchestration analysis-encoding-execution-feedback through autonomous iteration.
[0007] Furthermore, the interactive data analysis environment includes a user input interface, data processing tools, a file system, and a feedback interface; The user input interface is used to receive code instructions uploaded by the user for a specific open data research task and at least one original data source; The code execution engine is used to execute user-uploaded code instructions, process the original data source, and obtain the code execution result; The file system is used to store the original data source uploaded by the user and the results of code execution; The feedback interface is used to return the code execution results to the user.
[0008] Furthermore, the adaptive optimization training of the user-initialized intelligent agent large language model based on an interactive data analysis environment and a course learning strategy includes: The agent's large language model is initialized, and then supervised fine-tuning is performed using synthetic data containing inference trajectories to enable it to understand structured data and generate code. The fine-tuned agent large language model is placed into the interactive data analysis environment, and surrogate training is performed using synthetic data containing interaction trajectories to obtain the trained agent large language model.
[0009] Furthermore, the generation of synthetic data containing reasoning trajectories includes: using prompts with inserted mandatory guiding keywords and the original data source as input, and generating synthetic data containing reasoning trajectories using a preset teacher model.
[0010] Furthermore, the synthetic data containing the interaction trajectory is generated using a multi-agent system, which includes a questioner agent, a solver agent, and an inspector agent. The questioner agent is used to generate an analysis task based on the original data source. The solver agent is used to attempt to solve the analysis task and generate the interaction trajectory. The inspector agent is used to verify the correctness of the interaction trajectory and obtain the verified interaction trajectory.
[0011] Furthermore, the step of placing the fine-tuned agent-based large language model into the interactive data analysis environment and performing agent-type training using a model training dataset containing interaction trajectories to obtain the trained agent-based large language model includes: Based on the interaction trajectory data, the intelligent agent's large language model is further supervised and fine-tuned to familiarize it with the format and basic strategies of environmental interaction. By placing the intelligent agent large language model into an interactive data analysis environment and using the original data source to perform reinforcement learning in a real interactive data analysis environment, the trained intelligent agent large language model is obtained.
[0012] Furthermore, the step of placing the agent-based large language model into an interactive data analysis environment and performing reinforcement learning in a real interactive data analysis environment using the original data source to obtain the trained agent-based large language model includes: Using a large language model of an intelligent agent to generate analytical actions, we can perform task decomposition and logical reasoning on an open data research task. Based on the task breakdown and logical reasoning results, the agent's large language model generates coded actions and writes code instructions for processing the original data source. After receiving the code instruction, the interactive data analysis environment triggers the execution action, executes the code instruction in the interactive data analysis environment, and returns the code execution result as feedback to the agent's large language model; Based on the feedback results, a pre-set hybrid reward mechanism is used to evaluate the interaction process between the intelligent agent large language model and the interactive data analysis environment. The reward signal is calculated based on the evaluation results and used to update the parameters of the intelligent agent large language model. This guides the intelligent agent large language model to adaptively adjust subsequent actions until the data science task is completed, resulting in the trained intelligent agent large language model.
[0013] Secondly, the present invention provides a proxy-based training system for autonomous data science, comprising: The interactive environment building module is used to build interactive data analysis environments; The model training module is used to adaptively optimize and train the user-initialized intelligent agent large language model based on an interactive data analysis environment and a course learning strategy. The autonomous reasoning module is used to load the trained intelligent agent large language model, receive the raw data source input by the user and the requirements of a certain open data research task, and generate a data science report through an autonomous iterative execution of a closed-loop process of orchestration analysis-encoding-execution-feedback.
[0014] Thirdly, the present invention provides a computer-readable storage medium for storing one or more programs, the one or more programs including instructions that, when executed by a computing device, cause the computing device to perform the surrogate training method for autonomous data science.
[0015] Fourthly, the present invention provides a computing device comprising: one or more processors and a memory, wherein the memory stores one or more programs and is configured to be executed by the one or more processors, the one or more programs including instructions for executing the surrogate training method for autonomous data science.
[0016] The present invention has the following advantages due to the adoption of the above technical solutions: 1. Full-process autonomy: By constructing an interactive data analysis environment, this invention enables the intelligent agent's large language model to no longer rely on predefined workflows, but to autonomously decide on the next operation (such as analysis, writing code, and viewing results) based on data feedback, thus achieving true end-to-end automation.
[0017] 2. Environmental adaptability: Through reinforcement learning in an interactive data analysis environment, the intelligent agent's large language model possesses the ability to self-correct and adaptively optimize.
[0018] 3. Training efficiency: The model training method based on the course learning strategy proposed in this invention effectively alleviates the cold start problem in complex tasks by synthesizing inference trajectory data and interaction trajectory data, from single ability fine-tuning to multi-ability agent training.
[0019] Therefore, this invention can be widely applied in the fields of artificial intelligence and data science. Attached Figure Description
[0020] Various other advantages and benefits will become apparent to those skilled in the art upon reading the following detailed description of preferred embodiments. The accompanying drawings are for illustrative purposes only and are not intended to limit the invention. Throughout the drawings, the same reference numerals denote the same parts. In the drawings: Figure 1 This is a flowchart of a proxy-based training method for autonomous data science provided in an embodiment of the present invention; Figure 2 This is a flowchart illustrating the data base trajectory synthesis method provided in this embodiment of the invention; Figure 3 This is a flowchart illustrating the course-based agent-based training method provided in this embodiment of the invention. Figure 4 This is an overall interactive architecture diagram of the intelligent agent language large model and the interactive data analysis environment provided in this embodiment of the invention. Detailed Implementation
[0021] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. All other embodiments obtained by those skilled in the art based on the described embodiments of the present invention are within the scope of protection of the present invention.
[0022] It should be noted that the terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit the scope of exemplary embodiments according to the invention. As used herein, the singular form is intended to include the plural form as well, unless the context clearly indicates otherwise. Furthermore, it should be understood that when the terms "comprising" and / or "including" are used in this specification, they indicate the presence of features, steps, operations, devices, components, and / or combinations thereof.
[0023] In some embodiments of the present invention, a proxy-based training method for autonomous data science is provided. This method includes: constructing an interactive data analysis environment containing a code execution engine; implementing a training process based on a curriculum learning strategy, which is divided into a single-capability fine-tuning stage and a multi-capability proxy training stage. In the single-capability fine-tuning stage, keyword-guided synthetic inference trajectories are used to specifically enhance the reasoning and structured data understanding capabilities of the agent-based large language model. In the multi-capability proxy training stage, the agent-based large language model is placed in the interactive data analysis environment, and through reinforcement learning driven by a hybrid reward mechanism, the agent-based large language model learns to autonomously orchestrate closed-loop operations of analysis, encoding, execution, and feedback retrieval. This invention achieves adaptive optimization of the agent-based large language model for complex data tasks, enabling it to autonomously generate high-quality data science research reports end-to-end from raw data.
[0024] Correspondingly, in other embodiments of the present invention, a proxy training system, device, and medium for autonomous data science are provided.
[0025] Exemplary embodiments of the invention will now be described in more detail with reference to the accompanying drawings. While exemplary embodiments of the invention are shown in the drawings, it should be understood that the invention can be implemented in various forms and should not be limited to the embodiments set forth herein. Rather, these embodiments are provided to enable a more thorough understanding of the invention and to fully convey the scope of the invention to those skilled in the art.
[0026] Example 1 like Figure 1 As shown, this embodiment provides a proxy-based training method for autonomous data science, which includes the following steps: 1) Environment Setup: Build an interactive data analysis environment to provide user input interfaces, code execution engines, file systems, and feedback interfaces.
[0027] In this embodiment, the constructed interactive data analysis environment includes a user input interface, a code execution engine, a file system, and a feedback interface. The user input interface receives code instructions uploaded by the user for a specific open-ended data research task and at least one raw data source. The code execution engine, which can be a Python interpreter, executes the user-uploaded code instructions, processes the raw data source, and obtains the code execution results. The file system stores the user-uploaded raw data source and the code execution results. The feedback interface returns the code execution results to the user.
[0028] The original data source uploaded by the user can include data in any format, such as commonly used PDF, TXT, CSV, etc.
[0029] 2) Model training: Based on the interactive data analysis environment, a course learning strategy is adopted to adaptively optimize and train the user-initialized intelligent agent large language model in order to improve the autonomous analysis capability of the intelligent agent large language model.
[0030] like Figure 2 , Figure 3 As shown, the training of the agent-based large language model in this invention adopts a learning strategy from easy to difficult, mainly including two core stages: the first is the single-ability fine-tuning stage, the purpose of which is to solidify the basic capabilities of the agent-based large language model; the second is the multi-ability agent training stage, the purpose of which is to cultivate the comprehensive orchestration capabilities of the agent-based large language model. Before training, high-quality training data also needs to be obtained, mainly including inference trajectory synthesis and interaction trajectory synthesis.
[0031] Specifically, it includes the following steps: 2.1) Reasoning Trajectory Synthesis: Using a pre-set teacher model, with prompts containing mandatory guiding keywords and the original data source as input, synthetic data containing reasoning trajectories is generated.
[0032] In this embodiment, the synthetic data containing reasoning trajectories is generated through a keyword-guided mechanism. Specifically, using prompts with inserted mandatory guiding keywords and the original data source as input, a teacher model generates synthetic data containing reasoning trajectories, which serves as part of the model training dataset. The teacher model is implemented using a powerful independent large model, selected based on actual needs, to generate high-quality reasoning trajectory data offline. Mandatory guiding keywords trigger the teacher model to deeply examine and reflect on the structured data content in the original data source, thereby generating reasoning trajectories containing detailed data understanding processes. For example, when generating reasoning data using the teacher model, keywords such as "Wait a moment, let me check the data" are forcibly inserted. This forces the agent's large language model to calibrate its reasoning by "looking" at the data during the generation process, avoiding illusions.
[0033] 2.2) Interaction trajectory synthesis: Construct a multi-agent system, using the original data source as input, to generate successfully verified interaction trajectory data.
[0034] In this embodiment, a multi-agent system is used to verify the interaction trajectories formed based on the original data source. Only successfully verified interaction trajectories are retained as part of the model training dataset. Specifically, a multi-agent system is constructed, comprising a questioner agent, a solver agent, and a checker agent. The questioner agent generates an analysis task based on the original data source; the solver agent attempts to solve the analysis task and generates interaction trajectories; and the checker agent verifies the correctness of the interaction trajectories and includes the verified interaction trajectories as part of the model training dataset.
[0035] 2.3) Single capability fine-tuning: Initialize the agent's large language model and use synthetic data containing inference trajectories to perform supervised fine-tuning of the agent's large language model, so that it can master the ability to understand structured data and generate code.
[0036] In this embodiment, when initializing the agent's large language model, an open-source large language model can be used, such as Qwen3, but it is not limited to this.
[0037] By fine-tuning a single capability of the agent-based large language model, the model learned how to read table headers, how to perform long chain reasoning, and how to generate grammatically correct code.
[0038] 2.4) Multi-capability agent training stage: The fine-tuned agent large language model is placed into the interactive data analysis environment constructed in step 1), and agent-type training is performed using the model training dataset containing interaction trajectories to obtain the trained agent large language model.
[0039] In this embodiment, the intelligent agent large language model autonomously predicts action sequences based on the task requirements of the open data research task. The action sequences include analysis planning, code generation, and result feedback reading. The intelligent agent large language model is optimized through reinforcement learning algorithms, enabling it to learn to adaptively adjust subsequent actions based on environmental feedback until the data science task is completed.
[0040] Specifically, it includes the following steps: 2.4.1) Cold start: Based on the interaction trajectory data generated in step 2.2), the agent large language model obtained in step 2.3) is again supervised and fine-tuned to make the agent large language model familiar with the format and basic strategy of environmental interaction.
[0041] 2.4.2) Reinforcement learning: The agent large language model is placed into the interactive data analysis environment constructed in step 1), and reinforcement learning is performed in the real interactive data analysis environment using the original data source to obtain the trained agent large language model.
[0042] like Figure 4 As shown, the intelligent agent large language model interacts with the interactive data analysis environment by pre-setting specific work tokens. Specifically, it includes the following steps: ① Utilize the intelligent agent's large language model to generate analytical actions, and perform task decomposition and logical reasoning for a certain open data research task; ② Based on the task decomposition and logical reasoning results, the agent's large language model generates coded actions and writes code instructions for processing the original data source; ③ After receiving code instructions through the user input interface, the interactive data analysis environment triggers the execution action, executes the code instructions in the interactive data analysis environment, and returns the code execution result as feedback to the agent's large language model; ④ Based on the feedback results, a pre-set hybrid reward mechanism is used to evaluate the interaction process between the intelligent agent large language model and the interactive data analysis environment. The reward signal is calculated based on the evaluation results and used to update the parameters of the intelligent agent large language model, guiding the intelligent agent large language model to adaptively adjust subsequent actions until the data science task is completed, and the trained intelligent agent large language model is obtained.
[0043] In this embodiment, the hybrid reward mechanism includes: Format reward: Evaluate whether the model output conforms to the predefined action specifications. If the code reports an error, negative feedback is given; otherwise, positive feedback is given. Outcome reward: Evaluate the accuracy of the final result of the task. If the final answer is correct, give positive feedback; otherwise, give negative feedback. Process rewards: In open-ended tasks, a more powerful agent-based large language model is used as a judge to score the generated reports and interaction processes based on the dimensions of usefulness, interpretability, and effectiveness of interaction steps.
[0044] Through the reinforcement learning phase, the intelligent agent's large language model learns how to debug code when encountering errors, and how to dynamically adjust the analysis plan based on data characteristics.
[0045] This closed-loop mechanism ensures that the model can solve complex problems through a cycle of "trial and error-feedback-correction," just like human data scientists.
[0046] 3) Autonomous Reasoning: Load the trained intelligent agent large language model, receive the user's input of the original data source and the requirements of a certain open data research task, and generate a data science report through an autonomous iterative closed-loop process of analysis-encoding-execution-understanding.
[0047] In summary, this invention, through its unique course training architecture and agent-based interaction design, successfully automates the entire data science process, demonstrating significant technological advancements and application value.
[0048] Example 2 The above-described embodiment 1 provides a surrogate training method for autonomous data science. Correspondingly, this embodiment provides a surrogate training system for autonomous data science. The system provided in this embodiment can implement the surrogate training method for autonomous data science of embodiment 1. The system can be implemented through software, hardware, or a combination of both. For example, the system may include integrated or separate functional modules or units to execute the corresponding steps in the methods of embodiment 1. Since the system in this embodiment is basically similar to the method embodiment, the description process in this embodiment is relatively simple. Relevant details can be found in the description of embodiment 1. The system embodiment provided in this embodiment is merely illustrative.
[0049] The proxy-based training system for autonomous data science provided in this embodiment includes: The interactive environment building module is used to build an interactive data analysis environment to provide user input interfaces, data storage, code execution engines, and feedback interfaces; The model training module is used to adaptively optimize and train the user-initialized intelligent agent large language model based on an interactive data analysis environment and a course learning strategy, so as to improve the autonomous analysis capability of the intelligent agent large language model. The autonomous reasoning module is used to load the trained intelligent agent large language model, receive the raw data source input by the user and the requirements of a certain open data research task, and generate a data science report through an autonomous iterative execution of a closed-loop process of orchestration analysis-encoding-execution-feedback.
[0050] Furthermore, the aforementioned autonomous reasoning module supports an active exploration mode, meaning that the model can autonomously decide to read specific files in the environment or generate new code for verification based on the current analysis results, without human intervention.
[0051] Example 3 This embodiment provides a processing device corresponding to the proxy-based training method for autonomous data science provided in Embodiment 1. The processing device can be a client-side processing device, such as a mobile phone, laptop, tablet computer, desktop computer, etc., to execute the method of Embodiment 1.
[0052] The processing device includes a processor, a memory, a communication interface, and a bus. The processor, memory, and communication interface are connected via the bus to enable communication between them. The memory stores a computer program that can run on the processor. When the processor runs the computer program, it executes the proxy training method for autonomous data science provided in Embodiment 1.
[0053] Preferably, the memory may be high-speed random access memory (RAM), and may also include non-volatile memory, such as at least one disk storage device.
[0054] Preferably, the processor can be any type of general-purpose processor such as a central processing unit (CPU) or a digital signal processor (DSP), and there is no limitation herein.
[0055] Example 4 The proxy training method for autonomous data science in Embodiment 1 can be specifically implemented as a computer program product. The computer program product may include a computer-readable storage medium on which computer-readable program instructions for executing the proxy training method for autonomous data science described in Embodiment 1 are loaded.
[0056] A computer-readable storage medium can be a tangible device that holds and stores instructions for use by an instruction execution device. A computer-readable storage medium can be, for example, but not limited to, an electrical storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any combination thereof.
[0057] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code. This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes. These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes. These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.
[0058] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and not to limit it. Although the present invention has been described in detail with reference to the above embodiments, those skilled in the art should understand that modifications or equivalent substitutions can still be made to the specific implementation of the present invention. Any modifications or equivalent substitutions that do not depart from the spirit and scope of the present invention should be covered within the scope of protection of the claims of the present invention.
Claims
1. A proxy-based training method for autonomous data science, characterized in that, include: Build an interactive data analysis environment; Based on an interactive data analysis environment, a course learning strategy is used to adaptively optimize and train the user-initialized intelligent agent large language model. The trained intelligent agent large language model is loaded, receives the raw data source input by the user and the requirements of a certain open data research task, and generates a data science report through a closed-loop process of orchestration analysis-encoding-execution-feedback through autonomous iteration.
2. The proxy training method for autonomous data science as described in claim 1, characterized in that, include: The interactive data analysis environment includes a user input interface, a code execution engine, a file system, and a feedback interface; The user input interface is used to receive code instructions uploaded by the user for a specific open data research task and at least one original data source; The code execution engine is used to execute user-uploaded code instructions, process the original data source, and obtain the code execution result; The file system is used to store the original data source uploaded by the user and the results of code execution; The feedback interface is used to return the code execution results to the user.
3. The proxy training method for autonomous data science as described in claim 1, characterized in that, include: The aforementioned interactive data analysis environment, employing a course-based learning strategy, adaptively optimizes and trains the user-initialized intelligent agent large language model, including: The agent's large language model is initialized, and then supervised fine-tuning is performed using synthetic data containing inference trajectories to enable it to understand structured data and generate code. The fine-tuned agent large language model is placed into the interactive data analysis environment, and surrogate training is performed using synthetic data containing interaction trajectories to obtain the trained agent large language model.
4. The proxy training method for autonomous data science as described in claim 3, characterized in that, include: The generation of synthetic data containing reasoning trajectories includes: using prompts with inserted mandatory guiding keywords and the original data source as input, and using a preset teacher model to generate synthetic data containing reasoning trajectories.
5. The proxy training method for autonomous data science as described in claim 3, characterized in that, include: The synthetic data containing the interaction trajectory is generated using a multi-agent system, which includes a questioner agent, a solver agent, and an inspector agent. The questioner agent generates an analysis task based on the original data source. The solver agent attempts to solve the analysis task and generates the interaction trajectory. The inspector agent verifies the correctness of the interaction trajectory and obtains the verified interaction trajectory.
6. The surrogate training method for autonomous data science as described in claim 3, characterized in that, include: The step of placing the fine-tuned agent-based large language model into the interactive data analysis environment and performing agent-based training using a model training dataset containing interaction trajectories to obtain the trained agent-based large language model includes: Based on the interaction trajectory data, the intelligent agent's large language model is further supervised and fine-tuned to familiarize it with the format and basic strategies of environmental interaction. By placing the intelligent agent large language model into an interactive data analysis environment and using the original data source to perform reinforcement learning in a real interactive data analysis environment, the trained intelligent agent large language model is obtained.
7. The surrogate training method for autonomous data science as described in claim 6, characterized in that, include: The process of placing the intelligent agent large language model into an interactive data analysis environment and performing reinforcement learning in a real interactive data analysis environment using the original data source to obtain the trained intelligent agent large language model includes: Using a large language model of an intelligent agent to generate analytical actions, we can perform task decomposition and logical reasoning on an open data research task. Based on the task breakdown and logical reasoning results, the agent's large language model generates coded actions and writes code instructions for processing the original data source. After receiving the code instruction, the interactive data analysis environment triggers the execution action, executes the code instruction in the interactive data analysis environment, and returns the code execution result as feedback to the agent's large language model; Based on the feedback results, a pre-set hybrid reward mechanism is used to evaluate the interaction process between the intelligent agent large language model and the interactive data analysis environment. The reward signal is calculated based on the evaluation results and used to update the parameters of the intelligent agent large language model. This guides the intelligent agent large language model to adaptively adjust subsequent actions until the data science task is completed, resulting in the trained intelligent agent large language model.
8. A proxy-based training system for autonomous data science, characterized in that, include: The interactive environment building module is used to build interactive data analysis environments; The model training module is used to adaptively optimize and train the user-initialized intelligent agent large language model based on an interactive data analysis environment and a course learning strategy. The autonomous reasoning module is used to load the trained intelligent agent large language model, receive the raw data source input by the user and the requirements of a certain open data research task, and generate a data science report through an autonomous iterative closed-loop process of analysis-encoding-execution-understanding.
9. A computer-readable storage medium for storing one or more programs, characterized in that, The one or more programs include instructions that, when executed by a computing device, cause the computing device to perform any of the methods described in claims 1 to 7.
10. A computing device, characterized in that, include: One or more processors and a memory, wherein the memory stores one or more programs and is configured to be executed by the one or more processors, the one or more programs including instructions for performing any of the methods described in claims 1 to 7.
