Sensitive word evolution method, sensitive word identification method, equipment, medium and product

Abstract

The invention discloses a sensitive word evolution method, a sensitive word recognition method, equipment, a medium and a product. The method comprises the steps of obtaining a sensitive word seed set; initializing an evolution diagram according to the sensitive word seed set, and initializing an evolvable node pool according to the evolution diagram; determining an evolution factor corresponding to each evolvable node in the evolvable node pool, determining an evolution priority of the evolvable nodes according to the evolution factors, screening out nodes to be evolved according to the evolution priority of each evolvable node, and determining a target evolution operator of each node to be evolved; evolving the node to be evolved according to the target evolution operator, and updating the evolution diagram and the evolvable node pool according to a variant obtained through evolution; judging whether an evolution stop condition is met or not, and if yes, generating a sensitive word variant set according to variants obtained through evolution; and if not, returning to execute the step of determining the evolution factor, so that the problem that the sensitive words cannot be systematically generated is solved, a large number of sensitive words are automatically generated, and the generation efficiency of the sensitive words is improved.

Description

Technical Field

[0001] This application relates to the field of data processing technology, and in particular to sensitive word evolution methods, sensitive word recognition methods, devices, media and products. Background Technology

[0002] With the rapid development of internet social networking and content production, the ways in which sensitive information is expressed are becoming increasingly covert and evolving rapidly. From similar-looking characters, homophones, pinyin abbreviations, and simplified / traditional character conversions to inserting interfering characters, splitting spaces, scrambling order, using emojis / English homophones, and slang terms, a variety of combinations and variations are constantly emerging, leading to different methods for identifying sensitive words. The way sensitive information is expressed affects the recognition of sensitive words. When identifying sensitive words through model training or rule-based methods, the more ways sensitive information is expressed, the higher the accuracy of sensitive word recognition. Current technologies cannot systematically generate a large number of sensitive words quickly; therefore, how to systematically generate sensitive words expressed in different ways has become a problem to be solved. Summary of the Invention

[0003] This application provides a sensitive word evolution method, a sensitive word recognition method, equipment, media, and products to achieve the systematic generation of sensitive words, automatically generate a large number of sensitive words, and improve the generation efficiency of sensitive words.

[0004] According to one aspect of this application, a sensitive word evolution method is provided, comprising:

[0005] Obtain a sensitive word seed set, the sensitive word seed set including at least one sensitive word; initialize an evolution graph based on the sensitive word seed set, and initialize an evolutionary node pool based on the evolution graph;

[0006] Determine the evolution factor corresponding to each evolvable node in the evolvable node pool, determine the evolution priority of the evolvable node based on the evolution factor, select nodes to be evolved based on the evolution priority of each evolvable node, and determine the target evolution operator for each node to be evolved.

[0007] The node to be evolved is evolved according to the target evolution operator, and the evolution graph and the pool of evolveable nodes are updated according to the variants obtained from the evolution.

[0008] Determine whether the evolution stopping condition is met. If yes, generate a set of sensitive word variants based on the variants obtained from the evolution. If no, use the updated evolution graph as the new evolution graph and the updated pool of evolvable nodes as the new pool of evolvable nodes, and return to the step of determining the evolution factor corresponding to each evolvable node in the pool of evolvable nodes.

[0009] According to another aspect of this application, a sensitive word identification method is provided, comprising:

[0010] The sensitive word variant set is processed based on a pre-constructed multidimensional sample coverage matrix to generate at least one original corpus. The sensitive word variant set is generated using the sensitive word evolution method as described in any embodiment of this application.

[0011] At least one sample pair is constructed based on the original corpus, and each sample pair includes a positive example pair and a negative example pair.

[0012] Based on each of the aforementioned sample pairs, a hierarchical corpus is constructed to generate a hierarchical corpus.

[0013] The sensitive word recognition model is obtained by training the model based on the hierarchical corpus sets, and the sensitive word recognition model is used to identify sensitive words.

[0014] According to another aspect of this application, an electronic device is provided, the electronic device comprising:

[0015] At least one processor, and a memory communicatively connected to said at least one processor;

[0016] The memory stores a computer program that can be executed by the at least one processor, and the computer program is executed by the at least one processor to enable the at least one processor to execute the sensitive word evolution method or sensitive word recognition method described in any embodiment of this application.

[0017] According to another aspect of this application, a computer-readable storage medium is provided, the computer-readable storage medium storing computer instructions, the computer instructions being configured to cause a processor to execute and implement the sensitive word evolution method or sensitive word recognition method described in any embodiment of this application.

[0018] According to another aspect of this application, a computer program product is provided, the computer program product including a computer program that, when executed by a processor, implements the sensitive word evolution method or sensitive word recognition method described in any embodiment of this application.

[0019] The technical solution of this application embodiment involves: obtaining a sensitive word seed set, wherein the sensitive word seed set includes at least one sensitive word; initializing an evolution graph based on the sensitive word seed set, and initializing an evolvable node pool based on the evolution graph; determining the evolution factor corresponding to each evolvable node in the evolvable node pool, and determining the evolution priority of the evolvable node based on the evolution factor; selecting nodes to be evolved based on the evolution priority of each evolvable node, and determining the target evolution operator for each node to be evolved; evolving the nodes to be evolved according to the target evolution operator, and updating the evolution graph and the evolvable node pool based on the evolved variants; determining whether the evolution stopping condition is met; if yes, generating a sensitive word variant set based on the evolved variants; if no, using the updated evolution graph as the new evolution graph, and the updated evolvable node pool as the new... An evolvable node pool is used to return to the step of determining the evolution factor corresponding to each evolvable node in the evolvable node pool, solving the problem of the inability to systematically generate sensitive words. An evolution graph is initialized through a sensitive word seed set, and an evolvable node pool is initialized based on the evolution graph. Evolvable nodes are stored in the evolvable node pool for subsequent sensitive word evolution. Evolution priorities are determined based on the evolution factors of the evolvable nodes, and nodes to be evolved are selected. The nodes to be evolved are then evolved using the target evolution operator corresponding to the nodes to be evolved, resulting in variants. Finally, the evolution graph and the evolvable node pool are updated based on the variants. If the evolution stopping condition is met, a sensitive word variant set is generated based on the variants, completing the sensitive word evolution; otherwise, evolution continues. The method provided in this application embodiment achieves systematic generation of sensitive words, automatically generating a large number of sensitive words and improving the generation efficiency of sensitive words.

[0020] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this application, nor is it intended to limit the scope of this application. Other features of this application will become readily apparent from the following description. Attached Figure Description

[0021] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0022] Figure 1 This is a flowchart of a sensitive word evolution method provided in Embodiment 1 of this application;

[0023] Figure 2 This is a flowchart of a sensitive word evolution method provided according to Embodiment 2 of this application;

[0024] Figure 3 This is a flowchart of a sensitive word recognition method provided according to Embodiment 3 of this application;

[0025] Figure 4 This is an example diagram illustrating the implementation of sensitive word recognition according to Embodiment 3 of this application;

[0026] Figure 5 This is a schematic diagram of a sensitive word evolution device according to Embodiment 4 of this application;

[0027] Figure 6 This is a schematic diagram of a sensitive word recognition device according to Embodiment 5 of this application;

[0028] Figure 7 This is a schematic diagram of the structure of an electronic device according to Embodiment Six of this application. Detailed Implementation

[0029] To enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present application, and not all embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative effort should fall within the scope of protection of the present application.

[0030] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0031] Example 1

[0032] Figure 1 This is a flowchart illustrating a sensitive word evolution method provided in Embodiment 1 of this application. This embodiment is applicable to situations involving the evolution of sensitive words. The method can be executed by a sensitive word evolution device, which can be implemented in hardware and / or software and can be configured in an electronic device. Figure 1 As shown, the method includes:

[0033] S101. Obtain a sensitive word seed set, which includes at least one sensitive word; initialize the evolution graph based on the sensitive word seed set, and initialize the pool of evolvable nodes based on the evolution graph.

[0034] In this embodiment, the sensitive word seed set can be understood as a set composed of sensitive words; the evolution graph can be understood as a graph structure that stores the relationship between sensitive words and their variants. The evolvable node pool can be understood as a data pool composed of nodes that can evolve.

[0035] Sensitive words are collected from different channels to form a sensitive word seed set. These collected sensitive words can be processed accordingly, and the resulting sensitive word seed set is formed based on the processed sensitive words. The processing of sensitive words can include standardization and deduplication to ensure data quality. Each sensitive word in the sensitive word seed set is used as a node in an evolutionary graph, generating the evolutionary graph. During the initialization of the evolutionary graph, the attribute information of each node is determined and saved to the evolutionary graph. The attribute information can include at least one of the following: node identifier, word text, node type, evolution level, out-degree, in-degree, saturation state, evolvable state, transformation trajectory, quality score, variant attributes, and language tag. The attribute information of the nodes in the evolutionary graph is analyzed to identify nodes that can undergo further evolution. These nodes are added to the evolvable node pool, completing the initialization of the evolvable node pool. For example, during the initialization phase, all nodes can be added to the evolvable node pool as evolvable nodes, and the evolvable node pool is continuously updated during subsequent evolution.

[0036] This application embodiment collects sensitive words from multiple channels and performs standardization and deduplication processing to output a standardized sensitive word seed set. Data collection can be carried out from one or more channels such as domain expert annotation, historical interception logs, public sensitive word databases, user report review, and related expansion discovery to collect sensitive words and generate an original seed word set Seeds_raw. Then, standardization processing (full-width / half-width conversion, simplified / traditional character conversion, standardization of decorative symbols, deletion of zero-width characters, merging of consecutive whitespace, etc.) and language recognition (determining the language category of characters according to the Unicode code point range) are performed on Seeds_raw, and metadata is supplemented. Finally, a standardized seed word set Seeds_standardized is output, where each element contains the sensitive word text, source_type, language tag language_tag (value range is {Chinese zh, English en, ja, ko, mixed, numeric, symbol, uncertain}), and metadata.

[0037] S102. Determine the evolution factor corresponding to each evolvable node in the evolvable node pool, determine the evolution priority of the evolvable node based on the evolution factor, select the nodes to be evolved based on the evolution priority of each evolvable node, and determine the target evolution operator for each node to be evolved.

[0038] In this embodiment, the evolution factor can be understood as a parameter used to control the evolution of nodes. The evolution priority can be understood as a priority order used to represent the evolution of nodes. The node to be evolved can be understood as a node with evolution requirements. The target evolution operator can be understood as an operator used to evolve the node; the operator can be a morphological, speech, structural, semantic, cross-modal, or other type of operator.

[0039] Each evolvable node in the evolvable node pool is identified. An evolutionary factor for each evolvable node is determined based on one or more information sources, including its attribute information and information formed during its historical evolution. This evolutionary factor can include one or more types of factors. The evolutionary priority of each evolvable node is further calculated based on the evolutionary factor. For example, a weighted fusion of each evolutionary factor is used to obtain the evolutionary priority. The evolutionary factors are compared, and one value is selected as the evolutionary priority, such as the maximum or minimum value. The evolutionary priorities of each evolvable node are compared, and nodes to be evolved are selected based on these priorities. For example, nodes with higher priority levels are selected as nodes to be evolved. In this embodiment, a preset number of evolvable nodes can be selected as nodes to be evolved. This preset number can be a fixed value or the total number of evolvable nodes multiplied by a certain proportion. Alternatively, all evolvable nodes can be selected as nodes to be evolved. One or more operators are predetermined, and a suitable operator is selected as the target evolution operator for each node to be evolved. For example, the operators are selected based on the attribute information of the node to be evolved and the operators used in the past, so as to determine the target evolution operator used by the node in this evolution.

[0040] S103. Evolve the nodes to be evolved according to the target evolution operator, and update the evolution graph and the pool of evolveable nodes according to the variants obtained from the evolution.

[0041] The evolution of a node to be evolved based on a target evolution operator can be achieved by calling the function corresponding to the target evolution operator to process the node. For example, if the target evolution operator is a structural dimension operator, the structure of the node to be evolved can be adjusted by calling the structural dimension operator to obtain the evolved variant. After determining the target evolution operator for each node to be evolved, each node is evolved separately to obtain the evolved variant. For example, if the node to be evolved is sensitive, the evolved variant is sensitive-sensitive. The evolved variants are then directly added to the evolution graph and the pool of evolving nodes to update them. Alternatively, the quality of the evolved variants can be judged, and variants that meet the quality requirements are added to the evolution graph and the pool of evolving nodes, while variants that do not meet the requirements are discarded, and so on.

[0042] S104. Determine whether the evolution stopping condition is met. If yes, proceed to S105; otherwise, proceed to S106.

[0043] In this embodiment, the evolution stopping condition can be understood as the condition for whether to continue evolution. The evolution stopping condition can be preset. For example, it can be determined that the evolution stopping condition is met when no more evolveable nodes are detected, or when the number of variants reaches a set value, etc. Here, the set value can be a fixed value, or it can be N times the number of sensitive words in the sensitive word seed set, etc. The evolution stopping condition is preset, and it is determined whether the evolution stopping condition is met. If it is met, S105 is executed to end the sensitive word evolution; if it is not met, S106 is executed to start the next iteration and continue the sensitive word evolution.

[0044] S105. Generate a set of sensitive word variants based on the variants obtained from the evolution.

[0045] In this embodiment, the sensitive word variant set can be understood as a dataset storing variants of sensitive words. After the evolution stopping condition is met, the evolution stops, and the evolved variants are added to the set to form the sensitive word variant set. All evolved variants can be added to the set, or only variants that meet the quality requirements can be added to the set, and so on.

[0046] S106. Use the updated evolution graph as the new evolution graph and the updated pool of evolvable nodes as the new pool of evolvable nodes, and return to the execution of step S102.

[0047] Based on the updated evolution graph, the updated nodes and their attribute information are determined. The updated pool of evolvable nodes is used as the new pool of evolvable nodes, and evolution continues based on the new pool. The process then returns to step S102 to redetermine the evolution factor corresponding to each evolvable node. In this embodiment, updating the evolvable node pool includes updating it based on a variant, and may also include updating the original nodes in the pool, and then updating the pool based on the updated nodes. The updated evolution graph is used as the new evolution graph, and evolution continues. During the evolution process, the evolution graph can be queried to obtain the corresponding attribute information of the nodes and the relationships between nodes.

[0048] This application provides a sensitive word evolution method to solve the problem of the inability to systematically generate sensitive words. It initializes an evolution graph through a sensitive word seed set and initializes an evolvable node pool based on the evolution graph. The evolvable node pool stores evolvable nodes for subsequent sensitive word evolution. Evolution priorities are determined based on the evolution factors of the evolvable nodes, thereby selecting nodes to be evolved. The nodes to be evolved are then evolved using the target evolution operator corresponding to the nodes to be evolved, resulting in variants. Finally, the evolution graph and the evolvable node pool are updated based on the variants. If the evolution stopping condition is met, a sensitive word variant set is generated based on the variants, completing the sensitive word evolution; otherwise, the evolution continues. This method provides a systematic way to generate sensitive words, automatically generating a large number of sensitive words and improving the efficiency of sensitive word generation.

[0049] Example 2

[0050] Figure 2 This is a flowchart illustrating a sensitive word evolution method provided in Embodiment 2 of this application. This embodiment is a refinement based on the above embodiments. Figure 2 As shown, the method includes:

[0051] S201. Obtain a sensitive word seed set, which includes at least one sensitive word; initialize the evolution graph based on the sensitive word seed set, and initialize the pool of evolvable nodes based on the evolution graph.

[0052] S202. Determine the evolution factor corresponding to each evolvable node in the evolvable node pool.

[0053] Optionally, determine the evolution factor corresponding to each evolvable node in the evolvable node pool, including at least one of the following A1-A5:

[0054] A1. Determine the evolved target cell of the evolving node based on the predetermined variant evolution matrix; determine the target quantity and the number of effective samples based on the target cell; determine the quantity gap based on the target quantity and the number of effective samples; and determine the quantity gap factor based on the quantity gap.

[0055] In this embodiment, the variant evolution matrix can be understood as a multi-dimensional matrix used to control the evolution of sensitive word variants belonging to combinations of each dimension, for example, controlling the number of sensitive word variants belonging to combinations of each dimension. The target cell is a cell in the variant evolution matrix. The target quantity can be understood as the total number of samples required for the target cell under this dimensional combination; the effective sample quantity can be understood as the number of effective samples. The quantity gap can be understood as the number of missing samples; the quantity gap factor can be understood as a parameter describing the quantity gap.

[0056] The values ​​of different dimensions are predetermined, and a variant evolution matrix is ​​generated based on the values ​​of different dimensions. The variant evolution matrix includes different cells, each cell corresponding to a combination of dimensions. For example, the variant evolution matrix in this application embodiment can be a four-dimensional matrix, with the four dimensions being mechanism, variant length, degree tier, and evolution level. The value range of the four dimensions can be as follows: the mechanism dimension is divided into five categories: shape, phonetic, structure, semantic, and mixed (cross-modal mechanism can be used in four-level evolution); the variant length dimension is divided into three levels according to the number of variant characters: short≤5 / medium 6-15 / long>15; the degree tier dimension is divided into three levels according to node degree: low (unpopular), medium (common), and high (popular); the evolution level dimension is divided into four levels according to complexity: level 1 (single-step), level 2 (multi-step), level 3 (cross-mechanism), and level 4 (cross-modal). The four-dimensional partitioning covers the mechanistic, length, popularity, and complexity characteristics of variants, forming a comprehensive description of the sample space.

[0057] Each cell in the variant evolution matrix supports unified management of quality and quantity. Each cell contains at least one of the following fields: samples (sample_id → sample_object, containing quality information), total_count (total number of generated samples), valid_count (number of valid samples with quality_label="pass"), quota_target (target number of samples), quality_distribution (quality distribution dictionary, recording the number of samples for each quality level, with values ​​ranging from excellent / good / fair / poor / disputed), and weighted_count (quality weighted count). The quality weighted count is calculated using the formula weighted_count = Σ(quality_weight × count), with weights configured as excellent = 1.0 / good = 0.8 / fair = 0.5 / poor = 0.0 / disputed = 0.3. Enhanced cells can manage both quantity and quality simultaneously, ensuring that the quality and quantity of generated variants meet the requirements at the same time, avoiding the data inconsistency problem caused by the separation of quality and quantity statistics in traditional methods. The target number of a cell can be pre-allocated and stored in a coverage matrix Matrix_coverage_target, with the number of valid samples continuously updated during the evolution process. The overall target `total_count` can be set according to training needs (e.g., 80,000-100,000 samples), and the target number for each cell is allocated according to the importance of the dimensions. The number of Level 1 variants is relatively large (50-100 samples per combination) because Level 1 variants are single-step, single-dimensional transformations (e.g., "sensitive" → "sensitive 0 sense"), with low complexity and stable quality; the number of Level 2 variants is moderate (30-50 samples per combination) because Level 2 variants are multi-step, same-dimensional transformations (e.g., "sensitive" → "sensitive 0 sense" → "sensitive 0 sense 0"), with moderate complexity; the number of Level 3 variants is relatively small (20-30 samples per combination) because Level 3 variants are cross-mechanism combination transformations (e.g., morphology + structure combination), with high complexity; the number of Level 4 variants is the smallest (10-20 samples per combination) because Level 4 variants are cross-modal round-trip transformations (e.g., OCR / ASR noise), with the highest complexity but scarce samples. The number is adjusted according to degree: the number of less common spelling combinations is increased (×1.5), and the number of popular spelling combinations is decreased (×0.7). The quantity allocation strategy takes into account three factors: sample complexity, popularity, and training requirements.

[0058] A variant evolution matrix is ​​predetermined, and the parameters of each cell in the current variant evolution matrix are analyzed. Based on the parameters of the cells, the target cells after evolution are selected for the evolving nodes. For example, the cell with the fewest effective samples is selected as the target cell. The target number and the number of effective samples corresponding to the target cell are determined, and the difference between the target number and the number of effective samples is calculated to obtain the number gap. Different number gaps correspond to different degrees of gap. A number gap factor is predetermined for each degree of gap. After determining the number gap, the corresponding number gap factor is determined according to the size of the number gap.

[0059] For example, for each evolvable node, predict the coverage cell to which its evolved variant will belong, and use this cell as the target cell. Based on information such as `node.mechanism` (inherited from the parent node or seed term `domain`), `node.evolution_level` (current evolution level), and `node.degree_tier` (degree tier), predict the target cell and query the quantity gap of the target cell from `Matrix_coverage_target`: `gap = target quantity quota_target - valid number of valid samples`. Calculate the quantity gap factor `coverage_gap_factor`: determine the gap degree based on the quantity, and then determine the quantity gap factor based on the gap degree. Gap degrees include: critical gap, high gap, medium gap, and low gap. For critical gaps (gap > 0.5 × quota_target and valid_count = 0), coverage_gap_factor = 1.0; for high gaps (gap > 0.5 × quota_target), coverage_gap_factor = 0.8; for medium gaps (gap > 0.15 × quota_target), coverage_gap_factor = 0.5; for low gaps or those already met, coverage_gap_factor = 0.2. The larger the quantity gap, the higher this factor, prioritizing nodes that can fill critical and high gaps.

[0060] A2. Determine the degree stratification factor of the evolvable node based on the variant properties of the evolvable node.

[0061] In this embodiment, the degree tier factor can be understood as the parameters corresponding to nodes in different tiers. Different degree tier factors corresponding to variant attributes are pre-set to determine the variant attributes of the evolvable nodes. Based on the relationship between the variant attributes and the degree tier factor, the degree tier factor of the evolvable nodes is determined. For example, the variant attributes can be low-degree nodes, medium-degree nodes, or high-degree nodes; low-degree nodes (uncommon writing methods) have a degree tier factor of 1.0, the highest priority, ensuring that uncommon writing methods are fully evolved and avoided omissions; medium-degree nodes (common writing methods) have a degree tier factor of 0.6, a medium priority; high-degree nodes (popular writing methods) have a degree tier factor of 0.3, a lower priority, to avoid excessive evolution of popular writing methods leading to an imbalance in sample distribution.

[0062] A3. Query the evolution path table to determine the outgoing edges of the evolvable nodes, determine the list of applied operators based on the outgoing edges of the evolvable nodes, filter the total number of applicable operators for the evolvable nodes from the operator registry, and determine the evolution potential factor based on the length of the list of applied operators and the total number of applicable operators.

[0063] In this embodiment, the evolution path table can be understood as a data table storing information related to the evolution path of each node. This information may include the evolved node, the operators used in the evolution, etc. Outgoing edges of an evolvable node can be understood as the edge relationships between the evolvable node and variants generated during the historical evolution process. The list of applied operators can be understood as a list of operators that have already been used. The operator registry is used to store pre-registered operators of different types; each type can also have multiple different operators, and each operator has pre-defined applicable conditions. The total number of applicable operators can be understood as the total number of operators suitable for the evolution of an evolvable node. The evolution potential factor can be understood as a parameter representing the evolution potential of an evolvable node.

[0064] An evolution path table is pre-generated to store path-related information generated by different nodes during evolution. Initially empty, the table is updated in real-time as evolution progresses. The table is queried to identify nodes matching the evolving nodes. Outgoing edges of these nodes are determined based on their evolution path information. The operators used by the evolving nodes when evolving these edges are identified, and different used operators are determined for different outgoing edges, forming an applied operator list. Different operators and their applicable conditions are determined from the operator registry. Applicable operators for the evolving nodes are determined based on these conditions, and the total number of applicable operators for each evolving node is calculated. The length of the applied operator list is obtained based on the number of applied operators in the list. The ratio of the applied operator list length to the total number of applicable operators is calculated, and this ratio is used to determine the evolution potential factor. For example, this ratio can be used as the evolution potential factor, and the result of 1 minus the ratio can be used as the evolution potential factor.

[0065] For example, the evolution potential factor (evolution_potential_factor) can be calculated as follows: Evolution potential is calculated based on the number of operators tried by a node. The outgoing edges generated for the node are queried from the evolution path table `Graph_evolution.explored_paths` (a hash table), and the list of applied operators (`tried_operators`) is extracted. The total number of applicable operators (`total_applicable_operators`) is filtered from the operator registry `Registry_operator` (based on criteria such as `language_tag` and `evolution_level`). The tried ratio (`tried_ratio`) is calculated as `len(tried_operators) / total_applicable_operators`. The evolution potential factor (evolution_potential_factor) is 1.0 - `tried_ratio`, with nodes that are not fully explored (lower `tried_ratio`) having higher priority, and nodes that are fully explored (higher `tried_ratio`) having lower priority.

[0066] A4. Obtain the quality score of the evolvable node as a quality factor.

[0067] In this embodiment, the quality factor can be understood as a parameter describing the quality of a node. After the evolutionary generation of variants is completed, the variants are given a quality score, and this score is saved. Alternatively, if a sensitive word is used as a seed and has not undergone quality evaluation, a default quality score can be set. The quality score can be saved as attribute information along with the node (i.e., seed or variant) in the evolutionary graph. During the evolution process, the evolutionary graph is directly queried to determine the quality score of evolveable nodes. If an evolveable node is a variant (not a seed word), its quality score is generated after quality evaluation. If the node is a seed word or has not yet undergone quality evaluation, a default quality score is set, for example, a quality score of quality_factor = 0.8 (assuming moderate quality). High-quality nodes are more likely to have high-quality offspring, so high-quality nodes are prioritized for evolution.

[0068] A5. Calculate the current number of level 4 variants and the total number of variants based on the variant evolution matrix. Determine the proportion of level 4 variants based on the current number of level 4 variants and the total number of variants. Determine the level 4 variant ratio control factor based on the proportion of level 4 variants.

[0069] In this embodiment, the current number of level 4 variants can be understood as the number of level 4 variants in the current evolution iteration round, and a level 4 variant can be understood as a variant with an evolution level of level 4; the total number of variants can be understood as the total number of all variants obtained through evolution. The proportion of level 4 variants can be understood as the percentage of level 4 variants in the total number of variants; the level 4 variant proportion control factor can be understood as a parameter used to control the proportion or number of level 4 variants.

[0070] Based on the evolutionary level and sample size of the variants stored in the variant evolution matrix, statistics are performed to obtain the current number of level 4 variants and the total number of variants. The ratio of the current number of level 4 variants to the total number of variants is taken as the proportion of level 4 variants. An initial value for the level 4 variant proportion control factor is preset, and the initial value of the level 4 variant proportion control factor is adjusted according to the level 4 variant proportion to determine the level 4 variant proportion control factor; alternatively, a correspondence between different levels of level 4 variant proportion and the level 4 variant proportion control factor is preset, and the level 4 variant proportion control factor is determined according to the correspondence after determining the level 4 variant proportion.

[0071] For example, if a node's `evolution_level` is greater than or equal to 3 (potentially generating level 4 variants), check the global proportion of level 4 variants. Calculate the ratio of level 4 variants (`ratio_level4`) from the `Matrix_coverage_target` count of the current number of level 4 variants (`count_level4`) and the total number of variants (`count_total`). If `ratio_level4` is greater than or equal to `ratio_level4_max` × 0.8 (close to the 15% upper limit), reduce the weight of higher-level nodes, and set the level 4 variant proportion control factor `level4_control_factor` to 0.5; otherwise, set `level4_control_factor` to 1.0. This factor is used to control the proportion of level 4 variants to not exceed the 15% upper limit.

[0072] Optionally, the evolved target cell of the evolvable node is determined according to a predetermined variant evolution matrix, including: determining the coverage state of each cell of the variant evolution matrix, wherein the coverage state is determined based on the number of valid samples, sample quality and quality weight corresponding to the cell; and determining the evolved target cell of the evolvable node based on the coverage state of each cell.

[0073] In this embodiment, coverage status can be understood as describing the coverage of the cell by the samples already generated in the cell. The coverage status of each cell in the variant evolution matrix is ​​determined. The coverage status of each cell can be stored in a coverage statistics table. The coverage status can be determined based on the number of valid samples, sample quality, and quality weight corresponding to the cell. For example, the quality weight corresponding to each variant is determined based on its sample quality. The number of valid samples of the same quality is counted to obtain the number of valid samples. The number of valid samples is multiplied by the corresponding quality weight to obtain the weighted sample number. The weighted sample numbers of different qualities corresponding to this cell are added together to obtain the quality-weighted count corresponding to the cell. The quality-weighted count is divided by the target number to obtain the coverage status. The coverage status of each cell is compared, and the cell with the poorest coverage status is selected as the target cell for the evolution of the evolveable node. For example, the coverage status can be blank, severely insufficient, moderately insufficient, or sufficient, etc. Cells with poor quality, such as blank, severely insufficient, and moderately insufficient, are preferentially selected as target cells for evolution to avoid large differences in the number of samples among cells and to balance the evolution process.

[0074] For example, in the initial stage of evolution, the coverage statistics table Stats_coverage_current can be initialized, with all cells having current_count=0 and coverage_rate=0, and all cells marked with priority=high and added to the priority list List_priority_fill. Coverage status rules are defined: coverage_rate=0 represents a blank cell, 0 < coverage_rate < 0.5 represents a severely insufficient cell, 0.5 < coverage_rate < 0.8 represents a moderately insufficient cell, and coverage_rate ≥ 0.8 represents a sufficient cell. Blank and severely insufficient cells are marked with priority=high, moderately insufficient cells with priority=medium, and sufficient cells with priority=low. These coverage status rules are used to dynamically adjust the generation strategy during subsequent iterations, selecting a suitable evolution direction (i.e., target cell) for the node to be evolved.

[0075] S203. Weight at least one of the evolutionary factors to be weighted according to the factor weighting coefficient to obtain a weighted score.

[0076] In this embodiment, the factor weighting coefficient can be understood as the coefficient used to weight the factors to be weighted, and the factor weighting coefficient can be preset. The factors to be weighted can be understood as evolutionary factors with weighting requirements, and the factors to be weighted can be quantity gap factors, degree stratification factors, evolutionary potential factors, or quality factors. Evolutionary factors may include multiple types of factors, and each type of factor can be used as a factor to be weighted. At least one factor to be weighted among the evolutionary factors is determined, and the factor to be weighted can be a quantity gap factor, degree stratification factor, evolutionary potential factor, or quality factor; the factor weighting coefficients of different factors to be weighted are preset, and the at least one factor to be weighted is weighted and summed according to the factor weighting coefficients to obtain a weighted score.

[0077] For example, the factor weighting coefficients Weights_node_priority are w1, w2, w3, and w4: w1=0.4, representing the factor weighting coefficient for the quantity gap factor (the larger the cell gap, the higher the priority); w2=0.3, representing the factor weighting coefficient for the degree stratification factor (low-degree nodes are prioritized to ensure coverage of less common writing methods); w3=0.2, representing the factor weighting coefficient for the evolution potential factor (nodes that have not been fully explored are prioritized); and w4=0.1, representing the factor weighting coefficient for the quality factor (high-quality nodes are prioritized). This four-factor weighting design ensures that the quantity gap dominates the generation direction, while also taking into account coverage of less common writing methods, evolution potential, and quality assurance.

[0078] S204. Determine whether the evolvable node meets the conditions for generating a fourth-level variant. If yes, proceed to S205; otherwise, proceed to S206.

[0079] In this embodiment, the fourth-level variant generation condition can be understood as the condition for determining whether an evolvable node can generate a fourth-level variant; for example, if the evolution level of an evolvable node is greater than or equal to level 3, it can be considered to meet the fourth-level variant generation condition. The fourth-level variant generation condition is preset, and it is determined whether the evolvable node meets the fourth-level variant generation condition. If yes, S205 is executed; if no, S206 is executed.

[0080] S205. The product of the weighted score and the fourth-level variant proportion control factor in the evolution factor is determined as the evolution priority of the evolvable node.

[0081] S206. Determine the weighted score as the evolution priority of the evolving nodes.

[0082] S207. Select the nodes to be evolved based on the evolution priority of each evolving node.

[0083] S208. Filter the operators in the operator registry according to the list of applied operators, language tags, and evolution levels corresponding to the node to be evolved, and generate a list of available operators for the node to be evolved.

[0084] In this embodiment, the list of available operators can be understood as a list of available operators, and available operators can be understood as operators that can be used to evolve the node to be evolved. The evolution path table is queried to determine the list of applied operators corresponding to the node to be evolved. The evolution graph is queried to determine the attribute information of the node to be evolved, and the language tag and evolution level are determined based on the attribute information. All operators in the operator registry and the applicable conditions for each operator are determined. Operators in the list of applied operators are removed from the obtained operators. The remaining operators are matched with the language tag and evolution level, and the successfully matched operators are taken as available operators, generating the list of available operators.

[0085] S209. Determine the evolution mechanism requirements based on the target cell after the evolution of the evolvable node.

[0086] Determine the target cell after the evolution of the evolvable node, take the mechanism dimension to which the target cell belongs as the mechanism requirement after evolution, and describe the evolution requirements of the evolvable node through the mechanism requirements.

[0087] S210. Adjust the basic weights of the available operators in the list of available operators according to the mechanism requirements, and determine the weights of each available operator.

[0088] Each operator has a pre-set base weight, which can be set during the evolution initialization phase. The mechanism requirements are matched with the dimensions of the available operators in the list of available operators, and the base weights of the successfully matched available operators are adjusted. For example, the base weights of the successfully matched available operators are increased, and the weights of each available operator are determined based on the weight adjustment.

[0089] S211. Determine the target evolution operator based on the weights of each available operator.

[0090] Compare the weights of each available operator and select the available operator with the higher weight as the target evolution operator.

[0091] For example, this application provides a method for filtering target evolution operators: For each evolvable node, query the explored paths: query the existing outgoing edges of the node from Graph_evolution.explored_paths, and extract the list of applied operators: tried_operators = [op1_id, op2_id, ...]. Filter applicable operators from the operator registry Registry_operator and exclude applied operators. Filter language-adaptive operators based on the node's language_tag; filter level-adaptive operators based on the node's evolution_level (evolution_level=0-2 can use shape / phonetic / structure / semantic, evolution_level≥3 can use cross_modal cross-modal operators); exclude operators already tried in tried_operators, and generate a list of available operators: available_operators. If available_operators is empty, mark the node expandable=False (no available operators) and remove it from the node pool.

[0092] The basic weights of different types of available operators are obtained based on `Weights_operator`, for example, `shape=1.0`, `phonetic=1.0`, `structure=0.8`, `semantic=0.6`, and `mixed=0.5`. The weights are adjusted according to the target cell's mechanism requirements; for example, if the cell requires a `shape` mechanism and the operator is a `shape` dimension, the weight is multiplied by 1.5. Operators are then sorted in descending order of their adjusted weights. For each node, an operator `operator_selected` is randomly selected from `node.available_operators_filtered` according to its weight (or the operator with the highest weight is selected greedily). This list of available operators can also be recorded as a candidate list. For each available operator in the list, a candidate operator is recorded, and a path signature for the candidate operator is generated: `signature = hash(node_id + operator_id + operator_parameters)`. The signature is checked against `Graph_evolution.explored_paths`; if it exists, it is removed from the candidate list (to avoid redundant evolution). The final list is then used as the list of available operators. After filtering, each node to be evolved is associated with a list of available operators: node.available_operators_filtered.

[0093] S212. Evolve the nodes to be evolved according to the target evolution operator, and update the evolution graph and the pool of evolveable nodes according to the variants obtained from the evolution.

[0094] S213. Determine whether the evolution stopping condition is met. If yes, execute S214; otherwise, execute S215.

[0095] Optionally, determining whether the evolution stopping condition is met includes: determining evolutionary state information based on the evolution graph and the coverage statistics table, wherein the evolutionary state information includes at least one of the following: variant set state, node pool evolvable state, quantity gap, quality gap; the coverage statistics table stores the coverage state of each cell in the variant evolution matrix; and determining whether the evolution stopping condition is met based on the evolutionary state information.

[0096] In this embodiment, evolutionary state information can be understood as information used to represent the current evolutionary situation. The evolutionary state information in this embodiment includes at least one of the following: variant set state, node pool evolvable state, quantity gap, and quality gap. The variant set state describes information about currently generated variants, such as the number of all currently generated variants, the number of effective variants, the proportion of effective variants, etc. The node pool evolvable state can be understood as the state of the evolvable node pool, such as the number of evolvable nodes in the pool. When the number of evolvable nodes is 0, it indicates that there are no nodes that can continue to evolve. The quality gap can be understood as information describing the quality distribution. For example, the quality gap includes at least one of high-quality sample gap, medium-quality sample gap, and low-quality sample gap. The high-quality sample gap is the number of high-quality target samples minus the current number of high-quality samples; the medium-quality sample gap is the number of medium-quality target samples minus the current number of medium-quality samples; and the low-quality sample gap is the number of low-quality target samples minus the current number of low-quality samples.

[0097] Analyze the evolution graph and coverage statistics table. Determine the evolution status information based on the attribute information of each node in the evolution graph and the coverage status in the coverage statistics table. Based on the evolution status information, determine whether the evolution stopping condition is met. For example, if the variant set status is that the number of variants reaches a set value, the evolution stopping condition is considered to be met. If the node pool is in an evolutionary state that there are no evolutionary nodes, the evolution stopping condition is considered to be met. If the quantity gap is less than a certain threshold, the evolution stopping condition is considered to be met. If the quality gap is less than a certain threshold, the evolution stopping condition is considered to be met, and so on.

[0098] S214. Generate a set of sensitive word variants based on the variants obtained from the evolution.

[0099] S215. Use the updated evolution graph as the new evolution graph and the updated pool of evolvable nodes as the new pool of evolvable nodes, and return to the execution of step S202.

[0100] Optionally, the evolution graph and the pool of evolvable nodes are updated based on the resulting variants, including steps B1-B3:

[0101] B1. For each variant, calculate the distance between the variant and the corresponding node to be evolved. If the distance is greater than the preset distance threshold, discard the variant; otherwise, retain the variant.

[0102] For each variant, the distance between the variant and the corresponding node to be evolved is calculated according to the distance calculation formula. If this distance is greater than a preset distance threshold, the variant is discarded; otherwise, the variant is retained. The distance threshold can be preset; for example, it can be represented by max_edit_dist(15). The distance between the variant and the corresponding node to be evolved can be the edit distance.

[0103] B2. For the retained variants, generate the variant's attribute information.

[0104] For the retained variants, attribute information of the variants is generated according to the evolution process. The attribute information of the variants may include at least one of the following: node identifier, word text, node type, evolution level, out-degree, in-degree, saturation state, evolvable state, transformation trajectory, quality score, variant attributes, language tag, parent node identifier, source seed word (used to trace back to the original seed word), etc.

[0105] B3. Update the evolution graph and the pool of evolvable nodes based on the attribute information of the variants.

[0106] Variants can be added directly to the evolution graph and the pool of evolvable nodes; alternatively, a quality assessment can be performed on the variants, and if the variants are of acceptable quality, they can be added to the evolution graph and the pool of evolvable nodes. When adding a variant to the evolution graph, the variant is treated as a node, and its attribute information is used as the attribute information of the corresponding node to update the evolution graph. When adding a variant to the pool of evolvable nodes, the attribute information of the variant is associated with the variant, or it can be added to the pool of evolvable nodes based solely on the node identifier of the variant.

[0107] Optionally, the method further includes: updating at least one of the saturation state and the evolvable state of the nodes in the evolvable node pool; for each node, if the node's saturation state is saturated or the node's evolvable state is non-evolvable, removing the node from the evolvable node pool.

[0108] Updating the evolvable node pool also includes updating the nodes in the pool, updating the attribute information of the evolved nodes (e.g., updating the node's out-degree and evolution level), and updating at least one of the node's saturation state and evolvable state based on the updated attribute information. For each updated node, if the node's saturation state is saturated or its evolvable state is non-evolvable, it is determined that the node cannot continue to evolve, and this node is removed from the evolvable node pool.

[0109] Updating at least one of the saturation state and the evolvable state of nodes in the evolvable node pool includes at least one of the following C1-C3:

[0110] C1. Determine the variant attributes of the node based on the out-degree and in-degree in the updated attribute information of the node, and determine the saturation state threshold of the node based on the variant attributes; if the out-degree is greater than or equal to the saturation state threshold, determine that the node's evolvable state is non-evolvable and the node's saturated state is saturated.

[0111] In this embodiment, the saturation threshold can be understood as a threshold used to determine the saturation state, and the saturation threshold can be preset. The out-degree and in-degree of the updated node attribute information are determined, where out_degree is the number of child variants generated by the node, and in_degree is the number of parent nodes. The node centrality index `node_degree = α×out_degree + β×in_degree` is calculated based on the out-degree and in-degree, where the parameters can be set to α=0.6 and β=0.4. A higher out-degree weight is given because a higher out-degree indicates a more flexible and easily evolving writing style. Variant attributes are divided into three tiers based on `node_degree`: `node_degree < 10`, the variant attribute is a low-degree node, labeled as an uncommon writing style; 10 ≤ `node_degree < 50`, the variant attribute is a medium-degree node, labeled as a common writing style; `node_degree ≥ 50`, the variant attribute is a high-degree node, labeled as a popular writing style. Variant attributes `degree_tier` ∈ {low, medium, high} are labeled based on `node_degree`, prioritizing coverage of uncommon writing styles to avoid omissions, and controlling the proportion of popular writing styles to avoid excessive concentration.

[0112] Different saturation thresholds are pre-defined for variant attributes at different levels. For example, the saturation threshold for high-degree nodes is 30 (out-degree ≥ 30 is marked as saturated), for medium-degree nodes it is 20, and for low-degree nodes it is 15. The node's out-degree is compared to its corresponding saturation threshold. If the out-degree is greater than or equal to the threshold, the node's evolvable state is determined to be non-evolvable, and its saturated state is determined to be saturated. This differentiated threshold design allows less common implementations more evolutionary opportunities, while popular implementations are promptly saturated to avoid overexploration.

[0113] C2. If a node is determined to have no available operators, then the node's evolvable state is determined to be non-evolvable.

[0114] Analyze the operators used in the historical evolution of the node and all applicable operators of the node (i.e. operators whose applicable conditions match the node), determine whether the node has available operators. If the node does not have available operators, that is, the node has tried all available operators, the node's evolvable state is determined to be non-evolvable.

[0115] C3. If the coverage state of the cell corresponding to the node in the variant evolution matrix is ​​severely over-limited, the node's evolvable state is determined to be non-evolvable.

[0116] Determine the cell corresponding to the node in the variant evolution matrix, and determine the coverage status of the cell based on the coverage statistics table. If the coverage status is severely out of control, determine the node's evolvable status as non-evolvable; for example, when coverage_rate > 1.5, the coverage status is severely out of control.

[0117] For example, this application provides an implementation method for sensitive word evolution, which includes the following steps:

[0118] Step 101: Extracting the Sensitive Word Seed Set from Multiple Channels. This step collects sensitive words from multiple channels, performs standardization and deduplication, and outputs a standardized sensitive word seed set.

[0119] Step 102: Variant Evolution Graph Modeling and Evolution Matrix Definition. This step establishes a control framework for variant generation. Popular / unpopular variant generation methods are identified through directed graph modeling of the iterative process. A Coverage Target Matrix (CTM) is designed to balance exploration strategies and provide continuous guidance for subsequent generation. The input to this step is `Seeds_standardized`, and the output is the evolution graph `Graph_evolution` and the evolution matrix `Matrix_coverage_target`. Implementation methods include:

[0120] 1. Construct a variant evolution graph. The processing objects are Seeds_standardized and the variant set generated in the previous iteration in subsequent processes. The evolutionary relationship is abstracted into a directed graph. Popular / unpopular implementations are identified using graph theory methods, and an evolvable node pool is established to dynamically manage the evolution process. The construction process is as follows:

[0121] 1) Initialize graph nodes: Create an empty graph G=(V, E), add sensitive words from the sensitive word seed set as seeds as nodes and mark them with node_type="seed" and evolution_level=0. Each node contains the following attributes: text stores the text content, node_type identifies the node type (value range is seed or variant), evolution_level records the evolution level (0 for seed words), out_degree records the out-degree (number of generated child variants), in_degree records the in-degree (number of parent nodes), is_saturated marks the saturated state (initially False), expandable marks the evolveable state (initially True), priority_score stores the evolution priority (dynamically calculated), trace records the transformation trajectory, and quality_score stores the quality score (to be filled later). The node attribute design supports evolution state tracking and dynamic priority calculation.

[0122] 2) Constructing directed edges: The evolution path is determined based on the transformation trajectory `trace.applied_operators`. For single-step transformations, directed edges are established from parent node to child variant; for multi-step transformations, the complete path is reconstructed and edges are established segment by segment. Each edge contains three types of attributes: operator ID, edit distance, and transformation dimension, supporting path tracing and duplicate detection.

[0123] 3) Calculate node degree and hierarchical labeling: Calculate the node centrality index node_degree and divide the variant attributes into three levels according to node_degree: low degree nodes (<10, labeled as uncommon), medium degree nodes (10-50, labeled as common), and high degree nodes (≥50, labeled as popular).

[0124] 4) Determining Node Saturation: Node saturation thresholds are configured with differentiated settings based on degree: High-degree nodes = 30 (marked as saturated if out-degree ≥ 30), Medium-degree nodes = 20, Low-degree nodes = 15. Saturated nodes are marked with `is_saturated=True` and `expandable=False`, and are no longer considered evolution sources; unsaturated nodes retain `expandable=True` and can continue evolving. This differentiated threshold design allows less common implementations more opportunities for evolution, while popular implementations are promptly saturated to avoid overexploration.

[0125] 5) Initialize the evolvable node pool: Create an `expandable_node_pool` data structure to store all nodes that can continue to evolve (nodes with `is_saturated=False` and `expandable=True`). The node pool is sorted by `priority_score`, supporting efficient querying and dynamic updates. The first iteration only contains seed node nodes, and subsequent iterations automatically expand as variants are generated. The node pool is the core data structure for unified iteration logic, avoiding the complexity of manually dividing evolution stages in traditional methods.

[0126] 6) Initialize evolution path tracing: Create an explored_paths hash table with the key being the path signature (signature = hash(parent_id + operator_id + operator parameters)) and the value being the generated child variant ID (the variant is uniquely identified by its ID). This structure is used to identify explored paths to avoid repeated evolution and quickly determine whether a path has been generated in O(1) time complexity.

[0127] After the framework is built, the output evolution graph Graph_evolution contains the following complete structure: nodes (node ​​ID node_id → node object node_object), edges (edge ​​list), expandable_node_pool (expandable node pool, sorted by priority_score), explored_paths (explored path hash table), and node_saturation_thresholds (saturation thresholds for each degree). Among these, node_object stores various information about the nodes. This establishes the framework structure of the evolution graph and the node pool management mechanism. Specific nodes and directed edges are dynamically added in each iteration of step 103, and the node pool is automatically updated with each iteration, ultimately forming a complete evolution graph containing all seed words and variant evolutionary relationships.

[0128] 2. Establish a four-dimensional variant evolution matrix. A four-dimensional variant evolution matrix (mechanism × variant_length × degree_tier × evolution_level) is established to control the number of sensitive word variants belonging to each dimension combination. The establishment process is as follows:

[0129] The four-dimensional value range is defined, which covers the mechanism characteristics, length characteristics, popularity characteristics, and complexity characteristics of the variant, forming a comprehensive description of the sample space.

[0130] 1) Design an enhanced cell structure: The enhanced cell design supports unified management of quality and quantity. Each cell contains one or more fields; the enhanced cell can manage both quantity and quality simultaneously, ensuring that the quality and quantity of generated variants meet the requirements at the same time, avoiding the data inconsistency problem caused by the separation of quality statistics and quantity statistics in traditional methods.

[0131] 2) Target Quantity Allocation: Create a coverage matrix Matrix_coverage_target, where each cell corresponds to a dimension combination. The coverage matrix stores the target quantity for each cell. The overall target total_count can be set according to training requirements (e.g., 80,000-100,000 samples), allocating the target quantity for each cell based on dimensional importance.

[0132] 3) Initialize Coverage Statistics: Initialize the coverage statistics table Stats_coverage_current, with all cells having current_count=0 and coverage_rate=0, and all cells marked with priority=high and added to List_priority_fill. Define coverage status rules: coverage_rate=0 for blank cells, <0.5 for severely insufficient cells, 0.5-0.8 for moderately insufficient cells, and ≥0.8 for sufficient cells. Blank and severely insufficient cells are marked with priority=high, moderately insufficient cells with priority=medium, and sufficient cells with priority=low. Coverage status rules are used to dynamically adjust the generation strategy during subsequent iterations.

[0133] 3. Initialize evolution control parameters. Initialize the coverage matrix configuration, node evolution control rules, and sampling weights for subsequent unified iterations. The generation process is as follows:

[0134] 1) Configure initial operator weights: Set the four-dimensional transformation operator weights Weights_operator: shape=1.0, phonetic=1.0, structure=0.8, semantic=0.6, mixed=0.5. These weights are used for weighted selection of operators. Morphological and phonetic transformations have higher weights because their transformation rules are clear and their quality is stable, while structural and semantic transformations have lower weights because their transformation complexity is higher.

[0135] 2) Configure node priority calculation weights: Set the four-factor weights for node evolution priority calculation: Weights_node_priority: w1=0.4 quantity gap factor (the larger the cell gap, the higher the priority), w2=0.3 degree stratification factor (low-degree nodes are prioritized to ensure coverage of less common writing methods), w3=0.2 evolution potential factor (nodes that have not been fully explored are prioritized), w4=0.1 quality factor (high-quality nodes are prioritized). These weights are used to dynamically calculate the evolution priority of each node in the node pool during each iteration in step 103. The four-factor weight design ensures that the quantity gap dominates the generation direction, while also taking into account coverage of less common writing methods, evolution potential, and quality assurance.

[0136] 3) Configure degree tier priority factor: Set the priority factor value for different degree tiers: Factor_degree_tier for low-degree nodes = 1.0 (highest priority for less common methods), Factor_tier for medium-degree nodes = 0.6 (medium priority for common methods), and Factor_tier for high-degree nodes = 0.3 (lower priority for popular methods to avoid over-evolution). This factor is used in the degree tier term of the node priority calculation formula to ensure that less common methods evolve first.

[0137] 4) Configure other parameters: Set coverage-driven sampling parameters (smoothing coefficient ε=0.1, batch size=1000, node selection batch=500), quality screening threshold (semantic similarity threshold=0.75, maximum number of steps=8, maximum edit distance=15), and ratio_level4_max=0.15.

[0138] The output of step 102 is an evolution graph Graph_evolution and an evolution matrix Matrix_coverage_target. The evolution graph manages the evolution state of nodes and path tracking, while the coverage matrix controls the number of sensitive word variants. The two work together to achieve balanced generation of coverage guidance.

[0139] Step 103: Iterative Incremental Evolution of Sensitive Word Variants. In each iteration, this step selects high-priority nodes from the pool of evolvable nodes in the evolution graph. It dynamically adjusts node priorities and operator selection using information from the covering matrix, and tracks explored paths in the evolution graph to avoid duplication, progressively evolving existing sensitive words and their variants. The inputs to this step are `Seeds_standardized` (i.e., the node pool is initialized based on the sensitive word seed set during the first iteration) and `Graph_evolution` (containing the pool of evolvable nodes). The output is the set of newly added variants in this round, `Set_candidates_new`, while simultaneously updating the evolution graph. The implementation process is as follows:

[0140] 1. Load the multi-dimensional transformation operator library. Construct a five-dimensional operator library encompassing morphology, speech, structure, semantics, and cross-modality. Each dimension contains multiple specific transformation operators, and each operator is registered with a unique ID, applicable conditions, parameter configuration, and priority weight. The construction process is as follows:

[0141] 1) Construction of morphological dimension operators: Based on the principle of visual similarity, the recognition is confused by using the similarity of glyph structures. The following operators are included: Homograph replacement operator, which replaces the original character with characters that are visually identical but have different encodings in Unicode (such as replacing the Chinese character "〇" with the Western letter O, and the Chinese character "Α" with the Western letter A), maintaining a homograph mapping table covering character sets such as CJK / Latin / Cyrillic / Greek, etc. After replacement, there is no visual difference but the hash value changes; Similar glyph replacement operator, which selects similar characters for replacement based on the calculation of glyph structure similarity (stroke edit distance, component overlap, visual confusion matrix) (such as "刀" → "力", "己" → "已", "未" → "末"), and the similarity threshold is set to ≥0.7 to ensure that it is still recognizable after replacement; Simplification and traditional conversion operator, which performs forward conversion (simplified → traditional) or reverse conversion (traditional → simplified) using the simplified and traditional mapping table, supports one-to-many mapping processing (such as "后" → "後 / 后") and regional difference characters (such as "里" in Taiwan is "裡"); Full-width and half-width conversion operator, which performs mutual conversion between full-width and half-width for ASCII characters, punctuation marks, and numbers (such as "!" → "!", "0" → "0"), and is implemented using the Unicode encoding offset calculation (full-width = half-width + 0xFEE0); Component splitting operator, which splits Chinese characters into independent component sequences according to Unicode radicals or strokes (such as "敏" → "每文", "感" → "咸心"), maintaining a split dictionary covering 3500 commonly used characters, and inserting delimiters (spaces / dots / zero-width characters) after splitting to form visual separation; Case transformation operator, which performs case conversion or mixed case for Latin letters (such as "fuck" → "FuCk", "PORN" → "pOrN"), supports random mixing mode and capitalization of the first letter mode; Decorative symbol replacement operator, which adds Unicode decorative symbols (such as combining diacritical marks: accents, tildes, overlines) above, below, left, or right of the character, or replaces it with a pre-combined character with decoration (such as "e" → "é / ê / ë"), and the decorative symbol library contains more than 300 Unicode combination symbols.

[0142] 2) Construction of voice dimension operators: Based on the principle of voice similarity, use pronunciation proximity for confusion recognition. It includes the following operators: Homophone replacement operator, select replacement characters based on the principle of exactly the same Chinese pinyin, maintain a homophone dictionary (accurately match by initial + final + tone), such as "sensitive" → "mingan", "yellow" → "huangse", and the homophone dictionary covers more than 6,000 entries of common characters; Near-homophone replacement operator, select replacements based on similar initials (such as zh / z, ch / c, sh / s), or similar finals (such as an / ang, en / eng, in / ing), or similar tones (such as first tone / second tone, third tone / fourth tone). The initial similarity matrix and the final similarity matrix are defined based on the place of articulation (bilabial / apical / velar) and the method of articulation (stop / fricative / nasal), and the similarity threshold is set to ≥0.6; Pinyin letter replacement operator, replace Chinese characters with the corresponding pinyin letter sequence (such as "sensitive" → "mingan"), supporting three modes: full pinyin, initials abbreviation ("mg"), and digital tone annotation ("min3gan3"). The pinyin library is constructed based on the Modern Chinese Dictionary; Pinyin separation transformation operator, insert separators between pinyin letters to break the continuity (such as "mingan" → "min-gan", "m.i.n.g.a.n"), and the range of separator selection includes hyphens, dots, spaces, and underscores; Homophone replacement operator, use multi-word groups with similar pronunciations to replace the original sensitive words, maintain a homophone word library covering more than 500 entries of high-frequency sensitive words, and the sentence semantic fluency threshold after replacement is ≥0.5; Pinyin symbol confusion operator, perform symbol replacement on the converted pinyin letters (such as "o" → "0", "i" → "1", "s" → "$"), maintain a pinyin symbol mapping table (26 letters → numbers / symbols), and support single-character or multi-character mixed replacement.

[0143] 3) Construction of structural dimension operators: Based on the principle of text structure perturbation, the continuity is disrupted by insertion, deletion and rearrangement but human readability is maintained. Includes the following operators: Word-breaking space operator, inserting spaces within words to separate continuity (e.g., "sensitive" → "sensitive", "sensitive"), supporting single spaces, multiple spaces, full-width spaces, and non-breaking spaces (U+00A0); Zero-width character insertion operator, inserting zero-width characters between characters to break matching (zero-width space U+200B, zero-width non-connector U+200C, zero-width connector U+200D, zero-width non-breaking space U+FEFF), with no visual change after insertion but altering the string hash, supporting random and uniform distribution modes for insertion position, with a density parameter set to one insertion every 2-4 characters; Punctuation insertion operator, inserting punctuation marks within words to separate them (e.g., "sensitive" → "sensitive.feeling", "sensitive-feeling", "sensitive_feeling"), with punctuation mark selection including 20+ types such as periods, hyphens, underscores, slashes, and vertical lines, supporting even and random insertion positions; Repeating characters. The text includes several operators: a character insertion operator (repeating a character to create redundancy, e.g., "sensitive" → "sensitive sensitive", "sensitive feeling"), with options for repetition positions including the first character, last character, and random internal characters, and a repetition count of 1-3 times; a character order rearrangement operator (partially rearranging characters within a word, e.g., "sensitive word" → "sensitive sensitive word", "word sensitive"), supporting three modes: complete reversal, first and last character swap, and random pairwise swap; and a semantic similarity verification (threshold ≥ 0.4) to ensure comprehensibility after rearrangement; a mixed character set operator (using Chinese, English, numbers, and symbols to create mixed text, e.g., "yellow" → "yellow se", "porn obscene"), with character set combination types including mixed Chinese and English, mixed Chinese and numbers, and mixed characters, and a mixing ratio of 30%-70%; and a special formatting operator (using markup languages ​​such as Markdown / HTML / LaTeX to format text and introduce interference, e.g., "**sensitive**", "..."). sensitive "、"\text{sensitive}"), supports 10+ formatting tags including bold, italics, underline, strikethrough, superscript and subscript.

[0144] 4) Semantic Dimension Operator Construction: Based on the principle of semantic similarity, sensitive words are replaced with words or expressions of similar meaning while maintaining the basic semantics. This includes the following operators: a synonym replacement operator, which uses a thesaurus (built based on resources such as HowNet, WordNet, and CNKI semantic primitives) to query semantically similar words for replacement (e.g., "yellow" → "pornography", "money" → "rice"). Similarity calculation is based on the cosine distance of word vectors (e.g., Word2Vec / BERT). Embeddings), with a similarity threshold set to ≥0.75, and a thesaurus covering 10+ domains of commonly used sensitive word categories; a pronoun substitution algorithm, using pronouns, indicator words, and general pronouns to replace specific sensitive words (such as "that thing," "you know," "a certain merit"), maintaining a pronoun template library covering categories such as politics / pornography / violence, and template parameterization supports dynamic filling of context information; a mild metaphor operator, using metaphors, allegories, and euphemisms to replace direct sensitive words (such as "treating someone to dinner" referring to bribery), with a metaphor mapping table built based on cultural background and social context, covering 200+ high-frequency metaphor expressions, and requiring contextual consistency testing (based on contextual semantic coherence scoring); a hypernym replacement operator, using... The system replaces specific sensitive words with more general terms at a higher semantic level (e.g., "AK47" → "weapon"). It selects hypernyms based on the is-a hierarchy relationship of WordNet / HowNet, with the hypernym level parameter set to 1-2 levels (to avoid overgeneralization). It also employs an euphemism replacement operator, using socially accepted euphemisms to replace sensitive words (e.g., "sexual behavior" → "that kind of thing", "death" → "passed away"). The euphemism dictionary is maintained by cultural classification (East Asian / Western culture) and sensitive category, covering 500+ euphemisms. Finally, it uses a concept decomposition operator to break down sensitive words into multiple concept combinations (e.g., "playing cards" → "playing a couple of rounds"). The decomposition template is generated based on dependency parsing (subject-verb-object, attributive-head structure) to ensure semantic integrity after decomposition.

[0145] 5) Construction of cross-modal dimension operators: Based on the principle of modal conversion noise, simulate the real noise patterns introduced by OCR recognition errors and ASR dictation errors. Includes the following operators: An OCR noise operator, simulating common error patterns in optical character recognition (such as confusion between "0" / "O", "1" / "l" / "I", "5" / "S", and "8" / "B"); maintaining an OCR confusion matrix constructed based on error statistics from real OCR systems (e.g., Tesseract / PaddleOCR error sample analysis); and a confusion probability matrix P(error character | correct character) set based on glyph similarity and engine characteristics, supporting both high-definition (5% error rate) and low-quality (20% error rate) modes. An OCR layout noise operator, simulating recognition anomalies caused by image text layout (such as broken line breaks, excessive character spacing, and slanted text); simulating these by inserting line breaks, increasing space spacing, and character rotation markers; layout parameters including line break position, spacing multiple, and slant angle. An ASR speech recognition noise operator, simulating common errors in speech-to-text conversion (such as homophone errors, near-homophone errors, and initial and final vowel shifts due to accents), based on a real ASR system. The system employs a confusion matrix constructed using statistics, with noise intensity parameters including three levels: quiet environment (5% error rate), noisy environment (15% error rate), and strong accent (25% error rate). An ASR (Automatic Speech Recognition) segmentation noise operator simulates segmentation errors in speech recognition (e.g., recognizing "sensitive word" as "sensitive word" or "sensitive word"). This is achieved by inserting / deleting spaces within or at word boundaries, with segmentation positions sampled based on the probability distribution of syllable boundaries and pause durations. A text-image round-trip noise operator simulates the round-trip loss from text to image to OCR recognition (e.g., using artistic fonts and compressed noise when rendering text as an image, introducing recognition errors during OCR). This operator combines font transformation, image noise, and recognition confusion into a three-layer transformation, with noise intensity parameters controlling the overall error rate (5%-30%). A speech round-trip noise operator simulates the round-trip loss from text to TTS synthesis to ASR recognition (e.g., non-standard TTS pronunciation, background noise, and ASR recognition errors). This operator combines prosody transformation, audio noise, and recognition confusion into a three-layer transformation, supporting different timbre, speech rate, and sound quality parameter configurations.

[0146] Once all operators are built, a unified operator registry (Registry_operator) is generated. Each operator registration entry includes: operator_id (a unique identifier, such as "shape_homograph_v1"), dimension (the dimension to which the operator belongs: shape / phonetic / structure / semantic / cross_modal), applicable_conditions (applicable conditions: language_tag, evolution_level, etc.), parameter_schema (parameter definitions and default values), base_weight (basic weights used for operator selection), and quality_expectation (expected quality level). The registry supports dynamic querying and filtering, allowing subsequent iterations to select applicable operators based on conditions.

[0147] 2. Initialize or update the evolvable node pool. The object of this process is the evolutionary graph node pool; whether it's the first initialization or a subsequent update is determined based on the iteration round. The process is as follows:

[0148] 1) Initialize the node pool in the first iteration: If this is the first iteration, add all seed words from `Seeds_standardized` to the evolution graph node pool. Create a node for each seed word: `node_id` (unique identifier), `text` (seed word text), `node_type="seed"`, `evolution_level=0` (seed word is marked as level 0), `out_degree=0`, `in_degree=0`, `is_saturated=False`, `expandable=True`, `priority_score` (to be calculated), `original_seed` (self), `trace` (empty trace), and `domain / language_tag` attributes inherited from `Seeds_standardized`. Add all seed word nodes to `Graph_evolution.expandable_node_pool`. At this point, the node pool only contains seed words (`evolution_level=0`). This iteration can only generate first-level variants (`evolution_level=1`) from seed words. The evolution level can be increased by 1 after each evolution.

[0149] 2) Subsequent iterations update the node pool: For the second iteration and later, all evolvable nodes are selected from the evolution graph. The query conditions are: is_saturated=False and expandable=True, and the coverage cell to which it belongs is not severely over-limited (coverage_rate<1.5). The node pool automatically includes multiple levels: seed words with evolution_level=0 (if not saturated) + first-level variants with evolution_level=1 (if not saturated) + second-level variants with evolution_level=2 (if not saturated) + higher-level variants with evolution_level≥3 (if not saturated). The size of the node pool gradually expands with natural growth in iterations. The updated node pool is sorted by priority_score, with higher-priority nodes at the top. The current node pool status is statistically analyzed: total number of evolvable nodes (total_expandable_nodes), node count distribution at each level (node_count_by_level), and saturated node count (saturated_nodes_count), generating Stats_node_pool_current for monitoring.

[0150] 3. Coverage-Based Sensitive Word Variant Evolution. The processing object is each evolvable node in the node pool. Evolution priority is dynamically calculated using a four-factor formula, automatically controlling the evolution direction. The calculated evolution factors include at least one of the following: quantity gap factor, degree tier factor, evolution potential factor, quality factor, and level 4 variant ratio control factor. A comprehensive priority_score is calculated based on the above evolution factors: The node evolution priority is calculated using a multi-factor weighted formula: priority_score = w1×coverage_gap_factor + w2×degree_tier_factor + w3×evolution_potential_factor + w4×quality_factor, where the weights are configured as w1=0.4, w2=0.3, w3=0.2, and w4=0.1. If a node may generate level 4 variants, a control factor is applied: priority_score = priority_score × level4_control_factor. After calculation, the priority_score is stored in the node.priority_score field. All nodes in the expandable_node_pool are sorted in descending order of priority_score, with the highest priority node listed first for selection in subsequent batches.

[0151] 4. Perform new operator filtering based on evolutionary paths. The processing object is the priority-sorted node pool. For each node, untried operators are filtered to avoid duplicate paths. The filtering process is as follows:

[0152] 1) Select the Top-K nodes from the expandable_node_pool as the evolution source for this round according to priority. The value of K is obtained from Config_coverage_guidance.params_sampling.node_selection_batch (default 500). For each selected node, query the explored paths: query the existing outgoing edges of the node from Graph_evolution.explored_paths, and extract the list of applied operators trimed_operators = [op1_id, op2_id, ...].

[0153] 2) Filtering Available Operators: Filter applicable operators from Registry_operator and exclude those already tried. Filter language-adaptive operators based on the node's language_tag; filter level-adaptive operators based on the node's evolution_level (evolution_level=0-2 allows shape / phonetic / structure / semantic operators, evolution_level≥3 allows cross_modal cross-modal operators); exclude operators already tried in tried_operators, generating a list of available operators_operators. If available_operators is empty, mark the node expandable=False (no available operators) and remove it from the node pool.

[0154] 3) Sort available_operators according to the following rules: Obtain the basic weights of the operators based on Weights_operator (shape=1.0, phonetic=1.0, structure=0.8, semantic=0.6, mixed=0.5); adjust the weights according to the target cell's mechanism requirements (if the cell requires a shape mechanism and the operator is a shape dimension, multiply the weight by 1.5); sort the operators in descending order of the adjusted weights. For each candidate operator, generate a path signature signature = hash(node_id + operator_id + operator_parameters), check if the signature already exists in Graph_evolution.explored_paths, and remove it from the candidate list if it exists (to avoid duplicate evolution). After filtering, associate each selected node with a list of available operators node.available_operators_filtered.

[0155] 5. Perform single-step evolution and update the state. The process involves selecting high-priority nodes and their available operators. For each node, a one-step operator transformation is applied to generate a new variant, which is immediately registered to the evolution graph and covering matrix. The generation process for this round is then statistically analyzed. The process is as follows:

[0156] 1) Batch generation of variants: Traverse the selected Top-K nodes, and for each node, randomly select an operator_selected from node.available_operators_filtered according to weight (or greedily select the operator with the highest weight). Apply operator transformation: variant_text = operator_selected.apply_function(node.text, parameters). Calculate edit distance: edit_distance = levenshtein_distance(node.text, variant_text). If the edit distance > max_edit_dist(15), discard the variant and continue to the next node.

[0157] 2) Constructing Variant Objects: Constructing a complete object for the generated variant. This includes basic fields such as `variant_id` (unique identifier), `variant_text` (variant text), `parent_id` (parent node ID), and `original_seed` (tracing back to the original seed word). Inherited attributes: `domain`, `language_tag`, `seed_source_type`, etc., are inherited from the parent node. Transformation Trajectory Construction: Transformation trajectory `trace.applied_operators = parent.trace.applied_operators + [operator_selected.operator_id]` (the currently used operator ID); trajectory length `trace.steps = len(applied_operators)`, indicating the number of evolutions from the seed word to this variant; trajectory edit distance `trace.edit_distance` is calculated cumulatively, representing the sum of the edit distances between the variant and the corresponding seed word; trajectory mechanism span `trace.mechanism_span` counts the number of dimensions spanned, indicating the total number of dimensions used in the evolution from the seed word to this variant. Node initialization: node_type="variant", out_degree=0, in_degree=1, is_saturated=False, expandable=True, priority_score to be calculated later.

[0158] 3) Automatic Evolution Level Determination: The `evolution_level` is automatically determined based on the transformation trajectory, without manual specification. If `trace.steps=1` and `trace.mechanism_span=1` (single-step, single-dimensional): `evolution_level=1`, `difficulty_label="easy"`; if `trace.steps≥2` and `trace.mechanism_span=1` (multi-step, same-dimensional): `evolution_level=2`, `difficulty_label="medium"`; if `trace.mechanism_span≥2` and does not contain cross-modal operators (cross-mechanism combination): `evolution_level=3`, `difficulty_label="hard"`; if the transformation trajectory `applied_operators` contains the `cross_modal` operator (cross-modal round trip): `evolution_level=4`, `difficulty_label="very_hard"`. Automatic determination ensures accurate level labeling without manual intervention. Generate path signature: Generate a unique path signature based on the parent node ID and the current operator: signature = hash(parent_id + operator_selected.operator_id + parameters), used for subsequent path tracing. After batch generation is complete, the set of newly added variants in this round, Set_candidates_new, is obtained.

[0159] 4) Real-time registration to the evolution graph: For each new variant, create a graph node G.nodes[variant_id] = variant_object, create a directed edge G.edges.append((parent_id → variant_id, operator_id, edit_distance)), and update the parent node's out-degree parent_node.out_degree += 1. Calculate the node degree node_degree = α×out_degree + β×in_degree (α=0.6, β=0.4), and stratify the degree based on the degree value: <10 is low, 10-50 is medium, and ≥50 is high, labeled variant.degree_tier. Add the path signature to Graph_evolution.explored_paths[signature] = variant_id to avoid regenerating the same path in the future.

[0160] 5) Real-time registration to the coverage matrix: Locate coverage cells based on four-dimensional attributes. Extract the mechanism (main transformation mechanism) and evolution_level (automatically determined level) from the transformation trajectory, and calculate the variant length dimension variant_length_bucket (dividing levels based on the character length of variant_text) and degree_tier (the degree tier just calculated). Locate the cell Matrix_coverage_target[(mechanism, variant_length_bucket, degree_tier, evolution_level)], add the variant to the cell.samples dictionary, update cell.total_count += 1, and mark the registration status as preliminary (not yet quality evaluated).

[0161] 6) Node Pool Delayed Update Strategy: Newly generated variant nodes are marked with pending quality check (pending_quality_check=True) and are not added to the expandable_node_pool immediately. After quality screening and deduplication in step 104, only the high-quality nodes that are ultimately retained (quality_label="pass" and have not been removed by deduplication) are added to the node pool in batches. This ensures that the node pool in the next iteration only contains verified high-quality nodes, avoiding the participation of low-quality nodes in the evolution. Although nodes are not immediately added to the pool, they are registered in the evolution graph and included in the coverage matrix, ensuring statistical completeness.

[0162] 7) Node Pool Status Update: This process updates all nodes (including parent nodes), reassesses saturation, and maintains the node pool. Node saturation is determined as follows: If `out_degree` ≥ `node_saturation_thresholds[degree_tier]` (high=30, medium=20, low=15), mark `is_saturated=True` and `expandable=False`; if the coverage_rate of the node's cell is > 1.5 (severely exceeding the limit), temporarily mark `expandable=False`; if the node has tried all available operators (`available_operators` is empty), mark `expandable=False`. Iterate through `expandable_node_pool`, removing nodes with `expandable=False`, and generate `removed_nodes_list` to record the removed node ID and reason. Node Pool Size Control: If the node pool size > the upper limit (e.g., 2000 nodes), retain the highest priority Top-N nodes, and temporarily remove the remaining nodes (marking them as dormant, which can be activated later if needed). For the updated node pool, recalculate the priority_score of all nodes (because the coverage matrix has been updated, the number gap factor has changed), and sort them in descending order according to the new priority_score.

[0163] Step 104: Variant Quality Assessment, Deduplication, and Stream Management. This step assesses the quality and checks the constraints of candidate variants, then executes a deduplication strategy to remove redundancy, and finally performs refined multi-pool streaming based on quality tags while simultaneously updating the coverage matrix. This step manages the quality of newly added variants after each iteration, using industry-standard methods such as a three-level evaluation framework ("rule-based fast filtering + LLM intelligent evaluation + human expert evaluation") to generate quality tags, using maximum evolution steps, maximum edit distance, and novelty as constraints, and employing multiple deduplication methods ("text hashing + path signature + approximate matching"), which will not be elaborated further here. After assessing the quality of variants, medium-to-high-quality variants can be added to the seed words for the next round of evolution, while simultaneously updating relevant information in the evolution graph and coverage matrix.

[0164] Step 105: Analyze whether the evolution is complete. This step analyzes the current variant set and the evolvable state of the node pool based on the latest state of the evolution graph and covering matrix. It also identifies quantity and quality gaps to determine whether to continue iteration or proceed to the next stage. If the decision is made to proceed to the next iteration, return to Step 103 to execute the next iteration, adjusting the parameters for the next iteration to better complete it. Otherwise, accept the result and prepare to proceed to Stage Two. The specific implementation method is industry-standard and will not be detailed here.

[0165] At this point, all steps in generating sensitive word variants are complete. After multiple iterations, a high-quality set of sensitive word variants, Set_candidates_final_stage1, with balanced coverage on the multidimensional coverage matrix (mechanism×variant_length×degree_tier×evolution_level), can be output. It covers a complete variant space from simple to complex, from single to cross-mechanism, and from popular to unpopular. Each variant comes with a complete evolutionary trajectory, four-dimensional coverage label, quality score, and processing marker, providing a rich and reliable data foundation for the subsequent corpus construction in stage two.

[0166] Starting from a seed set collected from multiple channels, a balanced set of sensitive word variants is iteratively generated through a four-dimensional evolutionary mechanism of "form, sound, and meaning" guided by an "evolutionary matrix." During the iterative generation process, graph theory modeling is used to identify popular and unpopular writing styles, and statistical data drives real-time feedback to avoid blind exploration. After multiple layers of quality constraints, a high-quality variant set with balanced coverage across multiple dimensions (such as mechanism type × text length × node degree layering × evolution level) is output.

[0167] The sensitive word evolution method provided in this application model sensitive word variant generation as a four-dimensional coverage space (mechanism × variant length × degree tier × evolution level); it sets quota targets for each dimension combination through the evolution matrix (CTM) and dynamically calculates the coverage gap; it uses a five-dimensional operator library of morphology / speech / structure / semantics / cross-modality for variant evolution; it dynamically calculates the node evolution priority based on a four-factor weighted formula of quota gap factor, degree tier factor, evolution potential factor, and quality factor; and it achieves balanced coverage of the complete variant space from simple to complex, from single to cross-mechanism, and from popular to unpopular. The evolutionary relationship of sensitive words and their variants is abstracted into a directed graph G=(V, E); the popularity of nodes is calculated using the node centrality index node_degree=α×out_degree+β×in_degree (α=0.6, β=0.4); nodes are divided into three levels according to their variant attributes; differentiated saturation thresholds are designed to give less common writing styles more evolutionary opportunities; evolutionary state tracking and path deduplication are achieved through an expandable node pool and an explored path hash table; and a unified iteration logic is supported to automatically include multi-level nodes without the need for manual stage division. After each iteration, the data is registered in real-time to the coverage matrix cells, updating the total number of generated data (total_count) and the number of valid samples (valid_count). The coverage rate (coverage_rate = valid_count / quota_target) and the quota gap (gap = quota_target - valid_count) are dynamically calculated. Coverage priorities are assigned based on gap size (critical gap factor = 1.0, high gap factor = 0.8, medium gap factor = 0.5, low gap factor = 0.2). Nodes that can fill critical and high gaps are prioritized for evolution. A four-level variant ratio control factor is designed (when ratio_level4 approaches the 15% upper limit, the weight of high-level nodes is reduced by ×0.5). Real-time quota feedback avoids blind exploration, ensuring that the generation direction always points towards the coverage gap area.

[0168] This application provides a sensitive word evolution method. By determining different evolution factors and weighting these factors to control the evolution direction, it avoids blind exploration and achieves balanced coverage of the complete variant space evolution from simple to complex, from single to cross-mechanism, and from popular to unpopular. A saturation threshold is used to determine whether a node is saturated, thereby updating the pool of evolvable nodes. Differentiated saturation thresholds allow less popular spellings to have more evolution opportunities. During the evolution process, the evolution path determines the list of applied operators, and operators are filtered based on language tags and evolution levels to obtain a list of available operators, effectively avoiding duplicate evolution paths and unreasonable evolution. The basic weights of available operators are further adjusted based on the evolution mechanism requirements, and the target evolution operator is determined based on the adjusted weights, which effectively filters reasonable operators, resulting in better sensitive word evolution performance.

[0169] Example 3

[0170] Figure 3 This is a flowchart of a sensitive word recognition method provided in Embodiment 3 of this application. This embodiment is applicable to situations requiring sensitive word recognition. The method can be executed by a sensitive word recognition device, which can be implemented in hardware and / or software and can be configured in an electronic device. Figure 3 As shown, the method includes:

[0171] S301. The sensitive word variant set is processed based on the pre-constructed multidimensional sample coverage matrix to generate at least one original corpus. The sensitive word variant set is generated using the sensitive word evolution method as described in any embodiment of this application.

[0172] In this embodiment, the multidimensional sample coverage matrix can be understood as a matrix composed of multidimensional data. This multidimensional sample coverage matrix is ​​used to control the quantity and quality of various types of samples during the sample generation process, avoiding homogenization of sample generation. The multidimensional sample coverage matrix can be composed of at least one of the following dimensions: mechanism, domain, corpus length, and sensitive word position. The original corpus can be understood as corpus including sensitive words, for example, a sentence or a few words containing sensitive words.

[0173] For example, the dimensions of a multidimensional sample coverage matrix can include the following four types:

[0174] 1. Mechanism dimension: Inherited from the stage 1 variant, it represents the main transformation mechanism, with a value range of {shape, phonetic, structure, semantic, mixed}, used to ensure that the corpus generated by sensitive words is evenly distributed in the mechanism dimension.

[0175] 2. Domain dimension: Inherited from the Phase 1 variant and corpus, it represents the content category to which the sensitive words belong. The value range is {political, pornographic, violent, gambling, spam, fraud, ...}. It is used to filter and select appropriate corpus to carry appropriate sensitive words, while ensuring that the corpus generated by the sensitive words is evenly distributed in the domain dimension.

[0176] 3. Sentence length dimension: Based on the total number of characters in the corpus, it is used to ensure that the corpus generated by sensitive words is evenly distributed in length dimension.

[0177] 4. Sensitive word position dimension: Based on the relative position of sensitive segments in the corpus, the calculation formula is position_ratio=start_idx / sentence_length, which is used to ensure that the corpus generated by sensitive words is evenly distributed in the relative position dimension.

[0178] Then, a four-dimensional matrix is ​​constructed based on the above four dimensions, which is used to control the coverage and quality of the generated corpus.

[0179] The sensitive word evolution method of any embodiment of this application generates a set of sensitive word variants, which includes one or more variants of sensitive words. A multidimensional sample coverage matrix is ​​pre-constructed. Guided by the statistical data of the multidimensional sample coverage matrix, the variants of one or more sensitive words in the sensitive word variant set are processed to generate at least one original corpus. Since the variants of sensitive words are also sensitive words, they will be referred to as sensitive words in the following description. For example, the dimensions corresponding to a cell in the multidimensional sample coverage matrix are: mechanism as semantics, domain as advertising, corpus length as 8, and sensitive word position as 3. Based on the above dimensional information, a semantically similar original corpus in the advertising domain is generated. The length of this original corpus is 8, and the sensitive word position starts from the third word in the original corpus. Embodiments of this application can generate one or more corpora based on a single sensitive word. For example, corpora can be generated through template-driven methods and corpus extraction methods; during the corpus generation process, the corresponding dimensional information of the multidimensional coverage matrix can be obtained to update the corresponding statistical information. The final output is a sample set Set_samples_annotated_complete with precise location annotations and complete four-dimensional attributes. The sample set includes at least one original corpus.

[0180] S302. Construct at least one sample pair based on the original corpus, each sample pair including a positive example pair and a negative example pair.

[0181] In this embodiment, a sample pair can be understood as a sample used for model training. The sample pairs in this embodiment include positive pairs and negative pairs. Positive pairs are used to train the recognition of standard form sensitive words, and negative pairs are used to train the recognition of non-sensitive content features.

[0182] The original corpus is processed as follows: a corpus of the original words is constructed as a control sample, generating positive example pairs; a clean version of the corpus is constructed as a control sample, generating negative example pairs; the positive and negative example pairs of the original corpus are combined into a single sample pair to generate sample pairs for this original corpus. Sample pairs are constructed for each original corpus separately to obtain the corresponding sample pairs for each original corpus.

[0183] S303. Construct a hierarchical corpus based on each sample pair to generate a hierarchical corpus.

[0184] In this embodiment, a hierarchical corpus can be understood as a dataset of different levels obtained by dividing sample pairs according to certain partitioning principles. Different hierarchical corpora represent different stages of training. Each sample pair is comprehensively evaluated, for example, based on constraints such as the difficulty and evolution level of the sample pairs. The sample pairs are then divided according to their difficulty level to obtain hierarchical corpora for different stages.

[0185] S304. Based on the hierarchical corpus sets, the model is trained to obtain the sensitive word recognition model, which is used to identify sensitive words.

[0186] In this embodiment, the sensitive word recognition model can be understood as a model used for sensitive word recognition. The architecture and initial parameters of an initial model are pre-built. Each layered corpus is sequentially input into the initial model for training. The parameters of the initial model are adjusted based on the training results until a model that meets the requirements is obtained. This model is denoted as the sensitive word recognition model. The trained sensitive word recognition model can identify sensitive words in the input text, determining whether sensitive words exist. If sensitive words are present, it can also identify the location of the sensitive words, whether the sensitive words have changed (i.e., whether the sensitive words are variants), and one or more other relevant information.

[0187] This application provides a sensitive word recognition method. It processes a set of sensitive word variants using a multi-dimensional sample coverage matrix to generate a balanced and diverse original corpus. Sample pairs corresponding to the original corpus are constructed, each containing both positive and negative examples. Comparison between positive and negative examples improves the model's recognition accuracy. The sample pairs are then layered to obtain a layered corpus, achieving hierarchical division of the corpus. The model is then progressively trained using this layered corpus to obtain a high-precision sensitive word recognition model, which accurately identifies sensitive words.

[0188] Optionally, construct at least one sample pair according to the original corpus, including steps D1 - D3:

[0189] D1. Replace the variants of sensitive words in the original corpus with the corresponding seeds to obtain positive samples, and generate positive example pairs based on the positive samples and the original corpus.

[0190] Analyze the original corpus, determine the variants of sensitive words in the original corpus, and determine the seeds corresponding to the variants of sensitive words. Replace the variants of sensitive words with the corresponding seeds to obtain positive samples; use the positive samples and the original corpus as a positive example pair.

[0191] D2. Delete the variants of sensitive words in the original corpus to obtain negative samples, and generate negative example pairs based on the negative samples and the original corpus.

[0192] Analyze the original corpus, determine the variants of sensitive words in the original corpus, and delete the variants of sensitive words in the original corpus to obtain negative samples; use the negative samples and the original corpus as a negative example pair.

[0193] D3. Form sample pairs of the original corpus based on the positive example pairs and the negative example pairs.

[0194] In the embodiments of this application, by constructing a three - version control sample of the original word / variant / clean for the original corpus, contrast pairs are formed to support contrast learning. The currently annotated original corpus is retained as variant_version (annotated with sentence_label = 1, position, multi - granularity labels) for training the model to recognize variant - form sensitive words. Replace the variant variant_text in the original corpus with the seed original_seed to generate original_version (e.g., "敏0感" → "敏感", annotated with sentence_label = 1) for training to recognize standard - form sensitive words, and use original_version as positive samples. Remove the sensitive fragments to generate clean_version (annotated with sentence_label = 0, and all token_labels are O) for training to recognize non - sensitive content features, and use clean_version as negative samples. Organize them as triplet=(original_version, variant_version, clean_version) to form contrast pairs: original and variant are positive example pairs, and variant and clean are negative example pairs for contrast learning training.

[0195] Before constructing the hierarchical corpus, the embodiments of this application can also perform quality verification on the sample pairs. For example, automated verification can be performed using methods such as logical inclusion / question-answer consistency, or manual review can be performed using a hierarchical sampling strategy. Finally, the automated and manual quality inspection labels are merged to form the final quality inspection labels. Then, the samples are refined through various deduplication strategies (such as text-level hash deduplication, location signature deduplication, and similar content deduplication), filtering out poor-quality sample pairs and retaining high-quality and non-repeating sample pairs.

[0196] Optionally, a hierarchical corpus is constructed based on each sample pair to generate a hierarchical corpus, including: for each sample pair, determining the sample score information of the sample pair, determining the difficulty score of the sample pair based on the sample score information; dividing each sample pair into hierarchical stages based on the difficulty score to generate a hierarchical corpus.

[0197] In this embodiment, sample scoring information can be understood as information used to score the difficulty of samples. Sample scoring information includes at least one of the following: evolutionary level, edit distance, mechanism span, corpus length, relative position of sensitive words, node centrality index, quality score, and domain category. For each sample pair, the evolutionary process of the corresponding variant is analyzed, and the sample scoring information is determined based on the information generated during the evolutionary process. For example, the variant corresponding to the sample pair is identified, the evolutionary level, out-degree, and in-degree of the variant are determined by querying the evolution graph, and the node centrality index is calculated based on the out-degree and in-degree, etc. The information in the sample scoring information is normalized, and then the normalization results are weighted to obtain the difficulty score. The difficulty scores are divided according to predetermined partitioning rules to generate hierarchical corpus sets for different stages. For example, determine the interval where the difficulty score is located, divide the samples in the same interval into a set, and generate a hierarchical corpus; or, determine the total number of sample pairs, divide the total number of sample pairs according to a certain ratio, determine the number of sample pairs in each training stage, sort the sample pairs according to the difficulty score from low to high, and obtain the sample pairs corresponding to each training stage in sequence according to the number of sample pairs in each training stage, so as to obtain the hierarchical corpus for each training stage.

[0198] The embodiments of this application can also construct a multi-dimensional bucket index structure for each sample pair in the hierarchical corpus, which facilitates the acquisition of the corresponding sample pairs during subsequent model training.

[0199] For example, Figure 4 An example diagram of sensitive word recognition is provided. Sensitive word recognition includes three stages: Stage 1: generation of sensitive word variants, the steps of which can be referred to steps 101-105 in the above embodiment; Stage 2: generation of course-based sensitive word recognition corpus; Stage 3: training of course-based hierarchical multi-task model.

[0200] Phase 2: Step 201: Initialization of the multidimensional sample coverage matrix.

[0201] Step 202: Generating and labeling the original corpus.

[0202] Step 203: Construction of a three-version comparative corpus. This step involves constructing three versions of the corpus: original word, variant, and clean version, forming sample pairs to support comparative learning.

[0203] Step 204: Corpus Quality Verification. Verify the quality of the sample pairs.

[0204] Step 205: Construction and Iterative Decision of Course-Based Hierarchical Corpus.

[0205] This embodiment utilizes the multidimensional meta-information recorded during the variant generation and corpus construction processes described above to calculate the comprehensive difficulty score of the samples. Following the principle of easy-to-difficult learning in a curriculum-based approach, the samples are divided into three training stages. A multidimensional bucket index structure is established. Simultaneously, the corpus distribution is analyzed based on the multidimensional sample coverage matrix, and a decision is made on whether to trigger iteration. Finally, a hierarchical corpus set supporting curriculum-based progressive training is output. The input to this step is `Set_samples_deduped_refined`, and the output is `Dataset_training_stage2`, a curriculum-based hierarchical training dataset. The implementation method is as follows:

[0206] 1. Calculate the overall difficulty score of the samples. Extract multi-dimensional features from the sample metadata, including evolution level (evolution_level), edit distance (edit_distance), mechanism span (mechanism_span), corpus length (sentence_length), relative position of sensitive words (position_ratio), node degree (node_degree), retention score, and domain category. After normalizing each feature to a unified range, calculate the overall difficulty score (difficulty_score) using a multi-factor weighting method. The weight design prioritizes the complexity of variant evolution and the degree of text modification, with evolution level having the highest weight (25%), followed by edit distance (20%), and a combined weight of mechanism span, corpus length, position characteristics, node degree, and quality score (55%). Further adjust the difficulty coefficient based on the domain category of the sensitive words; political sensitive words are increased in difficulty due to their high variant diversity, while advertising sensitive words are decreased in difficulty due to their relatively simple variant patterns. The final difficulty score ranges from 0 to 1, where 0 represents the simplest sample and 1 represents the most difficult sample.

[0207] 2. The training set is divided into three stages according to the principle of course-based learning. Considering multi-dimensional constraints such as difficulty score, evolution level, edit distance, and mechanism span, the samples are divided into three training stages: initial, intermediate, and advanced. The initial stage selects simple samples with low difficulty scores, requiring single-step or multi-step same-dimensional variants, minor text modifications, single transformation mechanisms, and short to medium-length corpora, accounting for 40%-50% of the total samples. This is used for initial training to enable the model to quickly learn basic patterns. The intermediate stage selects medium-difficulty samples, including cross-mechanism combination variants, medium text modifications, single or dual-mechanism combinations, and full-length corpus coverage, accounting for 30%-35% of the total samples. This is used for intermediate training to improve the model's ability to recognize complex patterns. The advanced stage selects difficult samples, including cross-modal round-trip variants, significant text modifications, complex combinations of multiple mechanisms, OCR or ASR noisy samples, and difficult online examples, accounting for 15%-25% of the total samples. This is used for advanced training to strengthen the model's ability to combat complex variants and real noise. For each sample, its stage affiliation is determined and labeled according to priority. The actual proportion is checked to ensure it matches the target range. If the initial stage has insufficient samples, samples from the mid-stage boundary are added. If there are too many samples in higher-order stages, they are moved to the mid-stage to avoid training instability. The three-stage division follows the "easy first, difficult later" principle to ensure the model's progressive learning ability. Within each stage's dataset, it is divided into training, validation, and test sets using industry-standard hierarchical partitioning strategies to ensure consistency in mechanism, domain, and length distribution, while maintaining a balanced proportion of samples across the three versions.

[0208] 3. Construct a multi-dimensional bucketed index structure and supplement complete process metadata. A multi-dimensional bucketed index structure is established for each stage dataset according to three dimensions: mechanism, domain, and corpus length. Within each bucket, samples are sorted in ascending order of difficulty score to ensure a progression from easy to difficult. This is used to dynamically adjust the sampling ratio of each mechanism, domain, and length during training to ensure a balanced sample distribution. Simultaneously, complete process metadata is supplemented, including inherited stage one variant metadata (evolutionary level, main mechanism, edit distance, node degree, quality score, etc.), supplemented stage two corpus construction metadata (domain category, corpus length, sensitive word position, version type, etc.), and derived metadata (comprehensive difficulty score, stage affiliation, bucketed index key, etc.). A unique composite primary key is generated for each sample for full-process tracing.

[0209] 4. Perform multi-dimensional corpus distribution analysis and iterative decision-making. Based on the statistical analysis of the quantity and quality of various types of samples generated in the multi-dimensional sample coverage matrix, the types of imbalance in sample generation are analyzed to determine whether to trigger the next round of iteration or proceed to the next stage. The specific method of this process is similar to step 105. If iteration is triggered, the next round strategy is formulated and the original corpus generation is returned to be executed; otherwise, the next step is taken to output the final dataset.

[0210] 5. Output the curriculum-based hierarchical training dataset. Package the datasets from the initial, intermediate, and advanced stages, along with the bucketed index structure, three versions of control sample groups, complete metadata, and statistical analysis reports, into the Dataset_training_stage2 curriculum-based hierarchical training dataset. This dataset supports progressive loading by stage, balanced sampling by bucketed structure, and flexible filtering and sorting based on metadata, providing a complete data foundation for training the curriculum-based multi-task model in stage three.

[0211] At this point, the generation of the course-based hierarchical training corpus is complete. This stage ensures the balanced diversity of the generated corpus across the selected dimensions based on the statistical information of the multi-dimensional sample coverage matrix. It constructs three versions of comparison samples: original word, variant, and clean word. Based on the various meta-information recorded during variant generation and corpus generation, it calculates the comprehensive difficulty score (difficulty_score). The training samples are divided into easy, medium, and hard difficulty samples according to their difficulty. Within each stage, the samples are organized into three-dimensional buckets based on mechanism × domain × length and sorted in ascending order of difficulty, forming a hierarchical structured corpus that supports course-based progressive training.

[0212] This application employs a "multi-task joint optimization" and "curriculum-based learning" strategy. It uses the constructed three-version comparison data (containing complete labels such as positive example pairs, negative example pairs, fragment positions, and original word restoration targets) for comparative learning. Multi-objective collaborative optimization is achieved through a joint loss function of five sub-tasks (sentence-level determination / word-level classification / similarity measurement / fragment localization / original word restoration). A three-stage curriculum planning (initial, intermediate, and advanced) enables progressive training from easy to difficult, outputting a trained sensitive word recognition model with multi-task capabilities including sentence-level determination, word-level localization, and original word restoration. The implementation steps are as follows:

[0213] Step 301: Design of Multi-Objective Joint Optimization Loss Function. This step designs a joint loss function encompassing five sub-tasks. By weighted summation to optimize multiple objectives, the model simultaneously learns multiple capabilities including judgment, classification, measurement, localization, and reconstruction. Furthermore, leveraging the course-based hierarchical training corpus constructed in Phase Two, the model's recognition ability is gradually improved from easy to difficult and from simple to complex. The implementation process is as follows:

[0214] 1. Design loss functions for five sub-tasks. Design loss functions for five related sub-tasks with different characteristics. Details are as follows:

[0215] 1) Sentence-level sensitivity determination loss L_sens: This subtask is a binary classification task, requiring the determination of whether the input text contains sensitive content. Binary cross-entropy is used as the loss function, calculated as L_sens = -[y×log(p) + (1-y)×log(1-p)], where y is the true label (1 for sensitive, 0 for non-sensitive), and p is the model's predicted sensitivity probability output. Binary cross-entropy is suitable for binary classification tasks and can effectively optimize the model's ability to distinguish between sensitive and non-sensitive text.

[0216] 2) Word-level multi-class classification loss L_word: This subtask is a multi-class classification task, requiring the identification of specific sensitive words contained in the text. Each sensitive word seed (including its variants) is treated as an independent class, and the categorical cross entropy is used as the loss function. The formula is L_word = -Σ y_c×log(p_c), where y_c is the one-hot encoded vector of the true label (only the correct class position is 1, and the rest are 0), and p_c is the probability distribution of each class output by the model (normalized by softmax). Categorical cross entropy is suitable for multi-class classification tasks and can effectively optimize the model's ability to identify specific sensitive word categories.

[0217] 3) Similarity metric loss L_metric: This subtask is a contrastive learning task, which requires mapping different variants of the same sensitive word to similar embedding spaces while maximizing the distance between different sensitive words. The InfoNCE loss function is used for contrastive learning, calculated as L_metric = -log[exp(sim(anchor, positive) / τ) / Σexp(sim(anchor, negative_i) / τ)], where anchor is the anchor sample embedding, positive is the positive sample embedding (variants of the same sensitive word), negative_i is the negative sample embedding (different sensitive words), sim(·,·) is the similarity function (usually cosine similarity), and τ is the temperature parameter (set to 0.07). The InfoNCE loss utilizes the positive pairs (original, variant) constructed in stage two to compare with the negative pairs (samples from different sensitive words), enabling the model to learn representations where variants of the same word are close in the embedding space and variants of different words are far apart. The temperature parameter τ=0.07 controls the smoothness of the distribution; a smaller temperature makes the model more sensitive to difficult negative examples.

[0218] 4) Segment Localization Loss L_span: This subtask is a sequence labeling task, requiring precise localization of the start and end positions of sensitive word segments within the text. Pointer network loss or sequence labeling cross-entropy can be used. The pointer loss is in the form L_span = L_start + L_end, where L_start is the prediction loss for the start position and L_end is the prediction loss for the end position, both calculated using cross-entropy. The sequence labeling loss is in the form L_span = -Σ_t y_t×log(p_t), where t iterates through each token in the text, y_t is the true label at that position (B-sensitive / I-sensitive / O-insensitive BIO label), and p_t is the probability distribution of the label predicted by the model. The position (start_idx, end_idx) information from the stage 2 labeling is used as the training objective, enabling the model to learn precise localization capabilities. The pointer network approach is more suitable for scenarios where sensitive word segments are continuous and have clear boundaries, while the BIO labeling approach is more flexible and can handle multiple segments.

[0219] 5) Original Word Restore Loss L_restore: This subtask is a sequence generation task, requiring the restoration of variant text to the original seed word. Generation Cross Entropy is used as the loss function, calculated as L_restore = -Σ_i log(p_i), where i iterates through each position of the generated sequence, and p_i is the probability that the model generates the correct token at position i. The training objectives are set as follows: for variant_version samples, the target sequence is original_seed (restoring the variant to the original seed word); for original_version samples, the target sequence is an identity mapping (input equals output, preserving the original). Generation Cross Entropy optimizes the generation probability token-by-token, enabling the model to learn the ability to reverse-engineer the original word from the variant. Identity mapping training teaches the model that the original seed word does not need to be restored, avoiding excessive modification.

[0220] Five loss functions cover optimization objectives across five dimensions: sentence-level determination, word-level classification, similarity measurement, fragment localization, and word restoration. These are then combined using weighted summation to form a joint loss, and a phased weight adjustment strategy is designed. The joint loss function is defined as L_total = λ1×L_sens + λ2×L_word + λ3×L_metric + λ4×L_span +λ5×L_restore, where λ1, λ2, λ3, λ4, and λ5 are the weight coefficients for each subtask. Weight allocation follows a "start easy, then get difficult" learning principle: the initial stage focuses on sentence-level determination and word-level classification; the intermediate stage increases the weights for similarity measurement and fragment localization; and the advanced stage comprehensively optimizes, especially word restoration. Weights can be dynamically fine-tuned based on the performance of each subtask on the validation set; weights are appropriately increased for subtasks with insufficient performance, and appropriately decreased for tasks that have met the performance targets.

[0221] Step 302: Course-based Multi-stage Training. This step employs a three-stage progressive training strategy: "start-mid-advanced" and "advanced." It gradually improves the model's capabilities from simple samples to samples of full difficulty. Uniform batch construction, bucketed round-robin sampling, and sample weighting mechanisms ensure balanced training, while stage advancement and rollback mechanisms guarantee training stability. The inputs to this step are `Dataset_training_stage2` and `Definition_loss_function`, and the outputs are `Model_final` (the final trained model) and `Metrics_final` (a comprehensive performance report). The implementation process is as follows:

[0222] First, load the three-stage dataset constructed in Stage 2. The processing object is the course-based hierarchical training dataset `Dataset_training_stage2` output from step 205 of Stage 2, from which the initial, intermediate, and advanced stage datasets and their bucket index structures are extracted. The dataset integrity is verified by checking the sample proportions, mechanism distribution, domain distribution, length distribution, and the completeness of metadata fields (including `evolution_level`, `edit_distance`, `mechanism_span`, `node_degree`, `retention_score`, `difficulty_score`, `position`, `target_restoration`, etc.).

[0223] Next, training sample batches are constructed. Industry-standard deep learning batch construction, bucketed round-robin sampling, and sample weighting methods are used to construct training sample batches. Strategies include: batch size setting, positive / negative example ratio construction (constructing positive example pairs based on three versions of control samples for comparative learning, and constructing difficult / easy negative example combinations), and metadata preservation (position, target_restoration, training_metadata, etc. for multi-task training). The bucketed round-robin sampling mechanism includes: round-robin sampling based on the three-dimensional bucketed index (mechanism×domain×sentence_length) constructed in stage two; sampling within buckets in ascending order of difficulty to achieve course learning; node degree weighted sampling (increased weight for less common methods ×1.3, decreased weight for popular methods ×0.6); and dynamic ratio adjustment to ensure balance.

[0224] Finally, an end-to-end three-stage model training, validation, and evaluation process is performed. Industry-standard deep learning training and evaluation methods are used to train and evaluate the model. During training, stage switching or rollback protection is determined based on the model's performance metrics. After training is complete, the final model (Model_final) and a comprehensive performance report (Metrics_final) are output (including overall metrics, hierarchical metrics, confusion matrix, and error case analysis).

[0225] Step 303: Model Deployment and Continuous Optimization. This step deploys the trained model to the online environment and establishes a continuous iteration mechanism. Industry-standard deployment methods are employed, including shadow deployment to verify real-world performance, gradual rollout to increase traffic, and continuous monitoring and alerting to promptly detect anomalies, ensuring system security, controllability, and traceability. Simultaneously, a difficult example feedback collection mechanism is established, allowing for restarting model performance improvements from Phase 1, Phase 2, or Phase 3 as needed, based on different situations, thus enabling continuous model evolution. Specific implementation methods are industry-standard and will not be elaborated here.

[0226] At this point, the course-based hierarchical multi-task model training is complete. Through multi-objective joint loss function design, three-stage progressive training, batch construction strategy and bucketed round-robin sampling, sample weighting and stage-based rollback mechanism, as well as model deployment and continuous optimization mechanism, a complete course-based hierarchical multi-task model training and deployment process is formed. The output is a high-performance sensitive word recognition model optimized through course-based learning and multi-task joint optimization, possessing sentence-level judgment, word-level localization, and original word reconstruction capabilities, and supporting continuous iterative optimization.

[0227] The sensitive word identification method provided in this application, based on the variant generation metadata (evolution level, edit distance, mechanism span, node degree, retention score) and corpus construction metadata (domain, sentence length, position ratio) generated during the sensitive word evolution process, calculates the comprehensive difficulty score using a multi-factor weighted formula; divides the samples into different training stages according to the difficulty score and multi-dimensional constraints; establishes a three-dimensional bucket index structure of mechanism × domain × corpus length for each stage, and sorts the buckets in ascending order of difficulty; and realizes a "from easy to difficult" course-style learning data organization.

[0228] By employing a joint loss function across multiple tasks and a phased weight adjustment strategy (emphasizing judgment and classification in the initial stage, improving measurement and localization in the mid-stage, and comprehensively optimizing, especially word restoration, in the advanced stage), multi-objective collaborative optimization is achieved, enabling the model to simultaneously possess multiple capabilities such as judgment, classification, measurement, localization, and restoration. Multi-dimensional bucket indexing is used for round-robin sampling; sampling quotas are set for each dimension; each epoch samples from each three-dimensional bucket according to the quota, with sampling within each bucket ordered by difficulty to ensure learning within that bucket; node degree-weighted sampling is introduced; a dynamic quota adjustment strategy is designed; and a balanced sample distribution is ensured during training to avoid overfitting of popular samples and neglecting unpopular samples.

[0229] Current technologies for sensitive word identification employ several approaches: rule-based / lexicon approaches, traditional machine learning, and end-to-end deep models / large language models. The traditional rule-based / lexicon approach relies primarily on pre-set lexicons and manually expanded variation rules. While this system is fast and low-cost in known scenarios, it becomes inadequate when faced with cross-language and cross-modal mixed writing, or the "combination explosion" resulting from multiple methods. The proliferation of expressions such as simplified / traditional character conversion, homophone / near-phonetic substitution, full / half-width mixed text, zero-width / control character insertion, word segmentation and linking, punctuation perturbation, splitting and recombination, emoji and English homophones, and slang allusions quickly circumvent the rules. Furthermore, due to a lack of true understanding of the context, the system easily misclassifies normal contexts such as objective reports, refutations, and educational counterexamples as sensitive content. Traditional machine learning-based solutions typically follow a "feature engineering + classifier" approach, offering advantages such as rapid deployment and good interpretability. However, these methods heavily rely on manual features and rules, exhibiting poor transferability. Their generalization ability is significantly insufficient when faced with more complex semantic avoidance or combinations of perturbations. Polysemous words, ironic tones, and negative contexts often lead to false positives. As business evolves, features and thresholds need frequent modification; thresholds are prone to drift, resulting in instability when data distribution changes, and long-term maintenance costs rise accordingly. Deep learning and large language models possess strong semantic understanding capabilities and can handle some implicit expressions, but training and updating are costly, and convergence speed is not fast enough. They remain vulnerable in fine-grained adversarial tasks involving form, sound, and noise; encountering new mechanisms or cold-start domains often requires retraining or fine-tuning, and performance is easily affected by data quality and distribution drift. Directly deploying high-parameter models is difficult to withstand the costs of large-scale, high-concurrency scenarios, while overly lightweight small models are prone to inaccuracy in the face of complex variations.

[0230] The method provided in this application identifies sensitive words by linking variant exploration and sensitivity detection to continuously generate and filter high-quality samples with multiple mechanisms and difficulties, whose meaning remains unchanged within a certain range. On the other hand, operation trajectory signatures and sensitivity retention scores are written into the training objective, enabling the model to learn to distinguish boundaries, provide evidence, and maintain consistent interpretation. A coverage matrix of "mechanism × length × domain" is used in conjunction with a learning process progressing from easy to difficult to systematically expand the coverage of unknown combination variants. With this entire mechanism, the system can significantly improve judgment accuracy, reduce false positives, and control costs, allowing newly emerging variants to be incorporated into training and evaluation as quickly as possible.

[0231] Example 4

[0232] Figure 5 This is a schematic diagram of a sensitive word evolution device provided in Embodiment 4 of this application. Figure 5As shown, the device includes: a seed set acquisition module 410, a target operator determination module 420, an update module 430, and an evolution judgment module 440.

[0233] The seed set acquisition module 410 is used to acquire a sensitive word seed set, the sensitive word seed set including at least one sensitive word; initialize an evolution graph according to the sensitive word seed set, and initialize an evolutionary node pool according to the evolution graph;

[0234] The target operator determination module 420 is used to determine the evolution factor corresponding to each evolvable node in the evolvable node pool, determine the evolution priority of the evolvable node according to the evolution factor, filter out nodes to be evolved according to the evolution priority of each evolvable node, and determine the target evolution operator of each node to be evolved.

[0235] Update module 430 is used to evolve the node to be evolved according to the target evolution operator, and update the evolution graph and the pool of evolveable nodes according to the variants obtained from the evolution;

[0236] The evolution judgment module 440 is used to determine whether the evolution stopping condition is met. If yes, a sensitive word variant set is generated based on the variants obtained from the evolution. If no, the updated evolution graph is used as the new evolution graph, the updated evolvable node pool is used as the new evolvable node pool, and the process returns to the step of determining the evolution factor corresponding to each evolvable node in the evolvable node pool.

[0237] This application provides a sensitive word evolution device to solve the problem of the inability to systematically generate sensitive words. It initializes an evolution graph through a sensitive word seed set and initializes an evolvable node pool based on the evolution graph. The evolvable node pool stores evolvable nodes for subsequent sensitive word evolution. Evolution priorities are determined based on the evolution factors of the evolvable nodes, thereby selecting nodes to be evolved. The nodes to be evolved are then evolved using the target evolution operator corresponding to the nodes to be evolved, resulting in variants. Finally, the evolution graph and the evolvable node pool are updated based on the variants. If the evolution stopping condition is met, a sensitive word variant set is generated based on the variants, completing the sensitive word evolution; otherwise, evolution continues. The method provided in this application achieves systematic generation of sensitive words, automatically generating a large number of sensitive words and improving the generation efficiency of sensitive words.

[0238] The sensitive word evolution device provided in this application embodiment can execute the sensitive word evolution method provided in any embodiment of this application, and has the corresponding functional modules and beneficial effects of the execution method.

[0239] Example 5

[0240] Figure 6This is a schematic diagram of a sensitive word recognition device provided in Embodiment 5 of this application. Figure 6 As shown, the device includes: a raw corpus generation module 510, a sample pair construction module 520, a hierarchical corpus generation module 530, and a model training module 540.

[0241] The original corpus generation module 510 is used to process the sensitive word variant set based on a pre-constructed multidimensional sample coverage matrix to generate at least one original corpus, wherein the sensitive word variant set is generated using the sensitive word evolution method described in any embodiment of this application;

[0242] The sample pair construction module 520 is used to construct at least one sample pair based on the original corpus, each sample pair including a positive example pair and a negative example pair;

[0243] The hierarchical corpus generation module 530 is used to construct a hierarchical corpus based on each of the sample pairs and generate a hierarchical corpus.

[0244] The model training module 540 is used to train the model based on each of the hierarchical corpus sets to obtain a sensitive word recognition model, which is used to identify sensitive words.

[0245] This application provides a sensitive word recognition device. It processes a set of sensitive word variants using a multi-dimensional sample coverage matrix to generate a balanced and diverse original corpus. Sample pairs corresponding to the original corpus are constructed, each containing positive and negative examples. Comparison between positive and negative examples improves the model's recognition accuracy. The sample pairs are then layered to obtain a layered corpus, achieving hierarchical division of the corpus. The model is then progressively trained using this layered corpus to obtain a high-precision sensitive word recognition model, which accurately identifies sensitive words.

[0246] The sensitive word recognition device provided in this application embodiment can execute the sensitive word recognition method provided in any embodiment of this application, and has the corresponding functional modules and beneficial effects of the execution method.

[0247] Example 6

[0248] Figure 7This is a schematic diagram of an electronic device provided in Embodiment Six of this application. This electronic device 60 can be used to implement the methods provided in any embodiment of this application. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device can also represent various forms of mobile devices, such as personal digital assistants, cellular phones, smartphones, wearable devices (e.g., helmets, glasses, watches, etc.), and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present application described and / or claimed herein.

[0249] like Figure 7 As shown, the electronic device 60 includes at least one processor 61 and a memory, such as a read-only memory (ROM) 62 and a random access memory (RAM) 63, communicatively connected to the at least one processor 61. The memory stores computer programs executable by the at least one processor. The processor 61 can perform various appropriate actions and processes based on the computer program stored in the ROM 62 or loaded from storage unit 68 into the RAM 63. The RAM 63 can also store various programs and data required for the operation of the electronic device 60. The processor 61, ROM 62, and RAM 63 are interconnected via a bus 64. An input / output (I / O) interface 65 is also connected to the bus 64.

[0250] Multiple components in electronic device 60 are connected to I / O interface 65, including: input unit 66, such as keyboard, mouse, etc.; output unit 67, such as various types of monitors, speakers, etc.; storage unit 68, such as disk, optical disk, etc.; and communication unit 69, such as network card, modem, wireless transceiver, etc. Communication unit 69 allows electronic device 60 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0251] Processor 61 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of processor 61 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various processors running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. Processor 61 performs the various methods and processes described above, such as sensitive word evolution or sensitive word recognition methods.

[0252] In some embodiments, the sensitive word evolution or sensitive word recognition method may be implemented as a computer program tangibly contained in a computer-readable storage medium, such as storage unit 68. In some embodiments, part or all of the computer program may be loaded and / or installed on electronic device 60 via ROM 62 and / or communication unit 69. When the computer program is loaded into RAM 63 and executed by processor 61, one or more steps of the sensitive word evolution or sensitive word recognition method described above may be performed. Alternatively, in other embodiments, processor 61 may be configured to perform the sensitive word evolution or sensitive word recognition method by any other suitable means (e.g., by means of firmware).

[0253] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0254] Computer programs used to implement the methods of this application may be written in any combination of one or more programming languages. These computer programs may be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing device, such that when executed by the processor, the computer programs cause the functions / operations specified in the flowcharts and / or block diagrams to be performed. The computer programs may be executed entirely on a machine, partially on a machine, or as a standalone software package, partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0255] This application provides a computer program product, which includes a computer program that, when executed by a processor, implements the sensitive word evolution or sensitive word recognition method described in any embodiment of this application.

[0256] In the context of this application, a computer-readable storage medium can be a tangible medium that may contain or store a computer program for use by or in conjunction with an instruction execution system, apparatus, or device. A computer-readable storage medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. Alternatively, a computer-readable storage medium can be a machine-readable signal medium. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0257] To provide interaction with a user, the systems and techniques described herein can be implemented on an electronic device having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user; and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the electronic device. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0258] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as data servers), or middleware components (e.g., application servers), or frontend components (e.g., user computers with graphical user interfaces or web browsers through which users can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., communication networks). Examples of communication networks include local area networks (LANs), wide area networks (WANs), blockchain networks, and the Internet.

[0259] A computing system can include clients and servers. Clients and servers are generally located far apart and typically interact through communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. The server can be a cloud server, also known as a cloud computing server or cloud host, which is a hosting product within the cloud computing service system to address the shortcomings of traditional physical hosts and VPS services, such as high management difficulty and weak business scalability.

[0260] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this application can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution of this application can be achieved, and this is not limited herein.

[0261] The specific embodiments described above do not constitute a limitation on the scope of protection of this application. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this application should be included within the scope of protection of this application.

Claims

1. A sensitive word evolution method, characterized in that, include: Obtain a sensitive word seed set, wherein the sensitive word seed set includes at least one sensitive word; Initialize the evolution graph based on the set of sensitive word seeds, and initialize the pool of evolvable nodes based on the evolution graph; Determine the evolution factor corresponding to each evolvable node in the evolvable node pool, determine the evolution priority of the evolvable node based on the evolution factor, select nodes to be evolved based on the evolution priority of each evolvable node, and determine the target evolution operator for each node to be evolved. The node to be evolved is evolved according to the target evolution operator, and the evolution graph and the pool of evolveable nodes are updated according to the variants obtained from the evolution. Determine whether the evolution stopping condition is met. If yes, generate a set of sensitive word variants based on the variants obtained from the evolution. If no, use the updated evolution graph as the new evolution graph and the updated pool of evolvable nodes as the new pool of evolvable nodes, and return to the step of determining the evolution factor corresponding to each evolvable node in the pool of evolvable nodes.

2. The method according to claim 1, characterized in that, The evolutionary factors include at least one of the following: quantity gap factor, degree stratification factor, evolutionary potential factor, quality factor, and fourth-level variant ratio control factor; Determining the evolution factor corresponding to each evolvable node in the evolvable node pool includes at least one of the following: The evolved target cell of the evolving node is determined according to a predetermined variant evolution matrix; the target number and the number of effective samples are determined according to the target cell; the number gap is determined according to the target number and the number of effective samples; and the number gap factor is determined according to the number gap. The degree hierarchical factor of the evolvable node is determined based on the variant properties of the evolvable node; The evolution path table is queried to determine the outgoing edges of the evolvable node. Based on the outgoing edges of the evolvable node, the list of applied operators is determined. The total number of applicable operators for the evolvable node is filtered from the operator registry. The evolution potential factor is determined based on the length of the list of applied operators and the total number of applicable operators. The quality score of the evolvable node is obtained as a quality factor; The number of current level 4 variants and the total number of variants are counted based on the variant evolution matrix. The proportion of level 4 variants is determined based on the current number of level 4 variants and the total number of variants. The level 4 variant ratio control factor is determined based on the proportion of level 4 variants.

3. The method according to claim 2, characterized in that, The step of determining the evolved target cell of the evolvable node based on a predetermined variant evolution matrix includes: The coverage status of each cell in the variant evolution matrix is ​​determined based on the number of valid samples, sample quality, and quality weight corresponding to the cell. The target cell after the evolution of the evolving node is determined based on the coverage status of each cell.

4. The method according to claim 1, characterized in that, Determining the evolution priority of the evolvable node based on the evolution factor includes: At least one of the evolutionary factors to be weighted is weighted according to the factor weighting coefficient to obtain a weighted score. The factor to be weighted is a quantity gap factor, a degree stratification factor, an evolutionary potential factor, or a quality factor. Determine whether the evolvable node meets the fourth-level variant generation conditions. If yes, determine the product of the weighted score and the fourth-level variant ratio control factor in the evolution factors as the evolution priority of the evolvable node; if no, determine the weighted score as the evolution priority of the evolvable node.

5. The method according to claim 1, characterized in that, The determination of the target evolution operator for each of the nodes to be evolved includes: The operators in the operator registry are filtered according to the list of applied operators, language tags, and evolution levels corresponding to the node to be evolved, and a list of available operators for the node to be evolved is generated. The evolution mechanism requirements are determined based on the evolved target cell of the evolving node; The basic weights of the available operators in the list of available operators are adjusted according to the mechanism requirements to determine the weight of each available operator; The target evolution operator is determined based on the weights of each available operator.

6. The method according to claim 1, characterized in that, The step of updating the evolution graph and the pool of evolvable nodes based on the variants obtained from the evolution includes: For each variant, the distance between the variant and the corresponding node to be evolved is calculated. If the distance is greater than a preset distance threshold, the variant is discarded; otherwise, the variant is retained. For the retained variants, generate attribute information for the variants; The evolution graph and the pool of evolvable nodes are updated based on the attribute information of the variant.

7. The method according to claim 6, characterized in that, Also includes: Update at least one of the saturation state and the evolvable state of the nodes in the evolvable node pool; For each node, if the node's saturation state is saturated or the node's evolvable state is non-evolvable, the node is removed from the evolvable node pool. Wherein, updating at least one of the saturation state and the evolvable state of the nodes in the evolvable node pool includes at least one of the following: The variant attributes of a node are determined based on the out-degree and in-degree of the updated attribute information of the node, and the saturation state threshold of the node is determined based on the variant attributes; if the out-degree is greater than or equal to the saturation state threshold, the evolving state of the node is determined to be non-evolvable and the saturation state of the node is determined to be saturated. If it is determined that there are no available operators for the node, the evolutionary state of the node is determined to be non-evolvable; If the coverage state of the cell corresponding to the node in the variant evolution matrix is ​​severely over-limited, the evolutionary state of the node is determined to be non-evolvable.

8. The method according to any one of claims 1-7, characterized in that, The determination of whether the evolutionary stopping condition is met includes: Evolutionary state information is determined based on the evolution graph and the coverage statistics table. The evolutionary state information includes at least one of the following: variant set state, node pool evolvable state, quantity gap, and quality gap. The coverage statistics table stores the coverage state of each cell in the variant evolution matrix. Based on the evolutionary state information, determine whether the evolution stopping condition is met.

9. A method for identifying sensitive words, characterized in that, include: The sensitive word variant set is processed based on a pre-constructed multidimensional sample coverage matrix to generate at least one original corpus, wherein the sensitive word variant set is generated using the sensitive word evolution method as described in any one of claims 1-8; At least one sample pair is constructed based on the original corpus, and each sample pair includes a positive example pair and a negative example pair. Based on each of the aforementioned sample pairs, a hierarchical corpus is constructed to generate a hierarchical corpus. The sensitive word recognition model is obtained by training the model based on the hierarchical corpus sets, and the sensitive word recognition model is used to identify sensitive words.

10. The method according to claim 9, characterized in that, The construction of at least one sample pair based on the original corpus includes: The variants of sensitive words in the original corpus are replaced with corresponding seeds to obtain positive samples. Positive sample pairs are then generated based on the positive samples and the original corpus. Remove variants of sensitive words from the original corpus to obtain negative samples, and generate negative example pairs based on the negative samples and the original corpus; Sample pairs of the original corpus are formed based on the positive and negative example pairs.

11. The method according to claim 9, characterized in that, The step of constructing a hierarchical corpus based on each of the sample pairs to generate a hierarchical corpus includes: For each sample pair, determine the sample score information of the sample pair, and determine the difficulty score of the sample pair based on the sample score information; Based on the difficulty score, each sample pair is divided into stratified stages to generate a stratified corpus.

12. An electronic device, characterized in that, The electronic device includes: At least one processor, and a memory communicatively connected to said at least one processor; The memory stores a computer program that can be executed by the at least one processor, the computer program being executed by the at least one processor to enable the at least one processor to perform the sensitive word evolution method according to any one of claims 1-8 or the sensitive word recognition method according to any one of claims 9-11.

13. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer instructions that cause a processor to execute the sensitive word evolution method of any one of claims 1-8 or the sensitive word recognition method of any one of claims 9-11.

14. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, implements the sensitive word evolution method according to any one of claims 1-8 or the sensitive word recognition method according to any one of claims 9-11.

Images