A time-scale-based multi-modal semantic topology and constraint reasoning CAD sequence generation method

Abstract

A time-scale-based multi-modal semantic topology and constraint reasoning CAD sequence generation method belongs to the cross technical field of computer-aided design and artificial intelligence. The method constructs an end-to-end automatic generation framework from multi-modal input to editable parameterized CAD model, significantly improving the semantic consistency, structural rationality and logical correctness of the generated sequence; it can deeply integrate multi-source data such as images, sketches and point clouds, and accurately capture the design intent by using time-scale-aware feature extraction and dynamic topology graph evolution, and effectively overcome the error accumulation and logical drift problems in traditional autoregressive models through the sequence synthesis mechanism guided by syntax and geometric constraints, and realize efficient and robust generation of parameterized models combined with the geometric feedback-driven optimization engine, thereby achieving systematic breakthroughs in generation quality, automation level and cross-scene applicability, and providing key technical support for intelligent manufacturing and intelligent design.

Description

Technical Field

[0001] This invention belongs to the field of computer-aided design (CAD) and artificial intelligence, and particularly relates to a time-scale-based multimodal semantic topology and constraint reasoning CAD sequence generation method. Background Technology

[0002] Computer-aided design (CAD), as a core tool for modern industrial design and manufacturing, plays an irreplaceable role in fields such as machinery, architecture, and aerospace. In recent years, the intelligentization and automation of CAD technology have become key directions for industry development. Currently, AI-based CAD model generation methods have become a research hotspot, especially in the initial progress made in 3D reconstruction and sequence generation based on point clouds, images, or sketches. For example, models like DeepCAD can generate CAD command sequences from images, and methods like Point2Cyl attempt to reconstruct basic geometry from point clouds. However, existing methods still have several key problems:

[0003] Most methods rely on a single modal input (such as an image or point cloud), making it difficult to effectively integrate multi-source heterogeneous data such as sketches, images, and point clouds, thus limiting their applicability in complex real-world scenarios. Existing generative methods often ignore the hierarchical logic in the design process and lack modeling of the human design paradigm of "overall priority, local refinement," resulting in deficiencies in semantic consistency and structural rationality of the generated CAD sequences. Traditional generative models such as Transformer are prone to invalid commands or logical errors when generating long sequences, severely affecting the editability and reusability of the generated models.

[0004] More importantly, existing methods generally treat the design process as a single, uniform flow of time, failing to effectively model the inherent mixed-time characteristics of CAD design. In actual design, the designer's thinking and behavior frequently switch between continuous parameter adjustments and discrete command operations, constituting a typical mixed-time domain. Traditional methods lack a unified modeling framework for this mixed-time dynamics, resulting in a discontinuous design sequence in terms of temporal logic, making it difficult to capture the evolution of the designer's intentions. Time-scale theory, as a mathematical framework unifying continuous and discrete dynamic systems, provides an ideal theoretical foundation for solving the above problems. However, currently, no research has applied time-scale theory to the intelligent generation of CAD sequences to achieve an accurate description and reasoning of the mixed-time dynamics in the design process.

[0005] Most existing methods fail to achieve end-to-end automation of the process from multimodal input to editable parametric models, still requiring a large amount of manual intervention, which makes it difficult to meet the dual requirements of efficiency and quality in intelligent manufacturing. Summary of the Invention

[0006] To address the aforementioned challenges, an intelligent method is urgently needed that can integrate multimodal inputs, modeling and design hierarchies, and generate high-quality, editable CAD sequences. This invention proposes a time-scale-based multimodal semantic topology and constraint reasoning CAD sequence generation method. This method achieves end-to-end automatic generation from multimodal inputs such as sketches, images, and point clouds to parametric CAD model sequences, effectively improving the rationality, editability, and cross-scenario applicability of the generated models, providing key technical support for intelligent manufacturing and intelligent design. Specifically, the following operations are performed:

[0007] Step A. The images, sketches, and point cloud data of the same component are encoded by modality-specific encoders and then projected into a unified semantic space to obtain unified semantic features, and then the collaborative alignment loss is optimized.

[0008] Step B. Transform the unified semantic features into a semantic topology graph, explicitly representing entities, operations, and constraint relationships. The evolution of the graph structure is defined as node operation prediction and connection prediction on the time scale. Furthermore, based on a spatiotemporally synchronized geometric semantic linker, embed the geometric semantic relationships of the perceived context into the semantic topology graph.

[0009] Step C. Decompose the natural language input instructions into structured command triples and generate corresponding embedding vectors to obtain a command sequence. The triples include operation type, parameter list, and parameter type. Input the semantic topology graph into the Transformer decoder to obtain candidate tokens and their probability distribution. Add the generated candidate tokens to the command sequence and perform real-time syntax checking and geometric feasibility judgment. After verification, the dynamic bundle search algorithm controlled by the time-scale adaptive scheduler is responsible for path selection and sequence expansion.

[0010] Step D. The generated CAD command sequence and semantic topology graph are converted into CAD-CL intermediate representations. Then, global optimization and code transformation are performed based on geometric algebra and temporal state dependency graphs. Finally, the final target code is generated and verified based on the kernel capability cognitive graph.

[0011] Step A is described in detail below:

[0012] Step A1. Apply three deformable convolutional layers with different dilation rates in parallel to the input image to obtain a set of feature maps. Concatenate these feature maps to obtain a fused feature tensor. Then, perform global average pooling on the fused feature tensor to obtain channel descriptors. Finally, learn the weight of each channel of the channel descriptor through two fully connected layers. Finally, weight the fused feature tensor based on the weights to obtain the final image features.

[0013] Step A2. For the input point cloud, construct a local dynamic graph for each point based on its local neighborhood; then perform relational dynamic learning and graph signal evolution on the local dynamic graph; the nodes in the local dynamic graph... Geometric differences between nodes are mapped into high-dimensional potential features using a multilayer perceptron; neighborhood nodes The high-dimensional potential energy characteristics, after symmetric max pooling, drive the nodes. The update is performed at a micro-timescale. After the local dynamic graph update converges, a steady-state neighborhood feature set is obtained. Then, max pooling and average pooling are performed in parallel. The two results are concatenated to obtain the final local geometric semantic features of the point.

[0014] Step A3. System processes sketch sequence ,in For a mixed timescale that includes continuous rendering phases and discrete events. Indicated in mixed time scales Above, moment The sketch state vector is obtained; the sketch sequence is parsed into a topological graph, whose node set includes sketch primitives and edge set includes topological connection edges and spatial proximity edges; the topological graph is subjected to heterogeneous graph convolution and attention mechanism to obtain topological enhancement features; then it is concatenated with the temporal dynamic features of the sketch strokes to obtain the feature representation of the topological graph nodes; the features of all nodes are aggregated to obtain sketch features; the temporal dynamic features of the strokes include velocity and acceleration during continuous drawing phases, and discrete event feature vectors;

[0015] Step A4. The features of the three modalities are fed into a shared semantic projector to obtain unified semantic features;

[0016] Step A5. Perform L2 normalization on the unified semantic features, and then train and optimize them using cross-modal contrast loss, adversarial modality alignment loss, and temporal scale smoothness loss.

[0017] The cross-modal contrast loss specifically involves constructing positive sample pairs of multimodal data from the same task and negative sample pairs from different tasks, and using the cross-modal contrast loss to bring positive sample pairs closer together and push negative sample pairs apart.

[0018] The adversarial modality alignment loss minimizes the distribution differences of different modal features through adversarial training between a three-layer multilayer perceptron discriminator and a modality-specific encoder.

[0019] Step B is described in detail below:

[0020] Step B1. Generate a three-layer semantic topology graph based on unified semantic features, including: entity layer, where nodes represent basic geometric voxels and edges represent spatial adjacency relationships; operation layer, where nodes represent feature operations and edges represent dependencies between operations; and constraint layer, where nodes represent parameters and geometric constraints and edges represent the association between parameters and operations, or the entities to which constraints apply.

[0021] Step B2. Iterative Graph Structure Learning and Time-Scale Dynamics;

[0022] At every point in time The controller takes the current semantic topology graph and unified semantic features as input and calculates the Δ-derivative of the semantic topology graph. The Δ-derivative specifically consists of two predicted actions: node operation prediction (selecting an action from the action space, which includes adding entity nodes, adding operation nodes, adding constraint nodes, and no operation); and edge connection prediction (if the prediction is to add a node, further predicting which existing nodes in the semantic topology graph the new node should connect to and determining the edge type). The update of the semantic topology graph state follows the basic dynamic equation of the time scale. The controller is trained based on the asymptotic stability regularization term of the time scale exponential function.

[0023] Step B3. Any two nodes representing geometric elements in the dynamic semantic topology graph. and The basic spatial relationships between them are obtained by using a lightweight multilayer perceptron to generate spatial relationship query vectors; the basic spatial relationships include relative displacement, relative scaling, and relative orientation.

[0024] Each semantic topology graph node is associated with a multimodal feature fragment during initialization. For the image modality, the node is associated with the corresponding image features and their spatial location encoding; for the point cloud modality, it is associated with the corresponding point cloud block features and their 3D bounding box center coordinates; and for the sketch modality, it is associated with the sketch stroke features and their 2D trajectory coordinates.

[0025] Then, guided by spatial relationship query vectors, the methods were applied to images, point clouds, and grass. Figure 3 Attention aggregation is performed in the feature pools of each modality to calculate the similarity score between the spatial relation query vector and the node association features in each modality, and the features are weighted and summed accordingly to generate three modality-independent semantic enhancement vectors; the semantic enhancement vectors of the three modalities are concatenated and passed through a multilayer perceptron to obtain a cross-modality semantic enhancement vector;

[0026] Finally, the basic spatial relations and cross-modal semantic enhancement vectors are concatenated to obtain the geometric semantic relation embedding vector, which is then appended to the connection nodes. and On the edge features.

[0027] Step C is as follows:

[0028] Step C1. Decompose the CAD command into a structured command triple, including operation type, parameter list, and parameter type; perform embedding learning on the operation type, parameter type, and parameter value respectively. Finally, the embedding vector of a CAD command is the sum of the embeddings of its parts.

[0029] Step C2. At each decoding step, the Transformer decoder generates its internal decoding state based on the current context information and calculates the probability distribution of candidate tokens based on this state. The current context information includes the generated command sequence and the dynamic semantic topology graph.

[0030] A real-time syntax checker with a pre-built CAD command context-free grammar and type system is used to check each candidate token. If adding it to the current sequence would cause a syntax error, the probability of that candidate token is set to zero.

[0031] A parametric geometric feasibility discriminant is used to evaluate the probability that the entire sequence can construct a valid 3D model after adding candidate tokens; this probability is used to adjust the final score of the candidates.

[0032]

[0033] in, Representative candidate token The overall evaluation score; Represents the Transformer decoder at time... The internal decoding state; Represents the probability generated by the Transformer decoder. Represents the geometric feasibility weighting coefficient; This represents the probability predicted by the parameterized geometric feasibility discriminator. Represents the current decoding time. Prefixes for already generated CAD command sequences;

[0034] The width of the beam search is dynamically adjusted according to an exponential function of the time scale of the generation progress.

[0035] Step D is as follows:

[0036] Step D11. Convert the command triples and semantic topology graph into a domain-specific intermediate representation CAD-CL;

[0037] First, a functor is constructed from the general command category to the strongly typed CAD-CL category. This functor combines each command triple with the semantics of nodes and edges in the semantic topology graph. The specific semantics of parameter references are resolved through the pull-back operation in category theory.

[0038] Domain-specific intermediate representation CAD-CL's type depends on compile time. Type checking is performed on the compile time scale, and type errors will be immediately triggered as right discrete events, causing compilation interruption and error reporting.

[0039] For each parameter in the compilation pipeline, a parameter semantic passport is built and maintained. The parameter semantic passport contains basic physical dimensions, numerical effective domain, design intent traceability, geometric constraint context, version and evolution history, and verification and state metadata.

[0040] Step D12. Perform symbolic geometric reasoning and temporal state dependency analysis on the domain-specific intermediate representation CAD-CL and its accompanying parametric semantic passport;

[0041] First, we conduct symmetry analysis and feasibility verification of Lie groups based on parametric semantics; then, we construct a dependency graph that preserves the symmetry of Lie groups based on the domain-specific intermediate representation CAD-CL and its accompanying parametric semantic passport, formalizing geometric operations as group actions of three-dimensional special Euclidean groups or rotation groups.

[0042] Then, based on the unified simplification of parametric expressions using geometric algebra, geometric algebra is used as a unified language to formalize the geometric entities and their operations in the front-end parameter semantic passport.

[0043] Normalization of parametric constraint systems based on Globnaji: All parametric constraints are expressed as a system of polynomial equations with driving size parameters as variables, forming a polynomial ideal. By calculating the Globnaji of this ideal, the original constraint system is transformed into an equivalent algebraic normalized form.

[0044] The key states of the CAD kernel are formalized as shared resources. Each CAD-CL is labeled with its read and write effects on these resources. Based on the read and write effect labels of CAD-CL, a temporal state dependency graph is constructed, where the nodes are CAD-CL and the edges represent the read and write dependencies between commands caused by shared resources.

[0045] Based on the aforementioned temporal state dependency graph, the optimization process is modeled as a dynamic system on a time scale, with the system state being the current code sequence and the dependency graph. Under the constraints of the dependency graph, commands that can be rearranged, parallelized, or eliminated are identified. Stretch commands executed on different sketches are scheduled for parallel execution if there are no state conflicts. Commands that create intermediate entities but are not subsequently referenced are safely eliminated. The optimization scheduling process is controlled by a time-scale exponential function.

[0046] Step D13. Compile the optimized intermediate representation CAD-CL into target code for a specific CAD kernel;

[0047] A multi-objective code generator driven by a kernel capability cognitive graph is constructed. This generator integrates a kernel capability cognitive graph that structurally encodes the core attributes of different kernel APIs. The code generation process is constructed as a multi-constraint satisfaction problem. Based on this cognitive graph, the solver selects the Pareto optimal API call sequence for a given CAD-CL program through heuristic search, while satisfying multiple objective constraints such as performance, accuracy, and compatibility.

[0048] The generated API call sequence is simulated in a lightweight simulation environment, which runs on a verification timescale. The simulator checks whether the preconditions and postconditions of the API calls are met, and whether the sequence may cause known kernel exceptions. Any potential failure will generate a right discrete failure event on the verification timescale, triggering the backend to immediately regenerate and schedule code. The stability of this verification process is guaranteed by the Lyapunov function on the timescale.

[0049] Step D2. Geometric feedback-driven optimization mechanism, which is constructed as a dynamic equation on the parameter optimization time scale;

[0050] Step D21. Δ-gradient descent on the manifold; parameter update based on the time-scale Δ-gradient, the parameter vector to be optimized. Existing in a manifold Above, it encapsulates all adjustable driving parameters in the parametric CAD model and calculates the multimodal loss function. Δ gradient The parameter update rule is as follows:

[0051] ;

[0052] in, , It is the time scale for parameter optimization. The next iteration point in time; The adaptive learning rate is adjusted using an exponential function over a time scale. For time points The parameter vector;

[0053] D22. Parameter dependency graph and causal navigation optimization of dynamic topology awareness; construct a parameter dependency graph, with nodes including parameter nodes and geometric entity nodes; establish a one-to-one mapping between geometric entity nodes and entity nodes in the semantic topology graph to achieve topology awareness; automatically establish initial edge connections based on the semantics and explicit geometric constraints of CAD command sequences.

[0054] The edge weights evolve dynamically over the parameter optimization timescale, and their updates follow a Δ-dynamic process based on perturbation analysis:

[0055] At any moment The system applies a small perturbation to the parameter nodes and observes the change in the target node caused by this perturbation through lightweight forward simulation, thus determining the causal weight of the target node. Iterative updates are performed using the following formula:

[0056]

[0057] in, The learning rate is used to update the causal weights, controlling the update step size; It is a small perturbation; The target node caused by this disturbance The change in state;

[0058] When the optimization algorithm is at time... When deciding to adjust the target parameter, the system immediately queries the parameter dependency graph and, through graph traversal, accurately locates the set of all downstream nodes with strong causal connections to the target parameter. Subsequently, an incremental symbolic reconstruction mechanism is initiated, which represents the parametric modeling history as a computation graph. Through partial evaluation techniques, only the computation subgraph induced by the downstream node set is re-evaluated and geometrically reconstructed.

[0059] Before the parameter update instruction is submitted to the kernel for execution, the system performs a lightweight forward simulation along the parameter dependency graph to predict the geometric constraint conflicts that the update may cause. Once a failure event is predicted, the system starts the repair strategy generator. The repair strategy generator traces the key causal path that leads to the conflict back based on the parameter dependency graph and uses the Lyapunov stability theory on the time scale to solve the local parameter adjustment strategy.

[0060] This invention also includes a pulse backtracking and correction control mechanism, which is modeled as a pulse control system on the generation time scale. The mechanism consists of three steps:

[0061] Step C31. Fault Mapping and Location: Receive the error report from step D, analyze the error type and context, and map the fault back to a specific command step in the sequence. The error event is considered to have occurred at time [time]. An impulse interference occurred;

[0062] Step C32. Generate state rollback; roll back the internal state from step C to the fault command. The previous safe state, i.e., the step And freeze the previously generated and verified sequence prefixes;

[0063] Step C33. Adaptive constraint reinforcement and guided exploration; in step During regeneration, the system dynamically initiates an adaptive constraint reinforcement and guided exploration mechanism. This mechanism first injects the commands or parameter combinations that caused the previous failure into a dynamic taboo table, and adaptively adjusts the balance between exploration and utilization based on the decay characteristics of the time-scale exponential function. In the early stages of rollback, the decision weight of the geometric feasibility discriminator is significantly increased to avoid known fault domains. As the generation process progresses, the constraint weights decay smoothly, guiding the model to explore new generation paths within the feasible solution space. The stability of this impulse control is guaranteed by the time-scale Lyapunov function.

[0064] The beneficial effects of this invention are that by introducing time-scale theory to unify the hybrid time dynamics in the modeling and design process, an end-to-end automatic generation framework from multimodal input to editable parametric CAD models is constructed, significantly improving the semantic consistency, structural rationality, and logical correctness of the generated sequences. The system can deeply integrate multi-source data such as images, sketches, and point clouds, and accurately capture design intent by utilizing time-scale-aware feature extraction and dynamic topology graph evolution. At the same time, the sequence synthesis mechanism guided by syntax and geometric constraints effectively overcomes the error accumulation and logical drift problems in traditional autoregressive models. Combined with a geometric feedback-driven optimization engine, it achieves efficient and robust generation of parametric models, thus achieving a systematic breakthrough in generation quality, automation level, and cross-scenario applicability, providing key technical support for intelligent manufacturing and intelligent design. Attached Figure Description

[0065] Figure 1 This is a framework diagram of the method of the present invention;

[0066] Figure 2 The structure diagram of a time-scale-aware multimodal semantic fusion network (Module A);

[0067] Figure 3 This is a structural diagram of the dynamic topology graph generator (module B) based on time-scale dynamics;

[0068] Figure 4 The diagram shows the structure of a sequence synthesizer (module C) guided by syntax and geometric constraints under optimal time-scale control.

[0069] Figure 5 Structure diagram of the time-scale dynamic parameterization modeling and geometric feedback optimization engine (Module D);

[0070] Figure 6 This is a diagram illustrating the effect of an embodiment of the present invention;

[0071] Figure 7 This is a training loss diagram for a module in an embodiment of the present invention. Detailed Implementation

[0072] A time-scale-based multimodal semantic topology and constraint reasoning CAD sequence generation method, the overall process of which is as follows: Figure 1 As shown, the method includes:

[0073] Step A. A time-scale-aware multimodal semantic fusion network is used. Image, sketch, and point cloud data of the same component are encoded by modality-specific encoders and then projected into a unified semantic space to obtain unified semantic features. Cooperative alignment loss is then optimized.

[0074] Step B. A dynamic topology graph generator based on time-scale dynamics transforms unified semantic features into a semantic topology graph, explicitly representing entities, operations, and constraint relationships. The evolution of the graph structure is defined as node operation prediction and connection prediction on the time scale. Furthermore, a spatiotemporally synchronized geometric semantic linker embeds the geometric semantic relationships of the perceived context into the semantic topology graph.

[0075] Step C. A sequence synthesizer guided by grammatical and geometric constraints under optimal time-scale control decomposes natural language input instructions into structured command triples and generates corresponding embedding vectors to obtain a command sequence. The triples include operation type, parameter list, and parameter type. The semantic topology graph is input to the Transformer decoder to obtain candidate tokens and their probability distributions. The generated candidate tokens are added to the command sequence and undergo real-time grammatical checking and geometric feasibility judgment. After verification, the dynamic bundle search algorithm controlled by the time-scale adaptive scheduler is responsible for path selection and sequence expansion.

[0076] Step D. The time-scale dynamic parameterized modeling and geometric feedback optimization engine transforms the generated CAD command sequence and semantic topology graph into an intermediate CAD-CL representation. Then, it performs global optimization and code transformation based on geometric algebra and temporal state dependency graph. Finally, it generates and verifies the final target code based on the kernel capability cognitive graph.

[0077] The time-scale-aware multimodal semantic fusion network encodes the temporal dynamics of the design process into feature representations. For example... Figure 2 As shown, the complete network structure of the time-scale-aware multimodal semantic fusion network consists of three modality-specific encoders, a shared semantic projector, and a collaborative alignment loss calculation unit. Image, sketch, and point cloud data are processed by a staircase deformable convolution module, a dynamic graph signal convergence module, and a topology-enhanced graph convolution module, respectively. Their output features are projected onto a unified semantic space through a shared multilayer perceptron and optimized under the joint constraints of cross-modal contrast loss, adversarial alignment loss, and temporal scale smoothness loss, ultimately forming a unified feature representation with semantic consistency and temporal coherence.

[0078] Step A1. Design a modality-specific semantic-sharing stepped deformable convolutional image encoder; traditional CNNs use convolutional kernels with fixed grid structures, which have limited ability to model geometric deformations. This invention designs a vision-stepped deformable convolutional architecture, the core idea of ​​which is to deploy multiple deformable convolutional layers with different dilation rates in parallel to form a multi-scale geometric perception flow.

[0079] Let the input image be Three deformable convolutional layers are used in parallel. Its void ratio The values ​​are set to 1, 2, and 3 respectively. Each convolutional layer outputs a set of feature maps. ,in, To output the height of the feature map, To determine the width of the output feature map, This represents the number of channels in the output feature map.

[0080] The three sets of multi-scale feature maps are then concatenated along the channel dimension to form a fusion feature tensor with multi-scale geometric awareness. To enhance key geometric features related to contours and boundaries and suppress irrelevant information, a squeeze-excited attention module is introduced. This module first processes the fused feature tensor... Perform global average pooling (squeezing) to obtain channel descriptors that represent global information for each channel. Each element in this descriptor The calculation formula is:

[0081]

[0082] in, This is the feature map height orientation index, with values ​​ranging from 1 to... ; This is the feature map width direction index, with values ​​ranging from 1 to... ; This is the channel dimension index of the feature map, indicating that the current calculation is for the [channel dimension index]. The descriptor value of each channel.

[0083] Next, the weights of each channel are learned through two fully connected layers (activations). :

[0084]

[0085] in It is the ReLU activation function. For the Sigmoid function, These are the learning parameters for the two fully connected layers. This represents the channel reduction rate. Ultimately, the image encoder's output features are the channel-weighted result: This structure can adaptively focus on key geometric features across different spatial scales.

[0086] Step A2. Design a point cloud encoder for local geometric semantic extraction based on dynamic graph signal convergence, aiming to solve the core problem of extracting local geometric semantics that conform to CAD modeling logic from disordered and sparse point clouds. Traditional methods mostly focus on static feature extraction. This invention is the first to model the local feature learning process as a process that operates on a microscopic time scale. An evolving dynamic graph signal convergence system is used to simulate the "solidification" process of design intent in local geometry, ensuring that the extracted features are highly consistent with the CAD modeling logic.

[0087] Step A21: Dynamic graph topology initialization. For the input point cloud... , To adjust the total number of points in the point cloud based on the input scene, first, for each point... The initial topology of its dynamically evolving system is constructed through the following steps:

[0088] Local neighborhood definition. The k-nearest neighbor algorithm is used, and in this embodiment, the value is fixed. This approach balances the representativeness of local features with computational efficiency. For each center point... Filtering local neighborhoods The neighborhood includes the center point and its 16 nearest neighbors.

[0089] Construction of a local dynamic graph. Based on points. The node set consists of the node and its neighboring points. Initialize the edge set based on the k nearest neighbor relationship. ,in This is the index of the center node of the current local graph, corresponding to the point. , Indicates belonging to the center point neighborhood The nearest node index, corresponding to a certain neighboring point. This led to the formation of Local dynamic diagram with the core ,in This is the time variable of the microscopic dynamic system, used to characterize the evolution process of local features.

[0090] Step A22: Relational Dynamics Learning and Graph Signal Evolution. On the aforementioned dynamic graph, a relational dynamics learning layer is designed to drive node features to evolve with microscopic time scales. The evolution continues until convergence, a process precisely described by Δ-dynamic equations. Its core lies in using the geometric potential function as the driving force to progressively refine the local geometric semantics.

[0091] Definition of geometric potential function. The geometric potential function is the core driving force of the evolution of a dynamic system, used to encode each edge in the graph. The corresponding geometric difference information between two points is defined as follows:

[0092]

[0093] in, , They are nodes , At any moment Feature vector (initial features are the three-dimensional coordinates of points) , The extended 6-dimensional vector includes coordinates and approximate initial normal values. A 3-layer multilayer perceptron with shared parameters (9 input dimensions, 128 output dimensions) is used to map geometric difference information into high-dimensional potential features; To supplement spatial scale information for Euclidean distance calculation; For high-dimensional potential energy characteristics, characterizing the edge At any moment The instantaneous potential energy is the core driving force for updating node features.

[0094] Δ-dynamic updates of node states. For each node... Feature updates are driven by the potential energy of its neighboring nodes, following a Δ-update rule on a micro-timescale to ensure the continuity and stability of feature evolution.

[0095]

[0096] in, for The next time point on, satisfying ; for Granularity function on ,in The time decay exponent controls the rate at which the granularity function decays exponentially with time. The larger the value, the faster the decay, ensuring that the system converges to a steady state at an appropriate rate. A symmetric max-pooling function is employed to avoid feature interference from outliers while enhancing the representation of significant geometric patterns. This update process is executed cyclically until the norm of node feature change at adjacent time steps is reached. This signifies that the dynamic system has reached a steady state, at which point the node features have fully encoded the local geometric semantics.

[0097] Step A23: Steady-state feature reading and semantic solidification. After the dynamic graph system converges (denoted as convergence time t), The steady-state neighborhood feature set is obtained. By extracting the solidified geometric features of each local region through a multi-view steady-state readout function, a competitive-cooperative dual-path aggregation mechanism is adopted to take into account both the salient patterns of local geometry and the overall properties.

[0098] Competitive readout: Perform max pooling on the steady-state neighborhood feature set to extract the most significant and discriminative feature signals, corresponding to the most prominent geometric patterns in the local region (such as sharp edges, corners, and other key modeling features).

[0099] Collaborative readout: Perform average pooling on the steady-state neighborhood feature set to capture the overall geometric properties of the local region (such as average surface normal, overall curvature, spatial distribution density, etc.) to ensure global consistency of features;

[0100] Finally, the results of the two-way aggregation are spliced ​​together to form a point. The final local geometric semantic features It takes into account both salient patterns and overall attributes, with 256 dimensions.

[0101] Step A3. Design a topology-enhanced time-scale graph convolutional network sketch encoder; for sketch input, the system processes its drawing sequence. ,in For a mixed timescale that includes continuous drawing phases (dense right points) and discrete events (discrete right points), Indicated on the time scale Above, moment The core of the encoder lies in constructing a sketch representation with rich structural semantics through deep fusion of dual topological relationship modeling and temporal dynamic feature extraction. The specific implementation steps are as follows:

[0102] Step A31. Topology Graph Construction and Feature Initialization: Parse the sketch sequence into a topology graph, where the node set contains sketch primitives (line keypoints or line segments), and each node's features are initialized to its geometric attributes (position, orientation, approximate curvature). The edge set contains two types of topological relationships:

[0103] Topological connecting edges: connect consecutive endpoints of the same line to maintain the continuity of the line's topological structure;

[0104] Spatial proximity edge: connects edges whose spatial distance is less than a threshold. Different line endpoints capture potential geometric relationships and constraints.

[0105] Step A32. Heterogeneous graph convolution and attention mechanism; design an independent convolution weight matrix for each type of topological edge. This forms a heterogeneous graph convolutional architecture. Nodes in the sketch topology graph. In the The feature update formula for a layer is:

[0106]

[0107] in, For nodes In relationship The set of neighbors below; For activation functions; For learnable weight matrix, For neighboring nodes The Layer feature vectors; The learnable weight matrix for node self-connection. As the central node The Layer feature vectors; topology-aware attention weights Calculated using an attribute-enhanced graph attention mechanism:

[0108]

[0109] in, Encoding function for topological attributes, type of merged edge ,length Joint curvature Iso-geometric features, This is a learnable attention parameter vector. It is a linear rectified activation function with leakage. This indicates a vector concatenation operation.

[0110] Step A33. Temporal dynamic feature extraction; continuous dynamic modeling. At the right dense point (continuous drawing stage), the kinematic features of the brushstroke are approximated by the Δ-derivative over the time scale: for any ,speed acceleration ,in for Granularity function on for superior The next point in time.

[0111] Discrete event capture. Record the moment of the event at the right discrete point (such as when the pen stroke is lifted or a new pen stroke begins). Including state transition information (such as starting position and stroke type), construct discrete event feature vectors. .

[0112] Step A34. Fusion of topological and dynamic features; convolution of the last layer graph to generate topological enhancement features. With time dynamic characteristics By concatenating the nodes, a unified representation of the nodes is formed. Then, by aggregating the features of all nodes through global pooling, a global spatiotemporal unified representation of the sketch is obtained. This allows the encoder to not only understand the static topology of the sketch, but also to perceive the design intent implied in its dynamic drawing process.

[0113] Step A4. Shared Semantic Projector and Mapping to a Unified Semantic Space: To achieve cross-modal semantic alignment, the high-dimensional features extracted by the three modality-specific encoders are fed into a shared semantic projector. The shared semantic projector is implemented using a three-layer multilayer perceptron, whose input dimension matches the output dimension of each modality encoder, with the output dimension uniformly set to 1024 dimensions. This multilayer perceptron uses ReLU as the activation function, and all modalities share its weight parameters to ensure consistency in the projection rules. Through this projector, heterogeneous features from images, sketches, and point clouds are mapped to the same unified semantic space, resulting in unified semantic features. Within this space, the feature vectors corresponding to different modal data representing the same design intent need to satisfy the constraint of "being close to each other," while the feature vectors corresponding to data representing different design intents need to satisfy the constraint of "being far from each other," thereby achieving effective alignment of cross-modal semantics.

[0114] Step A5. Distribution alignment technique based on contrastive learning; To effectively reduce the distribution differences between heterogeneous modes, a collaborative alignment loss mechanism is designed, the core of which is a distribution alignment technique based on contrastive learning.

[0115] In the loss function calculation, let Represented by a unified semantic feature vector The vector after L2 normalization.

[0116] Cross-modal contrastive loss: In a single training batch, data combinations from the same design task (image, sketch), (image, point cloud), and (sketch, point cloud) constitute positive sample pairs, while data combinations from different design tasks constitute negative sample pairs, thus bringing positive sample pairs closer together and pushing negative sample pairs apart. Cross-modal contrastive loss for:

[0117]

[0118] in, For the training batch set, Indicates batch size; These are all sample indices from the batch. For the current anchor point sample index, For positive sample index, For negative sample index; Anchor point sample The normalized eigenvectors; Anchor point sample A positive sample ( The normalized eigenvector of ), that is, with Samples originating from the same design task but with different modalities; Except for the batch Any sample other than ( The normalized feature vector of () is used as a negative sample; Anchor point sample The set of all positive sample indices; It is in the batch except for the sample All sample sets other than; The cosine similarity function; This refers to temperature hyperparameters.

[0119] Adversarial modality alignment: To further smooth out the distribution differences of different modality features in a unified semantic space, a modality discriminator is introduced. Perform adversarial training. Modal discriminator. It is a three-layer multilayer perceptron structure, and its input is a feature vector. The output is the predicted probability of the modality category (image, sketch, point cloud) corresponding to the feature. Adversarial training is implemented through a mini-maximum game: three modality-specific encoders and a shared semantic projector together constitute the feature extractor. Its goal is to generate something capable of "deceiving" others. Its characteristics make It is impossible to accurately distinguish the source modality of the features; and The goal is to determine the modality attribution of features as accurately as possible. Adversarial modality alignment loss. for:

[0120]

[0121] in, The true modality label corresponding to the feature; For the predicted mode labels of the mode discriminator; This refers to the raw input data for a specific mode. This represents the expectation of the distribution of the input data.

[0122] Step A6. Explicit encoding of time-scale information; for inputs with temporal dynamic characteristics (sketching sequence), an additional time-scale smoothness loss is introduced. This loss method explicitly encodes and constrains the evolution of features to conform to the temporal dynamics of design behavior. The core idea of ​​this loss is to encourage mixed-timescale design of sketch inputs. Above, the feature changes between adjacent time points are smooth and asymptotically stable, thus simulating the coherent evolution of the designer's intention and avoiding inconsistent and anomalous fluctuations in features. (Timescale smoothness loss) for:

[0123]

[0124] in, and Time scale The point in time; It is defined on a time scale The time-scale exponential function; and They are time points respectively and The corresponding L2-normalized feature vector in the unified semantic space; It is the decay exponent. When hour, With time interval The loss increases and decays exponentially, making the feature smoothness constraint stronger for nearby time points and weaker for distant time points. This allows for reasonable feature jumps such as the start of a new stroke, while effectively suppressing abnormal fluctuations.

[0125] The total training loss is the weighted sum of the above losses, and the contribution weights of different losses are balanced by hyperparameters.

[0126] The time-scale dynamics-based iterative dynamic topology graph generator models the construction process of design logic as a process that occurs over the design timescale. The dynamic system of evolution. The construction and evolution process of the iterative dynamic topology graph generator is as follows: Figure 3 As shown, unified semantic features from a multimodal semantic fusion network drive a graph-structured dynamic evolution controller, which in... Based on the time-scale dynamic equation, the addition of nodes and edges is iteratively predicted and executed, gradually constructing a three-layer semantic topology graph containing an entity layer, an operation layer, and a constraint layer.

[0127] Step B1. Three-layer semantic topology graph structure; generated semantic topology graph Adopting a three-layer semantic abstraction architecture, adapting to different design time scales. evolution:

[0128] Solid layer: Nodes are basic geometric elements (such as sketches, extrusions, and revolved bodies), and edges represent spatial adjacency relationships.

[0129] Operation layer: Nodes represent feature operations (such as stretching, punching, and chamfering), and edges represent dependencies between operations.

[0130] Constraint layer: Nodes are parameters (such as length "50mm") and geometric constraints (such as "parallel"), and edges represent the relationship between parameters and operations, or the entities to which constraints apply.

[0131] Step B2. Iterative Graph Structure Learning and Time-Scale Dynamics; The evolution of the graph structure is controlled by a graph structure dynamic evolution controller, the process of which is defined as occurring at the design time scale. The dynamic system above, the system state is the current semantic topology graph structure. .

[0132] At every point in time The controller uses the current semantic topology graph and unified semantic features from multimodal semantic fusion networks Using the input, compute the Δ-derivative of the semantic topological graph. This derivative describes the instantaneous trend or magnitude of change in the semantic topology graph, and is specified as two prediction actions:

[0133] Node operation prediction: Select an action from the action space, which includes the following actions: add entity node, add operation node, add constraint node, and no operation.

[0134] Edge connection prediction: If the prediction is to add a node, then further predict which existing nodes in the graph the new node should be connected to, and determine the type of edge.

[0135] The updating of the graph state follows the fundamental dynamic equations of the time scale:

[0136]

[0137] in, yes The next point in time; yes The granularity function is applied. This process loops until the controller predicts "no operation" (i.e., ...). This signifies the convergence of the design logic.

[0138] To ensure the rationality and convergence of the generation process, an asymptotically stable regularization term based on a time-scale exponential function is designed during controller training. :

[0139]

[0140] in, It is the current time point in the evolution of the topological graph. It is the initial point in time in the evolutionary process; It is the Δ-derivative of the graph structure, describing the graph structure at the current time point. The instantaneous trend of change; It is the initial moment of the design process. The trend of changes in the graph structure; It is defined in The time-scale exponential function; It is the stability decay exponent, a negative hyperparameter. ); It is the square of the Frobenius norm, used to measure the magnitude of the current modification. The square of the difference between the expected decay rate and the desired decay rate. This regularization term encourages the evolution of the graph structure to be asymptotically stable, i.e., as the design time increases. As progress is made, the magnitude of modifications to the graph decreases exponentially.

[0141] Step B3. Spatiotemporally synchronized geometric semantic linker: To embed continuous geometric semantics in the symbolic semantic topology graph and ensure the consistent transmission of design intent between multimodal perception and symbolic reasoning, a spatiotemporally synchronized geometric semantic linker is designed.

[0142] The linker connects to a system that operates on a design timescale. A lightweight cross-modal attention mechanism runs on top of this, dynamically associating underlying perceptual features from a multimodal semantic fusion network. This mechanism is based on any two nodes representing geometric elements in a dynamic semantic topology graph. and The basic spatial relationship between them (relative displacement) Relative scaling ratio and relative orientation represented by quaternions ), through a lightweight multilayer perceptron Construct a spatial relation query vector Each topology node is associated with a fragment of underlying multimodal features from the multimodal semantic fusion network during initialization. For image modalities, the node is associated with a set of local image features with significant geometric responses. ( (for feature fragment indexes) and their spatial location encoding (Represents the two-dimensional coordinates of the feature in the image); for point cloud modalities, associate local point cloud patch features. ( (for the feature block index) and its 3D bounding box center coordinates For the sketch modality, the sketch stroke features are associated. ( (For the index of brush stroke segments) and their two-dimensional trajectory coordinates Subsequently, the mechanism uses query vectors. To guide, in images, point clouds and grass respectively Figure 3 Attention aggregation is performed in the feature pool of each modality, and computation is performed. The similarity scores between the nodes and their associated features (after fusion of positional encoding) in each modality are used to generate a weighted sum of the features, thereby generating a semantically enhanced vector independent of each modality. , and These vectors represent the semantic information most relevant to the current spatial relationship from the image, point cloud, and sketch modalities, respectively. These modality-specific vectors are concatenated and passed through a multilayer perceptron to obtain a unified cross-modal semantic enhancement vector. .

[0143] Finally, the complete representation output by the linker, namely the geometric semantic relation embedding vector, is defined as:

[0144]

[0145] This dynamic, context-rich geometric semantic relation embedding vector Attached to the connection node and This allows the evolutionary reasoning of graph networks to not only be based on the spatial relationships between symbols, but also to continuously synchronize and interlock with the underlying continuous geometric perception, effectively preventing information loss during the abstraction process and fundamentally ensuring the geometric rationality and meaning of the generated topology. Figure 1 To the point of being responsive.

[0146] The sequence synthesizer guided by syntax and geometric constraints under optimal timescale control models the sequence generation process as a process that occurs at the generation timescale. The optimal control problem is addressed by deeply integrating the generative capabilities of Transformer with symbolic CAD syntax rules. The core workflow of the sequence synthesizer is as follows: Figure 4 As shown, using a dynamic semantic topology graph as the symbolization context, the Transformer decoder performs initial probability generation. The generated candidate tokens are then fed into a constraint verification environment consisting of a real-time syntax checker and a geometric feasibility discriminator. After successful verification, a dynamic bundle search algorithm (whose bundle width is...) controlled by a time-scale adaptive scheduler... (Exponentially shrinking over time) is responsible for path selection and sequence expansion. When the backend modeling engine fails, the pulse backtracking mechanism is activated, triggering state rollback and guided re-exploration under adaptive constraint reinforcement, forming a closed-loop correction circuit.

[0147] Step C1. Structured command representation and syntax embedding layer;

[0148] Each CAD command is broken down into a structured command triple (operation type). Parameter list Parameter type For example, “HOLE(Plane_XY,Main_Block,Diameter=10mm,Depth=15mm,Position=[25mm,10mm])” is represented as (HOLE,[Plane_XY,Main_Block,10,15,25,10],[DATUM,ENTITY,FLOAT,FLOAT,FLOAT,FLOAT]).

[0149] In the embedding layer, embeddings are learned separately for the operation type, parameter type, and parameter value (if they are discrete symbols). Ultimately, the embedding vector of a command is the sum of its individual embeddings:

[0150]

[0151] in, This represents the final embedding vector of the entire CAD command. An embedding vector of operation type. and The first An embedding vector of parameter values ​​and their types. This indicates that the summation is performed on all parameters. This structured representation provides a natural interface for subsequent syntactic constraints.

[0152] Step C2. Constraint-aware dynamic bundle search algorithm; the generation process is executed by a constraint-aware bundle search algorithm controlled by a time-scale adaptive scheduler.

[0153] Step C21, probability generation. At each decoding step... The Transformer decoder generates its internal decoding state based on the current context information (including the generated partial sequences and the global intent representation provided by the dynamic semantic topology graph). And calculate a candidate token based on this state. probability distribution .

[0154] Step C22, Real-time Syntax Check. A real-time syntax checker with a pre-built context-free grammar and type system for CAD commands checks each candidate token. Perform a check. If adding it to the current sequence would cause a syntax error (such as mismatched parentheses or parameter type mismatch), then set its probability to zero. .

[0155] Step C23: Geometric feasibility prediction. A parameterized geometric feasibility discriminant. Evaluation of adding candidate tokens Then, the probability that the entire sequence can construct an effective 3D model is calculated. This probability is used to adjust the final score of the candidates:

[0156]

[0157] in, Representative candidate token The overall evaluation score; Represents the Transformer decoder at time... The internal decoding state; This represents the probability generated by the Transformer decoder, i.e., given the current decoding state. Generate tokens under the following conditions The original likelihood; Represents the geometric feasibility weighting coefficient; represent The predicted probability, which assesses the candidate tokens Add to the currently generated command sequence Afterwards, the likelihood of the entire sequence successfully constructing an effective and conflict-free 3D solid model; Represents the current decoding time. Prefix for the already generated CAD command sequence.

[0158] Step C24, Time-scale adaptive beam width. The width of the beam search. It is no longer a fixed value, but is dynamically adjusted according to the generation progress:

[0159]

[0160] in, Indicates the point in time of generation Dynamic beamwidth; This represents the maximum beamwidth, i.e., the initial generation time. The beam search width; It is defined on a time scale The time-scale exponential function; It is the decay exponent. This formula guarantees that in the early stages of generation ( near The search width is relatively large to fully explore the solution space; as generation progresses ( (Increases), the search width shrinks exponentially, and it quickly focuses on the optimal path.

[0161] Step C3. Pulse backtracking and correction control mechanism;

[0162] This mechanism is activated when the modeling engine of the time-scale dynamic parametric modeling and geometric feedback optimization engine reports modeling failure, forming a closed-loop correction loop from the execution end to the generation end. This mechanism is modeled as occurring at the generation timescale... The pulse control system on the device has a mechanism consisting of three steps:

[0163] Step C31, Fault Mapping and Location. Receive error reports from module D (such as API (Application Programming Interface) exceptions, constraint solving failures), and map the faults back to specific command steps in the sequence by analyzing the error type and context. The error event is considered to occur at time [time]. An impulse interference occurred.

[0164] Step C32: Rollback the generated state. Roll back the internal state of the sequence generator. Rollback to the fault command A previous safe state (i.e., step) This freezes the previously generated and verified sequence prefixes. This corresponds to a state reset in pulse control:

[0165]

[0166] in, Corresponding to the erroneous command The resulting state changes; This represents the current internal state. This is the internal state after the reset.

[0167] Step C33: Adaptive Constraint Reinforcement and Guided Exploration. In step... During regeneration, the system dynamically initiates an adaptive constraint reinforcement and guided exploration mechanism. This mechanism first injects the commands or parameter combinations that led to the previous failure into a dynamic taboo table, and adaptively adjusts the balance between exploration and exploitation based on the decay characteristics of an exponential function over time. In the initial rollback phase ( near This significantly improves the decision weights of the geometric feasibility discriminator and strictly avoids known "fault domains"; as the generation process progresses ( (Increase the constraint weights) and smoothly decay the constraint weights, guiding the model to explore new and diverse generation paths within the feasible solution space.

[0168] The stability of this pulse control system is guaranteed by a Lyapunov function on the time scale, ensuring that the sequence generation process can return to a stable trajectory after a finite number of backtrackings.

[0169] The time-scale dynamic parametric modeling and geometric feedback optimization engine realizes the conversion and optimization from general CAD sequences to precise parametric models. This process is constructed to operate at the compilation time scale. and optimize time scale Dynamic systems. A complete compilation and optimization framework, such as... Figure 5 As shown, the details are as follows:

[0170] Step D1. A multi-stage compilation framework based on formal semantics;

[0171] Step D11. Front-end – Semantic preservation conversion and tense type system from intent to domain-specific language;

[0172] This stage will address the aforementioned general, potentially ambiguous, command triples. Based on the rich semantic context provided by the dynamic semantic topology graph, it is converted into a strongly typed domain-specific intermediate representation. This intermediate representation is a CAD command language defined in this invention, denoted as CAD-CL. It has a strict syntax and a temporal-based type system, and is specifically designed to express CAD modeling operations and all their parameters and constraints unambiguously and accurately during the compilation process. It serves as a bridge and standardized intermediate carrier connecting the upper-level design intent and the lower-level kernel code.

[0173] The system builds a framework based on general command categories. To the strongly typed CAD-CL category letter This functor will assign each command triplet By combining the semantics of nodes and edges in a semantic topology graph, and through the pullback operation in category theory, parameter referencing (such as...) can be resolved. The specific semantics of ) ensure semantic precision at compile time. Specifically, for arbitrary morphisms... and Hanzi The following two axiomatic conditions must be met:

[0174] ,

[0175] in, Category The objects in the table represent the input / output data types or status of the command; Category In this context, "state" represents a CAD command or a combination of commands. The composition of morphisms corresponds to the sequential execution of commands; Indicator Within the scope of the target The image in the text refers to strongly typed CAD-CL commands that have been compiled and converted by the front-end. Indicates within the target scope In morphic composition, it corresponds to the sequential combination of strongly typed commands; Representation Object A unit morphism on a given surface is a "no-operation" that does not change the state or data. Representation Object Within the scope of the target The image in the text refers to the strongly typed state after type enhancement and semantic parsing; Representation Object Within the scope of the target The identity morphism in the context is a "no-operation" in a strongly typed context.

[0176] The system builds a temporal type system for CAD-CL, whose types depend on compile time. For example, the type of a parameter is determined during the initial compilation phase. It's just a generalized entity type However, as the compilation process progresses (e.g., in...), (Constraints associated with the topology graph are resolved at any time), and their type is refined to... , indicating "with "Maintain parallel constraints for sketch entities." Type checking is performed on a time scale, and type errors will immediately trigger a compilation interruption and error report as a right discrete event.

[0177] Time-scale-aware metadata appending. To achieve accurate semantic translation from design intent to executable code, the system builds and maintains a structured parameter semantic passport for each parameter in the compilation pipeline. This passport contains six categories of metadata: fundamental physical dimensions, numerical effective domain, design intent tracing, geometric constraint context, version and evolution history, and verification and state metadata. The parsing, enrichment, and verification processes of this metadata are organized on the compilation timescale. A metadata pipeline is formed across a series of fine-grained sub-timescales to ensure that all contextual information is captured and verified in the correct time sequence, and potential problems such as semantic conflicts and constraint violations can be detected early in the compilation process.

[0178] Step D12. Mid-range – Global optimization based on geometric algebra and temporal state dependency graph;

[0179] This stage involves multi-level, intelligent program transformation of the CAD-CL code, establishing program optimization itself as a compilation time scale. The dynamic system undergoing controlled evolution achieves global optimization that balances efficiency and quality through symbolic geometric reasoning and temporal state dependency analysis.

[0180] Step D121: Symbolic geometric reasoning and global optimization of the parameter constraint system;

[0181] This stage takes the strongly typed, domain-specific intermediate representation CAD-CL output by the front end and its accompanying parametric semantic passport as input to perform symbolic geometric reasoning. The reasoning process is closely related to the specific parameters and constraints parsed by the front end:

[0182] Symmetry Analysis and Feasibility Verification of Lie Groups Based on Parametric Semantics. The system takes the geometric constraint context extracted from the front end (e.g., parallel, perpendicular, coplanar) as input and constructs a dependency graph for Lie group symmetry preservation for CAD-CL commands involving rigid body transformations (e.g., ROTATE and TRANSLATE). This graph formalizes geometric operations as group actions of 3D special Euclidean groups or rotation groups. For example, for a parameter... The rotation command, the system from The semantic passport parses the direction vector and verifies whether it satisfies the orthogonality constraint with the normal of the target geometric element subjected to the rotation. This verification is performed at compile time, and if the constraint is not satisfied, a type error is immediately triggered.

[0183] The system unifies and simplifies parametric expressions based on geometric algebra. It uses geometric algebra as a unified language to formalize geometric entities such as points, lines, surfaces, and vectors, along with their operations (dot product, cross product, distance, angle) involved in the front-end parameter semantic passport. For example, given two geometric entity parameters... and (Representing the direction vectors of the two sides), their geometric product is defined as ,in, Indicates the inner product. Represents the outer product. This is expressed using the geometric product identity (e.g., ...). The system can rewrite complex parameter calculation expressions (such as multiple distance and angle formulas used for constraint solving) into a more concise and standardized form, laying the foundation for subsequent algebraic simplification.

[0184] The system normalizes parametric constraint systems based on Globnadsky. The system will then extract all parametric constraints from the front end (e.g., "opposite sides are equal" in a rectangular sketch). "Adjacent sides perpendicular" This can be represented as a system of polynomial equations with the driving dimension parameters as variables, forming a polynomial ideal. , It is a polynomial. Grobneri is calculated using this ideal. , For elements in Grobnagi, satisfying ,in The first term is indicated. The system transforms the original constraint system into an equivalent canonical form with good algebraic properties. This process automatically eliminates redundant dependencies between parameters, derives the simplest independent parameter set, and identifies implicit geometric invariants, thereby achieving global optimization of the parametric expression and providing a simplified, non-redundant constraint system for subsequent code transformations.

[0185] Step D122: Construction and Effect Analysis of Temporal State Dependency Graph; Traditional compiler optimization lacks understanding of the specific state side effects in the CAD field. This invention solves this problem by constructing a temporal state dependency graph.

[0186] State effect modeling. The key states of the CAD kernel (working plane, active sketch, entity set, constraint solver context, etc.) are formalized as shared resources, and each CAD-CL command is labeled with its read and write effects on these resources (e.g., the HOLE command reads a datum plane and a target entity, and writes to the entity set).

[0187] Dependency Graph Construction. Based on the read-write effect annotation of commands, a temporal state dependency graph is constructed. The nodes of this graph are CAD-CL commands, and the edges represent the dependencies between commands due to shared state, including true dependencies (read after write), anti-dependencies (write after read), and output dependencies (write after write). This graph accurately depicts the temporal constraints that command execution must follow.

[0188] Step D123, Time-scale Adaptive Scheduling and Effect Safety Code Transformation; Based on the above temporal state dependency graph, the optimization process is modeled as follows: The dynamic system above, the system state is the current code sequence and dependency graph.

[0189] Effect-safe code movement. Identify commands that can be rearranged, parallelized, or eliminated under dependency graph constraints. For example, stretch commands executed on different sketches can be scheduled for parallel execution if there are no state conflicts; a command that creates an intermediate entity but is not subsequently referenced can be safely eliminated.

[0190] Time-scale driven optimization scheduling. The optimization strategy is dynamically adjusted according to the compilation progress. In the early stages of compilation ( superior near A more aggressive and time-consuming optimization strategy is adopted; when convergence of optimization benefits is detected (the Δ-derivative of the optimization effect), a more aggressive and time-consuming optimization strategy is adopted. When the value is less than the threshold, the system quickly executes a lightweight, high-reward transformation. The scheduling strategy is controlled by the following formula:

[0191]

[0192] in, Indicates at a point in time Optimized granularity adopted; Indicates the maximum optimization granularity; It is defined in The time-scale exponential function; It optimizes the granularity decay index. Decay index The function value follows The increase in size leads to an exponential decay, thereby driving the optimization of granularity. Synchronous decay achieves an optimal balance between compilation efficiency and generated code quality overall.

[0193] Step D13. Backend – Adaptive Kernel Code Synthesis and Executability Guarantee: This stage compiles the optimized CAD-CL intermediate representation into target code for a specific CAD kernel (such as OpenCascade).

[0194] A multi-objective code generator driven by a kernel capability cognitive graph. The generator integrates a kernel capability cognitive graph, which structurally encodes multi-dimensional capability descriptions of different kernels, including core attributes such as computational performance characteristics, numerical stability boundary conditions, memory access patterns, and version evolution compatibility. The code generation process is constructed as a multi-constraint satisfaction problem. Based on this cognitive graph, the solver uses heuristic search to select the Pareto optimal API call sequence for a given CAD-CL program, simultaneously satisfying multi-objective constraints such as performance, accuracy, and compatibility. Multi-objective loss. for:

[0195]

[0196] in, This represents the sequence of API calls generated by the solver; Represents API sequence The expected computation time; Represents API sequence Expected memory consumption; Represents API sequence The expected geometric error of the geometric model generated after execution; It is a weighting coefficient that adjusts the three objectives (time, memory, and error).

[0197] Time-scale driven API sequence verification. The generated API call sequence is simulated forward execution in a lightweight simulation environment, which runs at a verification timescale. Above. The simulator checks whether the preconditions and postconditions of API calls are met, and whether the sequence might trigger known kernel exceptions (such as topology consistency violations). Any potential failures will be detected in... A right-discrete failure event is generated, triggering the backend to immediately regenerate and schedule code, forming a fast micro-correction loop within the compilation pipeline, which greatly improves the first-time success rate of generated code. The stability of this verification process is determined by the Lyapunov function over time. ensure:

[0198]

[0199] in, To verify the time point; It is a Lyapunov function value that measures the API sequence during verification time. Instability or cumulative error during time; It is the Lyapunov function in The Δ-derivative on the time axis quantifies the trend of instability at the next time point; It is the exponential convergence coefficient, which determines the system state. tending to a stable state ( The minimum rate of ), this inequality guarantees that any instability in the verification process will be suppressed rapidly and exponentially, thus ensuring the asymptotic stability and high reliability of the API sequence verification and correction loop.

[0200] Step D2. Geometric feedback-driven optimization mechanism; this optimization process is constructed as a mechanism that optimizes parameters over time. The dynamic equations on.

[0201] Step D21. Δ-gradient descent on the manifold; parameter updates no longer use ordinary gradient descent, but rather time-scale-based Δ-gradient. The parameter vector to be optimized. Existing in a manifold It encapsulates all adjustable driving parameters in a parametric CAD model, such as feature dimensions, positioning coordinates, shape control points, and constraint weights. It calculates the multimodal loss function. Δ gradient The parameter update rule is as follows:

[0202]

[0203] in, Time scale The next iteration point in time; Adaptive learning rate; For time points The parameter vector. This unifies the gradient flow in the continuous-time domain and the stochastic gradient descent method in the discrete-time domain, providing a universal framework for optimization under mixed time dynamics.

[0204] Step D22. Variable granularity optimization; time scale The granularity can be dynamically adjusted according to the optimization stage. In the initial stage of optimization, Using a coarser granularity, the system employs a larger learning rate for global exploration; when a change in loss rate is detected... When the value is below a threshold, the algorithm automatically switches to a finer granularity for local fine-tuning of parameters to ensure convergence accuracy. This adaptive time-scale strategy adjusts the learning rate using a time-scale exponential function.

[0205]

[0206] in, The initial learning rate; It is defined on a time scale The time-scale exponential function; It is the decay index.

[0207] Step D23. Parameter dependency graph and causal navigation optimization of dynamic topology awareness; to realize the parameter optimization process on a time scale With high precision, high efficiency, and high robustness, this invention constructs and maintains a dynamic topology-aware parameter dependency graph. This diagram elevates the static dependencies between parameters into a dynamic causal intervention model that evolves over the optimization timescale, providing precise guidance for the optimization algorithm.

[0208] Step D231: Construction and dynamic evolution mechanism of parameter dependency graph.

[0209] Parameter dependency graph It contains two types of nodes:

[0210] Parameter node This represents adjustable parameterized driving dimensions in the model, such as hole diameter (Hole_Diameter=10mm), hole depth (Hole_Depth=15mm), and positioning dimensions (Hole_Position_X=25mm, Hole_Position_Y=10mm).

[0211] Geometric Entity Nodes These represent geometric entities generated by CAD operations that carry topological identity, such as the reference plane (Plane_XY) and the target extrusion (Main_Block). These nodes establish a one-to-one mapping with the entity nodes in the dynamic semantic topology graph generated by module B, achieving topology awareness.

[0212] Initialization and updating of edge sets and dynamic causal weights:

[0213] During the construction phase (static topological dependencies), the system automatically establishes initial edge connections based on the semantics and explicit geometric constraints of the CAD command sequence. For the command HOLE(Plane_XY,Main_Block,Diameter=10mm,...), a directed edge is established between the parameter node Hole_Diameter and the geometric entity node Hole_1 and its Cylindrical_Face; there is a Boolean subtraction dependency edge between Hole_1 and Main_Block, and a location dependency edge between Hole_1 and Plane_XY.

[0214] Optimization period (dynamic causal weights) The core of an edge is its weight. It is The dynamic evolution quantifies the nodes in the parameter-dependent graph. For nodes The causal intervention effect. Its update follows a Δ-dynamic process based on perturbation analysis:

[0215] At any moment The system applies a small perturbation to the parameter node Hole_Diameter. .

[0216] The effect of this perturbation on the target node was observed through lightweight forward simulation. (For example, the remaining wall thickness Wall_Thickness of the geometric entity node Main_Block, or the change in another parameter node Hole_Position_X due to constraint association) The amount of change .

[0217] Causal weight of the target node Iterative updates are performed using the following formula:

[0218]

[0219] in, The learning rate is used to update the causal weights, controlling the update step size; This refers to the small perturbation applied to the parameter node Hole_Diameter; For the downstream target node caused by this disturbance The change in state; That is, the node Hole_Diameter to the node The approximate derivative of the causal effect. This process transforms fuzzy correlations into quantified, symbolic causal derivatives, forming a dynamically evolving causal intervention effect diagram.

[0220] Step D232: Optimized navigation and guarantee mechanism based on dependency graph.

[0221] Incremental symbolic reconstruction driven by causal reasoning. When the optimization algorithm is at time... When deciding to adjust the parameter node Hole_Position_X, the system immediately queries the parameter dependency graph. By traversing the graph, the set of all downstream nodes that have a strong causal connection with Hole_Position_X (i.e., a causal weight greater than a set threshold) can be accurately located. (For example, Hole_1 itself, and other features concentric or distance-constrained with it). Subsequently, the system initiates an incremental symbolic reconstruction mechanism, which represents the parametric modeling history as a computational graph, and through partial evaluation techniques, only evaluates the data obtained from the previous modeling. The induced computational subgraph is re-evaluated and geometrically reconstructed. This ensures that the topological integrity and computational state of most features in the model unaffected by this positional adjustment are preserved, reducing the computational complexity of the reconstruction from... Reduced to approximation This achieves [something] on a time scale. Efficient evolution on the surface.

[0222] Predictive constraint maintenance and stability assurance repair strategies. Before parameter update instructions (such as increasing Hole_Diameter from 10mm to 12mm) are submitted to the kernel for execution, the system will follow... A lightweight forward simulation is performed to predict potential geometric constraint conflicts that the update might trigger (e.g., the remaining wall thickness Wall_Thickness between the hole wall and the outer side of the part might fall below the design lower limit of 1.5 mm). Once a potential failure event is predicted, the system immediately initiates a remediation strategy generator. This generator traces the critical causal path leading to the conflict back through a dependency graph and utilizes Lyapunov stability theory over time to solve for local parameter adjustment strategies. Conditions met:

[0223]

[0224] in, It is defined on a time scale The Lyapunov function on the system is used to measure the instability or energy of the current system state. It is the Δ-derivative of the Lyapunov function on the time scale, characterizing its evolution trend; The convergence rate coefficient is positive. This inequality requires a repair strategy. (For example, while increasing the aperture, automatically offsetting the aperture position at equal intervals to maintain minimum wall thickness) can ensure the "energy" of the system state. At least exponentially along the optimal time scale Attenuation, in which For definition in The time-scale exponential function (decay exponent) This allows the system state index to be stably guided back to the feasible region.

[0225] To visually demonstrate the overall effectiveness of this invention, Figure 6 This diagram illustrates the end-to-end implementation from multimodal input to the final parametric model. It exemplifies how the input (such as 2D engineering drawings, hand-drawn sketches, or 3D point clouds) yields the corresponding CAD command sequence, and the final editable 3D model reconstructed by the CAD kernel.

[0226] The training process of this invention involves the joint optimization of multiple loss functions. Figure 7 The changes in key metrics of each core module during training are systematically illustrated through three subgraphs.

[0227] Figure 7 The convergence curve of the training loss of the multimodal semantic fusion network illustrates the convergence process of the loss function of the multimodal semantic fusion network over 200 training epochs, including the total loss. And its three key components: cross-modal contrast loss Adversarial mode alignment loss and time-scale smoothness loss All loss terms decreased rapidly with training and then plateaued, among which... The fastest convergence indicates that the multimodal features are well aligned in the unified semantic space; There are slight oscillations in the early stage of training, reflecting the game process between the modality discriminator and the feature extractor in adversarial training, but they eventually converge to low values, indicating that the distribution differences between modalities are effectively reduced. The steady decline verifies the promoting effect of timescale smoothness constraints on feature evolution stability.

[0228] Figure 7 The topology graph evolution stability curve depicts the asymptotic stability of the graph structure evolution in the dynamic topology graph generator, with the horizontal axis representing the design time scale. Evolutionary steps The vertical axis represents the Frobenius norm of the graph's structural variation. This refers to the difference between adjacent states in the topological graph. The actual evolution trajectory decays around the theoretical asymptotic stability boundary and eventually approaches zero, verifying the asymptotic stability regularization term. The effectiveness.

[0229] Figure 7 The variable-granularity optimization process curves reveal the dynamic characteristics of the parameter optimization process in the geometric feedback optimization engine, using two vertical axes to represent the Lyapunov function values. and gradient magnitude The horizontal axis is Number of iterations . The curve drops rapidly in the early stage of optimization, and then enters the fine-grained optimization stage, with the gradient magnitude also decaying accordingly. The vertical dashed line marks the switching point between the two stages, and the vertical dashed line clearly marks the switching point between the two stages.

[0230] In summary, this invention, through the collaborative work of four modules and deep integration of time-scale theory, achieves breakthroughs in the quality, efficiency, robustness, and automation of automatic CAD sequence generation. The embodiments described are merely illustrative of the technical solutions of this invention. Those skilled in the art can make any modifications, equivalent substitutions, and improvements within the spirit and principles of this invention, and all such modifications, equivalent substitutions, and improvements should be included within the scope of protection of this invention.

Claims

1. A time-scale-based multimodal semantic topology and constraint reasoning CAD sequence generation method, characterized in that, Includes the following steps: Step A. The images, sketches, and point cloud data of the same component are encoded by modality-specific encoders and then projected into a unified semantic space to obtain unified semantic features, and then the collaborative alignment loss is optimized. Step B. Transform the unified semantic features into a semantic topology graph, explicitly representing entities, operations, and constraint relationships. The evolution of the semantic topology graph structure is defined as node operation prediction and connection prediction on the time scale. Furthermore, based on a spatiotemporally synchronized geometric semantic linker, embed the geometric semantic relationships of the perceived context into the semantic topology graph. Step C. Decompose the natural language input instructions into structured command triples and generate corresponding embedding vectors to obtain a command sequence. The triples include operation type, parameter list, and parameter type. Input the semantic topology graph into the Transformer decoder to obtain candidate tokens and their probability distribution. Add the generated candidate tokens to the command sequence and perform real-time syntax checking and geometric feasibility judgment. After verification, the dynamic bundle search algorithm controlled by the time-scale adaptive scheduler is responsible for path selection and sequence expansion. Step D. The generated CAD command sequence and semantic topology graph are converted into CAD-CL intermediate representation. Then, global optimization and code transformation are performed based on geometric algebra and temporal state dependency graph. Finally, the final target code is generated and verified based on the kernel capability cognitive graph. Step A is described in detail below: Step A1. Apply three deformable convolutional layers with different dilation rates in parallel to the input image to obtain a set of feature maps. Concatenate these feature maps to obtain a fused feature tensor. Then, perform global average pooling on the fused feature tensor to obtain channel descriptors. Learn the weight of each channel of the channel descriptor through two fully connected layers. Finally, weight the fused feature tensor based on the weights to obtain the final image features. Step A2. For the input point cloud, construct a local dynamic graph for each point based on its local neighborhood; then perform relational dynamic learning and graph signal evolution on the local dynamic graph; the nodes in the local dynamic graph... Geometric differences between nodes are mapped into high-dimensional potential features using a multilayer perceptron; neighborhood nodes The high-dimensional potential energy characteristics, after symmetric max pooling, drive the nodes. Updates at the micro-timescale; after the local dynamic graph update converges, a steady-state neighborhood feature set is obtained, and then max pooling and average pooling are performed in parallel. The two results are concatenated to obtain the final local geometric semantic features of the point. Step A3. System processes sketch sequence ,in For a mixed timescale that includes continuous rendering phases and discrete events. Indicated in mixed time scales Above, moment The sketch state vector is generated; the sketch sequence is parsed into a topological graph, whose node set includes sketch primitives and edge set includes topological connection edges and spatial proximity edges; the topological graph is subjected to heterogeneous graph convolution and attention mechanism to obtain topological enhancement features; then it is concatenated with the temporal dynamic features of the sketch strokes to obtain the feature representation of the topological graph nodes; the features of all nodes are aggregated to obtain sketch features; the temporal dynamic features of the strokes include velocity and acceleration during continuous drawing phases, and discrete event feature vectors; Step A4. The features of the three modalities are fed into a shared semantic projector to obtain unified semantic features; Step A5. Perform L2 normalization on the unified semantic features, and then train and optimize them using cross-modal contrast loss, adversarial modality alignment loss, and temporal scale smoothness loss.

2. The method for generating CAD sequences based on time-scale multimodal semantic topology and constraint reasoning according to claim 1, characterized in that, Step B is described in detail below: Step B1. Generate a three-layer semantic topology graph based on unified semantic features, including: entity layer, where nodes represent basic geometric voxels and edges represent spatial adjacency relationships; operation layer, where nodes represent feature operations and edges represent dependencies between operations; and constraint layer, where nodes represent parameters and geometric constraints and edges represent the association between parameters and operations, or the entities to which constraints apply. Step B2. Iterative graph structure learning and time-scale dynamics; At every point in time The controller takes the current semantic topology graph and unified semantic features as input and calculates the Δ-derivative of the semantic topology graph. The Δ-derivative specifically consists of two predicted actions: node operation prediction (selecting an action from the action space, which includes adding entity nodes, adding operation nodes, adding constraint nodes, and no operation); and edge connection prediction (if the prediction is to add a node, further predicting which existing nodes in the semantic topology graph the new node should connect to and determining the edge type). The update of the semantic topology graph state follows the basic dynamic equation of the time scale. The controller is trained based on the asymptotic stability regularization term of the time scale exponential function. Step B3. Any two nodes representing geometric elements in the dynamic semantic topology graph. and The basic spatial relationships between them are obtained by using a lightweight multilayer perceptron to generate spatial relationship query vectors; the basic spatial relationships include relative displacement, relative scaling, and relative orientation. Each semantic topology graph node is associated with a multimodal feature fragment during initialization. For the image modality, the node is associated with the corresponding image features and their spatial location encoding; for the point cloud modality, it is associated with the corresponding point cloud block features and their 3D bounding box center coordinates; and for the sketch modality, it is associated with the sketch stroke features and their 2D trajectory coordinates. Subsequently, guided by the spatial relationship query vector, attention aggregation is performed in the feature pools of the image, point cloud, and sketch modalities respectively. The similarity score between the spatial relationship query vector and the node association features in each modality is calculated, and the features are weighted and summed accordingly to generate three modal-independent semantic enhancement vectors. The semantic enhancement vectors of the three modalities are concatenated and passed through a multilayer perceptron to obtain a cross-modal semantic enhancement vector. Finally, the basic spatial relations and cross-modal semantic enhancement vectors are concatenated to obtain the geometric semantic relation embedding vector, which is then appended to the connection nodes. and On the edge features.

3. The method for generating CAD sequences based on time-scale multimodal semantic topology and constraint reasoning according to claim 2, characterized in that, Step C is as follows: Step C1. Decompose the CAD command into a structured command triple, including operation type, parameter list, and parameter type; perform embedding learning on the operation type, parameter type, and parameter value respectively. Finally, the embedding vector of a CAD command is the sum of the embeddings of its parts. Step C2. At each decoding step, the Transformer decoder generates its internal decoding state based on the current context information and calculates the probability distribution of candidate tokens based on this state. The current context information includes the generated command sequence and the dynamic semantic topology graph. A real-time syntax checker with a pre-built CAD command context-free grammar and type system is used to check each candidate token. If adding it to the current sequence would cause a syntax error, the probability of that candidate token is set to zero. A parametric geometric feasibility discriminant is used to evaluate the probability that the entire sequence can construct a valid 3D model after adding candidate tokens; this probability is used to adjust the final score of the candidates. ； in, Representative candidate token The overall evaluation score; Represents the Transformer decoder at time... The internal decoding state; Represents the probability generated by the Transformer decoder. Represents the geometric feasibility weighting coefficient; This represents the probability predicted by the parameterized geometric feasibility discriminator. Represents the current decoding time. Prefixes for already generated CAD command sequences; The width of the beam search is dynamically adjusted according to an exponential function of the time scale of the generation progress.

4. The method for generating CAD sequences based on time-scale multimodal semantic topology and constraint reasoning according to claim 3, characterized in that, Step D is as follows: Step D11. Convert the command triples and semantic topology graph into a domain-specific intermediate representation CAD-CL; First, a functor is constructed from the general command category to the strongly typed CAD-CL category. This functor combines each command triple with the semantics of nodes and edges in the semantic topology graph. The specific semantics of parameter references are resolved through the pull-back operation in category theory. Domain-specific intermediate representation CAD-CL's type depends on compile time. Type checking is performed on the compile time scale, and type errors will be immediately triggered as right discrete events, causing compilation interruption and error reporting. For each parameter in the compilation pipeline, a parameter semantic passport is built and maintained. The parameter semantic passport contains basic physical dimensions, numerical effective domain, design intent traceability, geometric constraint context, version and evolution history, and verification and state metadata. Step D12. Perform symbolic geometric reasoning and temporal state dependency analysis on the domain-specific intermediate representation CAD-CL and its accompanying parametric semantic passport; First, we conduct symmetry analysis and feasibility verification of Lie groups based on parametric semantics; then, we construct a dependency graph that preserves the symmetry of Lie groups based on the domain-specific intermediate representation CAD-CL and its accompanying parametric semantic passport, formalizing geometric operations as group actions of three-dimensional special Euclidean groups or rotation groups. Then, based on the unified simplification of parametric expressions using geometric algebra, geometric algebra is used as a unified language to formalize the geometric entities and their operations in the front-end parameter semantic passport. Normalization of parametric constraint systems based on Globnaji: All parametric constraints are expressed as a system of polynomial equations with driving size parameters as variables, forming a polynomial ideal. By calculating the Globnaji of this ideal, the original constraint system is transformed into an equivalent algebraic normalized form. The key states of the CAD kernel are formalized as shared resources. Each CAD-CL is labeled with its read and write effects on these resources. Based on the read and write effect labels of CAD-CL, a temporal state dependency graph is constructed, where the nodes are CAD-CL and the edges represent the read and write dependencies between commands caused by shared resources. Based on the aforementioned temporal state dependency graph, the optimization process is modeled as a dynamic system on a time scale, with the system state being the current code sequence and the dependency graph. Under the constraints of the temporal state dependency graph, commands that can be rearranged, parallelized, or eliminated are identified. Stretching commands executed on different sketches are scheduled for parallel execution if there are no state conflicts. Commands that create intermediate entities but are not subsequently referenced are safely eliminated. The optimization scheduling process is controlled by a time-scale exponential function. Step D13. Compile the optimized intermediate representation CAD-CL into target code for a specific CAD kernel; A multi-objective code generator driven by a kernel capability cognitive graph is constructed. This generator integrates a kernel capability cognitive graph that structurally encodes the core attributes of different kernel APIs. The code generation process is constructed as a multi-constraint satisfaction problem. Based on this cognitive graph, the solver selects the Pareto optimal API call sequence for a given CAD-CL program through heuristic search, while satisfying multiple objective constraints such as performance, accuracy, and compatibility. The generated API call sequence is simulated in a lightweight simulation environment, which runs on a verification timescale; The simulator checks whether the preconditions and postconditions of the API calls are met, and whether the sequence may cause known exceptions in the kernel. Any potential failure will generate a right discrete failure event on the verification timescale, triggering the backend to immediately regenerate and schedule the code. The stability of this verification process is guaranteed by the Lyapunov function on the timescale. Step D2. Geometric feedback-driven optimization mechanism, which is constructed as a dynamic equation on the parameter optimization time scale; Step D21. Δ-gradient descent on the manifold; parameter update based on the time-scale Δ-gradient, the parameter vector to be optimized. Existing in a manifold Above, it encapsulates all adjustable driving parameters in the parametric CAD model and calculates the multimodal loss function. Δ gradient The parameter update rule is as follows: ； in, , It is the time scale for parameter optimization. The next iteration point in time; The adaptive learning rate is adjusted using an exponential function over a time scale. For time points The parameter vector; D22. Parameter dependency graph and causal navigation optimization of dynamic topology awareness; construct a parameter dependency graph, with nodes including parameter nodes and geometric entity nodes; establish a one-to-one mapping between geometric entity nodes and entity nodes in the semantic topology graph to achieve topology awareness; automatically establish initial edge connections based on the semantics and explicit geometric constraints of CAD command sequences. The edge weights evolve dynamically over the parameter optimization timescale, and their updates follow a Δ-dynamic process based on perturbation analysis: At any moment The system applies a small perturbation to the parameter nodes and observes the change in the target node caused by this perturbation through lightweight forward simulation, thus determining the causal weight of the target node. Iterative updates are performed using the following formula: ； in, The learning rate is used to update the causal weights, controlling the update step size; It is a small perturbation; The target node caused by this disturbance The change in state; When the optimization algorithm is at time... When deciding to adjust the target parameter, the system immediately queries the parameter dependency graph and, through graph traversal, accurately locates the set of all downstream nodes with strong causal connections to the target parameter. Subsequently, an incremental symbolic reconstruction mechanism is initiated, which represents the parametric modeling history as a computation graph. Through partial evaluation techniques, only the computation subgraph induced by the downstream node set is re-evaluated and geometrically reconstructed. Before the parameter update instruction is submitted to the kernel for execution, the system performs a lightweight forward simulation along the parameter dependency graph to predict the geometric constraint conflicts that the update may cause. Once a failure event is predicted, the system starts the repair strategy generator. The repair strategy generator traces the key causal path that leads to the conflict back based on the parameter dependency graph and uses the Lyapunov stability theory on the time scale to solve the local parameter adjustment strategy.

5. The method for generating CAD sequences based on time-scale multimodal semantic topology and constraint reasoning according to claim 4, characterized in that, The relational dynamics learning and graph signal evolution are described in detail below: The design incorporates a relational dynamics learning layer to drive the evolution of node features in the local dynamic graph across micro-timescales until convergence. Specifically, a geometric potential function is used to encode each edge in the local dynamic graph. The corresponding geometric difference information between two points is defined as follows: ； in, , Don't be a node , At any moment eigenvectors; A 3-layer multilayer perceptron with shared parameters; It is a high-dimensional potential energy characteristic. Calculate the Euclidean distance; For feature points in a point cloud, For neighboring points; Each node The feature update is driven by the potential energy of its neighboring nodes, following a Δ-update rule on a micro-timescale: ； in, Represents a local neighborhood. For microscopic time scale The next time point on, satisfying ; For granularity function, ,in The time decay exponent, It is a symmetric max-pooling function; the update process is executed cyclically until a steady state is reached.

6. The method for generating CAD sequences based on time-scale multimodal semantic topology and constraint reasoning according to claim 5, characterized in that, The heterogeneous graph convolution and attention mechanism is as follows: For each type of topological edge in the topological graph, design an independent convolution weight matrix. , This forms a heterogeneous graph convolutional architecture, where nodes in the topological graph of the sketch... In the The feature update formula for a layer is: ； in, For nodes In relationship The set of neighbors below; For activation functions; For learnable weight matrix, Neighboring nodes The Layer feature vectors; The learnable weight matrix for node self-connection. As the central node Its own first Layer feature vectors; Topology-aware attention weights Calculated using an attribute-enhanced graph attention mechanism: ； in Encoding function for topological attributes, type of merged edge ,length Joint curvature Geometric features This is a learnable attention parameter vector. It is a linear rectified activation function with leakage. This indicates a vector concatenation operation.

7. The method for generating CAD sequences based on time-scale multimodal semantic topology and constraint reasoning according to claim 6, characterized in that, The time-scale smoothness loss is as follows: ； in, and For mixed time scales The time point on, It is defined on a mixed timescale The time-scale exponential function on the time scale, and They are time points respectively and The corresponding L2-normalized feature vector of the unified semantic vector, It is the decay index; The cross-modal contrast loss specifically involves constructing positive sample pairs of multimodal data from the same task and negative sample pairs from different tasks, and using the cross-modal contrast loss to bring positive sample pairs closer together and push negative sample pairs apart. The adversarial modality alignment loss minimizes the distribution differences of different modal features through adversarial training between a three-layer multilayer perceptron discriminator and a modality-specific encoder.

8. The method for generating CAD sequences based on time-scale multimodal semantic topology and constraint reasoning according to claim 7, characterized in that, The update of the semantic topology graph state follows the basic dynamic equations of the time scale: ； in, It is the Δ-derivative of the graph structure. It is the current time point in the evolution of the topological graph. Design time scale The next point in time, yes The granularity function is applied, and the process loops until the controller predicts no operation. This signifies the convergence of the design logic; When training the controller, an asymptotic stability regularization term based on a time-scale exponential function is designed. : ； in, It is the initial point in time in the evolutionary process; It is the initial moment of the design process. The trend of changes in the graph structure; It is a time-scale exponential function; It is the stability decay index. It is the square of the Frobenius norm.

9. The method for generating CAD sequences based on time-scale multimodal semantic topology and constraint reasoning according to claim 8, characterized in that, It also includes a pulse backtracking and correction control mechanism, which is modeled as a pulse control system on the generation timescale and consists of three steps: Step C31. Fault Mapping and Location: Receive the error report from step D, analyze the error type and context, and map the fault back to a specific command step in the sequence. The error event is considered to have occurred at time [time]. A pulse interference occurred; Step C32. Generate state rollback; roll back the internal state from step C to the fault command. The previous safe state, i.e., the step And freeze the previously generated and verified sequence prefixes; Step C33. Adaptive constraint reinforcement and guided exploration; in step During regeneration, the system dynamically initiates an adaptive constraint reinforcement and guided exploration mechanism. This mechanism first injects the commands or parameter combinations that caused the previous failure into a dynamic taboo table, and adaptively adjusts the balance between exploration and utilization based on the decay characteristics of the time-scale exponential function. In the early stages of rollback, the decision weight of the geometric feasibility discriminator is significantly increased to avoid known fault domains. As the generation process progresses, the constraint weights decay smoothly, guiding the model to explore new generation paths within the feasible solution space. The stability of this impulse control is guaranteed by the time-scale Lyapunov function.

Images