A construction method and system of an internet of things standard object model, an electronic device, and a storage medium

Abstract

The application relates to a construction method and system of an Internet of Things standard object model, electronic equipment and a storage medium, relates to the technical field of intelligent Internet of Things, and is applied to an Internet of Things platform embedded with a large language model. The construction method of the Internet of Things standard object model comprises the following steps: S10, the Internet of Things platform processes unstructured device documents based on the large language model to generate an object model draft; S20, the Internet of Things platform uses a genetic algorithm to perform multi-objective optimization on the object model draft to generate a performance-optimized standard object model; and S30, the Internet of Things platform judges whether the device capacity of a target Internet of Things device changes based on a detection instruction, if yes, the version of the standard object model is automatically upgraded, and if not, the Internet of Things device normally operates. The application has the beneficial effects that the object model construction efficiency can be improved, and the cost can be saved.

Description

Technical Field

[0001] This invention relates to the field of smart Internet of Things (IoT) technology, and more specifically, to a method, system, electronic device, and storage medium for constructing IoT standard object models. Background Technology

[0002] As a key driver of digital transformation, the Internet of Things (IoT) technology has been widely applied in numerous fields such as the Industrial Internet, smart homes, and smart cities. Object models, as abstract representations of physical devices and their functional characteristics, digitally map physical devices to the cloud, enabling efficient communication between devices and between devices and the cloud.

[0003] In current IoT practices, the construction of object models heavily relies on manual design and the experience of domain experts. Specifically, when a new IoT device needs to connect to a platform, a team of hardware engineers, embedded software engineers, and cloud platform development engineers typically spends days or even weeks defining the object model. This process involves: First, hardware and embedded engineers need to thoroughly interpret the device's technical specifications and communication protocol documents to understand its various functions, data points, and instruction sets. Then, they collaborate with cloud platform engineers to manually map these physical world entities and logic into the digital world object model, defining its attributes (such as the current reading of a temperature sensor, the on / off state of a smart light), services (such as calling the camera function, restarting the device), and events (such as device online, abnormal alarms). This process is not only time-consuming but also highly error-prone. Manual interpretation of documents may contain omissions or misunderstandings, and manually writing model code may introduce syntax errors or logical flaws, all of which can lead to device connection failures or operational anomalies, increasing debugging and rework costs significantly. Furthermore, once the existing IoT object model is built, the firmware of IoT devices may be upgraded during actual operation, adding new functions or optimizing existing ones; the network environment in which the devices operate may change, affecting the efficiency and stability of data transmission; and user business needs may evolve, placing new demands on the accuracy, frequency, and dimensions of data collection. However, the current static object model cannot perceive or adapt to these changes. For example, after a firmware upgrade of a smart meter, a new monitoring data point, "power factor," may be added. However, the old object model on the platform does not define this attribute, causing this new data to be ignored, and the platform cannot use this new information for analysis. Similarly, if the device operates in an environment with poor network signal, a fixed data reporting frequency may lead to a large amount of data loss, and the object model cannot adaptively reduce the reporting frequency or change the data compression strategy to ensure data integrity. This lack of self-learning and adaptive capabilities causes the object model to be locked in its initial state at creation, unable to continuously optimize and improve over time. The system's optimization and upgrade process heavily relies on manual intervention. Operation and maintenance personnel need to continuously monitor system logs, analyze user feedback, manually modify the model code, and then go through a series of processes such as testing and deployment to complete the upgrade. This process is not only costly and slow to respond, but also prone to errors.

[0004] To address this, the present invention provides a method, system, electronic device, and storage medium for constructing standard IoT object models, which can solve the problems of low efficiency and high cost caused by the high dependence on manual labor in the traditional object model construction process, thereby improving the efficiency of object model construction and saving costs. Summary of the Invention

[0005] To overcome the shortcomings of existing technologies, this invention provides a method, system, electronic device, and storage medium for constructing standard IoT object models. This method can solve the problems of low efficiency and high cost caused by the high dependence on manual labor in the traditional object model construction process, thereby improving the efficiency of object model construction and saving costs.

[0006] The technical solution adopted by this invention to solve its technical problem is: a method for constructing an IoT standard object model, applied to an IoT platform embedded with a large language model, wherein the improvement lies in that the method for constructing the IoT standard object model includes the following steps: S10, the IoT platform processes unstructured device documents based on a large language model to generate a draft of the device model; S20, the IoT platform uses a genetic algorithm to perform multi-objective optimization on the draft object model in order to generate a standard object model with optimized performance; S30: The IoT platform determines whether the device capabilities of the target IoT device have changed based on the detection command. If so, it automatically upgrades the version of the standard object model; otherwise, the IoT device operates normally.

[0007] Furthermore, in step S10, the IoT platform also embeds a document preprocessing component and a structure generator. The document preprocessing component is connected to the input end of the language model, and the structure generator is connected to the output end of the language model.

[0008] Furthermore, the specific steps for processing unstructured device documents based on a large language model include: Preprocessing: The document preprocessing component is used to extract text content, clean and segment text from the unstructured device document input by the user in sequence to obtain several text fragments; Key information extraction: Extract device attribute information, service information, and event information from text fragments using a large language model; Object model generation: The extracted key information is mapped to a predefined industry standard framework using a structured generator and the fields are automatically populated to generate a formatted object model draft.

[0009] Furthermore, in step S20, the specific process of using a genetic algorithm to perform multi-objective optimization of the standard model includes: Encoding and Population Initialization: Encode the parameters of the draft object model into gene sequences and initialize a population containing multiple different draft object models; Evaluation: A multi-dimensional fitness function was designed to quantitatively evaluate the overall performance of each draft model in the population, and the fitness scores of each standard model were calculated by weighting. Iterative optimization: The population is iteratively optimized through genetic operations until the population converges; Decoding: Decode the individual with the highest fitness score in the population and output the corresponding standard model.

[0010] Furthermore, the genetic operation includes: Selection operation: Based on the calculated fitness score, select the individual with the highest fitness score from the current population as the parent; Crossover operation: Recombining the gene sequences of two selected parents to generate two new offspring individuals; Mutation operation: Randomly fine-tuning the gene sequence of newly generated offspring individuals.

[0011] Furthermore, in step S30, the IoT platform also includes a response parser, a difference analyzer, and a version manager.

[0012] Furthermore, in step S30, the specific steps by which the IoT platform determines whether the device capabilities of the target IoT device have changed based on the detection command include: The IoT platform sends a probe command to the target IoT device, and the IoT device returns a response command to the IoT platform containing the set of device capabilities of the target IoT device according to a predefined protocol format. The IoT platform uses a response parser to convert response commands into device capability set description objects; The IoT platform uses a difference analyzer to perform a deep comparison between the device capability set description object and the current standard object model of the target IoT device stored in the database to generate a difference report. Based on the content of the difference report, it determines whether the device capability of the target IoT device has changed. When the device capability of the target IoT device changes, the IoT platform will automatically trigger a version upgrade of the standard object model through the version manager.

[0013] A system for constructing IoT standard object models, applied to the method for constructing IoT standard object models as described above, wherein the improvement lies in that the system for constructing IoT standard object models includes: The document parsing and draft generation module is used to process unstructured device documents to generate draft object models; The model optimization and evaluation module is used to perform multi-objective optimization on the draft object model to generate a standard object model with optimized performance. The device detection and model upgrade module is used to determine whether the device capabilities of the target IoT device have changed. If so, the standard object model version is automatically upgraded; otherwise, the IoT device operates normally.

[0014] An electronic device, improved in that it includes at least one processor and at least one memory, wherein, The memory stores computer-readable instructions; The computer-readable instructions are executed by one or more processors, enabling the electronic device to implement the method for constructing the Internet of Things standard object model as described above.

[0015] A storage medium storing computer-readable instructions, wherein the improvement is that the computer-readable instructions are executed by one or more processors to implement the method for constructing an Internet of Things standard object model as described above.

[0016] The beneficial effects of this invention are as follows: First, it automatically parses unstructured device documents using a large language model to generate an initial draft object model, replacing manual reading and summarization. Second, it introduces a genetic algorithm to perform multi-objective iterative optimization of the draft object model, automatically finding the optimal balance between cost, performance, and stability, replacing manual tuning that relies on expert experience. Finally, it actively detects changes in device capabilities, triggering automatic upgrades and iterations of the object model version to achieve continuous self-adaptation. The entire construction process of this standard object model transforms the highly dependent manual, static modeling of domain experts into an efficient, intelligent, and continuously optimized automated process, solving the problems of low efficiency and high cost caused by high reliance on manual labor in traditional object model construction. This improves the efficiency of object model construction while saving costs. Attached Figure Description

[0017] Figure 1 This is an overall flowchart of a method for constructing an IoT standard object model according to the present invention; Figure 2 This is a block diagram of a system for constructing an IoT standard object model according to the present invention; Figure 3 This is a flowchart illustrating a method for constructing an IoT standard object model, as shown in an exemplary embodiment. Figure 4 A schematic diagram illustrating the process of generating a draft object model as an example embodiment; Figure 5 A schematic diagram illustrating the optimization process of a draft object model as an example embodiment; Figure 6 This is a schematic diagram illustrating the process of updating a standard object model version as an example embodiment. Figure 7 This is a hardware structure diagram of an electronic device as an example embodiment; Figure 8 This is a block diagram illustrating an electronic device as an example embodiment. Detailed Implementation

[0018] The present invention will be further described below with reference to the accompanying drawings and embodiments.

[0019] The following will clearly and completely describe the concept, specific structure, and technical effects of the present invention in conjunction with embodiments and accompanying drawings, so as to fully understand the purpose, features, and effects of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, not all of them. Other embodiments obtained by those skilled in the art based on the embodiments of the present invention without creative effort are all within the scope of protection of the present invention. Furthermore, all connections / linkages involved in the patent do not simply refer to direct contact between components, but rather to the ability to form a better connection structure by adding or reducing connecting accessories according to specific implementation conditions. The various technical features in this invention can be combined interactively without contradicting each other.

[0020] Reference Figure 1-5 As shown, this invention discloses a method for constructing an IoT standard object model, applied to an IoT platform embedded with a large language model. The method for constructing the IoT standard object model includes the following steps: S10, the IoT platform processes unstructured device documents based on a large language model to generate a draft device model; wherein, the IoT platform also embeds a document preprocessing component and a structure generator, the document preprocessing component being connected to the input end of the large language model; the structure generator being connected to the output end of the large language model; the specific steps of processing unstructured device documents based on the large language model include: S101, Preprocessing: The document preprocessing component is used to extract text content, clean and segment text from the unstructured device document input by the user in sequence to obtain several text fragments. It should be noted that in this embodiment, the IoT platform supports various forms of unstructured documents as input, including but not limited to PDF, DOCX, TXT, HTML, and other file formats, or directly inputting the document's URL link. After receiving the document, the IoT platform will preprocess it using a document preprocessing component, which includes a document parser, a text cleaner, and a text segmenter. Specifically, during document preprocessing, firstly, the document parser calls the appropriate library (such as PyPDF2 for PDF, python-docx for DOCX) based on the file type to extract the text content. For HTML documents, tools such as BeautifulSoup are used to remove tags and retain the main text. Then, the text cleaner cleans the extracted raw text, removing irrelevant formatting information, headers, footers, advertising links, and other noise data. Next, the text segmenter divides long texts into smaller, semantically complete chunks based on the document's structure (such as chapters and paragraphs) to facilitate subsequent processing by the large model. Finally, these processed text chunks are fed into the large language model for key information extraction.

[0021] It should also be noted that, in this embodiment, the document parser includes, but is not limited to, PyPDF2 / pdfplumber, python-docx, BeautifulSoup, and Unstructured / Marker; the text cleaner includes, but is not limited to, clean-text, Scrubadub, and BeautifulSoup; and the text splitter includes, but is not limited to, RecursiveCharacterTextSplitter, Semantic Chunker, and Unstructured Chunking.

[0022] S102, Key Information Extraction: Extract device attribute information, service information, and event information from text fragments using a large language model; It should be noted that, in this embodiment, the large language model employs a deep learning model with powerful natural language understanding and generation capabilities, such as the DeepSeek series, GPT series, Llama series, or a domain-specific model. Furthermore, to enable the large language model to perform the specific task of extracting information from the object model, this embodiment employs model fine-tuning, prompting engineering, and context learning strategies to train and guide the large language model. This ensures that it can automatically identify and extract various key information required to construct the object model, such as device name, attribute list (including attribute name, data type, value range, unit, read / write permissions), service list (including service name, input parameters, output parameters), and event list (including event name, event...). (Item parameters); Specifically, during model fine-tuning, a dataset containing a large number of device documents and corresponding object model annotations is prepared. This dataset is used to fine-tune the pre-trained large model, enabling it to more accurately identify entities and relationships related to the object model; for example, teaching the model to recognize "temperature" as an attribute name, "degrees Celsius" as its unit, and "float" as its data type; During the prompting process, some prompts are designed to be given to the large language model. These prompts will clearly define the task objectives, output format, and specifications to be followed; for example, "Please extract all functional attributes from the following device documents and output them in JSON format. Each attribute must contain fields such as 'name', 'dataType', 'unit', and 'accessMode'."; During context learning, several examples (few-shot learning) are provided to show the model how to extract information from text and format it into the desired output, helping the model better understand the task requirements and improve the accuracy of extraction; S103 Object Model Generation: Utilizes a structured generator to map extracted key information to a predefined industry standard framework and automatically populate fields to generate a formatted object model draft.

[0023] It should be noted that, in this embodiment, after extracting key information, the structure generator organizes it into a structured draft object model that conforms to a specific industry standard. Specifically, firstly, the object model specification of the target industry standard (such as OCF, OneM2M) is prepared in advance. This specification defines in detail which parts (such as attributes, services, events) must be included in the final object model document, and how the name, data type, and format of each part should be written, just like a blank exam paper or template with a pre-printed title and fixed format. Then, the structure generator starts working. It accurately fills the key information identified and extracted from the device document by the large language model into the defined specification template to automatically generate an object model draft file (usually in JSON format) that is clearly structured and fully conforms to the syntax requirements of the target standard.

[0024] It should also be noted that, in this embodiment, the structure generator serves as an instance component for document parsing and draft generation. It predefines the object model specification (JSON Schema) of the target standard (such as OCF, OneM2M), fills and maps the key information (attributes, services, events) extracted from the large model to the corresponding fields of the Schema, and generates a structured draft (such as JSON format) based on the Schema constraints. This draft includes device identifier, attribute list (name / data type / unit / access permission), service list (input / output parameters), and event list.

[0025] S20, the IoT platform uses a genetic algorithm to perform multi-objective optimization on the draft object model in order to generate a standard object model with optimized performance; Specifically, the process of using a genetic algorithm to perform multi-objective optimization on the standard model includes: S201, Encoding and Population Initialization: Encode the parameters of the draft object model into gene sequences and initialize a population containing multiple different draft object models; It should be noted that, in this embodiment, during the encoding process, each component of the object model (such as attributes, services, events) and its attributes (such as data type, unit, access permission) are mapped to a gene sequence. For example, binary encoding, real number encoding, or more complex structured encoding can be used. That is, an object model scheme (an "individual") is composed of such a gene sequence. After the encoding is completed, a population needs to be initialized. This population is a collection containing multiple different individuals (object model schemes) and is the starting point for the genetic algorithm to search. In order to ensure the diversity of the population and avoid getting trapped in local optima too early, the initial population is usually randomly generated. For example, the initial object model draft can be randomly modified (such as changing the data type of an attribute or adjusting a value range) to generate a series of different variants, which constitute the initial population.

[0026] S202, Evaluation: Design a multi-dimensional fitness function to quantitatively evaluate the overall performance of each draft model in the population, and calculate the fitness score of each standard model by weighting. It should be noted that, in this embodiment, the multi-dimensional fitness function, as the core of the genetic algorithm, defines the optimization objective and can comprehensively and accurately reflect the performance of the model in various performance dimensions. Specifically, the fitness function is a multi-objective function that integrates the following four key dimensions: Interoperability: The degree of conformity between the evaluation model and industry standards (such as OCF, OneM2M) can be quantified by calculating the proportion of attributes and services in the model that conform to the standard definition. The higher the degree of conformity, the higher the score.

[0027] Resource consumption: Evaluates the overhead of the data transmission and storage of the object model. It can be estimated by calculating the sum of the data type sizes of all attributes in the document parser, text cleaner, and text segmenter models. The lower the resource consumption, the higher the score.

[0028] Data accuracy: Assess whether the data type and precision of the object model definition match the application requirements; for example, if a temperature sensor only needs to be accurate to integer degrees Celsius, but the model is defined as floating point, it will be considered over-designed and the score will be lower.

[0029] Model simplicity: This assesses whether the model has redundant definitions; for example, whether there are attributes with overlapping functions, or whether related attributes can be merged to reduce complexity. The simpler the model, the higher the score. The final fitness score is a weighted sum of the scores from these dimensions, and the weights can be adjusted according to the specific application scenario. For example, in resource-constrained sensor networks, the weight of resource consumption can be set higher.

[0030] In a preferred embodiment, the calculation expression of the multi-dimensional fitness function can be expressed as: ; In the above formula, Represents a multi-dimensional fitness function; Indicates the number of attributes that conform to the standard library; Indicates the weighting coefficient; Indicates the total number of attributes.

[0031] S203, Iterative Optimization: The population is iteratively optimized through genetic operations until the population converges; wherein, the genetic operations include: Selection operation: Based on the calculated fitness score, select the individual with the highest fitness score from the current population as the parent; Crossover operation: Recombining the gene sequences of two selected parents to generate two new offspring individuals; Mutation operation: Randomly fine-tuning the gene sequence of newly generated offspring individuals; It should be noted that in this embodiment, the selection operation employs various strategies, such as roulette wheel selection (individuals with higher fitness have a greater probability of being selected) or tournament selection (randomly selecting several individuals for comparison and choosing the optimal one); the crossover operation is the main way for genetic algorithms to generate new solutions, simulating the gene recombination process in biological heredity. For example, it can be performed by cutting at a single point (single-point crossover) or multiple points (multi-point crossover) in the gene sequence and then exchanging fragments; the mutation operation is crucial for genetic algorithms to maintain population diversity and prevent premature entrapment in local optima; for example, a binary base can be randomly flipped. The algorithm iterates through these three operations: adjusting the position or making a small perturbation to a real number gene value. The overall fitness of the population continuously improves, evolving towards the optimal solution. In each generation, a new generation of the population is generated by performing a series of operations such as evaluation, selection, crossover, and mutation. Then, the genetic algorithm checks whether the termination condition is met. The termination condition can be set as: reaching the preset maximum number of iterations (generations), or the fitness of the best individual in the population not significantly improving (convergence) in multiple consecutive generations, or finding a solution that meets the preset performance threshold. Once the termination condition is met, the algorithm stops iterating.

[0032] S204, Decoding: Decode the individual with the highest fitness score in the population and output the corresponding standard model.

[0033] It should be noted that, in this embodiment, the labeled object model of the individual with the highest fitness score after decoding is the best-performing object model in the population.

[0034] S30, the IoT platform determines whether the device capabilities of the target IoT device have changed based on the probe command. If so, it automatically upgrades the version of the standard object model; otherwise, the IoT device operates normally. The IoT platform also embeds a response parser, a difference analyzer, and a version manager. Specifically, the steps for the IoT platform to determine whether the device capabilities of the target IoT device have changed based on the probe command include: S301, the IoT platform sends a probe command to the target IoT device, and the IoT device returns a response command to the IoT platform containing the set of device capabilities of the target IoT device according to a predefined protocol format. It should be noted that, in this embodiment, the probe instruction set can be understood and responded to by various types of IoT devices, and can cover queries on all possible capabilities of IoT devices, including attribute lists, service lists, event lists and their detailed definitions. The probe instruction set is designed to be lightweight, which can reduce the consumption of network bandwidth and device processing resources. The response instruction is usually a structured data object, such as JSON format, and the response content can describe in detail all the functions supported by the IoT device. S302, the IoT platform uses a response parser to convert response commands into device capability set description objects; It should be noted that in this embodiment, when the IoT platform receives a response instruction, the response parser will parse it and convert it into an internally unified, structured capability description object for subsequent comparison and analysis. As a preferred embodiment, the response parser includes, but is not limited to, Jackson and Fastjson, which receive the structured response message returned by the device, parse and extract the attribute / service / event definitions, and convert them into a unified internal object. S303, the IoT platform uses a difference analyzer to perform a deep comparison between the device capability set description object and the current standard object model of the target IoT device stored in the database to generate a difference report. Based on the content of the difference report, it determines whether the device capability of the target IoT device has changed. When the device capability of the target IoT device changes, the IoT platform will automatically trigger a version upgrade of the standard object model through the version manager.

[0035] It should be noted that, in this embodiment, after the IoT platform obtains the latest device capability set of the IoT device, the difference analyzer will perform a deep comparison with the current standard object model of the device stored in the IoT platform's database. The comparison process will be performed layer by layer and item by item to identify all subtle differences; the types of differences include: New type: An IoT device has added a new attribute, service, or event; Deletion type: An IoT device has removed a previously supported feature.

[0036] Modification type: The definition of a function of an IoT device has changed, such as the data type, value range, or unit of an attribute has changed; The difference analyzer generates a detailed difference report based on the comparison results, listing all detected changes and their details. If the difference analyzer detects any non-zero differences, the version manager automatically triggers the version upgrade process for the object model. This process is automated and aims to minimize the impact on upper-layer applications. The specific steps are as follows: Generate a new version: Based on the difference report, the IoT platform will automatically generate a new version of the object model. This new version will incorporate the new functions added to the device and update the modified function definitions. Version storage: New object model versions are stored in the model library of the IoT platform and associated with the IoT device. Old model versions are retained to support version rollback and historical traceability. Update Device Shadow: The IoT platform will update the device shadow of the IoT device to keep it consistent with the new object model. The device shadow is a virtual representation of the IoT device in the cloud. The application layer mainly interacts with the IoT device by manipulating the device shadow. Compatibility handling and notification: The IoT platform will assess the impact of this device model change on existing applications. If the change breaks backward compatibility (for example, deleting an attribute that an application is using), the system will issue an alarm notification and may provide a compatibility adaptation solution. For non-destructive changes, the system will also notify the relevant application developers, informing them of the new features added to the device so that they can take advantage of these new features in a timely manner. The aforementioned automated process ensures that the IoT platform can dynamically and adaptively keep up with the evolution of IoT devices, achieving full lifecycle management of the object model.

[0037] It should also be noted that, in this embodiment, the difference analyzer, as an object comparison engine, can use Java's Apache Commons Lang EqualsBuilder or a custom comparison algorithm to compare the actual capability set of the device with the current object model field by field, identify added / deleted / modified items, and generate a difference report; the version manager, as a version control system, can use a Git-based model repository or database version table, generate and store new model versions based on the difference report, update the device shadow, retain historical versions to support rollback, and trigger notifications.

[0038] Reference Figure 6 As shown, the present invention also discloses an IoT standard object model construction system 600, applied to an IoT standard object model construction method as described in the above embodiments. The IoT standard object model construction system 600 includes: Document parsing and draft generation module 601 is used to process unstructured device documents to generate a draft of the object model; The model optimization and evaluation module 602 is used to perform multi-objective optimization on the draft object model to generate a standard object model with optimized performance; The device detection and model upgrade module 603 is used to determine whether the device capabilities of the target IoT device have changed. If so, the standard object model version is automatically upgraded; otherwise, the IoT device operates normally.

[0039] It should be noted that the construction strategy of the IoT standard object model provided in the above embodiments is only an example of the division of the above functional modules. In actual applications, the above functions can be assigned to different functional modules as needed. That is, the internal structure of the IoT standard object model construction system 600 will be divided into different functional modules to complete all or part of the functions described above. Furthermore, the IoT standard object model construction system 600 provided in the above embodiments and the IoT standard object model construction method embodiments belong to the same concept, and the specific way in which each module performs operations has been described in detail in the method embodiments, and will not be repeated here.

[0040] Figure 7 A schematic diagram of the structure of an electronic device according to an exemplary embodiment is shown.

[0041] It should be noted that this electronic device is merely an example adapted to the present invention and should not be construed as providing any limitation on the scope of use of the present invention. Furthermore, this electronic device should not be interpreted as requiring or depending on having... Figure 7 One or more components of the exemplary electronic device 2000 shown.

[0042] The hardware structure of electronic devices 2000 can vary significantly due to differences in configuration or performance, such as... Figure 7 As shown, the electronic device 2000 includes: a power supply 210, an interface 230, at least one memory 250, and at least one central processing unit (CPU) 270.

[0043] Specifically, power supply 210 is used to provide operating voltage for various hardware devices on electronic device 2000.

[0044] Interface 230 includes at least one wired or wireless network interface 231 for interacting with external devices. Of course, in other examples adapted to this invention, interface 230 may further include at least one serial-to-parallel conversion interface 233, at least one input / output interface 235, and at least one USB interface 237, etc. Figure 7 As shown, this does not constitute a specific limitation.

[0045] The memory 250 serves as a carrier for resource storage and can be a read-only memory, random access memory, disk, or optical disk, etc. The resources stored on it include the operating system 251, application programs 253, and data 255, etc., and the storage method can be temporary storage or permanent storage.

[0046] The operating system 251 is used to manage and control the various hardware devices and application programs 253 on the electronic device 2000, so as to enable the central processing unit 270 to perform calculations and processing on the massive data 255 in the memory 250. It can be Windows Server™, Mac OS X™, Unix™, Linux™, FreeBSD™, etc.

[0047] Application 253 is a computer-readable instruction based on operating system 251 that performs at least one specific task, and may include at least one module ( Figure 7 (Not shown), each module may contain computer-readable instructions for the electronic device 2000. For example, the device for building the Internet of Things standard object model can be regarded as application 253 deployed on the electronic device 2000.

[0048] Data 255 may be signal information, etc., and is stored in memory 250.

[0049] The central processing unit 270 may include one or more processors and is configured to communicate with the memory 250 via at least one communication bus to read computer-readable instructions stored in the memory 250, thereby enabling the computation and processing of massive amounts of data 255 in the memory 250. For example, a method for constructing an IoT standard object model can be completed by having the central processing unit 270 read a series of computer-readable instructions stored in the memory 250.

[0050] Furthermore, the present invention can also be implemented through hardware circuits or a combination of hardware circuits and software. Therefore, the implementation of the present invention is not limited to any specific hardware circuit, software, or combination thereof.

[0051] Please see Figure 8 This invention provides an electronic device 4000, which may include: a desktop computer, a laptop computer, a server, etc., with sensor recognition capabilities.

[0052] exist Figure 8 In this context, the electronic device 4000 includes at least one processor 4001 and at least one memory 4003.

[0053] The data interaction between the processor 4001 and the memory 4003 can be achieved through at least one communication bus 4002. This communication bus 4002 may include a path for transmitting data between the processor 4001 and the memory 4003. The communication bus 4002 may be a PCI (Peripheral Component Interconnect) bus or an EISA (Extended Industry Standard Architecture) bus, etc. The communication bus 4002 can be divided into an address bus, a data bus, a control bus, etc. For ease of representation, Figure 8 The bus is represented by a single thick line, but this does not mean that there is only one bus or one type of bus.

[0054] Optionally, the electronic device 4000 may further include a transceiver 4004, which can be used for data interaction between the electronic device and other electronic devices, such as sending and / or receiving data. It should be noted that in practical applications, the transceiver 4004 is not limited to one type, and the structure of the electronic device 4000 does not constitute a limitation on the embodiments of the present invention.

[0055] Processor 4001 may be a CPU (Central Processing Unit), a general-purpose processor, a DSP (Digital Signal Processor), an ASIC (Application Specific Integrated Circuit), an FPGA (Field Programmable Gate Array), or other programmable logic devices, transistor logic devices, hardware components, or any combination thereof. It can implement or execute the various exemplary logic blocks, modules, and circuits described in conjunction with the disclosure of this invention. Processor 4001 may also be a combination that implements computational functions, such as including one or more microprocessor combinations, a combination of a DSP and a microprocessor, etc.

[0056] The memory 4003 may be a ROM (Read Only Memory) or other type of static storage device capable of storing static information and instructions, RAM (Random Access Memory) or other type of dynamic storage device capable of storing information and instructions, or an EEPROM (Electrically Erasable Programmable Read Only Memory), CD-ROM (Compact Disc Read Only Memory) or other optical disc storage, optical disc storage (including compressed optical discs, laser discs, optical discs, digital universal optical discs, Blu-ray discs, etc.), magnetic disk storage media or other magnetic storage devices, or any other medium capable of carrying or storing desired program instructions or code in the form of instructions or data structures and accessible by the electronic device 4000, but not limited thereto.

[0057] The memory 4003 stores computer-readable instructions, and the processor 4001 can read the computer-readable instructions stored in the memory 4003 through the communication bus 4002.

[0058] The computer-readable instructions are executed by one or more processors 4001 to implement the method for constructing the IoT standard object model in the above embodiments.

[0059] Furthermore, this embodiment of the invention provides a storage medium storing computer-readable instructions, which are executed by one or more processors to implement the method for constructing the IoT standard object model as described above.

[0060] Compared with the prior art, the beneficial effects of the present invention are as follows: (1) In the traditional method of building object models, engineers need to spend a lot of time reading, understanding and manually converting device documents. This is a labor-intensive process. This invention fully automates this process by introducing a large language model. The Internet of Things platform only needs to receive the device documents and can generate a complete and standardized object model draft in a short time. This enables the Internet of Things platform to access a large number of new devices at extremely low marginal cost and extremely high speed, shortening the project development cycle from several months to several days, improving the efficiency of object model building, and saving costs. (2) By introducing genetic algorithms for multi-objective optimization, this invention can systematically evaluate and improve the performance of the object model on multiple key performance indicators. This means that the final generated object model is not only functionally correct, but also carefully optimized in terms of network transmission efficiency, data storage cost, and device computing load. This focus on performance ensures that the Internet of Things system can be more stable, efficient and economical in actual operation, avoids resource waste and performance bottlenecks caused by improper model design, and improves the reliability and user experience of the entire system. (3) Traditional static object models cannot cope with the dynamic changes of devices throughout their entire life cycle, such as new functions brought about by firmware upgrades. The active detection and adaptive upgrade mechanism of the object model in this invention can actively sense changes in the environment (device capabilities) and automatically adjust (upgrade the model) to adapt to the changes, so that the IoT platform can easily cope with changes in the device capabilities of IoT devices, and eliminate the tedious work of manual monitoring and manual updating of object models, freeing maintenance personnel from repetitive labor, further improving the efficiency of object model construction, and saving costs.

[0061] The above is a detailed description of the preferred embodiments of the present invention. However, the present invention is not limited to the embodiments described. Those skilled in the art can make various equivalent modifications or substitutions without departing from the spirit of the present invention. All such equivalent modifications or substitutions are included within the scope defined by the claims of this application.

Claims

1. A method for constructing a standard IoT object model, applied to an IoT platform embedded with a large language model, characterized in that, The method for constructing the IoT standard object model includes the following steps: S10, the IoT platform processes unstructured device documents based on a large language model to generate a draft of the device model; S20, the IoT platform uses a genetic algorithm to perform multi-objective optimization on the draft object model in order to generate a standard object model with optimized performance; S30: The IoT platform determines whether the device capabilities of the target IoT device have changed based on the detection command. If so, it automatically upgrades the version of the standard object model; otherwise, the IoT device operates normally.

2. The method for constructing an IoT standard object model according to claim 1, characterized in that, In step S10, the IoT platform is further embedded with a document preprocessing component and a structure generator. The document preprocessing component is connected to the input end of the language model, and the structure generator is connected to the output end of the language model.

3. The method for constructing an IoT standard object model according to claim 2, characterized in that, The specific steps for processing unstructured device documents based on a large language model include: Preprocessing: The document preprocessing component is used to extract text content, clean and segment text from the unstructured device document input by the user in sequence to obtain several text fragments; Key information extraction: Extract device attribute information, service information, and event information from text fragments using a large language model; Object model generation: The extracted key information is mapped to a predefined industry standard framework using a structured generator and the fields are automatically populated to generate a formatted object model draft.

4. The method for constructing an IoT standard object model according to claim 3, characterized in that, In step S20, the specific process of using a genetic algorithm to perform multi-objective optimization on the standard model includes: Encoding and Population Initialization: Encode the parameters of the draft object model into gene sequences and initialize a population containing multiple different draft object models; Evaluation: A multi-dimensional fitness function was designed to quantitatively evaluate the overall performance of each draft model in the population, and the fitness scores of each standard model were calculated by weighting. Iterative optimization: The population is iteratively optimized through genetic operations until the population converges; Decoding: Decode the individual with the highest fitness score in the population and output the corresponding standard model.

5. The method for constructing an IoT standard object model according to claim 4, characterized in that, The genetic operations include: Selection operation: Based on the calculated fitness score, select the individual with the highest fitness score from the current population as the parent; Crossover operation: Recombining the gene sequences of two selected parents to generate two new offspring individuals; Mutation operation: Randomly fine-tuning the gene sequence of newly generated offspring individuals.

6. The method for constructing an IoT standard object model according to claim 1, characterized in that, In step S30, the IoT platform is also equipped with a response parser, a difference analyzer, and a version manager.

7. The method for constructing an IoT standard object model according to claim 6, characterized in that, Step S30, the specific steps of the IoT platform determining whether the device capability of the target IoT device has changed based on the detection command include: The IoT platform sends a probe command to the target IoT device, and the IoT device returns a response command to the IoT platform containing the set of device capabilities of the target IoT device according to a predefined protocol format. The IoT platform uses a response parser to convert response commands into device capability set description objects; The IoT platform uses a difference analyzer to perform a deep comparison between the device capability set description object and the current standard object model of the target IoT device stored in the database to generate a difference report. Based on the content of the difference report, it determines whether the device capability of the target IoT device has changed. When the device capability of the target IoT device changes, the IoT platform will automatically trigger a version upgrade of the standard object model through the version manager.

8. A system for constructing an IoT standard object model, applied to the method for constructing an IoT standard object model as described in any one of claims 1-7, characterized in that, The system for constructing the IoT standard object model includes: The document parsing and draft generation module is used to process unstructured device documents to generate draft object models; The model optimization and evaluation module is used to perform multi-objective optimization on the draft object model to generate a standard object model with optimized performance. The device detection and model upgrade module is used to determine whether the device capabilities of the target IoT device have changed. If so, the standard object model version is automatically upgraded; otherwise, the IoT device operates normally.

9. An electronic device, characterized in that, Includes at least one processor and at least one memory, wherein, The memory stores computer-readable instructions; The computer-readable instructions are executed by one or more processors, causing an electronic device to implement the method for constructing an Internet of Things standard object model as described in any one of claims 1-7.

10. A storage medium having computer-readable instructions stored thereon, characterized in that, The computer-readable instructions are executed by one or more processors to implement the method for constructing an IoT standard object model according to any one of claims 1-7.

Images