A social simulation method, device and electronic equipment for large-scale agents
By configuring a dedicated cognitive model based on human survey data and optimizing the event queue, the contradiction between cognitive realism and scale efficiency in multi-agent simulation is resolved, achieving high-fidelity billion-level intelligent agent simulation, which is suitable for social science research and policy simulation.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- BEIJING ZHONGGUANCUN UNIVERSITY
- Filing Date
- 2026-01-26
- Publication Date
- 2026-06-12
AI Technical Summary
Existing multi-agent simulation technologies struggle to balance cognitive realism with scalability, exhibiting computational redundancy and performance bottlenecks, and are unable to support simulation needs involving millions or even billions of agents.
By loading a proprietary cognitive model configuration based on human survey data, events are computed and processed in parallel on demand. Combined with event queues and a lightweight distillation model, inference request processing is optimized to achieve high-fidelity decision-making and efficient resource utilization.
It achieves a balance between high cognitive realism and acceptable computational cost at the scale of billions of intelligent agents, improves simulation coherence and result credibility, and is suitable for social science research and policy simulation.
Smart Images
Figure CN122198786A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of social science and technology, and in particular to a social simulation method, apparatus, and electronic device for large-scale intelligent agents. Background Technology
[0002] In the current era of deep integration between artificial intelligence and computational social science, the digital simulation of social phenomena has become a core development direction for revealing the complex laws governing public opinion dissemination, market dynamics, and information cascading. The demand for full-scale social system simulation and large-scale group behavior prediction is increasingly urgent. The key to understanding how macro-social phenomena emerge from individual interactions lies in constructing a multi-agent simulation framework that combines massive scale, high cognitive realism, and efficient computing power. Multi-agent simulation technology, as the core support of this field, provides a quantifiable and reproducible research vehicle for social science research by simulating the interactive behavior of massive numbers of autonomous decision-making agents. Furthermore, the emergence of large-scale language models (LLMs) has broken through the limitations of traditional agent cognitive capabilities, laying the foundation for high-fidelity social simulation.
[0003] To achieve large-scale intelligent agent behavior simulation and interactive inference, existing multi-agent simulation technologies mainly include two types of solutions: First, traditional agent-based models (ABMs), which drive decision-making by pre-setting fixed rules, heuristic equations, or simple state machines for agents. Although they can support simulation deployments on a scale of millions, the agent behavior patterns are rigid and simplistic, resulting in a fundamental gap in cognitive realism. They cannot capture the complex abilities of human decision-making, such as context perception, learning reasoning, and situational adaptation, and are difficult to adapt to the ever-changing scenarios of real society. Second, a full-scale language model inference architecture based on synchronous time steps, which divides fixed time steps through a global main loop, polls all agents indiscriminately, independently calls the full LLM for each decision-making agent to perform inference, and then updates the state through a global synchronization point. Although this can endow agents with human-like cognitive abilities and improve behavioral fidelity, synchronous polling leads to idle computation of inactive agents, repeated inference requests for semantically equivalent requests causing resource waste, global synchronization points forming performance bottlenecks, and full LLM calls incurring high computational costs. Ultimately, this results in a lack of system scalability, making it unable to support the simulation needs of millions or even billions of agents.
[0004] Therefore, how to overcome the core bottlenecks in multi-agent simulation, such as the difficulty in balancing cognitive realism and scalability, severe computational redundancy, prominent performance bottlenecks, and high costs, is an urgent problem for those skilled in the art. Summary of the Invention
[0005] The purpose of this application is to provide at least one social simulation method, apparatus, and electronic device for large-scale intelligent agents, which can achieve a balance between a scale of billions of intelligent agents, high cognitive realism, and acceptable computational cost.
[0006] To address the aforementioned technical problems, at least one embodiment of this application provides a social simulation method for large-scale intelligent agents, comprising: Each intelligent agent is loaded, and the corresponding cognitive model configuration is matched according to the profile of the intelligent agent; the intelligent agent is generated by converting natural language descriptions for each structured survey record in human survey data; Extract the currently pending event from the event queue, update the corresponding target agent state and / or environment state according to the event payload, trigger the perception operation of the affected agent, and collect the context information after the perception operation; Based on the context information, an initial large-scale language model inference request is generated, and the inference model is invoked to execute the inference request based on the cognitive model configuration corresponding to the affected agent, so as to obtain the agent's decision. The agent's decision is transformed into a new event and added to the event queue; The final states of each agent and the environment are obtained for analysis based on the agent states and the environment states.
[0007] In one embodiment, retrieving the currently pending event from the event queue includes: The events in the event queue are sorted using a priority min-heap, and the earliest single event or a batch of events consisting of multiple adjacent events is extracted in timestamp order; wherein, the timestamp is set according to the simulation execution time of the event.
[0008] In one embodiment, between retrieving the currently pending event from the event queue and updating the corresponding target agent state and / or environment state based on the event's payload, the method further includes: If the extracted data is an event batch, compare the trigger identifier, target object identifier, and event type of each event in the event batch, and merge events with semantic overlap or consistent target.
[0009] In one embodiment, updating the corresponding target agent state and / or environment state based on the payload of the event includes: If the extracted data is an event batch, a causal dependency graph of the events is constructed. Based on the causal dependency graph, the precondition associations between each event in the event batch are analyzed. Events without causal dependency are assigned to different task groups, and events with causal dependency are assigned to the same task group. Parse the payload of the events in each of the task groups; the payload includes the triggerer identifier, the target object identifier, the event type, and specific parameters; Adjust the corresponding target agent state and / or environment state according to the load; If the extracted data is an event, treat the event as an independent task group.
[0010] In one embodiment, before the invocation inference model executes the inference request based on the cognitive model configuration corresponding to the affected agent, the method further includes: The inference request is converted into a vector representation to obtain the request vector; Search the historical request vector library and calculate the similarity between the request vector and each historical request vector; If the similarity reaches a preset threshold, the historical inference result corresponding to the historical request vector is returned directly, the current inference model call process is terminated, and the step of converting the agent's decision into a new event and adding it to the event queue is executed. If the similarity does not reach the preset threshold, then the step of calling the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent is performed.
[0011] In one embodiment, if the similarity does not reach the preset threshold, before executing the step of calling the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent, the method further includes: Determine whether the cumulative frequency of the task corresponding to the inference request within a preset statistical period exceeds a frequency threshold and meets the low complexity judgment condition; If the cumulative frequency of occurrence exceeds the frequency threshold within a preset statistical period and meets the real-time low complexity judgment condition, the inference request is passed to the lightweight distillation model for execution; the lightweight distillation model is a lightweight student model trained by knowledge distillation technology based on a large language model.
[0012] In one embodiment, matching the corresponding cognitive model configuration based on the agent's profile includes: Analyze the demographic, sociological, and psychological characteristics in the aforementioned agent profile as survey features; The cognitive complexity of the agent is quantitatively evaluated based on the survey features, and a complexity score is generated. If the complexity score does not exceed the complexity threshold, the matching cognitive pattern is determined based on the survey characteristics, and the enhanced prompt words corresponding to the matching cognitive pattern are used as the cognitive model configuration. If the complexity score exceeds the complexity threshold, a corresponding dedicated cognitive model is generated using efficient parameter fine-tuning technology; the dedicated cognitive model is bound to the group identifier of the corresponding intelligent agent.
[0013] In one embodiment, the invocation of the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent includes: Obtain a pre-built set of heterogeneous models; the set of heterogeneous models includes ultra-large models, medium-sized models, general-purpose lightweight models, and dedicated cognitive models, as well as benchmark data recording the inference accuracy, response speed and resource consumption of each model; Real-time monitoring of the load status of each model in the heterogeneous model set; Based on the complexity score of the affected agent, the system's preset quality requirements, and the load status, a matching model is determined from the heterogeneous model set to execute the inference request.
[0014] At least one embodiment of this application also provides a social simulation apparatus for large-scale intelligent agents, comprising: The intelligent agent cognitive configuration unit is used to load each intelligent agent and match the corresponding cognitive model configuration according to the profile of the intelligent agent; the intelligent agent generates the model by converting natural language descriptions for each structured survey record in the human survey data. An event extraction unit is used to extract the currently pending event from the event queue, update the corresponding target agent state and / or environment state according to the event payload, so as to trigger the perception operation of the affected agent and collect the context information after the perception operation. The decision generation unit is used to generate an initial large-scale language model inference request based on the context information, and call the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent, so as to obtain the agent's decision. A queue management unit is used to convert the agent's decision into a new event and add it to the event queue; The data analysis unit is used to obtain the final state of each agent and the state of the environment, so as to perform analysis based on the state of the agents and the state of the environment.
[0015] At least one embodiment of this application also provides an electronic device, including: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the above-described social simulation method for large-scale intelligent agents.
[0016] The social simulation method for large-scale intelligent agents provided in this application generates intelligent agents based on real human survey data and matches them with dedicated cognitive model configurations, ensuring the human-like characteristics and cognitive diversity of the intelligent agents from the source. It extracts events to be executed sequentially through an event queue and accurately updates the target state, activating only affected intelligent agents to perform perception operations, achieving on-demand computation and eliminating the computational idleness and resource waste of synchronous time-step architectures. It generates inference requests based on complete context and executes inference in conjunction with dedicated cognitive model configurations, ensuring that the intelligent agent's decisions are both consistent with the scenario logic and its own attributes, achieving high-fidelity human-like decision-making. It transforms decisions into new events and puts them back into the queue, constructing a cyclical driving mechanism of event-decision-new event, improving the simulation coherence in large-scale scenarios. Finally, it collects complete global states for analysis, enabling the simulation results to spontaneously emerge from real social phenomena and be verified against real-world data, ensuring the credibility of the results and providing high-value references for social science research, policy simulation, and other scenarios. It successfully achieves a synergistic unity of scalability on a billion-scale scale, high cognitive realism, and acceptable computational cost. Attached Figure Description
[0017] One or more embodiments are illustrated by way of example with reference to the accompanying drawings, and these illustrative descriptions do not constitute a limitation on the embodiments.
[0018] Figure 1 This is a flowchart of a social simulation method for large-scale intelligent agents provided in one embodiment of this application; Figure 2 This is a schematic diagram of a social simulation device for large-scale intelligent agents provided in one embodiment of this application; Figure 3 This is a schematic diagram of the structure of an electronic device provided in one embodiment of this application. Detailed Implementation
[0019] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the various embodiments of this application will be described in detail below with reference to the accompanying drawings. However, those skilled in the art will understand that many technical details have been provided in the various embodiments of this application to help readers better understand this application. However, the technical solutions claimed in this application can be implemented even without these technical details and various changes and modifications based on the following embodiments. The division of the various embodiments below is for the convenience of description and should not constitute any limitation on the specific implementation of this application. The various embodiments can be combined with and referenced by each other without contradiction.
[0020] The following is a detailed description of the implementation details of the social simulation method for large-scale intelligent agents in this embodiment. The following content is only for the convenience of understanding and is not necessary for implementing this solution.
[0021] Example 1: The specific process of the social simulation method for large-scale intelligent agents in this embodiment can be as follows: Figure 1 As shown, it includes: Step 101: Load each agent and match the corresponding cognitive model configuration according to the agent's profile.
[0022] Load human survey data containing dimensions such as demographics, sociology, and psychology, and extract the structured records for each individual (such as core features like age, education level, income level, and trust level) from each data point; through natural language conversion technology, transform these discrete structured data into complete and coherent natural language description text, i.e., intelligent agents. The intelligent agents completely replicate the key features of real individuals, making them simulated subjects that can be recognized by reasoning models.
[0023] For each generated agent, a suitable cognitive model configuration is selected based on its profile. The matching process focuses on key features in the profile that reflect an individual's cognitive abilities and decision-making tendencies, such as the depth of reasoning reflected in education level and the decision-making style reflected in personality traits. This ensures that the cognitive model configuration is highly consistent with the agent's identity attributes, forming a binding relationship between an agent (or a group of similar individuals) and a set of exclusive cognitive logic.
[0024] Traditional solutions often use preset rules or uniform models to generate intelligent agents, failing to reproduce the individual differences of real humans, leading to simulation results that deviate from reality. This step generates intelligent agents based on real human survey data, ensuring the authenticity of the simulated subject's characteristics. Furthermore, existing technologies often configure all intelligent agents with the same model, ignoring the cognitive diversity of human society. This step, through profile matching and customized cognitive model configuration, enables intelligent agents with different characteristics to possess differentiated decision-making logic, aligning with the cognitive distribution of real society. The binding between the intelligent agent and the cognitive model configuration provides a logical basis for subsequent event response and reasoning decisions, ensuring that the agent's behavior always conforms to its preset characteristics and avoiding a disconnect between decision-making and identity attributes.
[0025] Step 102: Extract the currently pending event from the event queue, update the corresponding target agent state and / or environment state according to the event payload, so as to trigger the perception operation of the affected agent and collect the context information after the perception operation.
[0026] From the event queue storing all pending trigger signals, the event that needs to be executed is selected in a predetermined order to ensure the rationality of the event processing sequence; the payload carried by the event is parsed. The event payload refers to a structured data set that carries the core execution logic and impact information of the event, and its contents include, but are not limited to, the triggerer identifier, the target object identifier, the event type, and the specific execution parameters.
[0027] Based on the payload content, the state of the target agent (such as attributes, relationships, resources, etc.) and / or the state of the environment (such as global parameters, rules, resource supply, etc.) are modified in a targeted manner. The target state is updated according to the payload of the event, avoiding indiscriminate modifications. This ensures that state changes have a clear basis, improving the realism and credibility of the simulation. Specifically, whether the state data of the target agent, the state data of the environment, or both are modified depends on the explicit target object identifier and event type definition in the event payload. If the target object identifier of the payload points to a specific agent (or multiple agents), and the event type is individual interaction or state change (such as cooperation invitation, trust adjustment, resource transfer), then the state data of the target agent is mainly modified. If the target object identifier of the payload points to the global environment, and the event type is macro-control or rule change (such as policy release, economic coefficient adjustment, changes in public resource supply), then the state data of the environment is mainly modified. If the payload contains both agent and environment identifiers, and the event type is a linkage effect (such as an agent releasing an industry standard, updating both the agent's industry influence state and the environment's industry rule parameters), then the state data of both the target agent and the environment are modified simultaneously. In this embodiment, the object to be modified is not limited, and corresponding modifications can be performed according to the event payload configuration.
[0028] The target agent refers to the individual or group of agents explicitly specified in the event payload that are directly affected by the event. For example, if the event is that agent A sends an invitation to agents B and C to cooperate on a new energy project, then agents B and C, whose target objects are identified in the payload, are the target agents for this event. This step only triggers the perception operations of the affected target agents, without activating irrelevant agents, thus avoiding resource waste and improving system efficiency.
[0029] After the event status is updated, the agents directly or indirectly affected by the event are automatically activated, triggering their perception operations, even if the agents have the ability to perceive changes in themselves or their surroundings. The agents obtain four types of key information through perception: their current status (updated attribute data), the real-time status of the environment (adjusted global parameters), the core details of the event (execution logic and scope of influence in the payload), and the relevant status of associated agents (such as the resource status and cognitive tendencies of interactive objects). In this embodiment, the types of information obtained are not limited, and only the above four main types of information are introduced as examples. These scattered information are integrated into structured context data to complete the collection of decision inputs.
[0030] Step 103: Generate an initial large-scale language model inference request based on contextual information, and call the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent to obtain the agent's decision.
[0031] Based on the contextual information collected in step 102, an initial large-scale language model inference request is constructed. This transforms scattered scene data into decision-oriented instructions that the model can understand. For example, if the context is agent A with 500 resources, a market subsidy policy with a subsidy ratio of 10%, and agent B issuing a cooperation invitation, the inference request can be constructed as follows: combining your current resource quantity of 500, the 10% market subsidy policy, and agent B's cooperation invitation, determine whether to accept the cooperation, and if so, specify the cooperation method. The inference request must completely cover the key information of the context, without omissions or redundancy, ensuring that the model can accurately understand the decision-making scenario and core needs.
[0032] The inference model is started, and the cognitive model configuration matched for the affected agent in step 101 is used as the inference constraint. The model is driven to execute the above inference request to ensure that the inference process is both in line with the scenario and in line with the cognitive characteristics of the agent, thus avoiding blind decision-making.
[0033] Extracting the core output after the inference model is executed yields the agent's decision, which is the agent's specific behavioral choice for the current scenario. This includes, but is not limited to, the agent's behavior (affected agent ID), the target of action (such as a partner or the environment), the behavior type (such as accepting cooperation, rejecting an invitation, or adjusting resource allocation), and the execution parameters (such as the cooperation period and the proportion of resource input). This provides the core basis for generating new events in the future.
[0034] Step 104: Transform the agent's decision into a new event and add it to the event queue.
[0035] Taking the decisions of the acquired agents as input, the abstract decision conclusions (such as accepting cooperation, issuing policies, and adjusting pricing) are transformed into new events that the system can recognize and execute.
[0036] For example, the original intelligent agent decision: Intelligent agent A (ID: A001) accepts the invitation of intelligent agent B (ID: B003) to cooperate on a new energy project, and invests 300 resources in stages, with 100 invested in the first stage and the remaining 200 invested in two equal installments, with a cooperation period of 2 years.
[0037] The transformed new events include: Event ID: EVT-2025001 (Unique Identifier) Trigger identifier: A001 (the agent that made the decision) Target object identifier: B003 (cooperative intelligent agent) Event Type: Cooperation Confirmation (Clear Behavioral Attributes) Execution parameters: Cooperation project = New energy project, Cooperation period = 2 years, Total investment resources = 300, Phased investment plan = Phase 1: 100 (immediately), Phase 6: 100, Phase 12: 100, Cooperation performance requirements = Project progress is synchronized quarterly. Timestamp: T10 (Current simulation logic time, to be executed immediately) Priority: Medium (regular business cooperation).
[0038] It should be noted that events are the core driving force of simulation and must contain clear execution logic and impact information. However, this embodiment does not limit the specific information items included. Taking the above information as an example, it can be configured according to actual needs, which will not be elaborated here.
[0039] The transformed new events are added to the event queue, becoming pending trigger signals that await subsequent sequential execution. This ensures that the impact of the decision continuously drives the simulation's evolution. The event queue serves as a unified storage and scheduling center for all trigger signals. Adding new events to the queue, rather than executing them directly, ensures that all events are processed in an orderly manner, avoiding simulation logic conflicts caused by disordered decision execution order. For example, executing resource consumption decisions before resource acquisition decisions can lead to state contradictions. Furthermore, agent decisions often trigger chain reactions. For instance, agent A accepting a cooperative decision may trigger agent B's resource allocation decision and updates to the cooperative relationship network of the environment. Transforming decisions into new events and queuing them ensures that the impact of the decision is transmitted sequentially to relevant objects, recreating the causal logic of a decision triggering a series of interactions in real society.
[0040] Step 105: Obtain the final states of each agent and the environment, and perform analysis based on the agent states and the environment.
[0041] When the simulation reaches the termination condition, the final state data of each agent and the final state data of the environment are collected so that the simulation results can be analyzed based on the collected data of each agent state and the environmental state data, so as to extract social phenomena and verify the value of the simulation.
[0042] The data used to obtain the final state of each agent includes, but is not limited to, demographic characteristics (such as age and education level), dynamic evolution status (such as changes in cognitive attitudes and trust levels), social relationship networks (such as partners and the strength of associations), and resource accumulation (such as wealth, authority, and material reserves). The data used to obtain the final environmental state includes, but is not limited to, macroeconomic indicators (such as inflation rate and market interest rate), policy implementation results (such as the coverage of subsidies and the proportion of qualified enterprises), resource supply status (such as the surplus of public resources and energy reserves), and overall social atmosphere (such as public opinion and cooperation rate).
[0043] The termination conditions are not limited in this embodiment. For example, the simulation is terminated when the event queue is empty (no new events can drive the simulation to continue) or when the preset maximum simulation time is reached.
[0044] Based on the above introduction, the social simulation method for large-scale intelligent agents provided in this embodiment generates intelligent agents based on real human survey data and matches them with dedicated cognitive model configurations, ensuring the human-like characteristics and cognitive diversity of the intelligent agents from the source; by extracting events to be executed sequentially through an event queue and accurately updating the target state, only the affected intelligent agents are activated to carry out perception operations, realizing on-demand computing and eliminating the computational idleness and resource waste of synchronous time-step architecture; by generating inference requests based on complete context and combining them with dedicated cognitive model configurations to execute inference, it ensures that the intelligent agent's decisions are both consistent with the scenario logic and its own attributes, achieving high-fidelity human-like decision-making; by converting decisions into new events and returning them to the queue, a cyclical driving mechanism of event-decision-new event is constructed, improving the simulation coherence in large-scale scenarios; finally, by collecting complete global states for analysis, the simulation results can spontaneously emerge real social phenomena and can be benchmarked and verified with real-world data, ensuring the credibility of the results and providing high-value references for social science research, policy simulation, and other scenarios, successfully achieving a synergistic unity of scalability on a scale of billions, high cognitive realism, and acceptable computational cost.
[0045] Example 2: In the event-driven architecture of large-scale intelligent agent social simulation, the traditional synchronous time step architecture suffers from timing chaos and low efficiency due to indiscriminate polling and global synchronization, which are the core technical pain points. As the core driving carrier of simulation evolution, the event queue, through its event sorting and extraction methods, directly determines the timing consistency, parallel processing efficiency, and rationality of resource utilization in the simulation.
[0046] The above embodiments do not limit the specific sorting rules and extraction methods in the event queue. In order to solve the problem of orderly scheduling of multiple events in the event queue and avoid the conflict between the agent state and the environment state caused by the disorder of event processing order, this embodiment proposes an event scheduling mechanism. Step 102 extracts the event to be executed from the event queue. Specifically, the events in the event queue can be sorted by priority min-heap, and the earliest single event or a batch of events composed of multiple adjacent events can be extracted according to the timestamp order. The timestamp is set according to the simulation execution time of the event.
[0047] The event queue is constructed as a minimum priority heap, with each event as a node in the heap. The heap's sorting weight is uniquely bound to the event's timestamp, following the rule that smaller timestamps have higher priority. That is, events that need to be executed first in the simulation have a higher priority position in the heap. When a new event is enqueued (such as the new event transformed in step 104) or an old event is dequeued (after the event is extracted in this step), the heap structure is automatically adjusted and quickly reconstructed through heapification operations, ensuring that the top of the heap is always the event with the smallest current timestamp that needs to be executed first, without the need for manual intervention in sorting.
[0048] The timestamps of all events are bound to the simulation timeline when they are generated (e.g., execution immediately corresponds to the current simulation logic time, and execution delayed by 3 simulation units corresponds to the current time + 3). The sorting process is based solely on the timestamps and does not introduce other variables, ensuring the objectivity of the sorting results.
[0049] A time window threshold is set, with a very small preset time window (e.g., ±0.1 simulation units) to determine whether events are adjacent. This threshold only applies to timestamp judgment and does not involve other technical logic. First, the timestamp of the top event is checked, then compared with the timestamps of the immediately following events: if the timestamps of subsequent events fall within the preset time window, these events are popped from the heap together to form an event batch; if the timestamps of subsequent events exceed the window, only the top event is popped. After event extraction is complete, the remaining events are automatically re-heapened, maintaining the characteristic that the top event is the next earliest event, ensuring that subsequent extraction operations can still be executed efficiently and orderly.
[0050] When an event is generated, a timestamp is assigned according to its preset simulation execution plan. For example, for an event that responds immediately to a collaboration invitation, the timestamp is set to the current simulation logic time; for an event that re-evaluates collaboration after 3 months, the timestamp is set to the current simulation time + 3 months (converted according to the simulation time unit).
[0051] The core operation of the priority min-heap has low time complexity. Even if there are millions or even billions of events in the event queue, it can still quickly complete the sorting and extraction, avoiding the sorting process from slowing down the overall simulation speed. At the same time, the timestamp is strictly bound to the simulation execution time, and the sorting logic completely follows the simulation timeline. The order of event processing is consistent with the cause-and-effect time sequence in real society, which can reduce the distortion of simulation results caused by time sequence disorder.
[0052] Event batches may contain causally dependent events with preconditions (e.g., resource injection events must be executed before resource consumption events). Directly processing all events within a batch in parallel may cause logical conflicts in the target agent or environment state. To resolve these conflicts and maximize the parallel computing power of the distributed execution engine while ensuring simulation timing consistency and processing efficiency, this embodiment proposes a method for updating the corresponding target agent state and / or environment state based on the event payload. Specifically, if the extracted event batch is a causal dependency graph, the preconditions between events within the batch are analyzed based on the graph. Events without causal dependencies are assigned to different task groups, while events with causal dependencies are assigned to the same task group. The payloads of events in each task group are parsed; the payloads include the trigger identifier, target object identifier, event type, and specific parameters. The corresponding target agent state and / or environment state are adjusted based on the payloads. If the extracted event is an individual event, it is treated as an independent task group.
[0053] If the extracted events are in batches, a causal dependency graph is first constructed to systematically analyze the preconditions of each event within the batch, clarifying whether the execution of one event depends on the completion of another. Then, task groups are formed based on these relationships: events without causal dependencies are grouped into different task groups (which can be executed independently and in parallel), while events with causal dependencies are grouped into the same task group (which must be executed sequentially according to the preconditions). Subsequently, the payloads of events in each task group are analyzed one by one (the payloads contain four core pieces of information: trigger identifier, target object identifier, event type, and specific parameters). Finally, based on the clearly defined target object and execution rules of the payloads, the corresponding target agent state (such as attributes, resources, relationships, etc.) and / or environmental state (such as global parameters, policy rules, resource supply, etc.) are precisely adjusted. If a single event is extracted, it is directly treated as an independent task group, skipping the causal dependency analysis and grouping steps, and directly performing payload analysis and state update operations.
[0054] This method analyzes the preconditions through causal dependency graph analysis, ensuring that dependent events are executed in the order of cause and effect, completely avoiding conflicts in the target agent or environment state caused by disordered processing, and improving the credibility of simulation results. At the same time, this method divides events without causal dependencies into different task groups, which can fully adapt to the computing power of the distributed execution engine and realize the synchronous parallel processing of multiple task groups. Compared with the mode of executing individual events one by one, it significantly reduces the overall processing time of event batches, especially suitable for the processing needs of high-frequency and massive events in simulations of billions of agents.
[0055] Furthermore, an event batch may contain multiple events with the same trigger identifier, target object identifier, event type, or consistent objective. Repeated execution of such events leads to redundant updates of the target agent or environment state, resulting in wasted computational resources and state logic conflicts. To further improve simulation efficiency and avoid redundant computation, the following steps can be performed between extracting the currently pending event from the event queue and updating the corresponding target agent state and / or environment state based on the event's payload: If the extracted event is a batch, compare the trigger identifier, target object identifier, and event type of each event in the batch, and merge events with semantic overlap or consistent objective.
[0056] The extracted event batches are broken down into independent individual events. Each event contains three core fields: trigger identifier, target object identifier, and event type. All events within the batch are traversed sequentially, and the three identifiers of any two events are precisely compared. Trigger ID comparison: Determine whether the subject initiating the event is consistent (such as whether the agent ID and environment module ID are completely identical). Target object identification comparison: Determine whether the objects affected by the event are consistent (such as the same agent ID, the same environment global identifier, or the same group identifier). Event type comparison: Determine whether the behavioral attributes of the events are consistent (e.g., both are of the same type, such as cooperation invitation, policy notification, resource transfer, etc.).
[0057] If two or more events have completely identical three identifiers, or if they are not completely identical but have equivalent core semantics (such as sending multiple cooperation invitations with the same conditions), they are marked as semantically duplicated events. If multiple events have completely identical target object identifiers and the event types belong to the same behavioral category (such as multiple resource replenishment events targeting the same agent), they are marked as events with consistent action targets. After integrating the core information of semantically duplicated or action target consistent events, the original multiple duplicate or same-target events are deleted, and only one integrated new event is retained. The merged event is then recombined with other unmarked events in the batch to form an optimized and streamlined event batch for subsequent state update operations.
[0058] In simulations involving billions of intelligent agents, event batches may contain a massive number of events of the same type or with the same objective. This method can quickly reduce the volume of events, ensuring that the system can still operate efficiently when processing large-scale event batches and avoiding system lag caused by event redundancy.
[0059] Example 3: A large number of intelligent agents will generate highly semantically equivalent reasoning requests in similar scenarios. If a complete reasoning model call is executed for each request, it will lead to serious semantic duplication, which will not only increase the amount of text processing and financial costs, but also consume computing resources due to repeated reasoning, forming an efficiency bottleneck.
[0060] Based on the above embodiments, in order to further optimize the efficiency and cost control of the inference process and overcome the waste of computing power and efficiency bottleneck caused by semantic repetitive calculation, this embodiment proposes a semantic prompt caching optimization method. By vectorizing the inference request and matching it with the historical request vector library, the historical inference results of semantically equivalent requests can be reused, which can significantly reduce redundant inference model calls. Under the premise of ensuring the consistency of inference results, the amount of text processing and financial costs are reduced, and the overall throughput of the system is improved.
[0061] Specifically, before step 103 executes the inference request based on the cognitive model configuration corresponding to the affected agent, the following steps can be further performed: Step 106: Convert the inference request into a vector representation to obtain the request vector; Step 107: Retrieve the historical request vector library and calculate the similarity between the request vector and each historical request vector; if the similarity reaches the preset threshold, directly return the historical inference result corresponding to the historical request vector, terminate the current inference model call process, execute step 104 to convert the agent's decision into a new event, and add it to the event queue; if the similarity does not reach the preset threshold, execute step 103 to call the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent.
[0062] Steps 106 and 107 will be described together here.
[0063] First, the initial large-scale language model inference request generated in step 103 is converted into a machine-recognizable vector representation, namely the request vector. This vector can accurately map the core semantics of the inference request, avoiding repeated recognition omissions due to differences in expression. Then, the system retrieves the pre-stored historical request vector library and calculates the matching degree between the current request vector and all historical request vectors in the library using a vector similarity algorithm (such as cosine similarity). The historical request vector library synchronously stores the corresponding historical inference results, ensuring that they can be directly reused after matching. Finally, it determines whether the cache is hit based on the preset similarity threshold. If the similarity reaches the threshold, it means that the current request and the historical request are highly semantically equivalent. There is no need to repeat the inference model call. The corresponding historical inference result is directly returned and the process jumps to step 104 to complete the transformation from decision to new event. If the threshold is not reached, it means that the current request is a completely new request or a request with significant semantic differences. The inference model call process in step 103 needs to be continued.
[0064] This method does not require modification of the core reasoning logic. It can intercept repeated reasoning requests and reuse historical valid results by pre-filtering at the semantic level without affecting the cognitive authenticity. This significantly reduces the frequency of calling the reasoning model and is especially suitable for high-frequency reasoning needs in similar scenarios of large-scale intelligent agents. It solves the problems of high cost and low efficiency caused by repeated semantic calculations.
[0065] It should be noted that in this embodiment, even if the inference request does not semantically overlap with the historical request (i.e., the cache is not hit), the handling method is not limited. The corresponding large-scale language model can be directly invoked to perform inference, ensuring the authenticity of the core cognition. To further optimize the resource allocation efficiency of the inference process and address the resource mismatch problem of high-frequency, low-complexity tasks consuming expensive computing power, this embodiment proposes a high-frequency, low-complexity task diversion optimization method. Through dual verification of frequency filtering and complexity determination, inference requests that meet the conditions are diverted to a lightweight distillation model for execution. This can significantly reduce computational costs and inference latency without sacrificing the fidelity of the inference results, further improving the throughput of large-scale simulations.
[0066] Specifically, if the similarity does not reach the preset threshold, step 107 may further perform the following steps before executing the step of calling the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent: Step 108: Determine whether the cumulative frequency of the task corresponding to the reasoning request within the preset statistical period exceeds the frequency threshold and meets the low complexity judgment condition. Step 109: If the cumulative frequency of occurrence exceeds the frequency threshold within the preset statistical period and meets the real-time low complexity judgment condition, the inference request is passed to the lightweight distillation model for execution; the lightweight distillation model is a lightweight student model trained by knowledge distillation technology with a large language model as the benchmark model.
[0067] Steps 108 and 109 will be described together here.
[0068] For inference requests that miss the cache, the system first makes a judgment from two dimensions: First, a statistical dimension, checking the cumulative frequency of the task corresponding to the request within a preset statistical period to determine if it reaches a preset frequency threshold (i.e., whether it belongs to a high-frequency repetitive task); second, a complexity dimension, evaluating the cognitive complexity of the task through a semantic analysis unit to determine if it meets the low complexity criteria (e.g., no complex logical deduction required, no creative decision-making needs). If both criteria are met, the task is considered a high-frequency, low-complexity type, and does not require the computationally expensive resources of a large language model. It is then passed to a lightweight distillation model for execution. This model uses the corresponding large language model as a benchmark (teacher model), inherits the core decision-making logic of the benchmark model through knowledge distillation technology, and has the advantages of small size, fast inference speed, and low resource consumption, accurately matching the processing needs of this type of task.
[0069] In addition, if the cumulative frequency of occurrence within the preset statistical period does not exceed the frequency threshold, or does not meet the real-time low complexity judgment condition, this embodiment does not limit the processing method in this case. For example, it can directly call the large language model (or its dedicated cognitive model configuration) corresponding to the affected agent to perform inference, ensuring the cognitive authenticity of complex tasks and low-frequency tasks; or it can be routed to the adaptation model (such as a medium-sized model) in the heterogeneous model pool to achieve a flexible balance between cost and fidelity.
[0070] Example 4: In large-scale agent-based social simulations, the accuracy of cognitive model configuration directly determines the human-like realism of agent behavior. However, existing technologies suffer from core challenges: traditional solutions either employ a one-size-fits-all uniform model, ignoring the cognitive diversity arising from demographic, sociological, and psychological differences in human society, or incur exorbitant computational costs in pursuit of personalization. To ensure accurate matching between cognitive model configuration and agent characteristics, and to resolve the contradiction between homogeneous cognitive modeling and high-cost personalization, this embodiment proposes a hierarchical adaptation method for cognitive model configuration. By analyzing the multi-dimensional core features of the agent profile, quantitatively assessing its cognitive complexity, and matching the adapted cognitive model configuration hierarchically based on the scoring results, this approach can guarantee accurate matching between the cognitive model and agent characteristics, restore cognitive diversity, and control computational costs through a low-cost configuration scheme and a group model reuse mechanism.
[0071] Specifically, step 102, which matches the corresponding cognitive model configuration based on the agent's profile, can be performed according to the following steps: Step 21: Analyze the demographic, sociological, and psychological characteristics in the agent profile as survey features.
[0072] The intelligent agent profile is analyzed in a structured manner, focusing on three key features: demographic features (such as age, gender, education level, occupation, etc., which are attributes based on objective statistics), sociological features (such as subjective social class, income level, social network size, group affiliation, etc., which reflect social relations and status), and psychological features (such as trust in strangers, risk tolerance, decision-making preferences, value orientation, etc., which are intrinsic psychological traits). In the end, a complete and quantifiable set of survey features is formed.
[0073] Step 22: Quantitatively evaluate the cognitive complexity of the agent based on the survey features and generate a complexity score.
[0074] By employing pre-defined weighting rules, such as assigning higher weights to features like education level and career cognitive needs, and assigning appropriate weights to basic demographic features, the three types of survey features are numerically transformed and comprehensively calculated to ultimately generate a single-dimensional complexity score. This score directly reflects the cognitive ability level required by the agent; for example, higher scores correspond to higher education levels, high-risk decision-making needs, and complex social networks, while lower scores correspond to lower education levels and simple decision-making scenarios.
[0075] Step 23: If the complexity score does not exceed the complexity threshold, determine the matching cognitive pattern based on the survey characteristics, and use the enhanced prompt words corresponding to the matching cognitive pattern as the cognitive model configuration.
[0076] If the complexity score does not exceed a preset threshold, meaning the agent does not require complex logical deduction or deep thinking ability, the corresponding cognitive pattern is matched based on the survey features extracted in step 21. This includes behavioral logic that aligns with the agent's characteristics, such as risk-averse, intuitive decision-making, or short-term benefit-oriented approaches. This cognitive pattern is then transformed into standardized enhanced prompts. These prompts contain descriptions of the agent's core characteristics, inference depth constraints (e.g., quick response based on intuition, prioritizing immediate gains), and specific cognitive biases, which can be directly used as the cognitive model configuration. For example, if the cognitive pattern is risk-averse, a corresponding enhanced prompt might be: "You are a 45-year-old ordinary employee with a college diploma, a monthly income of 6000 yuan, a middle-class social class, low trust in strangers, and weak risk tolerance. When making decisions, you need to respond quickly based on intuition, prioritize avoiding any possible losses, and avoid behaviors without clear guarantees; you exhibit loss-averse cognitive biases, are overly sensitive to potential risks, underestimate the possibility of low-probability gains, and only choose certain short-term safety options."
[0077] Step 24: If the complexity score exceeds the complexity threshold, use the parameter efficient fine-tuning technique to generate the corresponding exclusive cognitive model.
[0078] If the complexity score exceeds the preset threshold, meaning the agent needs complex ethical judgments, long-chain logical deductions, or deep contextual awareness, a parameter-efficient fine-tuning technique is used (only a few key parameters of the model are fine-tuned, rather than all parameters). Based on typical interaction data of this type of agent group, a dedicated cognitive model is trained and generated. This model inherits the core capabilities of the benchmark large language model, while solidifying the cognitive logic and decision preferences that conform to its survey characteristics.
[0079] Then, the exclusive cognitive model is bound to the group identifier of the corresponding intelligent agent, instead of modeling an individual intelligent agent independently, to realize a reuse mechanism for multiple intelligent agents to share an exclusive model.
[0080] This configuration method ensures high fidelity and personalization in decision-making for highly complex intelligent agents, while avoiding the high cost of full-scale model training through efficient parameter fine-tuning and group reuse. It can adapt to the personalized cognitive modeling needs of a billion-scale intelligent agent.
[0081] It should be noted that the generated enhanced prompts or customized cognitive models will be stored in the model registry. When the simulation's main loop triggers a decision event, the system can directly call these generated customized models for calculation.
[0082] Example 5: Agents with different cognitive complexities and their reasoning tasks have significantly different requirements for model reasoning accuracy, response speed, and resource consumption. In order to further improve the accuracy of reasoning resource allocation and the overall system operating efficiency, and to balance computational cost and decision fidelity, this embodiment proposes a heterogeneous model dynamic routing method. Based on the complexity score calculated in Embodiment 4, by integrating the benchmark data of the heterogeneous model set and the real-time load status for multi-dimensional matching, the optimal model resources can be accurately allocated for reasoning tasks with different requirements, while ensuring high fidelity of key decisions and minimizing overall computational overhead.
[0083] Specifically, step 103, which calls the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent, can be performed according to the following steps: Step 31: Obtain the pre-built set of heterogeneous models.
[0084] The system invokes a pre-built collection of heterogeneous models, which consists of two core components: First, a multi-type inference model, encompassing ultra-large models (adapted to high-complexity, high-fidelity decision-making needs), medium-sized models (adapted to medium-complexity routine tasks), general-purpose lightweight models (adapted to low-complexity, fast-response tasks), and dedicated cognitive models (fine-tuned models customized for specific high-complexity intelligent agent groups), forming a model matrix covering all complexity scenarios; Second, supporting benchmark data, which records the core performance indicators of each model in detail, such as inference accuracy (the degree to which the decision result matches real human behavior), response speed (the time taken to complete one inference), and resource consumption (the cost of computing power, storage, etc.), ensuring that the features of each model are quantifiable.
[0085] Step 32: Monitor the load status of each model in the heterogeneous model set in real time.
[0086] The system's built-in load monitoring mechanism is activated to collect and update the running status of each model in the collection in real time. The core dimensions of monitoring may include, but are not limited to: the length of the inference task queue currently being processed, CPU / GPU computing power utilization, memory utilization, response latency fluctuations, etc., ultimately forming a real-time load profile of each model, such as a super-large model: high load (15 task queues, computing power utilization of 85%), and a general lightweight model: low load (2 task queues, computing power utilization of 30%).
[0087] The monitoring process is continuous and real-time, ensuring that the latest model load data is obtained before each routing decision, so as to avoid assigning new tasks to overloaded models.
[0088] Step 33: Based on the complexity score of the affected agent, the system's preset quality requirements, and the load status, determine the matching model from the heterogeneous model set to execute the inference request.
[0089] Based on the complexity score of the affected agent (low score corresponds to low complexity task, high score corresponds to high complexity task), the type range of suitable models is initially defined (e.g., low-scoring tasks exclude very large models, and high-scoring tasks exclude general lightweight models); secondly, combined with the system's preset quality requirements (e.g., policy decision-making tasks require inference accuracy ≥90%, and regular interactive tasks require response speed ≤0.5 seconds), the range of model selection is further narrowed to ensure that the model performance meets the core requirements of the task; finally, referring to the real-time load status obtained in step 32, the model with the lowest load and the most efficient resource utilization is selected from the candidate models, and the model to execute the current inference request is finally determined and the call is initiated.
[0090] By making comprehensive decisions across multiple dimensions, we can ensure the inference fidelity of high-complexity tasks, reduce the computational cost of low-complexity tasks, balance the load pressure of the entire model set, and maximize the overall inference throughput and resource utilization of the system.
[0091] It should be noted that this embodiment only determines the order based on complexity score, system preset quality requirements, and load state model, but it is not limited to this. The scope can be narrowed down step by step in other orders, or the three core features can be subject to simultaneous conditions. Adjustments can be made according to actual configuration requirements.
[0092] Example 6: This embodiment relates to a social simulation device for large-scale intelligent agents. A schematic diagram of the social simulation device for large-scale intelligent agents in this embodiment can be seen as follows: Figure 2 As shown, it includes: an agent cognitive configuration unit 201, an event extraction unit 202, a decision generation unit 203, a queue management unit 204, and a data analysis unit 205.
[0093] Among them, the intelligent agent cognitive configuration unit 201 is used to load each intelligent agent and match the corresponding cognitive model configuration according to the intelligent agent's profile; the intelligent agent generates a natural language description based on each structured survey record in the human survey data. The event extraction unit 202 is used to extract the currently pending event from the event queue, update the corresponding target agent state and / or environment state according to the event payload, so as to trigger the perception operation of the affected agent and collect the context information after the perception operation. The decision generation unit 203 is used to generate an initial large-scale language model inference request based on context information, and call the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent, so as to obtain the agent's decision. The queue management unit 204 is used to convert agent decisions into new events and add them to the event queue; The data analysis unit 205 is used to obtain the final state of each agent and the state of the environment, so as to perform analysis based on the state of the agents and the state of the environment.
[0094] The social simulation device for large-scale intelligent agents provided in this embodiment includes an intelligent agent cognitive configuration unit 201 that generates human-like intelligent agents based on real human survey data through structured recording of natural language conversion, ensuring the cognitive diversity of billions of intelligent agents and avoiding simulation distortion caused by homogeneous modeling; an event extraction unit 202 that adopts an event-driven architecture, abandoning the traditional synchronous time step mechanism, only activating relevant intelligent agents and updating their states when an event occurs; a decision generation unit 203 that deeply integrates the intelligent agent's exclusive cognitive model configuration with the inference model, enabling high-fidelity decision generation; a queue management unit 204 that transforms intelligent agent decisions into new events and puts them back into the queue, forming a closed loop of event triggering-decision generation-new event driving, allowing the simulation to evolve spontaneously without human intervention and accurately simulating the dynamic evolution logic of social phenomena; and a data analysis unit 205 that focuses on the final state of the intelligent agent and the environment, providing highly reliable and practical reference data for social science research, policy simulation, and other scenarios.
[0095] Furthermore, it should be noted that all modules involved in this embodiment are logical modules. In practical applications, a logical unit can be a physical unit, a part of a physical unit, or a combination of multiple physical units. In addition, to highlight the innovative aspects of this application, this embodiment does not introduce units that are not closely related to solving the technical problems proposed in this application; however, this does not mean that other units do not exist in this embodiment.
[0096] Example 7: Another embodiment of this application relates to an electronic device, such as... Figure 3 As shown, it includes: at least one processor 301; and a memory 302 communicatively connected to at least one processor 301; wherein the memory 302 stores instructions executable by at least one processor 301, which are executed by at least one processor 301 to enable at least one processor 301 to perform the steps of the social simulation method for large-scale intelligent agents in the above embodiments.
[0097] The memory and processor are connected via a bus, which can include any number of interconnecting buses and bridges, connecting various circuits of one or more processors and memories. The bus can also connect various other circuits, such as peripheral devices, voltage regulators, and power management circuits, which are well known in the art and will not be described further herein. The bus interface provides an interface between the bus and the transceiver. The transceiver can be a single element or multiple elements, such as multiple receivers and transmitters, providing a unit for communicating with various other devices over a transmission medium. Data processed by the processor is transmitted over the wireless medium via an antenna, which further receives data and transmits it to the processor.
[0098] The processor manages the bus and general processing, and also provides various functions, including timing, peripheral interfaces, voltage regulation, power management, and other control functions. Memory is used to store data used by the processor during operation.
[0099] Those skilled in the art will understand that the above embodiments are specific embodiments for implementing this application, and in practical applications, various changes can be made to them in form and detail without departing from the spirit and scope of this application.
Claims
1. A social simulation method for large-scale intelligent agents, characterized in that, include: Load each intelligent agent and match the corresponding cognitive model configuration according to the profile of the intelligent agent; The intelligent agent is generated by converting natural language descriptions for each structured survey record in the human survey data. Extract the currently pending event from the event queue, update the corresponding target agent state and / or environment state according to the event payload, trigger the perception operation of the affected agent, and collect the context information after the perception operation; Based on the context information, an initial large-scale language model inference request is generated, and the inference model is invoked to execute the inference request based on the cognitive model configuration corresponding to the affected agent, so as to obtain the agent's decision. The agent's decision is transformed into a new event and added to the event queue; The final states of each agent and the environment are obtained for analysis based on the agent states and the environment states.
2. The social simulation method for large-scale intelligent agents according to claim 1, characterized in that, The step of retrieving the currently pending event from the event queue includes: The events in the event queue are sorted using a priority min-heap, and the earliest single event or a batch of events consisting of multiple adjacent events is extracted in timestamp order; wherein, the timestamp is set according to the simulation execution time of the event.
3. The social simulation method for large-scale intelligent agents according to claim 2, characterized in that, Between retrieving the currently pending event from the event queue and updating the corresponding target agent state and / or environment state based on the event's payload, the method further includes: If the extracted data is an event batch, compare the trigger identifier, target object identifier, and event type of each event in the event batch, and merge events with semantic overlap or consistent target.
4. The social simulation method for large-scale intelligent agents according to claim 2, characterized in that, The step of updating the corresponding target agent state and / or environment state based on the payload of the event includes: If the extracted data is an event batch, a causal dependency graph of the events is constructed. Based on the causal dependency graph, the precondition associations between each event in the event batch are analyzed. Events without causal dependency are assigned to different task groups, and events with causal dependency are assigned to the same task group. Parse the payload of the events in each of the task groups; the payload includes the triggerer identifier, the target object identifier, the event type, and specific parameters; Adjust the corresponding target agent state and / or environment state according to the load; If the extracted data is an event, treat the event as an independent task group.
5. The social simulation method for large-scale intelligent agents according to claim 1, characterized in that, Before the inference model is invoked to execute the inference request based on the cognitive model configuration corresponding to the affected agent, the method further includes: The inference request is converted into a vector representation to obtain the request vector; Search the historical request vector library and calculate the similarity between the request vector and each historical request vector; If the similarity reaches a preset threshold, the historical inference result corresponding to the historical request vector is returned directly, the current inference model call process is terminated, and the step of converting the agent's decision into a new event and adding it to the event queue is executed. If the similarity does not reach the preset threshold, then the step of calling the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent is performed.
6. The social simulation method for large-scale intelligent agents according to claim 5, characterized in that, If the similarity does not reach the preset threshold, before executing the step of calling the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent, the method further includes: Determine whether the cumulative frequency of the task corresponding to the inference request within a preset statistical period exceeds a frequency threshold and meets the low complexity judgment condition; If the cumulative frequency of occurrence exceeds the frequency threshold within a preset statistical period and meets the real-time low complexity judgment condition, the inference request is passed to the lightweight distillation model for execution; the lightweight distillation model is a lightweight student model trained by knowledge distillation technology based on a large language model.
7. The social simulation method for large-scale intelligent agents according to any one of claims 1 to 6, characterized in that, The step of matching the corresponding cognitive model configuration based on the profile of the intelligent agent includes: Analyze the demographic, sociological, and psychological characteristics in the aforementioned agent profile as survey features; The cognitive complexity of the agent is quantitatively evaluated based on the survey features, and a complexity score is generated. If the complexity score does not exceed the complexity threshold, the matching cognitive pattern is determined based on the survey characteristics, and the enhanced prompt words corresponding to the matching cognitive pattern are used as the cognitive model configuration. If the complexity score exceeds the complexity threshold, a corresponding dedicated cognitive model is generated using efficient parameter fine-tuning technology; the dedicated cognitive model is bound to the group identifier of the corresponding intelligent agent.
8. The social simulation method for large-scale intelligent agents according to claim 7, characterized in that, The invocation of the inference model, based on the cognitive model configuration corresponding to the affected agent, executes the inference request, including: Obtain a pre-built set of heterogeneous models; the set of heterogeneous models includes ultra-large models, medium-sized models, general-purpose lightweight models, and dedicated cognitive models, as well as benchmark data recording the inference accuracy, response speed and resource consumption of each model; Real-time monitoring of the load status of each model in the heterogeneous model set; Based on the complexity score of the affected agent, the system's preset quality requirements, and the load status, a matching model is determined from the heterogeneous model set to execute the inference request.
9. A social simulation device for large-scale intelligent agents, characterized in that, include: The agent cognitive configuration unit is used to load each agent and match the corresponding cognitive model configuration according to the profile of the agent. The intelligent agent is generated by converting natural language descriptions for each structured survey record in the human survey data. An event extraction unit is used to extract the currently pending event from the event queue, update the corresponding target agent state and / or environment state according to the event payload, so as to trigger the perception operation of the affected agent and collect the context information after the perception operation. The decision generation unit is used to generate an initial large-scale language model inference request based on the context information, and call the inference model to execute the inference request based on the cognitive model configuration corresponding to the affected agent, so as to obtain the agent's decision. A queue management unit is used to convert the agent's decision into a new event and add it to the event queue; The data analysis unit is used to obtain the final state of each agent and the state of the environment, so as to perform analysis based on the state of the agents and the state of the environment.
10. An electronic device, characterized in that, include: At least one processor; And, a memory communicatively connected to the at least one processor; The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the social simulation method for large-scale intelligent agents as described in any one of claims 1 to 8.