Pdk parameterization unit development acceleration method for large language model

Abstract

This invention discloses a method for accelerating the development of PDK parameterized units for large-scale language models, relating to the field of integrated circuit layout design automation. It solves the technical problems of low development efficiency, unstable quality, and difficulty in knowledge transfer associated with traditional PDK parameterized unit development. The method includes: S11: collecting data resources and preprocessing them to obtain the training dataset and auxiliary database required for the model; S12: selecting a model and training and optimizing it; S13: merging and lightweighting the weights of the trained and optimized model; S14: locally deploying and applying the merged and lightweighted model; S15: validating and optimizing the locally deployed and applied model to obtain feedback data, and inputting the feedback data back into S11 for re-collection. This invention can effectively shorten the code generation time of PDK parameterized units and significantly improve code development efficiency for PDK parameterized units with complex structures.

Description

Technical Field

[0001] This invention relates to the field of automated integrated circuit layout design, and more specifically, to a method for accelerating the development of PDK parameterized cells for large language models. Background Technology

[0002] In existing integrated circuit layout design, parameterized cells are a key technology for achieving automatic layout generation. Traditional PDK parameterized cell development mainly relies on designers manually writing Virtuoso Skill language code, which has the following problems:

[0003] In terms of development efficiency, traditional PDK parameterized unit development heavily relies on engineers' programming skills and proficiency in the Skill language. A complete PDK parameterized unit often requires several months of development time, with engineers needing to repeatedly modify and debug the code, which significantly extends the chip design cycle.

[0004] Traditional methods suffer from inconsistent design quality. Differences in engineers' familiarity with the Skill language and their programming styles lead to inconsistent quality in the generated PDK parameterized unit code, making it difficult to guarantee consistency and maintainability. This is especially true in the implementation of complex layout structures, where manually writing code easily introduces logical errors and structural problems, requiring significant time for verification.

[0005] PDK parameterized unit development involves a large amount of domain-specific knowledge and experience accumulation. This knowledge is often difficult to record and pass on systematically, resulting in serious knowledge loss when team members change and a long training cycle for new employees.

[0006] In recent years, large language models (LLMs) have made significant breakthroughs in the field of code generation. However, directly using commercial cloud-based LLMs poses data privacy and security risks, especially for highly sensitive fields such as chip design. While existing open-source LLM models can be deployed locally, they lack specific understanding and optimization for the Skill language, making them difficult to apply directly to PDK parameterized unit development.

[0007] Domain-specific model fine-tuning and knowledge distillation can significantly improve the performance of LLMs in vertical domains, but there are currently no specific optimization schemes developed for Skill language and PDK parameterized units. Summary of the Invention

[0008] The technical problem to be solved by the present invention is to provide a method for accelerating the development of PDK parameterized units of large language models, which addresses the shortcomings of existing technologies and solves the technical problems of low development efficiency, unstable quality and difficulty in knowledge transfer of traditional PDK parameterized units.

[0009] The present invention discloses a method for accelerating the development of PDK parameterized units for large language models, the method comprising:

[0010] S11: Collect data resources and preprocess the data resources to obtain the training dataset and auxiliary database required by the model;

[0011] S12: Select a model, train and optimize the model to enhance the model's understanding of the Skill language;

[0012] S13: Merge and lightweight the weights of the trained and optimized models;

[0013] S14: Deploy and apply the merged and lightweighted model locally;

[0014] S15: Verify and optimize the model after local deployment and application to obtain feedback data, and input the feedback data back into S11 for recollection.

[0015] As a further improvement, in S11, the method for preprocessing the data resources includes:

[0016] S21: Organize the data resources into question-and-answer pairs in blocks, and perform structured data transformation on the question-and-answer pairs in blocks to construct a dataset and corresponding question-and-answer pairs;

[0017] S22: Perform data augmentation on the dataset and the corresponding question-answer pairs;

[0018] S23: Convert the structured data and the augmented data into the standard format required for model training, divide the dataset with the standard format into a training set, a validation set and a test set, and package the training set, validation set and test set to form a training dataset and an auxiliary database.

[0019] Furthermore, in S12, the method for training and optimizing the model is as follows:

[0020] S31: Train the model using a three-stage training strategy;

[0021] S32: Efficiently fine-tuning the parameters of the trained model using LoRA technology;

[0022] S33: Optimize and train the parameters after efficient fine-tuning through an optimizer;

[0023] S34: Use the DPO training strategy to augment the optimized and trained parameters, and use the augmented parameters as the database for the trained and optimized model.

[0024] Furthermore, in S31, the three-stage training strategy consists of a Skill language understanding stage, a Skill code capability training stage, and a PDK parameterized unit expertise fine-tuning stage.

[0025] Furthermore, in S13, the method for merging and lightweighting the weights of the trained and optimized model is as follows:

[0026] S41: Obtain the adapter parameters of the trained and optimized model, combine the adapter parameters with the original weights of the model element-wise to form a complete model, and save the combined complete model;

[0027] S42: The merged complete model is initially lightweighted using multiple lightweighting methods, the importance of the initially lightweighted model is evaluated using multiple evaluation methods, the lightweighted model is further lightweighted through iterative pruning, and the iteratively pruned model is fine-tuned using the PDK development domain dataset to form the final lightweighted model.

[0028] S43: Perform an end-to-end evaluation on the final lightweight model and use the final lightweight model as the model after merging and lightweighting.

[0029] Furthermore, in S42, the lightweight method includes a mixed-precision quantization method, an INT8 quantization method, and an INT4 quantization method.

[0030] Furthermore, in S42, the evaluation method includes a weight magnitude-based method, a gradient sensitivity-based method, and an activation value contribution method.

[0031] Furthermore, in S14, the method for local deployment and application of the merged and lightweight model is as follows: a knowledge base is constructed based on RAG deployment technology; an inference engine, integrated plugins, and an interactive development interface are developed based on the knowledge base; the merged and lightweight model is input into the interactive development interface; and the interactive development interface outputs standardized code.

[0032] Furthermore, in S11, the data resources include the official Skill language reference manual and API documentation, a verified PDK parameterized unit code library, design rules and constraint documentation, and typical PDK parameterized unit implementation examples.

[0033] Furthermore, in S12, the model selected is the DeepSeek-R1-Distill-Qwen model.

[0034] Beneficial effects

[0035] The advantages of this invention are:

[0036] 1. This invention utilizes a locally deployed LLM model specifically optimized for the Skill language, which, compared to traditional methods, can effectively shorten the code generation time for PDK parameterized units and significantly improve code development efficiency for complex PDK parameterized units.

[0037] 2. The specially trained model of this invention can generate high-quality Skill code that conforms to best practices, maintains a consistent coding style and commenting standards, and is significantly higher than the average level of traditional manual development.

[0038] 3. This invention integrates the experience and domain knowledge of engineers in related fields into the model, enabling even less experienced engineers to quickly generate high-quality PDK parameterized unit code, effectively solving the problem of knowledge transfer and lowering the threshold for model building.

[0039] 4. This invention, through local deployment, ensures that sensitive design data will not be leaked to external networks, thereby improving the security of model development and design data.

[0040] 5. The model of this invention can quickly adapt to changes in different process nodes, and update its understanding of new process rules through incremental learning, thereby reducing the adaptation time for process migration. Attached Figure Description

[0041] Figure 1 This is a flowchart of the PDK parameterization unit development acceleration method of the present invention;

[0042] Figure 2 This is a flowchart of the data preprocessing process of the present invention;

[0043] Figure 3 This is a diagram of the basic model training architecture of the present invention;

[0044] Figure 4 This is a schematic diagram of the PDK parameterized unit code generation and verification process of the present invention. Detailed Implementation

[0045] The present invention will be further described below with reference to embodiments, but this does not constitute any limitation on the present invention. Any limited modifications made by any person within the scope of the claims of the present invention are still within the scope of the claims of the present invention.

[0046] See Figures 1-4 This invention discloses a method for accelerating the development of PDK parameterization units for large language models, the method comprising:

[0047] S11: Data Preparation and Labeling

[0048] like Figure 2 As shown, the first step is to collect resources related to the Virtuoso Skill language. These resources include the official Skill language reference manual and API documentation, a verified PDK parametric cell code library (containing common design patterns), design rules and constraints documentation, and typical PDK parametric cell implementation examples.

[0049] The second step, data processing and labeling:

[0050] The basic Skill documentation has been organized into question-and-answer pairs, covering the fundamental knowledge of Skills.

[0051] The collected data is converted into a mapping between "task description → skill code implementation".

[0052] Add hierarchical comments to the code, including function descriptions, parameter meanings, and usage methods.

[0053] The DPO dataset is constructed based on the code that generates "high-quality samples" and "low-quality samples".

[0054] Build a RAG knowledge base by converting structured data such as PDK design rules, process documents, and SkillAPI manuals into vector embeddings and establishing a multi-level indexing mechanism.

[0055] This document summarizes common PDK parameterized unit development issues and solutions, and constructs corresponding question-and-answer pairs.

[0056] The third step is data augmentation:

[0057] Skill code-related SFT dataset: Expand the training samples by changing parameter names and adjusting code structure.

[0058] PDK parameterized unit examples: Generate PDK parameterized unit implementation examples of different complexities, from simple components to complex structures.

[0059] Build error example and correction pairs to help the model learn to identify and fix common errors.

[0060] Step 4, data formatting:

[0061] The processed, labeled, and augmented dataset is converted into the standard format required for model training.

[0062] Implement a dataset partitioning strategy, dividing the dataset into training, validation, and test sets in an 8:1:1 ratio.

[0063] like Figure 3 As shown, S12: Model selection and training:

[0064] Step 1, Basic Model Selection:

[0065] DeepSeek-R1-Distill-Qwen (version 32B) was chosen as the base model, as it has good code comprehension and generation capabilities. The LLaMA-Factory framework was used for model loading and management.

[0066] The second step is the model-supervised fine-tuning strategy:

[0067] Implement a three-stage training strategy: Skill language comprehension stage: focus on learning Skill language content, syntax, and API usage; Skill code capability training: enhance basic code capabilities using public Skill code datasets and specific Skill code; PDK parameterized cell expertise fine-tuning: optimize for specific layout design rules and PDK parameterized cell patterns.

[0068] The third step involves efficient parameter fine-tuning:

[0069] The LoRA (Low-Rank Adaptation) technique is used for efficient parameter fine-tuning. LoRA configuration: rank = 32, alpha = 32, dropout = 0.05. Low-rank adaptation is applied to the query and value matrices of the attention mechanism.

[0070] Step 4: Training parameters and optimization strategies:

[0071] Learning rate: Initially set to 1e-5, using cosine annealing. Batch size: Set according to hardware conditions, typically 32. Training epochs: 10 epochs (dynamically adjusted based on validation set performance). Optimizer: AdamW, parameters set to beta1 = 0.9, beta2 = 0.999, weight_decay = 0.01. Gradient clipping: Set the maximum gradient norm to 1.0 to prevent gradient explosion.

[0072] Step 5, DPO training strategy:

[0073] Data Source: Historical code review records (Good / Bad examples). Manual Annotation: Three implementation schemes were generated for the same requirement, ranked by "Quality > Efficiency > Readability". Data Augmentation: Parameter perturbations were applied to high-quality code to generate negative samples.

[0074] S13: LoRA Method Model Weight Merging and Lightweighting Module

[0075] Step 1: LoRA method model weight merging operation:

[0076] Obtain the LoRA adapter parameters (ΔW) that have been successfully trained and validated using the model training and optimization module after completing SFT / DPO training. Then, combine the LoRA adapter parameters (ΔW) with the base model.

[0077] The original weights (W_base) of DeepSeek-R1-Distill-Qwen-32B are merged using element-wise addition: W_final = W_base + ΔW. A dataset partitioning strategy is implemented, dividing the dataset into training, validation, and test sets in an 8:1:1 ratio.

[0078] Save the merged complete model (W_final). This model no longer depends on LoRA runtime loading; it is an independent, fine-tuned model that incorporates Skill language domain knowledge and can be directly used for subsequent lightweighting and deployment.

[0079] The second step is to lightweight the model:

[0080] Hybrid precision quantization: Post-training quantization (PTQ) technique applied to the merged complete model (W_final). INT8 quantization: Applied to the weights of most linear layers (e.g., FFN layers), embedding layers, and layer normalization layers. Employs either symmetric or asymmetric quantization schemes. INT4 quantization: Selectively applied to performance-sensitive key layers, particularly the Query(W_q), Key(W_k), Value(W_v) projection matrices in the attention mechanism, and the final output projection layer (W_o). Employs advanced 4-bit quantization algorithms such as group quantization or GPTQ / AWQ to minimize precision loss.

[0081] Calibration set: The calibration dataset is developed using representative PDK parameterized units as task samples.

[0082] Importance assessment: On the quantized model (or after pruning and requantizing on the full-precision model), the importance of neurons / channels / attention heads is assessed using methods such as weight magnitude, gradient sensitivity (e.g., using the validation set to calculate the gradient of the loss with respect to the weights), or activation contribution.

[0083] Iterative pruning: Set a target sparsity (e.g., 30%, 50%) or progressively remove the least important neurons / channels. For example... Figure 4As shown, after removing a small portion (e.g., 5%) each time, the model performance (e.g., code generation quality, DRC / LVS pass rate simulation) is evaluated on the validation set. The removal and evaluation steps are repeated until the target sparsity is reached or the performance degradation exceeds a preset threshold.

[0084] Restorative fine-tuning: After pruning, the pruned model is fine-tuned for a short period (1-5 epochs) using the PDK domain dataset to adjust the remaining parameters to adapt to the new structure and restore the accuracy lost due to pruning.

[0085] Step 3: Lightweight Model Evaluation and Deployment

[0086] The final lightweight (quantization + pruning) model undergoes rigorous end-to-end evaluation, including: the syntax correctness of the generated code (compilation pass rate), the DRC / LVS rule compliance of the generated PDK parameterized units (pass rate), performance integrity and code quality, processing speed (Token / s), and memory usage (VRAM / RAM). The lightweight model that passes the evaluation will then be deployed to the local deployment and application modules.

[0087] S14: Local Deployment and Application:

[0088] Step 1: RAG deployment implementation:

[0089] Knowledge base construction, establishing a hierarchical index: process node (top level) → component type (middle level) → rule entry (bottom level), retrieval generation-coordination: semantic retrieval, building an enhanced Prompt, and finally generating an LLM model.

[0090] The second step is the development of the inference engine:

[0091] Implements efficient CPU / GPU hybrid inference based on llama.cpp. Optimizes the inference process, supporting batch processing and context reuse. Memory optimization includes attention state caching to reduce redundant computations.

[0092] Step 3: Virtuoso integration plugin development:

[0093] Based on Virtuoso's plugin architecture, we developed an LLM-assisted design tool. This enables seamless integration between the Skill editor and the model, providing features such as code auto-completion, error detection, and refactoring suggestions.

[0094] The fourth step is the interactive development interface: design a natural language input interface that supports PDK parameterized unit requirement description; thereby realizing multi-turn dialogue functionality, supporting iterative optimization of design schemes; and providing a parameterized configuration interface that allows users to adjust the generated results.

[0095] Step 5, Output Processing:

[0096] Implement code formatting functionality to maintain a consistent coding style. Develop a compliance check module to ensure code conforms to design specifications. Support template-based management and reuse of code snippets.

[0097] This invention also provides a PDK parameterization unit development acceleration system for large language models, the system comprising:

[0098] The data preparation and labeling module collects Virtuoso's Skill language manual, PDK parameterized unit code examples, and related tutorials to build a domain-specific corpus. It employs feature extraction techniques to convert the collected data into "instruction-response" pairs. The code is annotated hierarchically, including function descriptions, parameter explanations, and usage examples. Data augmentation strategies are implemented to generate diverse training samples for different complexities and application scenarios. A RAG knowledge base is built, converting structured data such as PDK design rules, process documents, and SkillAPI manuals into vector embeddings and establishing a multi-level indexing mechanism.

[0099] The model training and optimization module is used to select a base model: DeepSeek-R1-Distill-Qwen-32B (for local deployment) is selected as the base model with strong language understanding and code generation potential and supports local deployment; a preliminary model fine-tuning method is designed: an efficient parameter fine-tuning method (LoRA / SFT) is adopted to anchor domain knowledge into the model parameters, complete the injection of basic Skill language knowledge into the model, and quickly improve the model's ability to learn basic Skill language knowledge and understand rules; the model is strengthened and optimized: a preference dataset ("high-quality code / scripts" and "low-quality code / scripts") is constructed in combination with the scenario, and the DPO (Direct Preference Optimization) method is used for model training to optimize the model's Skill language code generation logic and enhance the model's ability to generate Skill language code and corresponding scripts; it is used to build a RAG knowledge base and introduce the RAG "retrieval-generation" collaborative reasoning module to make up for the defects of "knowledge solidification (inability to update new Skill language rules in real time) and insufficient reasoning for complex tasks" in the fine-tuned model, and improve the model's dynamic learning and retrieval enhancement capabilities.

[0100] The LoRA method model weight merging and lightweight export module is used for LoRA method model weight merging. It fuses the trained LoRA adapter weights with the original weights of the DeepSeek base model using the Merge_lora technique (essentially LoRA) to generate a fully fine-tuned model incorporating knowledge of the Skill language domain. A lightweight merging strategy is implemented: for tasks sensitive to numerical precision, such as Skill language code generation, a precision quantization strategy is adopted to convert model parameters from FP32 to INT8 or INT4. This reduces memory usage while maximizing the model's understanding of syntax rules and code logic. A structured pruning technique is implemented: based on quantization, redundant convolutional kernels or attention heads are removed through importance evaluation (e.g., calculating the contribution of each neuron to the Skill language task). The network structures related to code generation and syntax parsing are retained to further reduce model size while avoiding loss of core capabilities. Inference optimization of the lightweight model is performed: to address potential precision loss introduced by lightweight processing, the merged lightweight model after quantization and pruning is systematically evaluated and iteratively repaired to ensure the model meets practical deployment requirements.

[0101] like Figure 4 As shown, the local deployment and application module is used to develop Virtuoso integration plugins, enabling direct invocation of model functions within the IDE; it builds an interactive development interface that supports the conversion of natural language descriptions into Skill code; thereby implementing a post-processing mechanism for model output results, including code formatting and compliance checks.

[0102] The verification and feedback optimization module is used to establish RAG performance evaluation indicators: rule retrieval accuracy and knowledge citation relevance; establish a multi-dimensional evaluation system, including compilation pass rate, DRC / LVS check rate and functional completion; design an automated testing process to achieve continuous code verification and quality monitoring, implement a user feedback collection mechanism, and thus build a closed-loop system for continuous model optimization.

[0103] The above description is only a preferred embodiment of the present invention. It should be noted that those skilled in the art can make several modifications and improvements without departing from the structure of the present invention, and these will not affect the effectiveness of the implementation of the present invention or the practicality of the patent.

Claims

1. A method for accelerating the development of PDK parameterized units for large language models, characterized in that, The method includes, S11: Collect data resources and preprocess the data resources to obtain the training dataset and auxiliary database required by the model; S12: Select a model, train and optimize the model to enhance the model's understanding of the Skill language; S13: Merge and lightweight the weights of the trained and optimized models; S14: Deploy and apply the merged and lightweighted model locally; S15: Verify and optimize the model after local deployment and application to obtain feedback data, and input the feedback data back into S11 for recollection; In S12, the method for training and optimizing the model is as follows: S31: Train the model using a three-stage training strategy; S32: Efficiently fine-tuning the parameters of the trained model using LoRA technology; S33: Optimize and train the parameters after efficient fine-tuning through an optimizer; S34: Use the DPO training strategy to perform data augmentation on the optimized and trained parameters, and use the data-augmented parameters as the database of the trained and optimized model; In S31, the three-stage training strategy consists of the Skill language understanding stage, the Skill code capability training stage, and the PDK parameterized unit professional knowledge fine-tuning stage.

2. The method for accelerating the development of PDK parameterized units for large language models according to claim 1, characterized in that, In S11, the method for preprocessing the data resources includes: S21: Organize the data resources into question-and-answer pairs in blocks, and perform structured data transformation on the question-and-answer pairs in blocks to construct a dataset and corresponding question-and-answer pairs; S22: Perform data augmentation on the dataset and the corresponding question-answer pairs; S23: Convert the structured data and the augmented data into the standard format required for model training, divide the dataset with the standard format into a training set, a validation set and a test set, and package the training set, validation set and test set to form a training dataset and an auxiliary database.

3. The method for accelerating the development of PDK parameterized units for large language models according to claim 1, characterized in that, In S13, the method for merging and lightweighting the weights of the trained and optimized model is as follows: S41: Obtain the adapter parameters of the trained and optimized model, combine the adapter parameters with the original weights of the model element-wise to form a complete model, and save the combined complete model; S42: The merged complete model is initially lightweighted using multiple lightweighting methods, the importance of the initially lightweighted model is evaluated using multiple evaluation methods, the lightweighted model is further lightweighted through iterative pruning, and the iteratively pruned model is fine-tuned using the PDK domain dataset to form the final lightweighted model. S43: Perform an end-to-end evaluation on the final lightweight model and use the final lightweight model as the model after merging and lightweighting.

4. The method for accelerating the development of PDK parameterization units for large language models according to claim 3, characterized in that, In S42, the lightweight method includes a mixed-precision quantization method, an INT8 quantization method, and an INT4 quantization method.

5. The method for accelerating the development of PDK parameterized units for large language models according to claim 3, characterized in that, In S42, the evaluation methods include methods based on weight magnitude, methods based on gradient sensitivity, and methods based on activation value contribution.

6. The method for accelerating the development of PDK parameterized units for large language models according to claim 1, characterized in that, In S14, the method for local deployment and application of the merged and lightweight model is as follows: a knowledge base is constructed based on RAG deployment technology; an inference engine, an integrated plugin, and an interactive development interface are developed based on the knowledge base; the merged and lightweight model is input into the interactive development interface; and the interactive development interface outputs standardized code.

7. The method for accelerating the development of PDK parameterized units for large language models according to claim 1, characterized in that, In S11, the data resources include the official Skill language reference manual and API documentation, a verified PDK parametric unit code library, design rules and constraint documentation, and typical PDK parametric unit implementation examples.

8. The method for accelerating the development of PDK parameterized units for large language models according to claim 1, characterized in that, In S12, the model selected is the DeepSeek-R1-Distill-Qwen model.

Images