Large model-based native advertisement generation method, server, client and system

Abstract

The invention relates to a native advertisement generation method based on a large model, a server side, a client side and a system, and the method comprises the steps that the server side receives an advertisement request of the client side, and the advertisement request comprises real-time context information of a user; obtaining an original material provided by an advertiser and design theme information of a client application; based on a large language model, carrying out multi-modal fusion analysis on the real-time context information, the original material and the design theme information of the user; generating at least one description file of the advertisement interface layout visually fused with the design theme information, wherein the description file comprises an interface layout definition and an interaction logic definition corresponding to a target interaction strategy matched with the real-time context information of the user; and issuing a target description file determined in the at least one description file to the client, analyzing and rendering the target description file by the client, and realizing display and interaction of the native advertisement. According to the method and the device, personalized generation of the advertisement style and dynamic advertisement style are realized, and the user experience is improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of Internet advertising and artificial intelligence technology, and in particular to a native advertisement generation method based on a large model, a server, a client and a system. BACKGROUND

[0002] With the development of mobile Internet, embedding dynamic advertisements in native applications (such as reading, news, video, etc.) has become an important promotion mode. At present, in order to realize the dynamic of advertisement content, the industry mainly exists the following several technical routes: Client pre-installed template technology: This method requires that possible advertisement styles be pre-packaged in the form of code templates in the client before the application is published. The server only issues the data content that needs to be updated and a style identifier, and the client matches and activates the corresponding preset template according to the identifier, and renders the page based on the updated data content. This method has obvious flexibility bottlenecks: the diversity and novelty of the advertisement style are completely limited by the client version. Any visual update or introduction of new styles must be implemented by publishing a new client version, which cannot meet the needs of rapid iteration, A / B testing and large-scale personalization.

[0003] Rule-based content configuration technology: This method configures a series of advertisement display rules (for example, according to simple conditions such as user geographic location, time, etc.) through a background system, and binds different advertisement materials with rules. Its dynamicity depends on the "IF-THEN" logical rules set manually by the operation personnel. This method has low intelligence and cannot handle complex, multi-dimensional user real-time context (such as the emotional tendency of the user's current reading content, the semantic association with the advertisement content, etc.). The maintenance cost of the rules increases rapidly with the increase of business complexity, and it is difficult to realize the precise combination of deep personalization content and dynamic form.

[0004] Offline content generation technology: In recent years, some schemes have tried to use artificial intelligence to generate the script and pictures required for advertisements. However, such technology is usually located in offline, auxiliary creation tools, and its output result is a static picture or text file. These static materials still need to be put through the above-mentioned template or rule system, and cannot be rendered in real time into a dynamic UI (User Interface) component that seamlessly integrates with the native interface and can be deeply interacted, which has a sense of fragmentation with the experience and native function.

[0005] However, whether it is a client preset template, rule-based content configuration or offline content generation, its technical architecture is derived from the same design paradigm: "static configuration". This paradigm has a fundamental and insurmountable technical contradiction: the contradiction between the infinite demand for dynamic personalization of the ad serving system and the limited carrying capacity of the client preset template and rule system.

[0006] Specifically: the number of client preset templates is limited, while the combination of user scenarios, ad creatives and visual styles is infinite. This conflict between "limited" and "infinite" leads to homogenization of ad styles and user experience fatigue. Rule-based configuration cannot understand complex, multi-dimensional real-time context semantics (such as the emotional orientation of the user's current browsing content and the deep association with the ad content). Its "IF-THEN" logic chain expands dramatically as business complexity increases, resulting in high maintenance costs and difficulty in achieving creative adaptation. Offline generation technology only solves the problem of creating ad "content" (copy, images), but its output is static, unstructured material files. These materials still need to be embedded in a preset template framework, resulting in a separation between the generated "content" and the applied "form", making it impossible to achieve a truly native experience.

[0007] Therefore, the technical dilemma that practitioners in the field have long faced is: how to generate an ad experience that seamlessly integrates visually and deeply fits interactively in a dynamic user environment that is unpredictable and infinitely variable, while breaking free from absolute dependence on client-side preset capabilities. The existing technical system, due to its inherent static architecture, cannot provide a solution to this fundamental contradiction. SUMMARY

[0008] The present application is to overcome the above-mentioned defects of the prior art, and provides a large model-based native ad generation method, a server, a client and a system. The core idea is to introduce a large language model as an intelligent generation and decision engine, and to integrate the two traditionally separate aspects of ad visual style generation and interactive logic decision-making into a unified, collaborative reasoning process, thereby achieving end-to-end intelligent dynamicization of native ads.

[0009] To achieve the above-mentioned purposes, the present application adopts the following technical solutions: In a first aspect, the present application provides a large model-based native ad generation method applied to a server, which comprises: receiving an ad request from a client, the ad request containing user real-time context information; obtaining original materials provided by an advertiser and design theme information of the client application; Based on a large language model, multimodal fusion analysis is performed on the user's real-time context information, the original materials, and the design theme information; Based on the fusion analysis results, the large language model simultaneously performs the following operations: Generate at least one description file for an advertising interface layout that visually integrates with the design theme information, wherein the description file contains interface layout definitions that visually integrate with the design theme information, and From a plurality of preset interaction strategies, a target interaction strategy that matches the user’s real-time context information is determined, and the interaction logic definition corresponding to the target interaction strategy is written into the description file; A target description file, defined in at least one description file, is sent to the client; the client then parses and renders the target description file using a dynamic rendering engine to display and interact with native ads. Secondly, this invention provides a method for generating native ads based on a large model, applied to a client, comprising: Send an advertising request to the server, the advertising request containing the user's real-time context information; The system receives a target description file for the advertising interface layout from the server. The target description file is determined by at least one description file generated by the server. The description file is generated by the server after performing multimodal fusion analysis on the user's real-time context information, the original materials provided by the advertiser, and the design theme information of the client application based on a large language model. It is configured with an interface layout definition that is visually integrated with the design theme information and an interaction logic definition corresponding to the target interaction strategy. The target interaction strategy is a strategy that matches the user's real-time context information among multiple interaction strategies. The target description file is parsed and rendered using a dynamic rendering engine to generate native advertising UI components. Based on the interaction logic definition in the target description file, bind the corresponding event listener to the native advertising UI component; In response to user interaction, the event listener is triggered to execute the corresponding local callback function. The local callback function encapsulates the business logic for implementing the target interaction strategy and performs ad conversion operations by calling the client's native functions.

[0010] Thirdly, the present invention provides a server-side for native ad generation based on a large model, comprising: The request receiving module is used to receive advertising requests from the client, wherein the advertising requests contain real-time context information of the user; The information acquisition module is used to acquire the original materials provided by the advertiser and the design theme information of the client application; a multi-modal fusion analysis module configured to perform multi-modal fusion analysis on the user real-time context information, the original material and the design theme information based on a large language model; a collaborative generation module configured to control the large language model to perform the following operations based on the fusion analysis result: generate at least one description file of an advertisement interface layout visually fused with the design theme information, wherein the description file is configured with interface layout definition visually fused with the design theme information, and determine a target interaction strategy matching the user real-time context information from a plurality of preset interaction strategies, and write interaction logic definition corresponding to the target interaction strategy into the description file; a file delivery module configured to deliver a target description file determined in at least one description file to the client, and parse and render the target description file based on a dynamic rendering engine to display and interact with the native advertisement by the client.

[0011] In a fourth aspect, the present application provides a client for generating a native advertisement based on a large model, comprising: a request sending module configured to send an advertisement request to a server, wherein the advertisement request contains user real-time context information; a file receiving module configured to receive a target description file of an advertisement interface layout from the server, wherein the target description file is determined in at least one description file generated by the server, the description file is generated by the server based on multi-modal fusion analysis on the user real-time context information, original material provided by an advertiser and design theme information of the client application by a large language model, and is configured with interface layout definition visually fused with the design theme information and interaction logic definition corresponding to a target interaction strategy, wherein the target interaction strategy is a strategy matching the user real-time context information determined from a plurality of interaction strategies; a dynamic rendering engine configured to parse and render the target description file to render a native advertisement UI component; an interaction execution module configured to bind a corresponding event listener to the native advertisement UI component according to the interaction logic definition in the target description file, and trigger the event listener to execute a corresponding local callback function in response to user interaction, wherein the local callback function encapsulates business logic for implementing the target interaction strategy, and performs advertisement conversion operations by calling native functions of the client.

[0012] In a fifth aspect, the present application provides a system for generating a native advertisement based on a large model, comprising a server and a client; The server side is the server side for generating the native advertisement based on the large model in the third aspect, and the client side is the client side for generating the native advertisement based on the large model in the fourth aspect.

[0013] The technical scheme provided by the embodiment of the application has at least the following technical effects: Through the generative ability of the large model, the dependence on the preset template is completely eliminated, the high dynamic and diversification of the advertisement style and the on-demand generation are realized, the online and testing of the new style can be supported without the client version, and the dynamic and flexibility of the advertisement style are realized.

[0014] Through the deep semantic understanding of the multi-dimensional real-time context information, the most suitable advertisement content and interaction mode can be dynamically generated for each user and each scene, and the truly real-time personalized advertisement generation based on the instantaneous situation perception is realized.

[0015] Since the style and the interaction strategy are generated by the model, the advertisement is highly unified with the host application in visual and interactive experience, the seamless integration of the advertisement content and the native function is realized, and the user acceptance and participation are greatly improved. BRIEF DESCRIPTION OF DRAWINGS

[0016] In order to more clearly illustrate the technical scheme in the embodiment of the application, the drawings needed in the embodiment description will be briefly introduced. Obviously, the drawings in the following description are some embodiments of the application, and other drawings can be obtained by those skilled in the art without creative labor.

[0017] Figure 1 The overall flowchart of the native advertisement generation method based on the large model according to the example embodiment is shown; Figure 2 The detailed flowchart of the server multi-modal fusion analysis and collaborative generation according to the example embodiment is shown; Figure 3 The structured definition diagram of the JSON description file according to the example embodiment is shown; Figure 4 The workflow diagram of the client dynamic rendering engine according to the example embodiment is shown; Figure 5 The advertisement generation optimization process schematic diagram based on data feedback according to the example embodiment is shown; Figure 6 The server side for generating the native advertisement based on the large model according to the example embodiment is shown; Figure 7 The client side for generating the native advertisement based on the large model according to the example embodiment is shown; Figure 8 A structural schematic diagram of a large model-based native advertisement generation system is shown. DETAILED DESCRIPTION

[0018] It should be noted that the embodiments in the present application and the features in the embodiments can be combined with each other without conflict. The present application will be described in detail below with reference to the accompanying drawings and in combination with the embodiments.

[0019] However, example embodiments can be implemented in various forms and should not be understood as being limited to the embodiments set forth herein; rather, these embodiments are provided so that the present application will be thorough and complete, and the concept of the example embodiments will be fully conveyed to those skilled in the art.

[0020] The example embodiments of the present application will be described below in combination with the accompanying drawings.

[0021] Figure 1 A whole flowchart of a large model-based native advertisement generation method according to an example embodiment is shown.

[0022] In S100, the client sends an advertisement request to the server.

[0023] The advertisement request is actively initiated by the client under a specific scenario (such as the user browsing to the page advertisement position, information flow refreshing, etc.), wherein structured user real-time context information is encapsulated.

[0024] In S101, the server receives the advertisement request from the client.

[0025] The server parses the advertisement request to obtain the user real-time context information encapsulated therein. The user real-time context information is dynamically collected, including but not limited to: the current content type (such as articles, videos, product details) browsed by the user, the keyword label of the content, the geographic location information of the user (which can be obtained by GPS (Global Positioning System) or IP (Internet Protocol) address resolution), accurate time information (including time, day of the week, whether it is a holiday, etc.), the current network environment (such as Wi-Fi, 5G, 4G), and long-term interest labels extracted from user historical behaviors.

[0026] At S103, the server obtains two aspects of information in parallel: one is the original material provided by the advertiser, such as product pictures, brand logos, core selling point copy, video links, etc.; the other is the design theme information currently applied by the client, which is usually obtained from the application configuration management center and contains the color system (such as primary color, accent color, background color) defined by the currently active theme, font specification (such as font family, font size, font weight), corner size, component spacing, etc. visual style attribute set.

[0027] At S105, multi-modal fusion analysis is performed based on a large language model.

[0028] This is the core step of the application. The server constructs all the information obtained in S101 and S103 into a structured prompt and inputs it into a specially trained large language model (such as GPT-4, ERNIE, etc.). The large language model plays the role of an "intelligent ad creative engine" and its task is to perform deep semantic understanding and correlation analysis on these heterogeneous information. For example, the large language model needs to understand the potential needs of the user at the current time, current location, and current content browsing, and think about how to present the product selling points of the advertiser in a way that conforms to the visual style of the client, while ensuring that the ad content naturally integrates with the user's current information consumption scenario.

[0029] At S107, based on the fusion analysis results, the large language model simultaneously performs two collaborative operations: a. Generate at least one description file of an ad interface layout that is visually integrated with the client's design theme information. The description file configures a complete interface layout definition, defining the complete UI structure of the ad, rather than just static materials.

[0030] b. From a plurality of pre-configured interaction strategies, determine the target interaction strategy that best matches the current user's real-time context information through reasoning, and write the interaction logic definition corresponding to the target interaction strategy into the description file.

[0031] Synchronization and collaboration are key here. The large language model does not first design the UI and then match the interaction, but rather, within the same reasoning cycle, it considers the interaction strategy as a core constraint condition for UI design. For example, if the large language model decides to use the "preview" interaction strategy, the interface layout definition in the description file it generates will naturally contain visual elements and / or button text that are strongly related to the "preview" behavior.

[0032] Exemplarily, Figure 2 A detailed flowchart of the service-side multi-modal fusion analysis and collaborative generation according to an example embodiment is shown.

[0033] As Figure 2As shown, after completing the advertisement request receiving and information obtaining, the server enters the core processing stage of multi-modal fusion analysis and collaborative generation, which specifically includes: In the input stage, the server integrates the received user real-time context information, the original material provided by the advertiser, and the design theme information of the client application into a structured template that can be understood by the large language model. This template clearly defines the role positioning, analysis task, and output format requirements of the large language model.

[0034] In the core processing stage, the large language model performs deep semantic understanding and correlation analysis on the integrated multi-modal information. The large language model needs to understand the user's potential needs under the current context information, analyze the matching degree of the advertisement material and user interest, and consider the visual constraint conditions of the design theme information of the client application. Based on the fusion analysis results, the large language model generates one or more description files of the advertisement interface layout that visually fuse with the design theme information. The description file defines the complete UI component structure, style attributes, and layout relationship, ensuring that the advertisement is visually consistent with the host application. If multiple description files are generated based on the fusion analysis results, the multiple description files differ in interface layout and / or visual style, but all need to visually fuse with the design theme information.

[0035] Among them, while generating the description file of the advertisement interface layout (also known as the UI description file), the large language model determines the target interaction strategy that best fits the current user context information from the pre-set multiple interaction strategies through reasoning. The decision-making process considers user behavior characteristics, advertisement content characteristics, and conversion targets.

[0036] The interaction logic definition corresponding to the determined target interaction strategy is written into the corresponding position of the UI description file to form a complete description file (advertisement creative description file) for the client to use, providing complete technical specifications for client rendering and interaction. Among them, the generated complete description file can be one or more, and if multiple are generated, one is selected as the target description file to provide to the client.

[0037] In S109, the server delivers the target description file in at least one description file generated by S107 to the client.

[0038] The target description file is the selected file among the at least one description file. This file usually adopts a lightweight, cross-platform data exchange format, such as JSON.

[0039] In S111, the client receives the target description file from the server and, based on the built-in dynamic rendering engine, parses and renders the received target description file.

[0040] The target description file is the direct output of the server-side intelligent generation process, which carries the collaborative generation results obtained by the large language model based on multi-modal fusion analysis. Therefore, the client receives not only data, but also an executable UI blueprint encapsulating intelligent decision-making.

[0041] The dynamic rendering engine of the client can understand the interface layout definition in the target description file and convert it into a native ad UI component of the client operating system (such as iOS, Android). The parsing process of the dynamic rendering engine for the interface layout definition includes processing of style attributes: the dynamic rendering engine first processes the normal style attributes (such as directly defined color values) in the target description file and applies them directly to the corresponding UI component; for abstract style attributes, they are mapped to specific resource references in the current active theme, i.e., by querying the resource mapping table of the client's current active theme, they are converted into specific style values. After completing the complete parsing of the interface layout definition, the dynamic rendering engine converts it into a native ad UI component of the client operating system, thereby generating and displaying the native ad UI component.

[0042] Meanwhile, the client binds the corresponding event listener to the native ad UI component according to the interaction logic definition in the target description file. Specifically, according to the event type and target component identifier specified in the interaction logic definition, the corresponding interactive component is located in the multiple sub-components included in the native ad UI component, and the corresponding local callback function is registered for the located interactive component, thereby completing the binding of the event listener. The registered local callback function is used to execute when the event is triggered to complete the ad conversion operation defined in the target interaction strategy. Finally, a dynamic ad component that is visually seamlessly integrated with the APP native interface and has complete interaction functions is presented to the user.

[0043] In S113, the client triggers the event listener in response to the user's interaction operation, and executes the corresponding local callback function.

[0044] When the user interacts with the ad component (such as clicking the button), the event listener is triggered, and the local callback function registered in the above process is triggered. The local callback function encapsulates the business logic to achieve the target interaction strategy, and performs the ad conversion operation by calling the native functions of the client. Specifically, the function calls the existing native functions (such as page jump, add to shelf, play video, etc.) in the client application according to the action type and parameters specified in the interaction logic definition, to complete the ad conversion behavior defined in the target interaction strategy, and provide a seamless, native interaction experience for the user.

[0045] The following describes the large model-based native ad generation method of the embodiments of the present application through specific embodiments.

[0046] Embodiment One: Real-time generation and interaction of book advertisements in a reading APP This embodiment describes the specific application of advertisement generation and interaction in a reading APP named "Lingmao Kan Kan".

[0047] First stage: detailed data flow in the input stage The trigger time is set as follows: when the user reads a certain book to the end of a specific chapter (e.g., reads suspense novel A to chapter 150), the client renders an advertisement slot in the recommended works module.

[0048] The client collects information in real time through a pre-embedded SDK (Software Development Kit) and encapsulates the advertisement request to send to the server. The user context information collected by this SDK exceeds traditional advertisement SDKs in terms of dimension and depth, including: Content context: the ID of the current reading book (e.g., B801), title, author, and keywords extracted from the current chapter content in real time.

[0049] User status context: user membership level (e.g., VIP5), reading behavior tags (e.g., science fiction, suspense, high subscription rate author).

[0050] Device and environment context: the current active theme mode of the device (dark mode), operating system version.

[0051] These data are structured into a JSON object as an advertisement request and sent to the server through a secure network protocol. The server receives the request, retrieves matching materials from the advertisement material library, such as a new book promotion material similar to the user's current reading content type, including cover image, author avatar, and original copy; and obtains the dark theme design specifications used by the host application (Lingmao Kan Kan APP) from the configuration center.

[0052] Second stage: deep calculation in the large model processing stage (corresponding to S105, S107 above) The server integrates all the above input information into a carefully designed prompt word and inputs it into the large language model. The prompt word clearly defines the role of the large language model, the analysis task, and the output format requirements.

[0053] The large language model performs multi-modal fusion analysis, and its internal reasoning process can be analyzed as follows: Identify user core interests: based on the keywords and types of the content the user is reading, identify the user's interest in specific themes and styles.

[0054] Evaluate user value and preferences: combine the user's membership level and historical behavior to determine that the user requires high-quality content, has strong willingness and ability to pay.

[0055] Understanding design constraints: Dark themes require advertising UIs to use dark backgrounds, light text, and adhere to specific font sizes and rounded corner specifications.

[0056] Matching ad creatives: This involves assessing the degree of match between the ad creative to be promoted and the user's interests and real-time contextual information. Based on the assessment results, the ad creative is determined to be a suitable recommended work.

[0057] Based on this analysis, the large language model simultaneously performs collaborative generation and decision-making: Generative UI Design and Personalized Interaction Decisions: Based on the same fusion analysis results, the large language model generates two description files for ad interface layouts for A / B testing. Both description files are configured with interface layout definitions that blend seamlessly with the dark theme visuals.

[0058] Generative UI Design Scheme 1 (Path a1): Adopts a card layout, and its visual attributes are all referenced from the resource definition of the current theme on the client: the background color references the card background defined by the theme, the left side is configured with the cover image area of ​​the book to be recommended, the upper right side uses the main text color of the theme and bold style to display the title of the book to be recommended, and the lower right side uses the secondary text color of the theme to present the recommendation, forming a hierarchical information structure and native visual experience.

[0059] Generative UI Design Scheme 2 (Path a2): Generates a layout scheme that focuses on community popularity. Based on the card layout, this scheme adds icons (such as flames) and text components (such as 20,000 people reading) to represent community popularity in the configured interface layout definition, and the style is also adapted to the dark theme.

[0060] Personalized Interaction Decision (Path b): The model infers and selects the optimal interaction strategy from a pre-set strategy pool. For example, after inference, the "purchase" strategy, which has a high user decision threshold, and the "share" strategy, which has a weaker sharing motivation, are eliminated. Based on the characteristics of VIP users' strong willingness to pay and high acceptance of trial reading, "trial reading of the first chapter" is finally selected as the target interaction strategy to seamlessly connect with the user's reading experience. Crucially, the "generative UI design" and "personalized interaction decision" of the large language model are not simply the superposition of two independent tasks, but are completed in a unified and collaborative reasoning process. Within a single semantic understanding cycle, the large language model uses the "trial reading" interaction strategy as the core constraint of UI design, while simultaneously integrating the visual presentation of the UI (such as the "progress bar") as the carrier of the "trial reading" strategy. This deep binding of cognition and function ensures the internal consistency and external nativeness of the final advertising experience, which cannot be achieved by traditional sequential design or simple rule matching.

[0061] This embodiment clearly demonstrates the fundamental improvements brought about by the present invention: Paradigm shift: from "static configuration" to "dynamic generation": the entire process completely breaks free from the dependence on pre-set templates, and realizes infinite possibilities and on-demand generation of ad styles and interaction logic based on unlimited user context scenarios.

[0062] Deep Collaboration: From "Content Generation" to "Experience Generation": By gaining a deep semantic understanding of multi-dimensional contexts and using a large language model to synchronously generate UI layouts and interaction strategies, what we get is not a simple graphic advertisement, but a "trial reading experience" that is seamlessly integrated with the reading scenario.

[0063] System closed loop: From "open-loop delivery" to "intelligent evolution": The advertising creative output in this embodiment will enter the delivery stage, and its effect data (such as trial reading completion rate) will be collected and used for subsequent attribution analysis and model optimization (as described in Embodiment Six), thereby constructing a complete self-iterative closed loop.

[0064] After finalizing the UI design from the two proposed solutions, the large language model integrates the finalized design with the interaction decisions, outputting a complete JSON description file. This file fully defines the hierarchy, style attributes, and layout position of UI components, explicitly configures the interaction type (e.g., navigateToReading) in the action fields of interactive components, and carries relevant parameters (e.g., target book ID and chapter ID), thus forming a complete advertising creative specification that can be parsed and rendered by the client.

[0065] Phase 3: Precise execution of the output and rendering phases (corresponding to S109, S111) The server sends the generated JSON description file to the client, and the client's dynamic rendering engine then starts and parses and executes it according to the following process: Parsing and building the UI tree: The dynamic rendering engine parses the JSON description file, instantiates the corresponding native UI components according to the component type field, and builds a complete UI tree in memory.

[0066] Style Mapping: The dynamic rendering engine traverses the UI tree, mapping and applying style attributes from the JSON description file to the corresponding components. For ordinary style attributes, they are directly applied to the corresponding UI components; for abstract resource references, the dynamic rendering engine queries the client's local theme resource table to parse them into specific values, ensuring seamless integration of ad visuals with the application theme.

[0067] Interaction binding: the dynamic rendering engine parses the action definition of the interactive component, binds the specified interaction type with the native callback method preset by the client, and configures the corresponding parameters, thereby establishing a complete user interaction response link. For example, in the interaction binding stage, the dynamic rendering engine parses the "action" field of the button component, binds its type "navigateToReading" with the page jump method preset in the client application, and when the user clicks the button, the bound callback method is triggered and the parameter is passed in, realizing seamless jump to the first chapter of the specified book and completing the preview function. The above embodiment realizes the full-process automation and personalization of the advertisement from triggering, generation to interaction. The generated advertisement is visually deeply integrated with the reading interface, the interaction behavior is consistent with the APP native function, the user perception is a precise intelligent recommendation rather than a conspicuous advertisement push, and the user experience and the smoothness of the advertisement conversion path are significantly improved.

[0068] Embodiment two: advertisement generation based on multi-dimensional context information This embodiment takes a reading APP (such as Lingmao Kan Kan) as an example, and focuses on how multi-dimensional real-time user context information is collected and applied.

[0069] The user browses a historical work through the "historical biography" channel of a reading APP (Lingmao Kan Kan) in B district of A city on Saturday afternoon. When it is identified that the user is reading the chapter intermittently, the client initiates an advertisement request, and finally receives and renders the advertisement from the server in the information stream advertisement position.

[0070] The client SDK collects multi-dimensional real-time context information and constructs a refined user scenario portrait: Deepen the content context: not only know that the user is reading a history book, but also accurately to the specific channel classification (historical biography), specific books and core keywords extracted from the content. Accurate geographic context: through IP address and location big data, the user is located in B district of A city, and based on the analysis of the user's historical activity track, it is identified that the user's common activity area contains a higher education institution and a cultural landmark, thereby inferring that the user has a potential interest in history and culture.

[0071] Time context: accurately record the time as spring Saturday afternoon, and exclude special times such as statutory holidays, thereby defining the potential characteristics of "weekend leisure travel".

[0072] Network and environmental context: it is monitored that the user is in a 5G network environment, uses a high-performance mobile device and has sufficient power, which indicates that it can support high-quality picture loading and execution of complex interaction processes.

[0073] The large language model performs correlation reasoning on the information of these dimensions in the fusion analysis stage: Content + Geography Correlation: Recognize that the user is reading history-related content and is located in a city area with rich historical and cultural heritage, which leads to the inference that the user has an interest in visiting local historical and cultural sites.

[0074] Time + Behavior Scenario Correlation: Combine the time characteristics of spring Saturday afternoon and non-statutory holidays, combine with the user's browsing of historical content and location in a city area with rich cultural resources, and comprehensively infer that visiting cultural leisure sites is a high-probability behavior, and judge that the user has a strong intention to travel and visit.

[0075] Network + Capability Correlation: Monitor that the user is in a 5G high-speed network environment and uses a high-performance device, confirm that the user's terminal can support high-definition background pictures and complete complex interaction processes.

[0076] Based on this, the large language model generates an advertisement inviting the user to visit the "Local Historical Artifact Essence Exhibition". The UI style adopts a national style design, with a light beige color similar to an ancient scroll, and an antique frame is added. The button text is dynamically generated as "Weekend Leisure, Travel Back to the Historical Site", skillfully combining the time feature (weekend) and scene intention (traveling). The interaction strategy decision is "Immediately book", directly meeting the user's potential travel planning needs.

[0077] The above embodiments, through deep correlation analysis of multi-dimensional context information, realize the precise matching of advertisement content and user real-time scene, improve the precision of advertisement recommendation from the user level to the real-time scene level, and greatly improve the timeliness, relevance and attractiveness of the advertisement.

[0078] Example Three: Deep Binding of Interaction Strategy and UI Style This embodiment continues from Example One, and exemplarily illustrates how the large language model dynamically generates highly matched button text and visual guide elements according to the selected interaction strategy.

[0079] In Example One, the large language model has determined that the target interaction strategy is "try reading the first chapter". The large language model does not simply generate a general button with the label "try reading", but performs deep binding reasoning: 1. Button text generation: The large language model reasons that for the "try reading" strategy, the button text needs to clearly inform the user of the action result and content to eliminate uncertainty and reduce decision cost. Accordingly, the text "free trial of the first chapter" is generated, where "free" eliminates price concerns and "first chapter" clearly defines the trial range.

[0080] 2. Visual guide element generation: The large language model further infers that a visual metaphor is needed to indicate to the user that this is a continuous reading experience, not a one-time link jump. Accordingly, a progress bar component is generated as a visual guide element. The component includes at least one of a progress label, a percentage indicator, and a visual progress bar, with an initial state set to 0.

[0081] 3. Dynamic interaction implementation: When the user clicks on the preview button and starts reading, the local logic of the client monitors the reading progress and dynamically updates the progress value of the visual progress bar (such as from "0%" to "30%"). This makes the ad UI from static display to real-time interaction with user behavior Dynamic component, realizing the immersive continuation of the ad experience.

[0082] The above embodiment embodies the advantages of generative UI over templated UI. Based on the deep understanding of the semantics of the interaction strategy, the large language model dynamically generates a UI style that is functionally and cognitively compatible. This deep binding significantly improves the native and smoothness of the user experience, transforming the ad conversion path from jump-adaptation to continuation-immersion, thereby improving interaction efficiency and conversion rate.

[0083] Example Four: Structured Definition of JSON Description File and Interface Layout This embodiment details the specific structure of the description file of the ad interface layout, as shown in Figure 3 The specific components include: Root structure: version: Description file version number, used for compatibility control; metadata: Meta information, including generator identification, timestamp and creative ID; layout: Core layout definition, including complete UI structure description.

[0084] Layout structure: type: Define container type, such as Container, LinearLayout, etc.; style: Style definition object, define visual properties through key-value pairs; children: Array of child components, support nested structure.

[0085] Component structure: Basic components: Image component (image display component), Button component (button component), also including Text component (text display component) not shown in the figure; Layout components: Container (general container component), also includes HorizontalContainer (horizontal layout container), VerticalContainer (vertical layout container), LinearLayout (linear layout container) not shown in the figure; Interaction components: Contains action definition, specifies interaction type and parameters.

[0086] Style mapping mechanism: Support specific values Support abstract references Support dynamic properties.

[0087] This structured JSON description file as a core carrier to carry large language model ideas, realizes the complete data encapsulation of advertising ideas, through a standardized interface, the generation result of large language model can be accurately parsed and rendered by the client, realizes the seamless connection from cloud to client.

[0088] The description file adopts JSON format, and contains interface layout definition in the embodiments of the application. The structure is carefully designed and has the characteristics of unambiguousness, extensibility and machine executability. The complete file specifically includes the following hierarchical structure: 1. Document header and metadata layer: contains version number (version), generator information (generator), generation timestamp (generatedAt) and creative ID (adCreativeId), provides version control, generation tracking and creative management capabilities for the description file.

[0089] 2. Root layout container layer: the overall container structure of the advertisement is defined through the layout object. The type field specifies the container type (such as Container). The style object defines the basic style attributes of the container through key-value pairs, such as background color, corner radius, inner margin and outer margin. Among them, the value of the style attribute can be a specific value, or a string referring to the client theme resource.

[0090] 3. Sub-component level: children is an array that defines the hierarchical relationship of all sub-components in the container, supporting nested structure. Each sub-component itself is also a JSON object, containing its own type, style and possible children array, thus forming a complete UI tree structure.

[0091] - Component Type: The type field explicitly specifies the kind of component, such as including basic components: Text (text), Image (image), Button (button), etc.; including layout components: HorizontalContainer (horizontal container), VerticalContainer (vertical container), etc.

[0092] - Style Attributes: Key-value pairs within the style object precisely control the appearance and layout of components. For example, horizontal defines the layout direction, width and height define the size.

[0093] - Interaction Event Definition: For interactive components, declarative interaction definition is achieved through the action object, for example, the object specifies the action type through type, and the required parameters are passed through the parameters object, realizing the declarative description of interaction logic.

[0094] The style mapping mechanism supports three value modes: specific numerical values, abstract resource references, and dynamic properties, ensuring perfect fusion of advertising visuals and client themes.

[0095] Through this structured JSON description file, dynamic advertising is realized in data encapsulation of visual and interaction logic, providing standardized and parsable technical specifications for the client engine, ensuring that the generated results can be accurately parsed and rendered by the client, realizing seamless connection from the cloud to the client execution.

[0096] Embodiment Five: Client Dynamic Rendering Engine This embodiment describes in detail the workflow of the client dynamic rendering engine, and its flowchart is shown in Figure 4 .

[0097] The dynamic rendering engine of the client is used to convert the JSON description file delivered by the server into a real and interactive native advertising UI component on the screen. Its workflow is as follows: S401: Engine initialization and resource preparation. When the APP starts, the dynamic rendering engine is initialized: Establish a component type registry to map the type field in the JSON description file to the native UI class of the client, providing a basis for subsequent instantiation of UI components.

[0098] Establish an action handler registry to map the type of JSON action to the local callback function preinstalled in the APP, establishing a mapping relationship for the execution of interaction events.

[0099] Cache theme resources: load and cache the resource mapping table of the current active theme, cache specific numerical values such as colors and sizes, for subsequent style parsing.

[0100] S403: Parsing JSON description file and constructing UI tree. After receiving the JSON description file, the dynamic rendering engine parses it using standard libraries (such as JSONObject). It starts from the root node and recursively traverses the entire JSON structure. For each node encountered, it finds the corresponding native class from the component type registry according to its type field and instantiates the UI component through the reflection mechanism, constructing a UI component tree corresponding to the JSON structure in memory, completing the underlying conversion from structured data to visual components.

[0101] S405: Style mapping. The dynamic rendering engine traverses the UI tree and maps the style properties in the style object of each node to the corresponding native component. This process is crucial for achieving visual originality between the ad and the host application.

[0102] For specific numerical values, the dynamic rendering engine converts them to device pixel units and sets them directly. For abstract references, the dynamic rendering engine queries the theme resource mapping table to find the corresponding specific color value under the current theme and sets it. This process ensures that the design intent delivered by the server can be correctly and consistently implemented under different themes (such as dark / light mode), completing the conversion from abstract style to specific rendering.

[0103] S407: Interaction registration. When parsing interactive components (such as Button) and their action objects, the dynamic rendering engine performs the binding process: According to action.type, find the corresponding ActionHandler from the action handler registry.

[0104] Set up a click event listener for the component to associate user operations with response logic.

[0105] When the click event is triggered, the click event listener calls the found ActionHandler and passes in the action.parameters parameter to implement specific interactions through client native functions (such as page jump, add to shelf, etc.).

[0106] S409: Layout calculation and rendering. After all component instances are instantiated and styled, the dynamic rendering engine calculates the final position and size of each component according to the layout properties defined in JSON, then calls the API to add the complete UI tree to the specified ad slot container, completing the rendering.

[0107] The above embodiment, the client dynamic rendering engine converts and renders the abstract JSON description file into a visual unified and interactive complete native advertisement component through the style mapping and interaction registration mechanisms, and realizes seamless fusion of the advertisement and the host application in vision and interaction.

[0108] Embodiment six: advertisement generation optimization based on data feedback This embodiment describes an optimization mechanism based on data feedback, and the flowchart is shown in Figure 5 .

[0109] The system constructed by the client and the server has the ability of continuous evolution. Taking the advertisement using the trial reading strategy in embodiment one as an example, the system collects detailed end-to-end user behavior data in the complete delivery cycle. The data collection dimensions include, for example: advertisement exposure, user clicks (for calculating click rate), trial reading content completion, content adding to the shelf, and final conversion to purchase (for calculating paid conversion rate).

[0110] S501: Data collection and effect aggregation. During the advertisement delivery process, the system tracks the effects of different generative creative schemes. Each creative scheme is composed of a specific UI design and interaction strategy.

[0111] All user behavior events are aggregated according to the corresponding advertisement creative identifier to form a comparable structured effect report. To accurately assess the impact of a single variable, the system supports comparative analysis under the condition of fixing other variables (such as UI design and advertisement content). For example, the report data can reveal that when using the same UI design scheme and advertisement content, the conversion rate from trial reading to payment (short-term paid conversion rate) of the creative scheme using the trial reading strategy is, for example, 1.5%, and the final conversion rate of the scheme using the add-to-shelf strategy to guide users to complete payment (long-term paid conversion rate) is, for example, 3.2%. Through this controlled variable comparison, the performance difference of different interaction strategies in guiding users to complete the final conversion can be clearly quantified, providing reliable data basis for subsequent creative optimization.

[0112] S503: Large model attribution analysis. The system automatically constructs an analysis report for this comparative case and submits it to a large language model for attribution analysis. For example, the model can output the following conclusion after analysis: Attribution: The trial reading strategy has a low decision threshold, making it easy for users to stop after a shallow taste and difficult to form a deep reading. The add-to-shelf strategy is a light commitment, which guides users to complete a light collection behavior and establishes an initial content association, making it easier to convert users into long-term readers, and the willingness to pay naturally increases with reading investment, thus performing better in long-term conversion data.

[0113] Design suggestion: Add a "collection" icon to the add-to-shelf button. By enhancing the sense of belonging to the collection behavior, we can effectively increase the user's click intention.

[0114] Strategy suggestion: For high-quality books that have been completed, prioritize the add-to-shelf strategy for high-value users to maximize long-term retention and conversion value.

[0115] S505: Optimize knowledge base updates. The system converts the attribution analysis conclusions into structured optimization rules and stores them in the strategy optimization knowledge base. The rules specify the applicable conditions (such as user level, book status, theme, etc.) and establish a mapping relationship between conditions and recommended strategies, such as automatically executing the preset strategy (recommended strategy = add-to-shelf, UI enhancement scheme = add collection icon component) when the conditions are met. Through the continuous accumulation of the knowledge base, a complete system from data feedback to strategy optimization is established. S507: Model weight optimization and rule solidification.

[0116] The system constructs high-quality training sample pairs based on the optimization rules in the strategy optimization knowledge base, and fine-tunes the large language model in a targeted manner. This process updates the model's internal weight parameters, solidifying proven successful strategies into the large language model's stable knowledge, thereby strengthening the weight configuration of specific patterns in the model parameter space. When faced with new scenarios that meet the conditions, the large language model can generate optimized ad creatives based on the decision preferences formed.

[0117] S509: Model iteration and closed-loop verification The new generation model with optimized weights is used to generate ad description files and perform ad placement. A new data tracking link is established to continuously monitor the effectiveness of the optimized ads, including click-through rate, conversion rate, user retention rate, and other key indicators. By comparing the effectiveness of ads generated by the new and old models, the actual effectiveness of model weight optimization is quantitatively evaluated, and the verification results are used as an important basis for subsequent model iteration, forming an optimization closed loop that drives continuous model updates.

[0118] The above embodiments realize a complete closed loop from data collection to attribution analysis and then to strategy optimization, which makes the system not just a static ad placement tool, but an intelligent system that learns from real user feedback and continuously optimizes, achieving continuous improvement in ad placement effectiveness.

[0119] Embodiment Seven: Intelligent Application of Diversified Interaction Strategies This embodiment demonstrates the pre-set diversified interaction strategies and their intelligent selection mechanism.

[0120] The server maintains a preset interaction strategy pool, each strategy is a structured object containing strategy ID, function description, applicable conditions, UI template and action definition. Strategy examples are: purchase (direct purchase): suitable for completed books and high willingness to pay users, aiming to quickly complete conversion.

[0121] addToShelf (add to shelf): suitable for books in progress and users with matching themes, aiming to cultivate long-term readers.

[0122] trialRead (trial read chapter): suitable for new users or unfamiliar authors, reducing the threshold for trying.

[0123] watchVideo (watch video): suitable for fantasy or epic themes with video previews.

[0124] Share (share recommendation): suitable for popular books and socially active users.

[0125] In a specific scenario, a user is browsing a reading app (such as Lingmao Kan) and their historical behavior shows "high follow-up stickiness" characteristics. When the server prepares to promote a popular serialized work, the large language model performs strategy reasoning based on multi-dimensional context: 1. Strategy screening: exclude inapplicable strategies Exclude purchase (direct purchase): since the work is in progress, it does not meet the purchase conditions for completed content.

[0126] 2. Strategy evaluation: analyze the matching degree of each strategy Evaluate trialRead (trial read): although it can lower the threshold for trying, it cannot meet the demand for continuous follow-up.

[0127] Evaluate addToShelf (add to shelf), which can effectively meet the user's reading habits of tracking updates and the characteristics of serialized content.

[0128] 3. Strategy decision: finally select the optimal strategy Use the addToShelf strategy to add the work to the user's personal bookshelf, establishing a long-term reading relationship, which meets the user's real-time follow-up needs and lays the foundation for future paid conversion.

[0129] The model generates an advertisement accordingly, with the button text "Add to Shelf and Follow Up" and a bookmark icon, and the interaction action is to add the book to the user's bookshelf. After the user clicks, they become a "follow-up reader" of the book, and can continue reading through the bookshelf entry, and the server will also push update notifications, greatly improving user stickiness and long-term paid conversion potential.

[0130] By pre-setting diversified strategies and intelligently selecting by a large language model, the advertisement interaction is realized from single rigidity to multi-precision, and the most effective conversion path can be selected according to different business targets and user scenarios, so as to maximize the long-term value of the advertisement.

[0131] The above is only a specific implementation of the large model-based native advertisement generation method of the present application, but the protection scope of the present application is not limited thereto, and any person skilled in the art can easily think of changes or replacements within the technical scope disclosed in the present application, which should be covered within the protection scope of the present application.

[0132] Embodiment eight: server of large model-based native advertisement generation The server of large model-based native advertisement generation of the present application will be described in detail below.

[0133] The server is deployed on a cloud infrastructure and serves as an intelligent core of the entire advertisement system, and its hardware foundation usually includes a multi-core processor, a large-capacity memory, a high-speed network interface, and a storage system for storing advertisement materials and model weights. The service program running on the server includes Figure 6 The core modules shown in the figure, and each module communicates and exchanges data through a pre-defined interface.

[0134] Figure 6 The server of large model-based native advertisement generation provided by the embodiments of the present application is shown in Figure 6 As shown in the figure, it includes a request receiving module 61, an information obtaining module 62, a multi-modal fusion analysis module 63, a collaborative generation module 64, and a file issuing module 65.

[0135] The request receiving module 61 is used to receive advertisement requests from the client, and the advertisement request contains user real-time context information.

[0136] This module serves as a high-concurrency network server point (such as a RESTful API implemented using Nginx and Spring Boot framework), which continuously monitors advertisement requests from the client. When an advertisement request is received, the module performs security verification (such as Token verification), data decryption (if necessary), and format parsing on the advertisement request, and extracts a structured JSON object (user real-time context information). The module encapsulates the parsed context information as an internal event and passes it to the downstream information obtaining module 62 and multi-modal fusion analysis module 63. To cope with high-concurrency scenarios, this module uses an asynchronous non-blocking I / O model and connects a load balancer to ensure that requests can be quickly distributed and processed.

[0137] The information obtaining module 62 is used to obtain original materials provided by the advertiser and design theme information of the client application.

[0138] The module executes two data acquisition tasks in parallel: Advertisement material acquisition: According to the ad slot ID or content label in the ad request, a query is initiated to the advertisement material database (such as Redis cluster or MySQL) to obtain the matching raw material, including but not limited to at least one of high-definition picture URL, video link, copy title and description.

[0139] Design theme information acquisition: By calling a unified configuration service, the currently activated design theme package of the client APP is obtained according to the version number and device information of the client APP. The theme package defines information such as color system, font specification, spacing, and round corners.

[0140] The module initiates two data requests using concurrent programming and reduces frequent access to the configuration center through a caching mechanism to improve response speed.

[0141] A multi-modal fusion analysis module 63 that performs multi-modal fusion analysis on the user's real-time context information, the raw material, and the design theme information based on a large language model.

[0142] This is the intelligent hub of the server side. The module constructs the output of the request receiving module 61 and the information acquisition module 62 into a structured prompt word that contains multi-modal information. For example: the user (VIP5, a deep fan of science fiction) is reading science fiction work A (keywords: mysterious sea, unknown creatures, supernatural phenomena), and the display mode is a dark theme with default font. Please design a native ad for science fiction work B (cover image: [URL]) with a dark theme color and default font, and the visual style should be consistent with the native experience of the host application. Please analyze and recommend the most suitable interaction strategy based on the above information, design the corresponding UI style scheme, and provide a complete ad creative description.

[0143] The prompt word is sent to the large language model. The large language model performs deep semantic understanding on the prompt word, performs multi-modal fusion analysis, and outputs a structured analysis result as the basis for subsequent processing.

[0144] A collaborative generation module 64 for controlling the large language model to perform the following operations based on the fusion analysis result: Generating at least one description file of an advertisement interface layout visually fused with the design theme information, wherein the description file is configured with an interface layout definition visually fused with the design theme information, and From a plurality of pre-set interaction strategies, determine a target interaction strategy that matches the user's real-time context information, and write the interaction logic definition corresponding to the target interaction strategy into the description file.

[0145] The module drives the large language model to perform the collaborative generation task based on the output of the multi-modal fusion analysis module 63.

[0146] Synchronous generation: the model processes UI generation and strategy decision in parallel within a single inference cycle. It does not design the UI first and then match the interaction, but when designing the UI, it already considers the interaction strategy as a core constraint of the UI design. For example, when the model decides to use the "trial reading" strategy, it will reserve the position and style of the button that triggers trial reading while generating the interface layout definition.

[0147] Generating at least one description file: the module can require the large language model to generate multiple (e.g., two) description files that slightly differ in visual style or interaction focus based on the same fusion analysis result according to business needs (such as A / B testing).

[0148] Output: the output of the module is one or more description files in JSON format. Each description file is configured with a complete interface layout definition (i.e., UI structure, style, position) and embedded interaction logic definition corresponding to the target interaction strategy (such as the action type and parameters of the button).

[0149] The file delivery module 65 is used to deliver the target description file determined in the at least one description file to the client.

[0150] The module receives one or more JSON description files generated by the collaborative generation module 64, and delivers the selected target description file to the client that initiates the request through a content distribution network (CDN) or directly through an HTTP response. To improve efficiency, the module supports GZIP compression and records delivery logs for subsequent data analysis and billing.

[0151] Optionally, the server further includes an adjustment and optimization module 66, which is configured to periodically collect historical advertising effect data; attributing the historical advertising effect data using the large language model to identify design elements and interaction strategy combinations that improve advertising effectiveness to obtain attribution analysis results; and adjusting internal weights of the large language model based on the attribution analysis results to optimize the large language model.

[0152] Figure 6 The server of the embodiment shown is modularly designed and deeply integrated with the large language model, realizing end-to-end automation from context perception to creative generation, and can produce diverse and highly personalized native ad description files in real time and intelligently, fundamentally solving the pain points of the lack of flexibility and creativity of traditional advertising systems.

[0153] Embodiment Nine: Client for Native Ad Generation Based on Large Model This embodiment describes the specific implementation of the client device in detail.

[0154] The client is integrated in the form of a software SDK (software development kit) in a mobile application (such as an iOS or Android APP). It relies on the computing power, rendering engine, and network module of the mobile device running the host application, and is responsible for converting the abstract description file issued by the server into a native advertisement experience that users can perceive.

[0155] Figure 7 The client schematic diagram for generating native advertisements based on large models provided by the embodiments of the application is shown in FIG. 1, which includes a request sending module 71, a file receiving module 72, a dynamic rendering engine 73, and an interaction execution module 74. Figure 7

[0156] The request sending module 71 is configured to send an advertisement request to the server, wherein the advertisement request contains real-time context information of a user.

[0157] This module is triggered when an application-defined advertisement position needs to be displayed (such as page initialization, information flow sliding to the bottom). It actively collects real-time context information of the user, including but not limited to: current page content, GPS location information obtained through a system API, device time, network type (Wi-Fi / 5G), and short-term interest tags extracted from user behavior logs. These information are assembled into a lightweight JSON data packet, which is sent to the request receiving module of the server in the form of an HTTPS POST request through the network connection of the device.

[0158] The file receiving module 72 is configured to receive a target description file of an advertisement interface layout from the server; the target description file is determined in at least one description file generated by the server, the description file is generated by the server based on multi-modal fusion analysis of real-time context information of a user, original materials provided by an advertiser, and design theme information of a client application by a large language model, and is configured with interface layout definitions visually fused with the design theme information and interaction logic definitions corresponding to a target interaction strategy, the target interaction strategy being a strategy matching the real-time context information of the user determined from multiple interaction strategies.

[0159] This module listens to network responses and receives a target description file (JSON format) of an advertisement interface layout issued by the server. It is responsible for completing data decryption, decompression (if necessary), and preliminary verification to ensure that the received file is complete and valid. The core attribute of this file is that it is not static material, but a "dynamic blueprint" generated by the server and configured with complete interface layout definitions and interaction strategies.

[0160] ​The dynamic rendering engine 73 is configured to parse and render a target description file to render a native advertisement UI component.

[0161] This is the core technology of the client. After the dynamic rendering engine 73 receives the JSON description file, a parsing and rendering process is started. Parsing and constructing a UI tree: The JSON description file is parsed, and according to the type field, a corresponding native UI component is instantiated through a reflection mechanism to construct a complete UI tree in memory.

[0162] Style mapping (realizing visual fusion): The UI tree is traversed, and the style properties in the style object of the JSON description file are mapped to the corresponding native components. This is a key step to realize the visual originality of the advertisement and the host application. For normal style properties, they are directly applied to the corresponding UI component; for abstract resource references, the resource mapping table of the current active theme of the client is queried to parse them into specific color values. This ensures that the design intention delivered by the server can be accurately and consistently restored on the client.

[0163] The interaction execution module 74 is configured to bind a corresponding event listener to the native advertisement UI component according to the interaction logic definition in the target description file, and trigger the event listener in response to a user interaction operation to execute a corresponding local callback function, wherein the local callback function encapsulates business logic for implementing the target interaction strategy, and performs an advertisement conversion operation by calling a native function of the client.

[0164] This module is responsible for injecting life into the advertisement, making it interactive.

[0165] When binding the corresponding event listener to the native advertisement component, the interaction execution module 74 is configured to: According to the event type and target component identifier specified in the interaction logic definition, locate the corresponding interaction component in the multiple sub-components included in the native advertisement UI component; Register a local callback function for the located interaction component, which is used to execute when an event is triggered to complete the advertisement conversion operation defined by the target interaction strategy.

[0166] For callback function registration, when the dynamic rendering engine 73 parses the interactive component (such as Button) and its action object, the interaction execution module 74 finds the corresponding local method (such as a function that can jump to a reading page) from the preset action processor registry according to action.type. Subsequently, it sets a click listening event for this button component.

[0167] Perform interaction: When the user clicks the ad button, the listening event is triggered, the previously registered local callback function is called, and the action.parameters parameter is passed in, so as to seamlessly perform the native function in the APP, and complete the ad conversion.

[0168] Figure 7 The client of the embodiment shown accurately converts the data "blueprint" issued by the server into a native UI component that is visually unified with the host application and has smooth interaction through a dynamic rendering engine and an interaction execution module. The template limitation of traditional ad SDK is broken, dynamic updating of ad style is realized, and an immersive experience is provided for users.

[0169] Embodiment ten: native ad generation system based on large model In one possible design, Figure 8 A native ad generation system based on a large model is shown, and the embodiment describes in detail how the server and the client of the system work together to realize end-to-end intelligent ad generation.

[0170] The system includes a server and a client, which communicate through well-defined interfaces and jointly complete the generation and display of a native ad.

[0171] Exemplarily, the server of the embodiment is deployed in the cloud and serves as the intelligent core of the entire ad system. Its hardware foundation generally includes a multi-core processor, a large-capacity memory, a high-speed network interface, and a storage system for storing ad materials and model weights. The server includes the following core modules: The request receiving module 81 is configured to receive an ad request from the client, wherein the ad request includes real-time context information of a user.

[0172] The module serves as a high-concurrency network server endpoint that continuously listens to ad requests from the client. When an ad request is received, the module performs security verification, data decryption, and format parsing on the ad request, and extracts a structured JSON object (real-time context information of a user).

[0173] The information obtaining module 82 is configured to obtain original materials provided by an advertiser and design theme information of a client application.

[0174] The module performs two data obtaining tasks in parallel: obtaining matched original materials from an ad material database; and obtaining a currently activated design theme package of the client application by calling a unified configuration service, wherein the theme package defines visual atoms such as a color system, a font specification, a spacing, and a rounded corner.

[0175] a multi-modal fusion analysis module 83 configured to perform multi-modal fusion analysis on the user real-time context information, the original material, and the design theme information based on a large language model.

[0176] This is the intelligent hub of the server side. This module constructs the output of the previous modules into a structured prompt word containing multi-modal information and sends it to the large language model. The large language model performs deep semantic understanding on the prompt word, performs multi-modal fusion analysis, and outputs a structured analysis result.

[0177] a collaborative generation module 84 configured to control the large language model to simultaneously perform the following operations based on the fusion analysis result: generate at least one description file of an advertisement interface layout visually fused with the design theme information, wherein the description file is configured with interface layout definitions visually fused with the design theme information, and determine a target interaction strategy matching the user real-time context information from a plurality of preset interaction strategies, and write interaction logic definitions corresponding to the target interaction strategy into the description file.

[0178] It is particularly critical that the above-mentioned "synchronous generation operation" of the large language model is not a simple superposition of two independent tasks, but a unified and collaborative reasoning process. The large language model integrates the interaction strategy as the core constraint condition of UI design and the visual presentation of UI as the carrier of the interaction strategy in a single semantic understanding cycle. For example, when the model decides to adopt a "trial reading" strategy based on the user's VIP identity and reading scenario, it will simultaneously reserve the button position for triggering trial reading in the generated interface layout, and dynamically generate the "free trial first chapter" button text and "progress bar" visual elements that highly match it. This deep binding of cognition and function ensures the internal consistency and external native feeling of the final advertisement experience, which cannot be achieved by traditional sequential design or simple rule matching.

[0179] a file delivery module 85 configured to deliver the target description file determined in the at least one description file to the client.

[0180] This module receives the JSON description file generated by the collaborative generation module 84 and delivers the selected target description file to the client that initiates the request through a content distribution network (CDN) or directly through an HTTP response.

[0181] Exemplarily, the client of the present embodiment is responsible for converting the abstract description file delivered by the server into a native advertisement experience that can be perceived by the user. The client includes the following core modules: a request sending module 86 configured to send an advertisement request to the server, wherein the advertisement request contains user real-time context information.

[0182] The module is triggered when the application-defined ad position needs to be displayed, actively collects and assembles context information, and sends it to the server through an HTTPS POST request.

[0183] The file receiving module 87 is configured to receive a target description file of an advertisement interface layout from the server.

[0184] The module listens to network responses, receives a JSON format target description file issued by the server, and completes decryption, decompression and preliminary verification.

[0185] The dynamic rendering engine 88 is configured to parse and render the target description file to render and generate a native advertisement UI component.

[0186] This is the core technology of the client. After the dynamic rendering engine 88 receives the JSON description file, the parsing and rendering process is started: Parsing and constructing a UI tree: parsing the JSON description file, instantiating the corresponding native UI component according to the type field, and constructing a complete UI tree in memory.

[0187] Style mapping (realizing visual fusion): traversing the UI tree, applying the style properties in the style object of the JSON description file to the corresponding native components. For normal style properties, they are directly applied to the corresponding UI components; for abstract resource references, the engine queries the resource mapping table of the current active theme of the client, and parses it into specific color values; thereby realizing the perfect visual fusion of the design intention issued by the server and the native environment of the client.

[0188] The interaction execution module 89 is configured to bind corresponding event listeners to the native advertisement UI component according to the interaction logic definition in the target description file, and trigger the event listeners in response to user interaction to execute corresponding local callback functions, wherein the local callback functions encapsulate business logic for implementing the target interaction strategy, and execute advertisement conversion operations by calling native functions of the client.

[0189] The module finds the corresponding local method from the preset action processor registry and binds it when the dynamic rendering engine 88 parses the interactive component according to the action object definition. When the user interacts, the local callback function is triggered to seamlessly execute the native function in the APP.

[0190] The server of the system further includes an adjustment and optimization module not shown in the figure, which is configured to periodically collect historical advertisement effect data; The large language model is used to perform attribution analysis on the historical advertising effect data, to identify a design element and an interaction strategy combination that improves the advertising effect, to obtain an attribution analysis result; and based on the attribution analysis result, internal weights of the large language model are adjusted to optimize the large language model.

[0191] The system displayed in the embodiment realizes a paradigm shift from "static configuration" to "dynamic generation", and through deep cooperation between the server and the client, the generation dimension of the advertisement is improved from "content" to complete "experience". More importantly, the system builds a complete technical closed loop from context perception -> multi-modal fusion analysis -> collaborative generation -> dynamic rendering -> data feedback -> model optimization (data feedback and optimization are shown in embodiment six). The system can automatically perform attribution analysis based on user interaction data and feed back the generation strategy of the large model to realize self-iteration of the advertisement generation system and continuous improvement of the effect, and has long-term self-adaptation capability that the traditional open-loop delivery system does not have.

[0192] In addition, the embodiment of the application provides a non-transitory machine-readable storage medium, and the non-transitory machine-readable storage medium stores executable code. When the executable code is executed by a processor of an electronic device, the processor can at least implement the large model-based native advertisement generation method of the server provided in the foregoing embodiments.

[0193] The device embodiments described above are only schematic, and the units described as separate components can or can not be physically separate. Part or all of the modules can be selected according to actual needs to achieve the purpose of the embodiment. Those skilled in the art can understand and implement without creative labor.

[0194] From the above description of the embodiments, those skilled in the art can clearly understand that the embodiments can be implemented by means of general hardware platforms as necessary, and of course, can also be implemented by means of hardware and software combination. Based on such understanding, the above technical solutions can be embodied in the form of a computer program product, and the application can be implemented in the form of a computer program product containing computer usable program codes in one or more computer usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.).

[0195] It should be noted that the above detailed description is exemplary and is intended to provide further explanation of the present application. Unless otherwise specified, all technical and scientific terms used herein have the same meaning as understood by those skilled in the art to which the present application belongs.

[0196] It is to be understood that the terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of example embodiments in accordance with the present application. As used herein, the singular forms "a", "an" and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms "comprises" and / or "comprising," when used in this specification, specify the presence of stated features, steps, operations, elements, components, and / or groups thereof, but do not preclude the presence or addition of one or more other features, steps, operations, elements, components, and / or groups thereof.

[0197] It should be noted that the terms "first", "second", and the like, herein do not necessarily have an ordinal meaning. Rather, these terms are used herein, inter alia, to distinguish a certain feature from another feature. It should be understood that the use of these terms is not intended to limit the scope of the application to any particular embodiment, but rather, the scope of the application is to be limited only by the claims.

[0198] Furthermore, the term "comprising" and "including" and their variants are intended to cover both the case where only the stated features are present and the case where additional features are also present. For example, a process, method, system, product, or apparatus that comprises or includes only the steps of those explicitly disclosed is still within the scope of the example embodiments.

[0199] For the purposes of the description hereinafter, the terms "upper", "lower", "right", "left", "rear", "front", "vertical", "horizontal", and derivatives thereof shall relate to the application as oriented in the drawings. However, it is to be understood that the application can assume various alternative orientations and, accordingly, such terms are not to be taken as limitations of the present application or any embodiments thereof described herein or is to be understood assuming each alternative orientation. Accordingly, the attached drawings are not necessarily drawn to scale.

[0200] In the detailed description above, reference is made to the accompanying drawings, which form a part hereof. In the drawings, similar symbols typically identify similar components, unless context dictates otherwise. The illustrative embodiments described in the detailed description, drawings, and claims are not meant to be limiting. Other embodiments can be used, and other changes can be made, without departing from the spirit or scope of the subject matter presented herein.

[0201] The above merely provides the preferred embodiments of the present application, and is not used to limit the present application. For those skilled in the art, the present application can have various modifications and changes. Any modifications, equivalent replacements, improvements, etc. made within the principles and technical scope of the present application shall fall into the scope of the present application.

Claims

1. A native ad generation method based on a large model, applied to the server side, characterized in that, The method includes: Receive an advertising request from a client, the advertising request containing real-time user context information; Obtain the original creative materials provided by the advertiser and the design theme information of the client application; Based on a large language model, multimodal fusion analysis is performed on the user's real-time context information, the original materials, and the design theme information; Based on the fusion analysis results, the large language model simultaneously performs the following operations: Generate at least one description file for an advertising interface layout that visually integrates with the design theme information, wherein the description file contains interface layout definitions that visually integrate with the design theme information, and From a plurality of preset interaction strategies, a target interaction strategy that matches the user’s real-time context information is determined, and the interaction logic definition corresponding to the target interaction strategy is written into the description file; The target description file, which is determined in at least one description file, is sent to the client. The client then parses and renders the target description file based on a dynamic rendering engine to display and interact with native advertisements.

2. The method according to claim 1, characterized in that, The real-time context information of the user includes at least one of the following: the type of content the user is currently browsing, the user's geographical location, time information, network environment, and user's historical behavior tags.

3. The method according to claim 1, characterized in that, When the large language model generates a description file for the advertising interface layout, it dynamically generates button text and / or visual guidance elements that match the target interaction strategy.

4. The method according to claim 1, characterized in that, The description file for the advertising interface layout is in JSON format, and the type, style, position, and bound interaction events of the user interface UI components are defined through key-value pairs or structured arrays.

5. The method according to claim 1, characterized in that, The method further includes: Periodically collect historical advertising performance data; The large language model is used to perform attribution analysis on the historical advertising performance data to identify the combination of design elements and interaction strategies that improve advertising performance in order to obtain attribution analysis results. Based on the attribution analysis results, the internal weights of the large language model are adjusted to optimize the large language model.

6. A native ad generation method based on a large model, applied to a client-side application, characterized in that, include: Send an advertising request to the server, the advertising request containing the user's real-time context information; The system receives a target description file for the advertising interface layout from the server. The target description file is determined by at least one description file generated by the server. The description file is generated by the server after performing multimodal fusion analysis on the user's real-time context information, the original materials provided by the advertiser, and the design theme information of the client application based on a large language model. It is configured with an interface layout definition that is visually integrated with the design theme information and an interaction logic definition corresponding to the target interaction strategy. The target interaction strategy is a strategy that matches the user's real-time context information among multiple interaction strategies. The target description file is parsed and rendered using a dynamic rendering engine to generate native advertising UI components. Based on the interaction logic definition in the target description file, bind the corresponding event listener to the native advertising UI component; In response to user interaction, the event listener is triggered to execute the corresponding local callback function. The local callback function encapsulates the business logic for implementing the target interaction strategy and performs ad conversion operations by calling the client's native functions.

7. The method according to claim 6, characterized in that, When the client parses the target description file based on the dynamic rendering engine, it also includes: The abstract style attributes declared in the target description file are mapped to specific resource references in the current active theme of the client. When binding a corresponding event listener to the native advertising UI component, the process includes: locating the corresponding interactive component among the multiple sub-components contained in the native advertising UI component according to the event type and target component identifier specified in the interaction logic definition; Register a local callback function for the located interactive component. The local callback function is executed when the event is triggered to complete the ad conversion operation defined by the target interaction strategy.

8. A server-side application for native ad generation based on a large model, characterized in that, include: The request receiving module is used to receive advertising requests from the client, wherein the advertising requests contain real-time context information of the user; The information acquisition module is used to acquire the original materials provided by the advertiser and the design theme information of the client application; The multimodal fusion analysis module is used to perform multimodal fusion analysis on the user's real-time context information, the original materials, and the design theme information based on a large language model; The collaborative generation module is used to control the large language model to perform the following operations synchronously based on the fusion analysis results: Generate at least one description file for an advertising interface layout that visually integrates with the design theme information, wherein the description file contains interface layout definitions that integrate with the design theme visual information, and From a plurality of preset interaction strategies, a target interaction strategy that matches the user’s real-time context information is determined, and the interaction logic definition corresponding to the target interaction strategy is written into the description file; The file delivery module is used to deliver a target description file determined in at least one description file to the client, which then parses and renders the target description file based on a dynamic rendering engine to display and interact with native advertisements.

9. A client-side application for native ad generation based on a large model, characterized in that, include: The request sending module is used to send an advertising request to the server, wherein the advertising request contains the user's real-time context information; The file receiving module is used to receive a target description file of the advertising interface layout from the server. The target description file is determined by at least one description file generated by the server. The description file is generated by the server after performing multimodal fusion analysis on the user's real-time context information, the original materials provided by the advertiser, and the design theme information of the client application based on a large language model. It is configured with an interface layout definition that is visually integrated with the design theme information and an interaction logic definition corresponding to the target interaction strategy. The target interaction strategy is a strategy that matches the user's real-time context information among multiple interaction strategies. A dynamic rendering engine is used to parse and render the target description file to generate native advertising UI components; The interaction execution module is used to bind corresponding event listeners to the native advertising UI component according to the interaction logic definition in the target description file, and to trigger the event listeners in response to the user's interaction operation to execute the corresponding local callback function. The local callback function encapsulates the business logic that implements the target interaction strategy and performs the advertising conversion operation by calling the native function of the client.

10. A native ad generation system based on a large model, characterized in that, Including server-side and client-side; The client includes: The request sending module is used to send an advertising request to the server, wherein the advertising request contains the user's real-time context information; The file receiving module is used to receive a target description file of the advertising interface layout from the server. The target description file is determined by at least one description file generated by the server. The description file is generated by the server after performing multimodal fusion analysis on the user's real-time context information, the original materials provided by the advertiser, and the design theme information of the client application based on a large language model. It is configured with an interface layout definition that is visually integrated with the design theme information and an interaction logic definition corresponding to the target interaction strategy. The target interaction strategy is a strategy that matches the user's real-time context information among multiple interaction strategies. A dynamic rendering engine is used to parse and render the target description file to generate native advertising UI components; The interaction execution module is used to bind a corresponding event listener to the native advertising UI component according to the interaction logic definition in the target description file, and to trigger the event listener in response to the user's interaction operation to execute the corresponding local callback function. The local callback function encapsulates the business logic that implements the target interaction strategy and performs the advertising conversion operation by calling the native function of the client. The server includes: The request receiving module is used to receive advertising requests from the client, wherein the advertising requests contain real-time context information of the user; The information acquisition module is used to acquire the original materials provided by the advertiser and the design theme information of the client application; The multimodal fusion analysis module is used to perform multimodal fusion analysis on the user's real-time context information, the original materials, and the design theme information based on a large language model; The collaborative generation module is used to control the large language model to perform the following operations synchronously based on the fusion analysis results: Generate at least one description file for an advertising interface layout that visually integrates with the design theme information, wherein the description file contains interface layout definitions that integrate with the design theme visual information, and From a plurality of preset interaction strategies, a target interaction strategy that matches the user’s real-time context information is determined, and the interaction logic definition corresponding to the target interaction strategy is written into the description file; The file delivery module is used to deliver a target description file determined in at least one description file to the client, which then parses and renders the target description file based on a dynamic rendering engine to display and interact with native advertisements.

Images