A method, device and medium for instant communication of a doll based on edge computing

Abstract

The application discloses a kind of based on edge computing's doll instant messaging method, equipment and medium, it is related to the technical field of voice communication security control of Internet of Things, including to mechanism consistent section combination construction deterministic disturbance sample section and generates disturbance candidate graph set, the similarity of calculating disturbance candidate graph set and mechanism internal candidate graph set is filtered, obtain candidate graph set, calculate proportion support and filter, generate final candidate graph set;Through in fixed observation window construction link observation sequence and introduce skewness criterion driven skewness robust modeling path selection, improve the accuracy of the description of real communication state under the condition of wireless link jitter and long tail delay, through the strategy filtering mechanism of combining causal direction determination, mechanism consistent section structure learning and counterfactual inference strategy, the explainability and adaptive adjustment of end-side communication strategy are realized, improve voice communication stability and resource utilization efficiency.

Description

Technical Field

[0001] This invention relates to the field of IoT voice communication security control technology, and in particular to a doll instant communication method, device and medium based on edge computing. Background Technology

[0002] Smart dolls designed for child companionship, emotional interaction, and remote monitoring use microphones, sensors, and embedded processors to acquire voice data and device operating status. The data is then uploaded to a server or cloud platform via a wireless network for processing, and the results are sent back to the monitoring or doll end to enable voice forwarding, interactive control, or status display. The system also attempts to move computing, authentication, and policy decision-making capabilities closer to the edge node to reduce cloud load and improve communication latency.

[0003] However, existing technologies still have shortcomings. Existing doll voice communication methods evaluate link status based on fixed thresholds or mean statistics, which is difficult to adapt to situations where latency and packet loss are skewed or have long tails in wireless environments. They are prone to misjudging link status in jitter or sudden congestion scenarios. Existing adaptive communication strategies rely on correlation analysis or empirical rules to adjust encoding and transmission parameters, failing to distinguish the causal driving relationship between end-side strategies and link status. This results in a lack of interpretability in strategy adjustments and insufficient stability when network conditions change. Summary of the Invention

[0004] In view of the aforementioned existing problems, the present invention is proposed.

[0005] Therefore, this invention provides a doll instant communication method, device, and medium based on edge computing, which solves the problems of existing doll voice communication methods that evaluate link status based on fixed thresholds or mean statistics, making it difficult to adapt to situations where latency and packet loss are skewed or have long tails in wireless environments, and easily causing link status misjudgments in jitter or sudden congestion scenarios. Existing adaptive communication strategies rely on correlation analysis or empirical rules to adjust encoding and transmission parameters, failing to distinguish the causal driving relationship between end-side strategies and link status, resulting in a lack of interpretability in strategy adjustments and insufficient stability when network conditions change.

[0006] To solve the above-mentioned technical problems, the present invention provides the following technical solution:

[0007] In a first aspect, the present invention provides a doll instant communication method based on edge computing, comprising,

[0008] The edge node obtains the session request message of the doll segment and constructs the initial record of the session entry. Based on the initial record of the session entry, it generates challenge materials and sends the challenge materials to the doll end and the monitoring end. The edge node performs consistency verification and generates a session constraint set.

[0009] Define a fixed observation window for the session and collect speech frames within the window. Construct a link observation sequence and calculate the skewness criterion value. Obtain the candidate causal variables and candidate result variables of the previous fixed observation window. Set skewed path labels based on the skewness criterion value. If the label is a skewed robust modeling path, construct noise samples and reverse noise samples based on the candidate causal variables and candidate result variables and perform independence tests to obtain causal direction labels.

[0010] Construct a node set and log sample table, obtain the number of autonomous samplings and generate a deterministic random seed, construct an autonomous sample set, extract link statistics fields to calculate the maximum relative entropy statistic, obtain candidate change points and divide the autonomous sample set to obtain a mechanism-consistent segment set, input the structure learner and output the candidate graph set within the mechanism;

[0011] The mechanism-consistent segments are combined to construct deterministic perturbation sample segments and generate a set of perturbation candidate graphs. The similarity between the perturbation candidate graph set and the mechanism-internal candidate graph set is calculated and filtered to obtain a candidate graph set. The proportion support is calculated and filtered to generate the final candidate graph set.

[0012] The final candidate graph set is filtered to obtain a fixed-order index. A candidate strategy set is constructed and filtered in conjunction with the session constraint set and causal direction markers to obtain a unique strategy, which is then sent to the doll terminal and stored in the local database.

[0013] As a preferred embodiment of the edge computing-based doll instant messaging method of the present invention, the step of constructing noise samples and reverse noise samples and performing independence tests to obtain causal direction labels includes:

[0014] Obtain the candidate causal variable X of the previous fixed observation window of the edge node, and construct the candidate result variable Y based on the link observation sequence. Construct noise samples from the candidate causal variable to the candidate result variable and reverse noise samples from the candidate result variable to the candidate causal variable.

[0015] The Hilbert-Schmidt independence criterion test was used to test the noise samples and the reverse noise samples respectively. The log-likelihood of the noise samples and the reverse noise samples was calculated. If the candidate causal variable to the candidate outcome variable passed the test and the log-likelihood of the candidate causal variable was greater than that of the reverse noise sample, it was marked as the end-side policy driving the link performance. Otherwise, it was marked as the link state reverse constraint end-side policy, thus obtaining the causal direction label.

[0016] As a preferred embodiment of the edge computing-based doll instant messaging method of the present invention, the step of constructing an autonomous sample set and extracting link statistics fields to calculate the maximum relative entropy statistic includes:

[0017] Construct a node set and a log sample table, obtain the number of autonomous samplings from edge nodes, and calculate the sum of the integer of the session ID and the number of the current fixed observation window to obtain a deterministic random seed. Use the deterministic random seed to initialize the pseudo-random number generator and construct the autonomous sample set.

[0018] The link statistics fields of the autonomous sample set are extracted and arranged horizontally to obtain the mechanism discrimination sequence set. For each sequence in the set, the maximum and minimum values ​​are selected. The maximum value minus the minimum value and then divided by the number of categories are used to obtain the bin width. The state interval is constructed. The empirical probability is obtained by combining the candidate split position. The empirical probability is smoothed by Laplace to obtain the smoothed probability. The relative entropy statistic is calculated, sorted in descending order, and the maximum relative entropy statistic is selected.

[0019] As a preferred embodiment of the edge computing-based doll instant messaging method of the present invention, the following steps are included: calculating and filtering the similarity between the perturbation candidate graph set and the intra-mechanism candidate graph set to obtain a candidate graph set; calculating and filtering the percentage support to generate the final candidate graph set; and including:

[0020] Define candidate change points, use candidate change points to partition the autonomous sample set to obtain a set of mechanism-consistent segments, combine them with the node set, input them into the structure learner, and output a set of candidate graphs within the mechanism;

[0021] Deterministic perturbation sample segments are constructed from the set of mechanism-consistent segments, and a set of perturbation candidate graphs is constructed.

[0022] The similarity of the edge sets of the candidate graph set within the mechanism and the perturbation candidate graph set is calculated using the Jaccard coefficient formula, and the filtered candidate graph set is obtained through screening.

[0023] Calculate the percentage support for the selected candidate graph set, remove the union edges with percentage support less than the percentage support threshold, obtain the final edges, generate the final candidate graph set, and calculate the uncertainty of the whole graph and the uncertainty of sensitive subgraphs.

[0024] As a preferred embodiment of the edge computing-based doll instant messaging method of the present invention, wherein: the step of filtering the final candidate graph set to obtain a fixed-order index includes:

[0025] If the number of graphs in the final candidate graph set is greater than or equal to a fixed integer K, then the graphs are sorted in descending order of frequency of occurrence, and the top K graphs are retained. Otherwise, all graphs are retained, and K is set to the number of graphs. The filtered graphs are then sorted in descending order of frequency of occurrence to obtain a fixed-order index.

[0026] As a preferred embodiment of the edge computing-based doll instant messaging method of the present invention, the step of constructing a candidate strategy set and filtering it in conjunction with a session constraint set and causal direction markers to obtain a unique strategy and sending it to the doll end, and storing it in a local database, includes:

[0027] A candidate strategy set is constructed based on the coding complexity level, the transmission rate level, and the retransmission limit. Sensitive attribute nodes, intervention inversion values, link statistics fields, end-side node fields, and skewed path markers and causal direction markers are set as fixed inputs. The counterfactual inference in the structural causal model (SCM) is used to deduce the end-to-end delay counterfactual value and the success rate counterfactual value, and the delay risk bound and the success rate risk bound are constructed.

[0028] Based on the uncertainty of the sensitive subgraph, the execution permission is marked, all allowed candidate strategies are extracted from the execution permission marks, and the strategies are classified using the session constraint set to obtain the constraint-satisfied strategies. The unique strategies are then filtered by the power and causal direction marks.

[0029] The unique strategy is sent to the doll via the API interface. The edge node sends the current voice frame to the monitoring segment and stores the data in the fixed observation window into the local database.

[0030] As a preferred embodiment of the doll-based instant messaging method based on edge computing described in this invention, the step of defining a fixed observation window for the session and collecting voice frames within the window, constructing a link observation sequence, and calculating a skewness criterion value includes:

[0031] Define a fixed observation window for the session, construct a link observation sequence at the end of the fixed observation window, and calculate the skewness criterion value.

[0032] As a preferred embodiment of the edge computing-based doll instant communication method of the present invention, wherein: the step of sending challenge materials to the doll end and the monitoring end, and the edge node performing consistency verification and generating a session constraint set includes:

[0033] The doll segment session request messages are obtained by edge nodes and arranged vertically to obtain the initial record of session entries. A one-time random number is generated using edge nodes to construct challenge materials.

[0034] After the challenge materials are sent to the doll and the monitoring terminal via the API interface, the edge node receives the response message, sends the session key to the doll and the monitoring terminal via the API interface, and retrieves the key and issues the completion status. If the completion status is "complete", the session constraint set is obtained.

[0035] In a second aspect, the present invention provides a computer device including a memory and a processor, wherein the memory stores a computer program, wherein: when the computer program is executed by the processor, it implements any step of the doll instant communication method based on edge computing as described in the first aspect of the present invention.

[0036] Thirdly, the present invention provides a computer-readable storage medium having a computer program stored thereon, wherein: when the computer program is executed by a processor, it implements any step of the doll instant communication method based on edge computing as described in the first aspect of the present invention.

[0037] The beneficial effects of this invention are as follows: This invention constructs deterministic perturbation sample segments by combining consistent segments of the mechanism and generates a set of perturbation candidate graphs. It calculates the similarity between the set of perturbation candidate graphs and the set of candidate graphs within the mechanism and filters them to obtain a set of candidate graphs. It calculates the proportion support and filters it to generate the final set of candidate graphs. This improves the accuracy of characterizing the real communication state under the conditions of wireless link jitter and long-tail latency, realizes the interpretability and adaptive adjustment of the end-side communication strategy, and improves the stability of voice communication and the efficiency of resource utilization. Attached Figure Description

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

[0039] Figure 1 This is a flowchart of the doll instant messaging method based on edge computing in Example 1.

[0040] Figure 2 This is a schematic diagram illustrating the timing of secure session establishment for the doll instant messaging method based on edge computing in Example 1.

[0041] Figure 3 This is a schematic diagram of the core of the causal inference model of the doll instant messaging method based on edge computing in Example 1.

[0042] Figure 4 This is a schematic diagram of the strategy optimization decision of the doll instant messaging method based on edge computing in Example 1. Detailed Implementation

[0043] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0044] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0045] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0046] Example 1, referring to Figures 1 to 4 This is the first embodiment of the present invention, which provides a doll instant messaging method based on edge computing, including the following steps:

[0047] S1. The edge node obtains the doll segment session request message and constructs the initial record of the session entry. Based on the initial record of the session entry, it generates challenge materials and sends the challenge materials to the doll end and the monitoring end. The edge node performs consistency verification and generates a session constraint set.

[0048] Specifically, the challenge materials are sent to the doll-end and the monitoring end, and the edge nodes perform consistency verification and generate a set of session constraints, including:

[0049] Voice frames are acquired through the microphone, and battery percentage, current temperature, and current CPU usage percentage are obtained through the API interface. The acquired data is then arranged horizontally to obtain the edge state vector.

[0050] The session request message for the doll segment is obtained through edge nodes (referring to lightweight servers or gateway devices with computing, storage, communication and security capabilities deployed at the network edge (close to terminal devices, such as doll end and monitoring end)). The message includes session ID, doll device ID, monitoring end ID and end-side state vector. The access timestamp is read and combined with the session request message for vertical arrangement to obtain the initial record of the session entry.

[0051] Based on the initial record of the session entry, a one-time random number is generated by the edge node, representing a fixed-byte length random sequence returned by the security interface of the edge node. The consistency confirmation window length is obtained through the edge node, which is a preset fixed value when the edge node is deployed. The sum of the consistency confirmation window length and the access timestamp is calculated to obtain the deadline timestamp. The one-time random number, session ID and deadline timestamp are arranged vertically to obtain the challenge material.

[0052] After the challenge materials are sent to the doll end and the monitoring end via the API interface, the edge node obtains the timing status (when the time window set by the edge node's timestamp and the deadline timestamp is open (meaning that the response message is accepted within the window), and waits for the responses from both ends), accepts the response message, and builds a response buffer for both ends respectively, including the response arrival timestamp, the session ID carried in the response, and the one-time random number carried in the response;

[0053] The response message includes a session ID, a one-time random number, a response arrival timestamp, a doll device ID or a monitoring terminal ID, and a response type identifier (indicating doll-end consistency confirmation and monitoring terminal consistency confirmation).

[0054] The edge node obtains the timestamps of the received response messages at both ends of the record. If the timestamp is consistent with the timestamp in the initial record of the session entry, the response random number of the response message is consistent with the one-time random number in the challenge material, and the arrival timestamp of the response message is less than or equal to the deadline timestamp, then the initial record of the session entry is marked as consistent. The edge node generates a session key (one-time random number) and records the current timestamp (set as the key effective timestamp) and the session validity period length. The current timestamp and the session validity period length are added to obtain the key expiration timestamp. Otherwise, it is marked as inconsistent and does not proceed to the next step.

[0055] The session key (key activation timestamp and key expiration timestamp) is sent to the doll end and the monitoring end via the API interface, and the key distribution completion status is retrieved. If the completion status is complete, the session constraint set is obtained, including the maximum available bandwidth limit, the maximum tolerable end-to-end latency limit, and the minimum acceptable success rate limit.

[0056] By constructing an edge-side state vector and implementing a two-end consistency verification mechanism, the security and reliability of edge session establishment are significantly improved. Traditional solutions typically rely on one-way authentication or pre-shared keys, which are difficult to resist replay attacks or device impersonation risks. This step synchronously collects multi-dimensional edge-side states through microphone and system API to form a high-dimensional state vector as the session context. The edge node generates a one-time random number as a challenge factor. Combined with a preset time window, synchronous response verification is performed on the doll end and the monitoring end. This mechanism ensures that only the two ends that correctly transmit the original challenge value within the specified time window can complete the session initialization, thereby effectively preventing man-in-the-middle attacks, device impersonation, and key leakage caused by time drift. At the same time, the session key directly reuses the one-time random number to avoid additional key negotiation overhead. Fine-grained lifecycle management is achieved through key activation and deactivation timestamps. The session constraint set obtained on this basis provides a quantitative boundary for subsequent adaptive strategies, forming a closed loop between security authentication and resource scheduling, and realizing lightweight and highly robust trusted startup of edge sessions.

[0057] S2. Define a fixed observation window for the session and collect speech frames within the window. Construct a link observation sequence and calculate the skewness criterion value. Obtain the candidate causal variables and candidate result variables of the previous fixed observation window. Set the skewed path label based on the skewness criterion value. If the label is a skewed robust modeling path, construct noise samples and reverse noise samples based on the candidate causal variables and candidate result variables and perform independence tests to obtain the causal direction label.

[0058] Specifically, a fixed observation window is defined for the session, and speech frames are collected within the window. A link observation sequence is constructed, and skewness criterion values ​​are calculated, including:

[0059] Define a fixed observation window for the session, including using the current timestamp of the edge node as the starting point of the window, and setting the observation window length based on a rule of thumb;

[0060] Voice frames are collected through edge nodes within a fixed observation window, and missing numbers in consecutive voice frame numbers are recorded as the number of lost packets. The number of times the same number appears is counted and set as the number of retransmissions.

[0061] At the end of the fixed observation window, construct the link observation sequence (samples), including a one-way transmission delay sample sequence (timestamp sent by the doll end minus the arrival timestamp of the edge node), an arrival interval sample sequence (timestamp difference between two adjacent voice frames), and a packet loss rate sequence (number of lost packets divided by number of retransmissions). Calculate the skewness criterion value using the following formula:

[0062] ,

[0063] in, This is the skewness criterion value. Where is the sample size, and is the time delay within a fixed observation window. For the first One delay sample, The mean of the time delay samples, The standard deviation of the time delay sample.

[0064] By introducing a fixed observation window and skewness criterion to jointly model the dynamic characteristics of the link, this method overcomes the limitations of traditional QoS assessments that rely solely on mean or variance. Existing methods often assume that network indicators follow a symmetrical distribution, ignoring the nonlinear impact of sudden packet loss or latency spikes on the voice interaction experience. This step, by accurately recording missing and duplicate voice frame numbers, defines the number of lost packets and retransmissions, respectively, and constructs a packet loss rate model that better reflects actual transmission behavior. At the same time, it extracts the one-way transmission delay and arrival interval sequences to comprehensively characterize the link's temporal features. The key innovation lies in calculating the skewness criterion value of the delay samples. This criterion can effectively identify the asymmetry at the tail of the distribution—positive skewness reflects occasional high-latency events, while negative skewness suggests systematic latency accumulation. This criterion not only reveals the potential risk patterns of link quality but also provides a basis for subsequent causal modeling path selection: high skewness triggers robust modeling paths to cope with non-Gaussian noise, while low skewness enables simplified paths to improve computational efficiency. This achieves a cognitive leap from average performance to distribution patterns, providing a more forward-looking link state awareness capability for edge voice communication.

[0065] Furthermore, noise samples and reverse noise samples are constructed and independence tests are performed to obtain causal direction labels, including:

[0066] Obtain the candidate causal variable X for the previous fixed observation window of the edge node, including the coding complexity level and the transmission rate level;

[0067] Based on the link observation sequence, candidate outcome variable Y is constructed, including success rate (represented by the number of voice frames successfully received within a fixed observation window divided by the number of voice frames sent) and end-to-end delay statistics (the mean of the one-way transmission delay sample sequence).

[0068] The skewness criterion value is used to set skewness path markings. If the skewness criterion value is greater than or equal to the skewness activation threshold (set by fixed threshold method), it is marked as a skewness robust modeling path for subsequent operations; otherwise, it is marked as a non-skewness simplified path.

[0069] Noise samples from candidate cause variables to candidate result variables are constructed, including setting a joint discrete point set based on actual application scenarios, including a set of possible discrete points for coding complexity levels and a set of possible discrete points for transmission rate levels. The joint discrete point set is combined by Cartesian combination to obtain a set of discrete states of candidate result variables, where each combination represents a unique end-side control state and is set as a discrete point.

[0070] Obtain the encoding complexity level and transmission rate level of the previous fixed observation window of the edge node, match them with discrete points, and if a match is found at the kth discrete point, add all samples from the previous fixed observation window to the discrete combination.

[0071] The positional statistics are obtained by averaging the candidate outcome variables in the discrete combination.

[0072] The residuals are obtained by subtracting the location statistics from the candidate outcome variables. The scale statistics are calculated by the mean absolute deviation method on the index residuals in the discrete combination. The location statistics and scale statistics are interpolated by adjacent point lines to obtain the location function and scale function. The noise sample is obtained by subtracting the location function from the candidate cause variable and then dividing by the scale function.

[0073] Construct inverse noise samples from candidate outcome variables to candidate cause variables, consistent with the above steps, by swapping the candidate outcome variables and candidate cause variables in the above steps;

[0074] The Hilbert-Schmidt Independence Criterion (HSIC) was used to test the independence of the candidate causal variable and the two noise samples for both the noise samples and the reverse noise samples. The test results were obtained, including pass and fail.

[0075] Calculate the log-likelihood for both the noise sample and the reverse noise sample. If the candidate causal variable to the candidate outcome variable passes and the log-likelihood is greater than that of the reverse noise sample, then it is marked as an end-side policy-driven link performance; otherwise, it is marked as a link state-reverse constraint on the end-side policy, thus obtaining the causal direction label, as shown in the formula:

[0076] ,

[0077] in, For log-likelihood, This is a causal direction marker, indicating that the cause is due to the candidate outcome variable. Leading to candidate cause variables , The probability value is obtained using a Gaussian distribution.

[0078] This invention creatively integrates discrete control state modeling, residual standardization, and HSIC independence testing to reliably determine the causal direction between end-side policies and link performance. Existing adaptive transmission schemes are mostly based on correlation or supervised learning, which cannot distinguish whether policy adjustments lead to link changes or link deterioration forces policy adjustments, easily leading to mis-tuning. This step first discretizes the coding complexity level and transmission rate level into finite control states, constructs the end-side policy space through Cartesian product, and then estimates the position and scaling function of link performance in each state based on historical observation data. The original variables are detrended and normalized to generate structured noise samples. This noise modeling method effectively removes the deterministic relationship between policy and link, retaining potential causal signals. By constructing forward and reverse noise samples and applying HSIC testing, the independence of variables and noise is rigorously verified. Combined with Gaussian log-likelihood comparison, the causal direction is objectively determined. This mechanism breaks through the dependence of traditional Granger causality on linearity and temporal stationarity, and is suitable for non-stationary edge device scenarios with small sample sizes. It provides a reliable causal graph prior for subsequent counterfactual inference, significantly improving the interpretability and robustness of policy decisions.

[0079] S3. Construct a node set and log sample table, obtain the number of autonomous samplings and generate a deterministic random seed, construct an autonomous sample set, extract link statistics fields to calculate the maximum relative entropy statistics, obtain candidate change points and divide the autonomous sample set, obtain a mechanism-consistent segment set, input the structure learner and output the candidate graph set within the mechanism;

[0080] Specifically, an autonomous sample set is constructed, and link statistics fields are extracted to calculate the maximum relative entropy statistic, including:

[0081] Construct a node set, including defining the encoding complexity level and the transmission rate level as policy nodes, defining the battery percentage, temperature and CPU usage as edge nodes, defining the number of packet loss, number of retransmissions, end-to-end latency statistics, success rate, skewness criterion value and skew path label as link nodes, defining the causal direction label as decision nodes, and the Tonggu edge node obtains privacy level switch fields such as whether cloud upload is allowed and defines them as sensitive attribute nodes;

[0082] The coding complexity level, transmission rate level, number of lost packets, number of retransmissions, packet loss rate sequence, end-to-end delay statistics, success rate, skewness criterion value, skewed path marker, causal direction marker, end-side battery percentage, temperature, and CPU usage are arranged vertically in the same fixed observation window to obtain a log sample table with n rows.

[0083] Obtain the number of autonomous samplings B from the edge nodes, and calculate the sum of the integer of the session ID (obtained by using a hash function on the session ID) and the number of the current fixed observation window to obtain a deterministic random seed. Use the deterministic random seed to initialize the pseudo-random number generator (e.g., Mason's rotation algorithm).

[0084] For an integer b, starting from 1, increment by 1 each time until b equals the number of autonomous samplings B, thus obtaining the autonomous sample set. This includes initializing an empty integer array and using a pseudo-random number generator to generate a set of samples within the interval... Take uniformly distributed random integers between the two integers and add them to the end of the integer array. Iterate through each row index in the integer array and extract the row data corresponding to that row from the log sample table to obtain B autonomous sample sets.

[0085] Extract link statistics fields from the autonomous sample set, such as end-to-end latency statistics, packet loss rate, and success rate sequences, and arrange them horizontally to obtain a mechanism discrimination sequence set. For each sequence in the set, select the maximum and minimum values. Subtract the minimum value from the maximum value and divide by the number of categories (based on an empirical rule) to obtain the bin width. Construct state intervals, combine them with candidate segmentation positions to obtain empirical probabilities, and then smooth the empirical probabilities using Laplace to obtain the smoothed probabilities. The formula is:

[0086] ,

[0087] ,

[0088] in, To be the minimum value, For the width of the box, For the first Each state interval For category indexing, For the left segment in the first The empirical probability of a state interval For the left segment in the first Sample count for each state interval, For left segment index;

[0089] The candidate segmentation position refers to the window number extracted from each row of the autonomous sample set, sorted in ascending order to obtain an index sequence. Each internal position in the index sequence is a candidate segmentation position. The first half of the sequence is the left segment, and the second half is the right segment.

[0090] Based on the smoothing probability, calculate the relative entropy statistic, sort in descending order, and select the statistic with the largest relative entropy. The formula is:

[0091] ,

[0092] in, The maximum relative entropy statistic. For candidate segmentation position index, and For the left and right segments in the first The smoothing probability of each state interval This represents the number of categories.

[0093] This paper proposes a mechanism change point detection method based on autonomous sampling and maximum relative entropy, which effectively identifies structural abrupt changes in link behavior. Traditional sliding window or CUSUM methods are sensitive to distribution types and have difficulty handling multidimensional heterogeneous data. This step first constructs a multidimensional node set covering policy, end-side, link, judgment, and sensitive attributes to form a unified log sample table. Then, a deterministic random seed is generated using session ID and window number to ensure the reproducibility of the autonomous sampling process, taking into account both randomness and audit requirements. The key innovation lies in calculating the smoothing probability of the left and right segments after binning the link statistical fields, and using the maximum relative entropy as the change point criterion. This method does not require assumptions about the distribution form and can sensitively capture abrupt changes in the joint distribution of multidimensional indicators. It is especially suitable for mechanism migration caused by network switching, interference, or device state transitions in voice communication. By traversing candidate segmentation positions and verifying the Sanov threshold, the change point is accurately located, providing homogeneous data segments for subsequent structure learning. This design deeply integrates temporal segmentation and distribution difference quantification, which is significantly better than fixed window or heuristic segmentation strategies, laying a high-quality data foundation for causal graph learning.

[0094] S4. Combine the consistent segments of the mechanism to construct deterministic perturbation sample segments and generate a set of perturbation candidate graphs. Calculate the similarity between the set of perturbation candidate graphs and the set of candidate graphs within the mechanism and filter them to obtain a set of candidate graphs. Calculate the percentage support and filter it to generate the final set of candidate graphs.

[0095] Specifically, the similarity between the perturbation candidate graph set and the within-mechanism candidate graph set is calculated and filtered to obtain a candidate graph set. The proportion support is then calculated and filtered to generate the final candidate graph set, which includes:

[0096] Based on the number of samples, the significance level (set by the fixed threshold method), and the number of categories, the threshold is calculated using the Sanov inequality. If the maximum relative entropy statistic is greater than or equal to the threshold, the candidate splitting position is defined as a candidate change point.

[0097] The autonomous sample set is partitioned using candidate change points to obtain a set of mechanism-consistent segments. The mechanism-consistent segments are extracted, combined with the node set, and input into a structure learner (e.g., PC algorithm or MMHC algorithm). Constraints are set, including prohibiting any node from pointing unidirectionally to a node with sensitive attributes and prohibiting edges that violate time consistency. The output is a set of candidate graphs within the mechanism.

[0098] Construct deterministic perturbation sample segments from the set of mechanism-consistent segments. This includes calculating the product of the perturbation ratio (set based on statistical analysis) and the number of samples within the segment (obtained by counting the number of rows in the mechanism-consistent segment), rounding down the product to obtain the number of samples to be removed k, sorting the rows of the mechanism-consistent segments in descending order, and removing the top k samples to obtain deterministic perturbation sample segments. Construct a set of perturbation candidate graphs from the deterministic perturbation sample segments, following the same process as obtaining the set of candidate graphs within the mechanism.

[0099] The similarity between the edge sets of the candidate graph set within the mechanism and the perturbation candidate graph set is calculated using the Jaccard coefficient formula. If the similarity is less than the similarity threshold (set based on a fixed threshold method), the corresponding candidate graph within the mechanism is deleted, resulting in a filtered candidate graph set.

[0100] Count the number of rows in the consistent segments of the candidate graph set to obtain the segment length. Sum all segment lengths to obtain the total length. Define the segment proportion as the segment length divided by the total length. Calculate the proportion support of the union of edges in the candidate graph set using the following formula:

[0101] ,

[0102] in, To determine the percentage of support, For segment index, For edge index, To filter the set of edges in the candidate graph set, For segment percentage;

[0103] Based on the selected candidate graph set, the union edges with a support percentage less than the support percentage threshold (set based on empirical rules) are removed to obtain the final edges and generate the final candidate graph set.

[0104] Count the occurrence frequency of each edge in the final candidate graph set, divide the occurrence frequency by the number of graphs to obtain the frequency, and then use the Shannon entropy formula to calculate the uncertainty entropy value. Calculate the overall graph uncertainty using the following formula:

[0105] ,

[0106] in, Due to the uncertainty of the entire map, The edge index of the final candidate graph set. For the uncertainty entropy value, The number of distinct edges is obtained by counting the number of edges in the final candidate graph set. The number of edges in the final candidate graph set;

[0107] Based on the final candidate graph set, the reachable nodes of each sensitive attribute node are counted, and the edges whose starting and ending points both belong to the union of sensitive attribute nodes and reachable nodes are extracted. The uncertainty of the sensitive subgraph is calculated, which is consistent with the above process for calculating the uncertainty of the whole graph.

[0108] By using perturbation stability screening and weighted proportional support, a high-confidence causal graph set is constructed to effectively suppress overfitting in structural learning under small marginal samples. Existing PC or MMHC algorithms are prone to generating spurious edges when samples are sparse and lack protection for sensitive attributes. This step first runs the structural learner on mechanism-consistent segments and applies privacy and time constraints, prohibiting edges pointing to nodes with sensitive attributes and connections that violate causal temporal order. Then, deterministic perturbation sample segments are constructed to generate a perturbation candidate graph set. Graphs with stable structures are screened using Jaccard similarity to remove fragile connections sensitive to small perturbations. Segment length-weighted proportional support is introduced to give higher weight to long-term observations and avoid short transient segments dominating the global structure. Finally, low-support edges are removed to generate a concise and reliable causal graph set. The uncertainty of sensitive subgraphs directly serves the privacy strategy, ensuring that cloud uploads are disabled under high uncertainty and achieving the principle of data minimization.

[0109] S5. Filter the final candidate graph set to obtain a fixed order index, construct a candidate strategy set and filter it in combination with the session constraint set and causal direction label to obtain a unique strategy and send it to the doll end and store it in the local database.

[0110] Specifically, the final candidate graph set is filtered to obtain a fixed-order index, including:

[0111] If the number of graphs in the final candidate graph set is greater than or equal to a fixed integer K (based on a fixed threshold method), then the graphs are sorted in descending order of frequency of occurrence, and the top K graphs are retained; otherwise, all graphs are retained. K is set to the number of graphs, and the filtered graphs are sorted in descending order of frequency of occurrence to obtain a fixed-order index.

[0112] By sorting high-frequency causal graphs in descending order and fixing the sequential index, efficient compression and stable retrieval of causal knowledge are achieved. In edge resource-constrained scenarios, maintaining a complete graph set is too costly. This step sets a fixed integer K as the upper limit of the graph set, prioritizing the retention of the most frequently occurring causal structures. This preserves mainstream behavior patterns while controlling storage and computational complexity. When the number of graphs is less than K, all graphs are automatically retained to ensure the modeling integrity of small-scale sessions. The fixed sequential index ensures the consistency of subsequent counterfactual inference inputs and avoids policy fluctuations caused by random graph order. This design balances model diversity and deployment stability, enabling edge nodes to maintain the most representative causal knowledge base in limited memory, providing reliable support for real-time policy generation.

[0113] Furthermore, a candidate policy set is constructed and filtered using a combination of a session constraint set and causal direction markers to obtain a unique policy, which is then sent to the puppet client and stored in a local database, including:

[0114] A candidate strategy set is constructed based on the coding complexity level, the sending rate level, and the retransmission limit. This includes sorting the strategies in ascending order by the sending rate level, then by the coding complexity level, and then by the retransmission limit to obtain the strategy index.

[0115] Sensitive attribute nodes, intervention inversion values, link statistics fields, end-side node fields, and skewed path markers and causal direction markers are set as fixed inputs. The counterfactual inference in the structural causal model (SCM) is used to deduce the end-to-end delay counterfactual value and the success rate counterfactual value, which are then sorted in descending order. The maximum and minimum values ​​of the two are extracted. The maximum end-to-end delay counterfactual value is multiplied by the full graph uncertainty amplification factor, and the minimum success rate counterfactual value is divided by the full graph uncertainty amplification factor. The two products are combined with the two maximum and minimum values ​​to construct intervals, thus obtaining the delay risk boundary and the success rate risk boundary.

[0116] The full-map uncertainty amplification factor refers to the ratio of the full-map uncertainty to the full-map uncertainty threshold (set based on statistical analysis). If the full-map uncertainty is less than the full-map uncertainty threshold, it is set to 1; otherwise, it is set to the ratio of the full-map uncertainty to the full-map uncertainty threshold.

[0117] If the uncertainty of the sensitive subgraph is greater than or equal to the uncertainty threshold of the sensitive subgraph (set based on the fixed threshold method), then candidate strategies that do not involve cloud uploads are marked as allowed, and those that do are marked as disallowed; otherwise, all candidate strategies are marked as allowed, and execution permission tags are obtained.

[0118] Extract all allowed candidate strategies from the execution permission flags, and classify them using the session constraint set. If the maximum value of the latency risk boundary of a candidate strategy is less than or equal to the maximum tolerable end-to-end latency limit, it is marked as latency satisfied; otherwise, it is marked as latency unsatisfied. If the minimum value of the success rate risk boundary is greater than or equal to the minimum acceptable success rate limit, it is marked as success rate satisfied; otherwise, it is marked as success rate unsatisfied. Retain the strategies marked as latency satisfied and success rate satisfied from all allowed candidate strategies in the execution permission flags to obtain the constraint satisfied strategies.

[0119] Based on statistical analysis, a power percentage threshold is set. If the power percentage is less than the power percentage threshold, the constraint satisfying strategy with the lowest transmission rate is selected. If the constraint satisfying strategy with the lowest transmission rate is not a single strategy, the constraint satisfying strategy with the lowest encoding level is selected. If it is still not a single strategy, the constraint satisfying strategy with the lowest retransmission limit is selected and set as the unique strategy.

[0120] If the battery percentage is greater than or equal to the battery percentage threshold, the causal direction marker is filtered. If the causal direction marker is the end-side policy-driven link behavior, the constraint-satisfying policy with the lowest transmission rate is filtered first. If there are tied conditions, the constraint-satisfying policy with the lowest coding level is filtered. If there are still tied conditions, the constraint-satisfying policy with the lowest retransmission limit is filtered (the constraint-satisfying policy that is filtered after typing is performed on the tied constraint-satisfying policy) to obtain a unique policy. If the causal direction marker is the link state reverse constraint end-side policy, the policy is filtered in the order of highest retransmission limit, lowest transmission rate, and lowest coding level to obtain a unique policy.

[0121] The unique policy is sent to the doll terminal via the API interface. After receiving the unique policy, the doll terminal sends the current voice frame (session ID, consecutive number, and timestamp) to the edge node. The edge node sends the current voice frame to the monitoring segment and stores all data in the fixed observation window (such as end-side state vector, link observation sequence, policy node field, and decision node field) in the local database.

[0122] By combining SCM counterfactual inference with a full-graph uncertainty amplification factor, a conservative risk bound is generated. Furthermore, differentiated strategy selection is implemented by integrating power state and causal direction, achieving a safe, efficient, and adaptive end-side decision-making closed loop. Traditional strategy selection is often based on current observations or simple rules, lacking the ability to predict unexecuted strategies. This step utilizes counterfactual inference through screening the causal graph to predict the latency and success rate distribution under each candidate strategy. It also innovatively introduces a full-graph uncertainty amplification factor: when the overall causal structure is highly uncertain, the latency risk bound is automatically expanded while the success rate risk bound is narrowed, prompting the system to select a more conservative strategy, reflecting risk aversion. The "malicious policy" principle, through the execution of a permission marking mechanism, links the uncertainty of sensitive subgraphs with privacy switches, dynamically blocking high-risk policies. The final policy selection logic deeply integrates device power consumption and causal direction—prioritizing energy saving when power is low, and intelligently weighing factors based on causal mechanisms when power is high: if the policy drives the link, it pursues low overhead; if the link conversely constrains the policy, it strengthens robustness. This multi-dimensional, context-aware decision-making framework is significantly superior to single-objective optimization methods, ensuring the optimal balance between privacy, security, energy efficiency, and user experience. After the policy is issued, edge nodes synchronously forward the voice stream and persist all observation data, providing a complete chain of evidence for continuous learning and auditing.

[0123] This embodiment also provides a computer device applicable to the doll instant communication method based on edge computing, including: a memory and a processor; the memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions to implement the doll instant communication method based on edge computing as proposed in the above embodiment.

[0124] The computer device can be a terminal, comprising a processor, memory, communication interface, display screen, and input devices connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The communication interface is used for wired or wireless communication with external terminals; wireless communication can be achieved through Wi-Fi, carrier networks, NFC (Near Field Communication), or other technologies. The display screen can be an LCD screen or an e-ink screen. The input devices can be a touch layer covering the display screen, buttons, a trackball, or a touchpad on the computer device's casing, or an external keyboard, touchpad, or mouse.

[0125] This embodiment also provides a storage medium storing a computer program that, when executed by a processor, implements the doll instant communication method based on edge computing as proposed in the above embodiments. The storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as Static Random Access Memory (SRAM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read Only Memory (EPROM), Programmable Red-Only Memory (PROM), Read-Only Memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk.

[0126] In summary, this invention constructs deterministic perturbation sample segments by combining consistent segments of the mechanism and generates a set of perturbation candidate graphs. It calculates the similarity between the perturbation candidate graph set and the candidate graph set within the mechanism and performs screening to obtain a candidate graph set. It then calculates the proportion support and performs screening to generate the final candidate graph set. This improves the accuracy of characterizing the real communication state under wireless link jitter and long-tail latency conditions, enables interpretable and adaptive adjustment of end-side communication strategies, and improves the stability of voice communication and resource utilization efficiency.

[0127] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A doll-based instant messaging method based on edge computing, characterized in that: include, The edge node obtains the session request message of the doll segment and constructs the initial record of the session entry. Based on the initial record of the session entry, it generates challenge materials and sends the challenge materials to the doll end and the monitoring end. The edge node performs consistency verification and generates a session constraint set. Define a fixed observation window for the session and collect speech frames within the window. Construct a link observation sequence and calculate the skewness criterion value. Obtain the candidate causal variables and candidate result variables of the previous fixed observation window. Set skewed path labels based on the skewness criterion value. If the label is a skewed robust modeling path, construct noise samples and reverse noise samples based on the candidate causal variables and candidate result variables and perform independence tests to obtain causal direction labels. Construct a node set and log sample table, obtain the number of autonomous samplings and generate a deterministic random seed, construct an autonomous sample set, extract link statistics fields to calculate the maximum relative entropy statistic, obtain candidate change points and divide the autonomous sample set to obtain a mechanism-consistent segment set, input the structure learner and output the candidate graph set within the mechanism; The mechanism-consistent segments are combined to construct deterministic perturbation sample segments and generate a set of perturbation candidate graphs. The similarity between the perturbation candidate graph set and the mechanism-internal candidate graph set is calculated and filtered to obtain a candidate graph set. The proportion support is calculated and filtered to generate the final candidate graph set. The final candidate graph set is filtered to obtain a fixed-order index. A candidate strategy set is constructed and filtered in conjunction with the session constraint set and causal direction markers to obtain a unique strategy, which is then sent to the doll terminal and stored in the local database.

2. The doll instant messaging method based on edge computing as described in claim 1, characterized in that: The process of constructing noise samples and reverse noise samples and performing independence tests to obtain causal direction labels includes: Obtain the candidate causal variable X of the previous fixed observation window of the edge node, and construct the candidate result variable Y based on the link observation sequence. Construct noise samples from the candidate causal variable to the candidate result variable and reverse noise samples from the candidate result variable to the candidate causal variable. The Hilbert-Schmidt independence criterion test was used to test the noise samples and the reverse noise samples respectively. The log-likelihood of the noise samples and the reverse noise samples was calculated. If the candidate causal variable to the candidate outcome variable passed the test and the log-likelihood of the candidate causal variable was greater than that of the reverse noise sample, it was marked as the end-side policy driving the link performance. Otherwise, it was marked as the link state reverse constraint end-side policy, thus obtaining the causal direction label.

3. The doll instant messaging method based on edge computing as described in claim 2, characterized in that: The process of constructing an autonomous sample set, extracting link statistics fields, and calculating the maximum relative entropy statistic includes: Construct a node set and a log sample table, obtain the number of autonomous samplings from edge nodes, and calculate the sum of the integer of the session ID and the number of the current fixed observation window to obtain a deterministic random seed. Use the deterministic random seed to initialize the pseudo-random number generator and construct the autonomous sample set. The link statistics fields of the autonomous sample set are extracted and arranged horizontally to obtain the mechanism discrimination sequence set. For each sequence in the set, the maximum and minimum values ​​are selected. The maximum value minus the minimum value and then divided by the number of categories are used to obtain the bin width. The state interval is constructed. The empirical probability is obtained by combining the candidate split position. The empirical probability is smoothed by Laplace to obtain the smoothed probability. The relative entropy statistic is calculated, sorted in descending order, and the maximum relative entropy statistic is selected.

4. The doll instant messaging method based on edge computing as described in claim 3, characterized in that: The similarity between the perturbation candidate graph set and the intra-mechanism candidate graph set is calculated and filtered to obtain a candidate graph set. The proportion support is calculated and filtered to generate the final candidate graph set, including: Define candidate change points, use candidate change points to partition the autonomous sample set to obtain a set of mechanism-consistent segments, combine them with the node set, input them into the structure learner, and output a set of candidate graphs within the mechanism; Deterministic perturbation sample segments are constructed from the set of mechanism-consistent segments, and a set of perturbation candidate graphs is constructed. The similarity of the edge sets of the candidate graph set within the mechanism and the perturbation candidate graph set is calculated using the Jaccard coefficient formula, and the filtered candidate graph set is obtained through screening. Calculate the percentage support for the selected candidate graph set, remove the union edges with percentage support less than the percentage support threshold, obtain the final edges, generate the final candidate graph set, and calculate the uncertainty of the whole graph and the uncertainty of sensitive subgraphs.

5. The doll instant messaging method based on edge computing as described in claim 4, characterized in that: The process of filtering the final candidate graph set to obtain a fixed-order index includes: If the number of graphs in the final candidate graph set is greater than or equal to a fixed integer K, then the graphs are sorted in descending order of frequency of occurrence, and the top K graphs are retained. Otherwise, all graphs are retained, and K is set to the number of graphs. The filtered graphs are then sorted in descending order of frequency of occurrence to obtain a fixed-order index.

6. The doll instant messaging method based on edge computing as described in claim 5, characterized in that: The process of constructing a candidate strategy set and filtering it using a set of session constraints and causal direction markers to obtain a unique strategy, which is then sent to the doll client and stored in a local database, includes: A candidate strategy set is constructed based on the coding complexity level, the transmission rate level, and the retransmission limit. Sensitive attribute nodes, intervention inversion values, link statistics fields, end-side node fields, and skewed path markers and causal direction markers are set as fixed inputs. The counterfactual inference in the structural causal model (SCM) is used to deduce the end-to-end delay counterfactual value and the success rate counterfactual value, and the delay risk bound and the success rate risk bound are constructed. Based on the uncertainty of the sensitive subgraph, the execution permission is marked, all allowed candidate strategies are extracted from the execution permission marks, and the strategies are classified using the session constraint set to obtain the constraint-satisfied strategies. The unique strategies are then filtered by the power and causal direction marks. The unique strategy is sent to the doll via the API interface. The edge node sends the current voice frame to the monitoring segment and stores the data in the fixed observation window into the local database.

7. The doll instant messaging method based on edge computing as described in claim 6, characterized in that: The process of defining a fixed observation window for the session, collecting speech frames within the window, constructing a link observation sequence, and calculating the skewness criterion value includes: Define a fixed observation window for the session, construct a link observation sequence at the end of the fixed observation window, and calculate the skewness criterion value.

8. The doll instant messaging method based on edge computing as described in claim 7, characterized in that: The process involves sending challenge materials to the doll-end and the monitoring end, with edge nodes performing consistency verification and generating a set of session constraints, including: The doll segment session request messages are obtained by edge nodes and arranged vertically to obtain the initial record of session entries. A one-time random number is generated using edge nodes to construct challenge materials. After the challenge materials are sent to the doll and the monitoring terminal via the API interface, the edge node receives the response message, sends the session key to the doll and the monitoring terminal via the API interface, and retrieves the key and issues the completion status. If the completion status is "complete", the session constraint set is obtained.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that: When the processor executes the computer program, it implements the steps of the doll instant communication method based on edge computing as described in any one of claims 1 to 8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by the processor, it implements the steps of the edge computing-based doll instant communication method as described in any one of claims 1 to 8.

Images