Electronic material intelligent coding method and system based on dynamic parameter mapping

Abstract

The invention discloses an electronic material intelligent coding method and system based on dynamic parameter mapping, and relates to the field of dynamic material coding, and the method comprises the steps: firstly, carrying out the processing of a complete parameter set of a material, and generating a globally unique and unchanged basic code, which is used for guaranteeing the identity identification of the material; more importantly, according to a specific application scene (such as power supply design or radio frequency application) where a user is located, most important parameters in the current scene can be dynamically mapped, screened and sorted from a material parameter set, and the parameters are coded to form dynamic feature codes. And finally, assembling the basic code and the dynamic feature code to obtain a final intelligent code. Therefore, the code not only ensures the uniqueness of the material, but also can dynamically display the key performance according to the context, thereby effectively overcoming the limitation of static coding, and remarkably improving the material type selection efficiency and accuracy of engineers.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of dynamic material coding, and more particularly, to an electronic material intelligent coding method and system based on dynamic parameter mapping. BACKGROUND

[0002] In the research and development, production and supply chain management of electronic information industry, electronic material coding plays a crucial role, which is the basis for realizing material standardization, informatization management and efficient circulation. A well-designed coding system can significantly improve the efficiency of material identification, retrieval, procurement and replacement. However, with the increasing refinement of industrial division and the deep verticalization of application scenarios, the limitations of traditional material coding methods are increasingly prominent. For example, for the same capacitor material, power engineers may be most concerned about its equivalent series resistance (ESR) and voltage resistance when designing high-speed DC-DC converters; while radio frequency (RF) engineers are more concerned about its quality factor (Q value) and self-resonant frequency (SRF) when designing filters. This difference in parameter priority based on different application scenarios is a pain point that existing coding systems cannot solve.

[0003] The material coding method in the prior art generally adopts a static coding system, which was designed in an era when the number of material types was relatively small and the division of labor was not very fine, aiming to establish a unified and universal classification standard. This method usually selects a few key parameters with the greatest common divisor for a certain type of material, and hard-codes them into a one-dimensional coding string in a fixed order and format. This one-size-fits-all design forces the compression and solidification of multi-dimensional material parameter information, which, although ensuring the unity of coding in the past, has become a bottleneck for efficiency in today's highly specialized application scenarios. Because the coding structure and parameter priority are rigidly fixed, the coding cannot reflect the importance of context-dependent parameters, making engineers with different professional backgrounds unable to quickly identify the most critical information for their current tasks from the coding, and needing to frequently consult lengthy specifications for confirmation, which seriously hinders the research and development efficiency and selection accuracy in agile development processes.

[0004] Therefore, due to the historical limitations of the design and the one-dimensional linear constraints of the coding carrier, the existing static coding method cannot essentially meet the efficient acquisition needs of fine and scenario-based material information in modern hardware research and development processes. In order to solve the technical problem of low application efficiency across scenarios caused by fixed parameter priority, a new electronic material coding method is urgently needed to break through the shackles of static coding, dynamically map and organize the key parameters of materials according to different application scenarios, generate intelligent coding with scenario adaptability, and thus significantly improve the selection efficiency and accuracy of engineers. SUMMARY

[0005] To solve the above-mentioned root problem, according to an aspect of the present application, an electronic material intelligent coding method based on dynamic parameter mapping is provided, which comprises: performing structured processing on the obtained original material data to obtain a structured parameter set; generating a unique basic code for the structured parameter set to obtain a basic code; performing dynamic parameter mapping based on an application scenario for the structured parameter set to obtain a mapped parameter list; performing dynamic feature code coding for the mapped parameter list to obtain a dynamic feature code; and performing final intelligent coding assembly for the basic code and the dynamic feature code to obtain a final intelligent code.

[0006] According to another aspect of the present application, an electronic material intelligent coding system based on dynamic parameter mapping is provided, which comprises: an original material data processing module for performing structured processing on the obtained original material data to obtain a structured parameter set; a basic code generation module for generating a unique basic code for the structured parameter set to obtain a basic code; a dynamic parameter mapping module for performing dynamic parameter mapping based on an application scenario for the structured parameter set to obtain a mapped parameter list; a dynamic feature code coding module for performing dynamic feature code coding for the mapped parameter list to obtain a dynamic feature code; and a coding assembly module for performing final intelligent coding assembly for the basic code and the dynamic feature code to obtain a final intelligent code.

[0007] Compared with the prior art, the electronic material intelligent coding method and system based on dynamic parameter mapping provided by the present application proposes a dual-structure coding model of basic code + dynamic feature code to solve the problem of low cross-scene application efficiency caused by fixed parameter priority in the existing static coding. The method first generates a globally unique and unchanging basic code by processing the complete parameter set of the material, which is used to ensure the identity of the material. More importantly, it can dynamically map, filter and sort the most important parameters in the current scene from the material parameter set according to the specific application scenario (such as power design or radio frequency application) of the user, and encode these parameters to form a dynamic feature code. Finally, the basic code and the dynamic feature code are assembled to obtain the final intelligent code. In this way, the coding not only ensures the uniqueness of the material, but also dynamically displays the key performance according to the context, thereby effectively overcoming the limitations of static coding and significantly improving the material selection efficiency and accuracy of engineers. BRIEF DESCRIPTION OF DRAWINGS

[0008] The above and other objects, features and advantages of the present application will become more apparent from the following detailed description of embodiments of the present application taken in conjunction with the accompanying drawings.

[0009] Figure 1 A flowchart of the electronic material intelligent coding method based on dynamic parameter mapping according to the embodiments of the present application.

[0010] Figure 2 A data flow diagram of the electronic material intelligent coding method based on dynamic parameter mapping according to the embodiment of the application.

[0011] Figure 3 A flow chart of step S2 in the electronic material intelligent coding method based on dynamic parameter mapping according to the embodiment of the application.

[0012] Figure 4 A flow chart of step S3 in the electronic material intelligent coding method based on dynamic parameter mapping according to the embodiment of the application.

[0013] Figure 5 A block diagram of the electronic material intelligent coding system based on dynamic parameter mapping according to the embodiment of the application. DETAILED DESCRIPTION

[0014] Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. It should be understood that the accompanying drawings and embodiments of the present disclosure are only for exemplary purposes, and are not intended to limit the protection scope of the present disclosure.

[0015] To solve the technical problem that normal working condition fluctuations and real fault signals are difficult to distinguish in battery pack extrusion force anomaly identification, the present application proposes an electronic material intelligent coding method based on dynamic parameter mapping. Figure 1 A flow chart of the electronic material intelligent coding method based on dynamic parameter mapping according to the embodiment of the application. Figure 2 A data flow diagram of the electronic material intelligent coding method based on dynamic parameter mapping according to the embodiment of the application. As shown in Figure 1 and Figure 2 The electronic material intelligent coding method based on dynamic parameter mapping according to the embodiment of the application includes: S1, performing structured processing on the obtained original material data to obtain a structured parameter set; S2, performing unique basic code generation on the structured parameter set to obtain a basic code; S3, performing dynamic parameter mapping based on an application scenario on the structured parameter set to obtain a mapped parameter list; S4, performing dynamic feature code encoding on the mapped parameter list to obtain a dynamic feature code; and S5, performing final intelligent coding assembly on the basic code and the dynamic feature code to obtain a final intelligent code.

[0016] In step S1, the obtained raw material data is structured to obtain a structured parameter set. It should be understood that the raw data of electronic materials is from a wide range of sources and in various formats, and is usually in the form of unstructured or semi-structured text, such as product specifications, web page descriptions, etc., which contains a large amount of redundant, ambiguous and inconsistent information. This data state cannot be directly used for accurate code generation. Therefore, the obtained raw material data is structured to obtain a structured parameter set, which can convert these heterogeneous and mixed raw information into a unified, standardized, complete and unambiguous computer processable data set, and provide a high-quality, standardized data basis for subsequent unique basic code generation and dynamic parameter mapping based on application scenarios.

[0017] In an exemplary operation, step S1, the obtained raw material data is structured to obtain a structured parameter set, including: S11, performing entity-relation extraction and preliminary formatting on the raw material data to obtain an extracted entity list; S12, performing parameter semantic mapping and unit standardization on each entity object in the extracted entity list to obtain a standardized parameter set; S13, based on a verification template library, performing structured data verification on the standardized parameter set to obtain the structured parameter set.

[0018] In the above exemplary operation, step S1 is implemented as follows: the raw material data can be obtained through various ways, such as crawling product description text from electronic component supplier websites or data aggregation platforms through a web crawler module, or extracting text information from electronic product specifications (PDF format) through an optical character recognition (OCR) module. In this embodiment, the obtained raw material data is a string describing a specific capacitor, such as Murata capacitor, part number GRM21BR61H106KE19L, parameters: 10uF, 50V, X5R, 10%, 0805 package, ESR typical value 20mΩ.

[0019] Next, step S11 is executed. First, entity tagging processing is performed on the received raw material data string. This processing is completed using a pre-trained Named Entity Recognition (NER) model. This model adopts an architecture combining Transducer-Based Bidirectional Encoder Representation (BERT) and Conditional Random Field (CRF), namely the BERT-CRF model. Specifically, the input text is first processed by word segmentation, for example, by using a word-slicing algorithm to divide the text into a series of words, and adding specific classification and delimiter tags at the beginning and end of the sequence. Subsequently, a corresponding word embedding, paragraph embedding, and position embedding are generated for each word. These three are added together to form the final input vector sequence, which is then fed into the BERT encoder. The BERT encoder is composed of multiple stacked bidirectional transducer encoding units. Its self-attention mechanism can capture the dependency relationship between any two words in the input sequence, regardless of their distance in the text, thereby generating a dynamic representation vector for each word that deeply integrates global contextual information. After processing by the BERT encoding layer, the representation vector corresponding to each word in the output is passed through a fully connected layer and mapped to a predefined entity label space, resulting in an emission score matrix. This matrix represents the non-normalized probability of each word being assigned to various entity labels. This emission score matrix is ​​then fed into the top-level CRF layer. The CRF layer not only considers the independent emission score of each word provided by BERT but also introduces a learnable label transition probability matrix, which quantifies the probability of transitioning from one label to another. By combining the emission score and transition probability, the CRF layer can evaluate the joint probability of the entire label sequence and decode a globally optimal label path using the Viterbi algorithm, thereby ensuring that the output label sequence is globally optimal and effectively solving the problems of unclear entity boundary recognition and label dependency. The model's weights, biases, and other parameters are obtained through supervised learning training on a massive corpus of electronic components manually annotated by domain experts. This corpus contains a large amount of data from specifications, technical manuals, and other texts. Text fragments such as "Murata," "10uF," and "GRM21BR61H106KE19L" are labeled with predefined entity tags. The predefined entity tag set is based on the general attributes of electronic components, including: manufacturer, material category, model, parameter name, value, unit, specification code, and package. After inputting the aforementioned raw material data strings into the NER model, the model scans and analyzes the text, outputting a series of tagged lexical units.For this example, the output tagged token sequence is: [('Murata','manufacturer'), ('capacitor','material category'), ('part number', 'delimiter'), ('GRM21BR61H106KE19L','model number'), ('parameters are:', 'delimiter'), ('10', 'value'), ('uF', 'unit'), (',', 'delimiter'), ('50', 'value'), ('V', 'unit'), (',', 'delimiter'), ('X5R','specification code'), (',', 'delimiter'), ('10', '%', 'unit'), (',', 'delimiter'), ('0805', 'package'), ('package', 'delimiter'), (',', 'delimiter'), ('ESR', 'parameter name'), ('typical value', 'delimiter'), ('20', 'value'), ('mΩ', 'unit')]. Next, the tagged token sequence output from the previous step is processed for relation extraction and aggregation to form structured entity groups. This process is performed by a relation extraction module that processes the tagged tokens based on a set of pre-defined syntactic rules. These rules are set according to common language patterns in electronic component parameter descriptions. For example, the rule set may include the following rules: Rule 1, a value token followed by a unit token forms a complete parameter value entity; Rule 2, a parameter name token followed by a parameter value entity formed by Rule 1 forms a named parameter entity; Rule 3, a parameter value entity formed by Rule 1, if no parameter name token appears before it, is assigned a default parameter type based on its unit token by consulting a pre-defined unit-default parameter mapping table; Rule 4, tokens labeled as manufacturer, material category, model number, specification code, and package form independent entities. An example of the pre-defined unit-default parameter mapping table is: {'F': 'capacity', 'V': 'voltage', '%': 'precision'}. The processing program iterates through the tagged token sequence and applies these rules. For example, encountering ('10', 'value') and ('uF', 'unit'), Rule 1 is applied to aggregate them into the parameter value "10uF". Since there is no parameter name before it, Rule 3 is applied, and the unit uF is known to correspond to the default parameter capacity by consulting the mapping table, resulting in the entity group (capacity, 10uF). Encountering ('ESR', 'parameter name'), ('20', 'value'), and ('mΩ', 'unit'), Rule 1 is applied to aggregate 20mΩ, and then Rule 2 is applied to form the entity group (ESR, 20mΩ). After processing all tokens, a series of entity groups is obtained. Finally, the generated entity groups are listed to generate the final extracted entity list. This process formats each entity group into a uniform key-value pair object and stores it in a list in order, forming the final extracted entity list.The key of the key-value object is fixed as the entity type and the entity value. Traverse the entity group obtained in the last step, for example, for the entity group (manufacturer, Murata), generate the object {"entity type": "manufacturer", "entity value": "Murata"}; for the entity group (capacity value, 10uF), generate the object {"entity type": "capacity value", "entity value": "10uF"}. Aggregate all generated objects, and the final output of the extracted entity list is as follows: [{ "entity type": "manufacturer", "entity value": "Murata"}, { "entity type": "material category", "entity value": "capacitor"}, { "entity type": "model", "entity value": "GRM21BR61H106KE19L"}, { "entity type": "capacity value", "entity value": "10uF"}, { "entity type": "rated voltage", "entity value": "50V"}, { "entity type": "specification code", "entity value": "X5R"}, { "entity type": "accuracy", "entity value": "10%"}, { "entity type": "package", "entity value": "0805"}, { "entity type": "ESR", "entity value": "20mΩ"}].

[0020] Next, step S12 is executed. First, category identification and pattern loading are performed. The processor iterates through the input list of extracted entities, searching for objects whose entity type is a material category, thereby determining the major category of the current material. In this application example, the material category is identified as capacitor. Based on this category, a standard parameter pattern corresponding to capacitor is loaded from a preset standard parameter pattern library. This pattern library is predefined by domain experts and stores standardized parameter templates for various materials. For example, the loaded capacitor standard parameter pattern is a structured object with the following content: {parameter_capacitance value: {"standard unit": "F", "alias": ["capacitance", "Capacitance"]}, "parameter_rated voltage": {"standard unit": "V", "alias": ["rated voltage", "withstand voltage", "Voltage"]}, "parameter_dielectric material": {"standard unit": "N / A", "alias": ["specification code", "material"]}, "parameter_precision": {"standard unit": "ratio", "alias": ["precision", "Tol."]}, "parameter_package": {"standard unit": "N / A", "alias": ["package", "Package"]}, "parameter_equivalent series resistance": {"standard unit": "Ω", "alias": ["ESR"]}}. Next, entity iteration and mapping are performed. The processor iterates through each entity object in the extracted entity list and maps them according to the loaded standard parameter pattern. For {"Entity Type":"Capacitance", "Entity Value":"10uF"}, the processor extracts its entity type as capacitance and then searches in the various alias lists of the pattern. A match is found under the parameter_capacitance value entry, so the entity is mapped to the standard parameter name parameter_capacitance value. Similarly, rated voltage is mapped to parameter_rated voltage, specification code to parameter_dielectric material, accuracy to parameter_accuracy, package to parameter_package, and ESR to parameter_equivalent series resistance. For generic attributes such as manufacturer and model, they can be directly mapped to the standard parameter name brand and model. Unit standardization is performed during or after parameter mapping. For each successfully mapped parameter containing both a value and a unit, the processor separates the value and the original unit from its entity value, obtains its target standard unit from the standard parameter pattern, and then calls the corresponding conversion function in a "unit conversion rule set" to complete the calculation. This rule set contains a series of functions for handling unit conversions of different physical quantities. For example, for an entity mapped to the parameter _capacitance value, its entity value is 10uF, which is separated into the numerical value 10 and the unit uF. The pattern indicates that its standard unit is F. The unit conversion function is called, which converts 10uF to 1.0E-5 F according to preset prefix conversion rules, such as u=10^-6, m=10^-3, k=10^3, etc.For parameter_nominal_voltage, the value 50V is already in the standard unit V, so the converted value is still 50. For parameter_equivalent_series_resistance, the value is 20mΩ, and the separated value is 20 and the unit is mΩ. The standard unit is Ω, so the converted value is 0.02. For parameter_precision, the value is 10%, which is converted to the ratio value 0.1. Finally, the set construction is performed. The processing program assembles all the mapped standard parameter names and the converted standard values with the standardized units into a new structured object, i.e., the standardized parameter set. The set takes the standard parameter name as the key and a sub-object containing the standardized value and the standard unit as the value. For the parameter without unit, the value is directly a string. After processing all entities, the generated standardized parameter set is: {“material category”:“capacitor”,“brand”:“Murata”,“model”:“GRM21BR61H106KE19L”,“parameter_capacitance value”:{“value”:1.0E-5,“unit”:“F”},“parameter_nominal_voltage”:{“value”:50,“unit”:“V”},“parameter_dielectric material”:“X5R”,“parameter_precision”:{“value”:0.1,“unit”:“ratio”},“parameter_package”:“0805”,“parameter_equivalent_series_resistance”:{“value”:0.02,“unit”:“Ω”}}.

[0021] Finally, step S13 is performed. In one example operation, step S13, based on the verification template library, performs structured data verification on the standardized parameter set to obtain the structured parameter set, including: S131, based on the material category information in the standardized parameter set, loading the corresponding verification rule from the verification template library; S132, based on the verification rule, performing the mandatory item verification and the value range verification on the standardized parameter set; S133, based on the verification rule, performing data completion on the standardized parameter set to obtain the structured parameter set.

[0022] In particular, the first step is performed in step S131. The verification template library is a pre-built, structured knowledge base, which is set up by experts in the field of electronic engineering according to industry standards, device physical properties and design experience. It is indexed by material categories, and stores a set of exclusive verification and completion rules for each category. In this embodiment, the processing program reads the material category in the input parameter set as capacitor, and uses it as the key to retrieve and load the verification rule template of capacitor from the verification template library. The template is a detailed structured object, and its specific content is shown as follows: {“mandatory items”:[“parameter_capacitance value”,“parameter_rating voltage”,“parameter_package”],“value range check”:{“parameter_capacitance value”:{“minimum value”:1.0E-13,“maximum value”:1.0E-2,“unit”:“F”},“parameter_rating voltage”:{“minimum value”:1,“maximum value”:5000,“unit”:“V”},“parameter_package”:{“allowed values”:[“0201”,“0402”,“0603”,“0805”,“1206”,“1210”]}},“data completion rule”:{“parameter_self-resonant frequency”:{“acquisition method”:“database query”,“query key”:“model”,“default value”:“N / A”},“parameter_rating ripple current”:{“acquisition method”:“database query”,“query key”:“model”,“default value”:“N / A”}}}. The second step is performed in step S132. The processing program first performs mandatory item check, which will traverse each element of the mandatory item list in the verification rule, and check whether it exists in the input standardized parameter set. The rule requires that parameter_capacitance value, parameter_rating voltage and parameter_package must exist, and after checking, the input parameter set contains all the three, so the mandatory item check is passed. If any is missing, the material data will be marked as incomplete, and the missing parameter item is recorded. Then the value range check is performed, and the processing program will check the parameters in the standardized parameter set related to the value range check rule one by one. For parameter_rating voltage, its value is 50, which is within the effective range of [1, 5000] volts defined by the rule, and the check is passed. For parameter_package, its value is 0805, which exists in the allowed value list defined by the rule, and the check is passed. If any parameter value is out of its specified range, for example, a capacitor with a rating voltage of 0.1 V, the data will be marked as abnormal, and the specific check failure information is recorded. Finally, step S133 is performed. This step aims to enrich the parameter set and supplement the parameters not provided in the original description but important for engineering applications. The processing program will traverse the data completion rule part in the verification rule. In this example, the rule defines that parameter_self-resonant frequency and parameter_rating ripple current need to be completed. For parameter_self-resonant frequency, the rule specifies that the acquisition method is database query, and the query key is model.Thus, the processing program extracts the value of the model from the input standardized parameter set, i.e. GRM21BR61H106KE19L. Then, a query request is initiated to an internally integrated, more detailed component characteristic database with the model as the query condition. The database stores detailed performance data provided by the manufacturer or measured through experiments. The query returns the typical value of the self-resonant frequency of the capacitor of the model as 15 MHz. After obtaining the value, it is also standardized to obtain {“value”: 1.5E7, “unit”: “Hz”}. Then, the new parameter key-value pair, i.e. parameter_self-resonant frequency: {“value”: 1.5E7, “unit”: “Hz”}, is added to the standardized parameter set. For the parameter_nominal ripple current, the same process is performed, and if the database query is unsuccessful, the default value N / A defined in the rule is used to fill in. After the above checking and completing operations, a complete, clean and information-rich structured parameter set is finally formed. The structured parameter set is the final output of the entire data structuring process. For this example, the final output of the structured parameter set is: {“material category”: “capacitor”, “brand”: “Murata”, “model”: “GRM21BR61H106KE19L”, “parameter_capacitance value”: {“value”: 1.0E-5, “unit”: “F”}, “parameter_nominal voltage”: {“value”: 50, “unit”: “V”}, “parameter_dielectric material”: “X5R”, “parameter_precision”: {“value”: 0.1, “unit”: “ratio”}, “parameter_package”: “0805”, “parameter_equivalent series resistance”: {“value”: 0.02, “unit”: “Ω”}, “parameter_self-resonant frequency”: {“value”: 1.5E7, “unit”: “Hz”}}.

[0023] In step S2, the structured parameter set is subjected to unique basis code generation to obtain a basis code. Accordingly, the electronic material intelligent coding proposed in the present application adopts a double structure of basis code + dynamic feature code. Among them, the dynamic feature code will change flexibly according to different application scenarios, in order to highlight the key parameters related to the scene. In such a system, in order to ensure that each electronic material, regardless of how the dynamic feature code changes, has a stable, unique and unchangeable identity at any time and in any system, in order to realize its accurate identification and traceability in the whole life cycle of design, procurement, production, warehousing, etc., and to provide a fixed anchor point for the variable dynamic feature code part, therefore, the step of generating a unique basis code for the structured parameter set needs to be performed, to create a globally unique, application scenario independent identity card number for each unique material specification.

[0024] In an exemplary operation, Figure 3This is a flowchart of step S2 in the electronic material intelligent coding method based on dynamic parameter mapping according to an embodiment of this application. Figure 3 As shown, step S2, generating a unique base code for the structured parameter set to obtain the base code, includes: S21, constructing a normalized unique identifier for the structured parameter set based on the identifier rule set to obtain a normalized unique identifier string; S22, generating a candidate base code for the normalized unique identifier string to obtain a candidate code and an initial salt value; S23, resolving conflicts and synthesizing the candidate code and the initial salt value to obtain the base code.

[0025] In the above example operation, step S2 is implemented as follows: first, step S21 is performed. First, rule loading is performed. This process relies on an identifier rule set. The rule set is a pre-defined configuration library, which is specified by domain experts for each material category according to industry conventions and supply chain management experience, and a set of ordered core parameter field names for generating a unique identifier. For example, for the capacitor category, it is generally believed in the industry that the combination of brand and manufacturer model (material number) is the fundamental basis for uniquely determining a material specification. Therefore, the rule corresponding to the capacitor in the identifier rule set is set to an ordered list: ["brand", "model"]. The processing program first reads the value of the material category field from the input structured parameter set, that is, capacitor. Then, the corresponding core parameter field name list is retrieved and loaded from the identifier rule set, and [“brand”, “model”] is obtained. This list specifies the type and order of subsequent parameter extraction. Then, ordered extraction and normalization are performed. The processing program strictly follows the order defined in the core field list [“brand”, “model”] loaded in the previous step, traverses each field name in the list, and extracts the corresponding value from the structured parameter set. First, process the brand, and extract its value from the parameter set as Murata. Then process the model, and extract its value as GRM21BR61H106KE19L. In this way, an ordered value list consistent with the order of the core field list is formed: [“Murata”, “GRM21BR61H106KE19L”]. Subsequently, normalization processing is performed on each value in the value list to eliminate recognition problems caused by format differences. Normalization processing includes a series of preset operations: first, remove all white space characters at the beginning and end of the string; second, convert all English letters in the string to lowercase to avoid case sensitivity issues; third, remove or replace special characters that do not affect uniqueness determination, such as parentheses. In this example, Murata is processed to murata, and GRM21BR61H106KE19L is processed to grm21br61h106ke19l. If the value of a core field is not present or an empty string during extraction, the normalization processing will replace it with a pre-defined, fixed placeholder, such as “_none_”, so that even in the case of incomplete information, a stable structure and consistent length input can be generated to ensure the stability of subsequent hash calculation. After normalization processing, a normalized value list is obtained: [“murata”, “grm21br61h106ke19l”]. Finally, string concatenation is performed. The processing program sequentially concatenates all elements in the normalized value list obtained in the previous step using a pre-defined, unambiguous separator to generate the final normalized unique identifier string.The separator is a sequence of characters that is extremely unlikely to occur in the normalized parameter value, to ensure that the string can be unambiguously back-parsed if needed later. In this embodiment, the predefined separator is |:|. The handler concatenates the elements in the list ["murata", "grm21br61h106ke19l"] with the separator |:| to get the final normalized unique identifier string: murata|:|grm21br61h106ke19l.

[0026] Next, step S22 is performed. First, a hash digest is calculated. The input normalized unique identifier string murata|:|grm21br61h106ke19l is fed into a selected hash algorithm. Here, a non-cryptographic hash function is selected, such as the 128-bit version of MurmurHash3 (MurmurHash3_x64_128). The reason for selecting this algorithm is that it provides excellent hash value distribution characteristics while maintaining very high operational speed, i.e., small changes in input cause large avalanches in output, thereby effectively reducing the probability of hash collisions in which different inputs produce the same output, making it very suitable for scenarios in which unique identifiers are generated. After calculation, the algorithm outputs a 128-bit binary hash digest, such as 0x8a3c...e5f1 in hexadecimal notation. Next, character encoding conversion is performed. The binary hash digest obtained in the previous step is not convenient for direct use as encoding, and needs to be converted into a string composed of general and secure characters. Base62 encoding algorithm is used in this step. Base62 encoding uses 62 characters ([0-9, a-z, A-Z]) to represent binary data, and has the advantages of not containing any special symbols, good system compatibility and URL friendliness, and being able to represent more information than Base16 (hexadecimal) or Base32 at the same length, making the encoding more compact. The binary hash digest 0x8a3c...e5f1 obtained in the previous step is input into the Base62 encoding algorithm, and a coded string is obtained, such as T4f7Bv9pQz.... Subsequently, fixed-length truncation is performed. In order to obtain a uniform and short base code, the Base62 encoded string generated in the previous step needs to be truncated. The length of the truncation is a predefined system parameter, such as base code length, which can be set according to the trade-off between the length of the encoding and the acceptable collision probability of the application system. In this embodiment, the base code length is set to 6. The processing program starts from the beginning of the coded string T4f7Bv9pQz... and truncates a substring of length 6 to obtain T4f7Bv. This truncated substring is used as the candidate code. Finally, the salt value is initialized. In order to deal with the candidate code collision that may occur in the next step, an initial salt value is initialized here for collision resolution. In a simple implementation, the initial salt value can be set to a fixed initial value, such as the integer 0. This initial salt value is output together with the candidate code.

[0027] Finally, step S23 is executed. In the first loop iteration, the processor uses the input candidate code T4f7Bv as the current candidate code, with a current salt value of 0. First, a database query operation is performed to check if the current candidate code T4f7Bv exists in a globally unique, persistent base code database. This database stores all base codes that have been successfully generated and assigned to materials. In this embodiment, if the query result is true, meaning there is already a record with the code T4f7Bv in the database, this indicates a hash collision. At this point, the collision resolution mechanism is activated. The processor first increments the current salt value by 1, changing it from 0 to 1. Next, a new input string is constructed, which is formed by concatenating the original normalized unique identifier string, a preset delimiter, such as |:|, and the updated current salt value. That is, concatenating murata|:|grm21br61h106ke19l with 1 yields the new input string: murata|:|grm21br61h106ke19l|:|1. Subsequently, the processing program re-enters this new input string into the same processing flow as step S22, that is, sequentially performs MurmurHash3 hash digest calculation, Base62 encoding conversion, and fixed-length truncation (removing the first 6 bits). Since the input string has changed, this process will deterministically generate a completely new candidate code. For example, the newly generated current candidate code is kLp8sW. Then, the second iteration begins. At this time, the current candidate code is updated to kLp8sW, and the current salt value is 1. The processing program again queries the "base code database" to see if the current candidate code kLp8sW exists. In this embodiment, if the query result is false, that is, the code does not exist in the database. This indicates that the verification is successful, and the newly generated candidate code kLp8sW is unique. At this point, the uniqueness verification loop terminates, and kLp8sW is confirmed as the final unique encoded string. After obtaining the unique encoded string, prefix synthesis is performed to increase the readability of the code, making it intuitively reflect the major category of the material. The processing program first extracts the value of the material category field, i.e., capacitance, from the input structured parameter set. Next, the corresponding category prefix for each category is looked up in a predefined category prefix mapping table. This mapping table is a simple set of key-value pairs, defined by domain experts, for example: {"capacitor":"C", "resistor":"R", "inductor":"L"}. The table shows that the category prefix for capacitor is C. Finally, the category prefix C, a predefined separator for connection, such as a hyphen "-", and the unique encoded string kLp8sW obtained in the previous step are concatenated. The concatenation results in the final base code: C-kLp8sW. After generating the final base code, persistent storage operations are performed.The processing program writes the newly generated base code C-kLp8sW as a new record into the base code database, which ensures that the code has been officially occupied, and in subsequent generation of base codes for other materials, if the same candidate code is generated again, the uniqueness verification loop can correctly detect the conflict.

[0028] In step S3, the structured parameter set is subjected to application scenario-based dynamic parameter mapping to obtain a mapped parameter list. It can be understood that the previous steps have generated a unique identity base code for the material and constructed a complete and normative structured parameter set containing all performance parameters of the material. However, this comprehensive parameter set does not distinguish the importance of each parameter in different engineering application scenarios. For example, a power engineer and a radio frequency engineer have completely different focuses when facing the same complete material parameter table, and a static and unordered parameter list cannot meet their demand for quick access to key information. Therefore, in order to convert static data into dynamic and instructive intelligence, and to provide a direct, ordered and formatted data source for subsequent generation of dynamic feature codes that can truly reflect intelligence and scenario adaptability, the step of subjecting the structured parameter set to application scenario-based dynamic parameter mapping to obtain a mapped parameter list needs to be performed.

[0029] In an exemplary operation, Figure 4 The flowchart of step S3 in the electronic material intelligent coding method based on dynamic parameter mapping according to the embodiment of the present application is shown in FIG. 3. As shown in FIG. 3, step S3, the structured parameter set is subjected to application scenario-based dynamic parameter mapping to obtain a mapped parameter list, including: S31, selecting and loading a scenarioized template based on the material category and the application scenario to obtain a selected template; S32, based on the selected template, extracting and filling values from the structured parameter set to obtain a filled parameter list; S33, data cleaning and formatting the filled parameter list to obtain the mapped parameter list. Figure 4

[0030] ​In the above exemplary operation, step S3 is implemented as follows: First, step S31 is executed. This step relies on a pre-built parameter priority template library. This library is a structured configuration library set by domain experts based on the performance requirements and concerns of different materials in different applications. For example, for power engineers, key parameters are voltage, ESR, capacitance value, and rated ripple current. For RF engineers, key parameters would be Q value, self-resonant frequency (SRF), capacitance value, etc. Its data structure is hierarchical. The first level uses the material category as the primary key, and its value is a set containing all scenario templates for that category, i.e., a category-specific template set. In the category-specific template set, the application scenario identifier is used as the secondary key, and its value is a specific parameter mapping template. Crucially, each category-specific template set contains a predefined default scenario template named "_default_" to handle application scenarios that are not explicitly defined. For example, a portion of the parameter priority template library has the following structure: {“Capacitor”:{“Power Supply-DC / DC-Output Filter”:{“Template Name”:“Capacitor-Power Supply-DC / DC-Output Filter”,“Parameter List”:[...]},“RF-Filter-Bandpass”:{“Template Name”:“Capacitor-RF-Filter-Bandpass”,“Parameter List”:[...]},“_default_”:{“Template Name”:“Capacitor-General Default”,“Parameter List”:[{“Field Name”:“Parameter_Capacitor Value”,...},{“Field Name”:“Parameter_Rated Voltage”,...}]}},“Resistor”:{...}}. In one scenario of this embodiment, such as the externally specified application scenario being Power Supply-DC / DC-Output Filter, firstly, a primary query key is constructed and an initial search is performed. The processor extracts the values ​​of the material category field from the input structured parameter set to obtain the capacitor. Using this capacitor as the primary key, a search is performed in the parameter priority template library, successfully locating the category-specific template set belonging to the capacitor. Next, a secondary query key is constructed and a template search is performed. The processor uses the specified application scenario, Power Supply-DC / DC-Output Filtering, as the secondary key and performs a second search in the previously acquired set of templates specific to the capacitor category. Since a matching key exists in the template library, the processor successfully retrieves the corresponding template: {"Template Name":"Capacitor-Power Supply-DC / DC-Output Filtering","Parameter List":[...]}. Finally, conditional loading is performed. Because a matching template is found, the processor loads this template as the selected template and simultaneously generates a fallback flag and sets it to False. This flag indicates whether the default template was used during this loading. At this point, the processing for this scenario is complete, and the output selected template is the specific template for Power Supply-DC / DC-Output Filtering, with the fallback flag set to False.In another scenario, if the application context is audio-signal coupling, which is not explicitly defined in the parameter priority template library under the category of capacitors, the process starts with constructing the primary query key capacitor and locating to the category-specific template set of capacitors. Then, the secondary key audio-signal coupling is used to search in the set, but no matching entry is found. At this time, the fallback mechanism is triggered. The handler automatically searches for the predefined key named “_default_” in the category-specific template set of capacitors. When found, the handler loads the default context template corresponding to the “_default_” key, i.e., {“template name”:“capacitor-general-default”,“parameter list”:[...]} as the selected template. Meanwhile, the fallback flag is set to True. This fallback mechanism ensures that even for rare or new application contexts that are not defined in detail, the method can still provide a general and reasonable parameter mapping scheme, ensuring the robustness and universality of the process.

[0031] In particular, during the selection and loading of the contextualized template, if the application context is only considered as an isolated and semantic-free string for exact matching, there will be significant limitations. This hard matching method lacks flexibility in the case of incomplete matching and cannot understand the inherent semantic relationship between different contexts, for example, it cannot recognize that “power_DC / DC” and “power_LDO” belong to the power management field and have similar engineering considerations. Therefore, when a new and not precisely defined application context such as a vehicle power module input is encountered, this method can only fall back to a general and insufficient default template, which cannot provide targeted guidance, which is a typical data sparsity and cold start problem. To overcome this technical bottleneck and make the template selection process more intelligent, generalizable, and robust, the present application proposes an intelligent matching method for contextualized templates based on semantic embedding and improved similarity calculation. It converts the application context from a simple text label to a mathematical object that can measure its semantic similarity in a high-dimensional vector space, so that when there is no exactly matching template, it can intelligently find and recommend a known context template that is most similar in semantics to the current context in the vector space, realizing the transition from string matching to semantic matching.

[0032] Based on this, in one preferred exemplary operation, step S31, scenario-based template selection and loading based on material category and application scenario to obtain the selected template, includes: defining a hierarchical label / feature system for each predefined application scenario to obtain a feature vocabulary. It should be understood that by establishing a unified feature vocabulary, all scenarios can be standardized and atomized. This step is performed in the offline training phase. First, all known and predefined application scenarios in the template library are hierarchically decomposed into features. According to the domain knowledge, the scene string is divided into multiple dimensional labels using a fixed separator (such as “_”). For example, for a predefined application scenario Power_DC / DC_Car in the present application, it can be decomposed into a feature set {“Power”, “DC / DC”, “Car”}. By traversing all predefined application scenarios, all non-repeated features are extracted to build a global feature vocabulary. For example, the vocabulary may include {“Power”, “DC / DC”, “LDO”, “Car”, “RF”, “Filter”,...}. This vocabulary defines the dimension of the entire vector space.

[0033] Each feature corresponding to each predefined application scenario in the feature vocabulary is decomposed and TF-IDF weight calculation is performed to obtain a TF-IDF weight set for each predefined application scenario. Accordingly, only the feature set cannot reflect the importance of each feature to a specific scene. Therefore, by introducing the TF-IDF model, the contribution of each feature in distinguishing a specific application scenario is quantified. The more unique a feature is in a scene and the more rare it is in all scenes, the higher its weight. This makes the subsequent vector representation more discriminative. This step is also performed in the offline training phase. For the feature set of each predefined application scenario, a modified TF-IDF model is used to calculate the weight of each feature. Specifically, for a feature t and a feature set C of an application scenario, the TF-IDF weight w(t, C) is obtained by weighted summation of a term frequency (TF) and an inverse document frequency (IDF). Wherein, the term frequency term TF(t, C)=exp(f t,C ) / N C , f t,C is the number of times feature t appears in set C, N C is the total number of features in set C, and the exponential function exp amplifies the influence of high-frequency features. The inverse document frequency term IDF(t, C)=logN S -log[N C′∈C:t∈C′ +1 / TF(t, C)], where N S is the total number of predefined application scenarios in the template library, and N C′∈C:t∈C′This represents the number of scenarios containing feature t. By introducing a 1 / TF(t,C) term to correct the inverse document frequency (IDF) based on term frequency, contextual relevance is enhanced. The final TF-IDF weight w(t,C) is the weighted sum of term frequency (TF(t,C)) and inverse document frequency (IDF(t,C)). Ultimately, each predefined application scenario yields a set containing all its features and their corresponding TF-IDF weights. For example, the processing will calculate the weights of each feature for the predefined application scenario C1 Power_DC / DC_Automobile. First, the weight of feature t as automobile is calculated. In the feature set C1 of this scenario, the number of times automobile appears, f... t,C The total number of features in the set is 1, N. C Since the value is 3, its term frequency term TF("car", C1) is calculated to be exp(1) / 3, which is approximately equal to 0.906. The influence of high-frequency features is amplified by the exponential function exp. Then, its inverse document frequency term IDF("car", C1) is calculated. If only one of the four scenarios contains the feature car, then the number of scenarios containing this feature N is N. C The value is 1. Its inverse document frequency term is calculated as log(4)-log(1+1 / 0.906), which is approximately equal to 0.642. Finally, according to the weight formula, the term frequency term and the inverse document frequency term are summed with weights. The weight value of this sum is determined by repeatedly experimenting on the validation dataset to obtain the best template matching performance. For example, the weight of the term frequency term is set to 0.4 and the weight of the inverse document frequency term is set to 0.6. The final TF-IDF weight w("car",C1) of the feature car is calculated to be approximately 0.75.

[0034] The features corresponding to each predefined application scenario in the feature vocabulary are embedded to obtain a set of feature word embedding vectors for each predefined application scenario. It should be understood that TF-IDF weights address the statistical importance of features but cannot capture deep semantic relationships between features, such as the similarity between "car" and "vehicle." This step introduces word embedding technology to map each feature from an independent word to a dense vector that expresses its inherent semantics. A pre-trained word embedding model is used, such as Word2Vec, GloVe, or a BERT model fine-tuned for large amounts of text in the electrical engineering field (such as technical manuals, specifications, and design forum content). This model has learned to convert words into fixed-dimensional (e.g., 128-dimensional) real-valued vectors. Each feature in the feature vocabulary is iterated and input into the model to obtain its corresponding feature word embedding vector. For example, the feature "car" might be converted into a vector [0.12, -0.45, ..., 0.88], while its synonym "vehicle" would be converted into a vector very close to it in the vector space. Ultimately, each predefined application scenario yields a set containing all its features and their corresponding embedding vectors.

[0035] The TF-IDF weight set and the feature word embedding vector set of each predefined application scenario are weighted and concatenated to obtain a set of predefined application scenario vectors. Accordingly, the TF-IDF weight serves as the weight and the feature word embedding vector serves as the value, and the combination of the two makes the final scenario vector more accurate. For each predefined application scenario, the TF-IDF weight set and the feature word embedding vector set of the features thereof are weighted and concatenated. An effective implementation is to multiply the embedding vector of each feature in the scenario by its corresponding TF-IDF weight (scalar multiplication), and then concatenate all the weighted feature vectors to obtain a single predefined application scenario vector representing the entire application scenario. For example, the final vector V_scene of the scenario power_DC / DC_car can be calculated as: [w("power", C)*Emb("power"), w("DC / DC", C)*Emb("DC / DC"), w("car", C)*Emb("car")]. In this way, each predefined application scenario in the template library has a corresponding unique vector representation.

[0036] The application scenario is vectorized to obtain an application scenario vector. It should be understood that in order to compare the user input query scenario with the predefined scenarios in the library, the query scenario also needs to be converted into a vector in the same vector space. When a user input query application scenario is received, for example, a vehicle-mounted DC / DC power supply, the same processing flow as the offline stage described above is performed. That is, first, it is decomposed into features {“vehicle-mounted”, “DC / DC”, “power supply”}, and then the TF-IDF weight of these features is calculated using the global model and statistical information that has been constructed, the embedding vectors thereof are obtained, and finally the application scenario vector of the query scenario is generated by weighted concatenation .

[0037] The application scenario vector is matched with each predefined application scenario vector in the set of predefined application scenario vectors based on cosine similarity, and the predefined application scenario corresponding to the predefined application scenario vector with the highest matching value is obtained as the selected template, that is: ; wherein, is the application scenario vector, is each predefined application scenario vector in the set of predefined application scenario vectors, represents and , the numerator and in the denominator represent the two-norm of and , respectively, and further introduce a spatial constraint of all pre-computed scenario vectors beyond the closeness of two vectors in the direction of, thereby representing the query material class specificity, thus quantifying the scenario contextual relevance, is and the matching value. That is, by computing the similarity in the vector space, one can go beyond the literal limit of strings, find the most similar known scenario to the query scenario in terms of functionality and engineering implications, and thus recommend the most suitable template, achieving the effect of intelligent recommendation. Compute the similarity between the generated application scenario vector Vq and all pre-defined application scenario vectors Vk under the current material class. Here, a modified cosine similarity formula is adopted. The formula adds a spatial constraint term to the denominator part of the standard cosine similarity, which is the sum of squares of the lengths of all known scenario vectors under the current material class, as a normalization factor to quantify the contextual relevance of the scenario. After computing the similarity scores of Vq and all Vk, select the one with the highest score. For example, if it is found that Vq (from the vehicle DC / DC power supply) has the highest similarity score with V_dcdc_auto (from the power DC / DC_automobile), then the template corresponding to the power DC / DC_automobile is loaded and output as the final selected template. In this way, by selecting and loading the scenario-based template corresponding to the application scenario with the highest score , the recall rate and accuracy of template matching can be significantly improved, and more highly relevant templates can be found for scenarios without precise pre-defined templates, while the system robustness is enhanced. For example, even if the user input application scenario has slight spelling errors or synonym variants, as long as their vector representations are close enough, the correct template can be found.

[0038] Step S32 is then executed. As the selected template from S31 corresponds to the power-DC / DC-output filter scenario, its content is: { "template name": "capacitor-power-DC / DC-output filter", "parameter list": [ { "field name": "parameter_nominal voltage", "encoding length": 2}, { "field name": "parameter_equivalent series resistance", "encoding length": 3}, { "field name": "parameter_capacitance value", "encoding length": 4}, { "field name": "parameter_nominal ripple current", "encoding length": 3} ]}. The encoding length is the parameter reserved for the subsequent step, indicating the character length of the parameter in the final dynamic feature code. First, template traversal is performed. The process strictly follows the order defined in the parameter list of the selected template, and iterates through each parameter object one by one. An empty filled parameter list is initialized to store the tuples generated subsequently. The process starts with the first parameter object in the template { "field name": "parameter_nominal voltage", "encoding length": 2}. Then, parameter value retrieval is performed. For the currently processed parameter object, the value of its field name, parameter_nominal voltage, is extracted. This parameter_nominal voltage is used as a key to search in the input structured parameter set. The search is successful, and the corresponding parameter value is obtained as an object: { "value": 50, "unit": "V"}. Subsequently, null value processing is performed. In this example, since the parameter value exists and is not null, the value { "value": 50, "unit": "V"} is directly used for the next step. Finally, list construction is performed. The parameter name parameter_nominal voltage obtained from the template, the parameter value { "value": 50, "unit": "V"} retrieved from the parameter set, and the encoding length 2 obtained from the template are appended to the filled parameter list as a triple, i.e., ("parameter_nominal voltage", { "value": 50, "unit": "V"}, 2). The process continues to traverse the second parameter object in the template { "field name": "parameter_equivalent series resistance", "encoding length": 3}. The above retrieval step is repeated, and the value { "value": 0.02, "unit": "Ω"} is found in the structured parameter set. This value is not null, so the triple ("parameter_equivalent series resistance", { "value": 0.02, "unit": "Ω"}, 3) is constructed and appended to the list. The process continues to traverse the third parameter object { "field name": "parameter_capacitance value", "encoding length": 4}. The value { "value": 1.0E-5, "unit": "F"} is found. The triple ("parameter_capacitance value", { "value": 1.0E-5, "unit": "F"}, 4) is constructed and appended to the list. The process continues to traverse the fourth parameter object { "field name": "parameter_nominal ripple current", "encoding length": 3}.A lookup is performed in the structured parameter set with this as the key, but no corresponding entry is found, i.e. the parameter value does not exist. At this point, the null value handling mechanism is triggered. The handler assigns a predefined, special marker value that can be recognized as invalid or unknown in the subsequent encoding phase. This marker value is a fixed string, e.g. unavailable, to ensure that the output list structure remains complete and the order is not scrambled even in the case of missing data. Thus, the constructed triple is (“parameter_nominal ripple current”, “unavailable”, 3) and is appended to the list. After all parameter objects in the selected template have been traversed and processed, the final output filled parameter list is an ordered list containing multiple triples: [(“parameter_nominal voltage”, {“value”: 50, “unit”: “V”}, 2), (“parameter_equivalent series resistance”, {“value”: 0.02, “unit”: “Ω”}, 3), (“parameter_capacitance value”, {“value”: 1.0E-5, “unit”: “F”}, 4), (“parameter_nominal ripple current”, “unavailable”, 3)].

[0039] Finally, step S33 is executed. First, data cleaning and formatting is performed. This step is functionally optional, and the specific logic of its execution depends on the specific requirements of the subsequent encoding function (step S4) on the input data. For example, if the subsequent encoding function requires that all input values must be in string format, then this step would be responsible for converting all parameter values, whether composite objects or special markers, into strings. However, in this embodiment of the invention, a design strategy of postponing complex logic is adopted. That is, the subsequent numerical encoding function, step S4, is designed to be able to directly handle composite objects containing numerical values and units, as well as to recognize and handle the unavailable special marker. Based on this, step S33 chooses a direct pass-through processing method. This means that the handler traverses the input filled parameter list, but does not modify or filter any data in it. The composite object with the value {“value”: 50, “unit”: “V”} remains unchanged, as does the special marker with the value unavailable. The consideration for choosing this way is that it makes the responsibilities of the data mapping phase purer, i.e. only responsible for parameter selection and ordering, and all specific formatting and logic processing related to numerical encoding are concentrated in the specialized encoding step, making the module division of the entire method clearer. Then, the final output is performed. After the data cleaning and formatting process (in this case, direct pass-through), the handler directly assigns or renames the filled parameter list to the mapped parameter list. This operation, although it does not change the data content, has important significance in the process semantics. It marks the formal completion of the dynamic parameter mapping process based on the application scenario, and clearly indicates that this list is the final data prepared for generating dynamic feature codes after the complete mapping process.

[0040] In step S4, the mapped parameter list is dynamically encoded to obtain a dynamic signature. It should be understood that the mapped parameter list generated in the previous step has successfully filtered and sorted the key parameters of the material according to the specific application scenario, forming an ordered data set. However, the list itself is still a structured data set, not a compact, directly embedded string of final encoding. The numerical information in the list (such as 50 volts, 0.02 ohms) needs to be converted into a character representation form with higher information density and fixed length. Therefore, in order to convert this ordered parameter list containing rich numerical information into a fixed-length text code with high information density, i.e. a dynamic signature, the mapped parameter list needs to be dynamically encoded to obtain a dynamic signature.

[0041] In an exemplary operation, step S4, the mapped parameter list is dynamically encoded to obtain a dynamic signature, includes: step S41, inputting each tuple in the mapped parameter list into a numerical encoding function to obtain a parameter encoded string set; step S42, sequentially splicing the parameter encoded string set to obtain the dynamic signature.

[0042] In the above exemplary operation, step S4 is implemented as follows: first, step S41 is performed. This step is implemented by a predefined numerical encoding function. In an exemplary operation, step S41, inputting each tuple in the mapped parameter list into a numerical encoding function to obtain a parameter encoded string set, includes: the numerical encoding function processes each tuple in the mapped parameter list according to the following formula: ; wherein, is the character of the exponent position, is the character of the mantissa position, is the length, is the numerical encoding function, is the parameter encoded string. This function is responsible for encoding a numerical value (V) into a string (C) of specified length (L). The encoding principle is a kind of scientific notation based on character mapping. The function relies on two preset character mapping tables: one is the exponent mapping table, which is used to map the integer power of 10 (E) to a character; the other is the mantissa mapping table, which is used to map the number to a character. For example, the exponent mapping table can be set as: {...-3: 'H', -2: 'J', -1: 'K', 0: 'A', 1: 'B', 2: 'C', 3: 'D'...}, covering the orders of magnitude from pico to Giga. The mantissa mapping table can directly use the number characters '0' to '9'. The processing program will traverse the input mapped parameter list. For the first tuple ("parameter_nominal_voltage", {"value": 50, "unit": "V"}, 2), the numerical encoding function receives the value V = 50 and the length L = 2. According to the formula, L = 2 means that the encoding consists of 1 exponent character and 1 mantissa character. 50 is decomposed into 5 * 10^1, getting the mantissa M = 5 and the exponent E = 1. Looking up the table, the exponent character corresponding to E = 1 is 'B', and the mantissa character corresponding to M = 5 is '5'. Combining them, we get the encoded string B5. For the second tuple ("parameter_equivalent_series_resistance", {"value": 0.02, "unit": "Ω"}, 3), the function receives V = 0.02 and L = 3. L = 3 means 1 exponent and 2 mantissas. 0.02 is decomposed into 20 * 10^-3, getting the mantissa M = 20 and the exponent E = -3. Looking up the table, the exponent character corresponding to E = -3 is 'H', and the mantissa character corresponding to the mantissa 20 is "20". Combining them, we get the encoded string H20. For the third tuple ("parameter_capacitance_value", {"value": 1.0E-5, "unit": "F"}, 4), the function receives V = 1.0E-5 and L = 4. L = 4 means 1 exponent and 3 mantissas. 1.0E-5, i.e. 10uF, is decomposed into 100 * 10^-7, getting the mantissa M = 100 and the exponent E = -7. Looking up the table (e.g. -7 corresponds to 'E'), we get the exponent character corresponding to E = -7 is 'E', and the mantissa character corresponding to the mantissa 100 is 100. Combining them, we get the encoded string "E100". For the fourth tuple ("parameter_nominal_ripple_current", "not available", 3), the function receives the special marker value not available and the length L = 3. The function has processing logic for special markers inside, i.e. return a string of length L composed of a preset placeholder (e.g. 'X'). Therefore, the encoded string returned is XXX. After traversal, the output parameter encoded string set is [ "B5", "H20", "E100", "XXX" ].

[0043] Then step S42 is performed. All the strings in the set ["B5", "H20", "E100", "XXX"] generated in the previous step are concatenated head to tail in the order they are in the set. The result of the concatenation is a single string: B5H20E100XXX.

[0044] In step S5, the final smart code assembly of the base code and the dynamic feature code is performed to obtain the final smart code. That is, after the previous series of steps, two core code components with different functions have been successfully generated for the same material: one is the base code to ensure the global identity of the material unique, stable and unchanging, and the other is the dynamic feature code which can dynamically highlight the key performance parameters according to different engineering application scenarios. However, at this time, the two components are still separate, independent data segments. In order to finally present a single, complete and functional code to the user, which can serve as both the unique identity card of the material and the efficient performance card in a specific scenario, it is necessary to organically combine the two parts together. Therefore, performing the final smart code assembly of the base code and the dynamic feature code will represent the two code parts of unchanging identity and variable intelligence, and fuse them into a unified, coherent final code string, thereby fully realizing the dual-structure smart code system proposed in the present application.

[0045] In one example operation, step S5 is implemented as follows: the implementation of this step is a deterministic string concatenation operation. In order to ensure that the final generated smart code is structurally clear and can be unambiguously parsed back to its two basic components by a program when needed, a separator for connecting the base code and the dynamic feature code needs to be predefined. The selection of this separator should follow a principle that it cannot be any of the characters in the character set used by either the base code or the dynamic feature code, in order to avoid ambiguity. In this embodiment, the base code uses letters, numbers and hyphen, and the dynamic feature code uses letters and numbers, therefore, a special character such as a period "." can be selected as the predefined separator. The specific assembly operation is as follows: the processing program obtains the base code C-kLp8sW and the dynamic feature code B5H20E100XXX. Then, according to the fixed order of the base code first and the dynamic feature code second, the two are concatenated with the predefined separator ".". The concatenation process is: concatenate the base code string C-kLp8sW, the separator string "." and the dynamic feature code string B5H20E100XXX end to end. The concatenation result is: C-kLp8sW.B5H20E100XXX. This final concatenated string C-kLp8sW.B5H20E100XXX is the final smart code. That is, this final smart code has a dual interpretation value: its first part C-kLp8sW is the unique identity of the material, which remains unchanged regardless of changes in application scenarios, and can be used for database indexing, material tracing and all other occasions that require accurate identity recognition. Its second part B5H20E100XXX is a performance snapshot of the material in the current power-DC / DC-output filter scenario, from which a power engineer can quickly interpret the key parameters, i.e. the rated voltage 50V, the equivalent series resistance 20mΩ, the capacitance value 10uF, and the unknown rated ripple current, which are exactly the parameters he is most concerned about in power design. If the material is used in other scenarios, such as radio frequency-filter, the dynamic feature code part will be another completely different string of characters, while the base code part will still be C-kLp8sW, thereby realizing the unification of identity uniqueness and scenario intelligence.

[0046] In summary, the electronic material intelligent coding method based on dynamic parameter mapping according to the embodiments of the present application is illustrated. The present application proposes a dual-structure coding model of basic code + dynamic feature code to solve the problem of low application efficiency across scenes caused by the fixed priority of parameters in the existing static coding. The method first generates a globally unique and unchanging basic code by processing the complete parameter set of the material, which is used to ensure the identity of the material. More importantly, it can dynamically map, filter and sort the most important parameters in the current scene from the material parameter set according to the specific application scenario (such as power design or radio frequency application) of the user, and encode these parameters to form a dynamic feature code. Finally, the basic code and the dynamic feature code are assembled to obtain the final intelligent coding. In this way, the coding not only ensures the uniqueness of the material, but also dynamically displays the key performance according to the context, thereby effectively overcoming the limitations of static coding and significantly improving the material selection efficiency and accuracy of engineers.

[0047] Figure 5 The block diagram of the electronic material intelligent coding system based on dynamic parameter mapping according to the embodiments of the present application is shown. As shown in Figure 5 The electronic material intelligent coding system based on dynamic parameter mapping 100 according to the embodiments of the present application includes: a raw material data processing module 110 for structurally processing the obtained raw material data to obtain a structured parameter set; a basic code generation module 120 for generating a unique basic code for the structured parameter set to obtain a basic code; a dynamic parameter mapping module 130 for performing dynamic parameter mapping based on the application scenario for the structured parameter set to obtain a mapped parameter list; a dynamic feature code encoding module 140 for encoding the mapped parameter list to obtain a dynamic feature code; and a coding assembly module 150 for assembling the final intelligent coding of the basic code and the dynamic feature code to obtain the final intelligent coding.

[0048] Here, those skilled in the art can understand that the specific operations of each step in the above electronic material intelligent coding system based on dynamic parameter mapping have been described in detail above with reference to the electronic material intelligent coding method based on dynamic parameter mapping Figures 1 to 4 , and therefore the repeated description thereof will be omitted.

Claims

1. A method for intelligent coding of electronic materials based on dynamic parameter mapping, characterized in that, include: The acquired raw material data is processed in a structured manner to obtain a structured parameter set; A unique base code is generated from the structured parameter set to obtain the base code; Perform dynamic parameter mapping on the structured parameter set based on the application scenario to obtain the mapped parameter list; The mapped parameter list is dynamically encoded to obtain the dynamic feature code; the basic code and the dynamic feature code are then assembled using final intelligent encoding to obtain the final intelligent code.

2. The electronic material intelligent coding method based on dynamic parameter mapping according to claim 1, characterized in that, The acquired raw material data is processed in a structured manner to obtain a structured parameter set, including: entity-relation extraction and preliminary formatting of the raw material data to obtain an extracted entity list; parameter semantic mapping and unit standardization of each entity object in the extracted entity list to obtain a standardized parameter set; and structured data validation of the standardized parameter set based on a validation template library to obtain the structured parameter set.

3. The intelligent electronic material coding method based on dynamic parameter mapping according to claim 2, characterized in that, Based on the verification template library, structured data validation is performed on the standardized parameter set to obtain the structured parameter set, including: loading corresponding validation rules from the verification template library based on the material category information in the standardized parameter set; performing mandatory item validation and value range validation on the standardized parameter set based on the validation rules; and performing data completion on the standardized parameter set based on the validation rules to obtain the structured parameter set.

4. The intelligent coding method for electronic materials based on dynamic parameter mapping according to claim 1, characterized in that, The process of generating a unique base code from a structured parameter set includes: constructing a normalized unique identifier from the structured parameter set based on an identifier rule set to obtain a normalized unique identifier string; generating a candidate base code from the normalized unique identifier string to obtain a candidate code and an initial salt value; and resolving conflicts and synthesizing the candidate code and the initial salt value to obtain the base code.

5. The intelligent electronic material coding method based on dynamic parameter mapping according to claim 1, characterized in that, The structured parameter set is dynamically mapped based on the application scenario to obtain a mapped parameter list, including: selecting and loading a scenario-based template based on the material category and application scenario to obtain a selected template; extracting and filling the structured parameter set with ordered parameters based on the selected template to obtain a filled parameter list; and cleaning and formatting the filled parameter list to obtain the mapped parameter list.

6. The intelligent electronic material coding method based on dynamic parameter mapping according to claim 1, characterized in that, The process of dynamically encoding the mapped parameter list to obtain a dynamic feature code includes: inputting each tuple in the mapped parameter list into a numerical encoding function to obtain a set of encoded string parameters; and sequentially concatenating the set of encoded string parameters to obtain the dynamic feature code.

7. The intelligent coding method for electronic materials based on dynamic parameter mapping according to claim 6, characterized in that, Each tuple in the mapped parameter list is input into a numerical encoding function to obtain a set of encoded strings, including: the numerical encoding function processes each tuple in the mapped parameter list using the following formula: ;in, The character for the exponent position. The last character. For length, It is a numerical encoding function.

8. An intelligent coding system for electronic materials based on dynamic parameter mapping, characterized in that, include: The raw material data processing module is used to perform structured processing on the acquired raw material data to obtain a structured parameter set; The base code generation module is used to generate a unique base code from the structured parameter set to obtain the base code; The dynamic parameter mapping module is used to perform dynamic parameter mapping on the structured parameter set based on the application scenario to obtain the mapped parameter list; The dynamic feature code encoding module is used to encode the mapped parameter list with dynamic features to obtain dynamic feature codes; the encoding assembly module is used to perform final intelligent encoding assembly of the basic code and dynamic feature codes to obtain the final intelligent code.

Images