利用大语言模型（KIMI）生成OPC UA 信息模型

在大语言模型没有出现之前，人们更倾向使用图形化工具或者基于窗口的软件来构建信息模型，图形化工具能够直观地表达信息模型中各元素之间的相互关系。但是图形化工具也有缺点，当描述一个复杂的信息模型时，图形会变得非常复杂和庞大。而且图形通常难以修改，复制和重用。基于CAD软件设计工程模型是非常耗费精力的“体力活”，加班熬夜的工作都是在CAD 软件的界面前渡过的。

但是，如果使用形式化语言来描述信息模型也并不轻松。形式化语言的语法有严格的规则，文档编排的主要精力都耗费在语法的检查和排错，而模型的构建只是极少的一部分。

以chatGPT为代表的大语言模型（LLM）出现，给构建信息模型提供了新的高效率方式，使用自然语言描述信息模型描述信息模型，如同AI 生成程序设计语言一样令人向往。

在传统计算机信息系统中，形式语言通过形式化方式描述语法，例如计算机语言使用BNF范式（巴科斯范式）描述语言，XML 使用了Schema 描述格式，而JSON 模型使用模板描述模型。

目前chatGPT 还没有直接理解BNF 范式的能力，它通过模板来学习和生成语言的。因此，为了让chatGPT 大模型生成形式化信息模型，需要为chatGPT 提供各种模板。

另一方面，形式化信息模型是为机器设计的，是一种相对底层的语言，为了能够使用自然语言描述模型，设计一种“高级"的中间语言更加方便。

利用大语言模型生成OPC UA 信息模型

中间语言的选择

JSON
XML

模型的规范

OPC UA 信息模型的描述语言是XML语言。格式为NodeSet2.xml。NodeSet.2.xml 文件能够直接导入OPC UA 服务器。

NodeSet2 文档十分繁琐，不适合人阅读和程序生成，为此，OPC UA 基金会开发了一个UAModelCompiler 程序，该程序使用一种DesignModel.xml 文档格式，UAModelCompiler 软件能够将DesignModel 文档转换成为NodeSet.xml 文档和C#的类定义。

例子：对象类型的定义。

  <opc:ObjectType SymbolicName="GenericControllerType" BaseType="ua:BaseObjectType">
        <opc:Description>A generic PID controller</opc:Description>
        <opc:Children>
            <opc:Property SymbolicName="Measurement" DataType="ua:Double" />
            <opc:Property SymbolicName="SetPoint" DataType="ua:Double" AccessLevel="ReadWrite" MinimumSamplingInterval="1" />
            <opc:Property SymbolicName="ControlOut" DataType="ua:Double" />
        </opc:Children>
    </opc:ObjectType>

我们在实验中选择了DesignModel 的规范来定义OPCUA 的模型。

基于ModelDesign的模型生成

模板的构建

为了让chatGPT 能够理解模型的规范，需要提供模型的模板（templates），而不是schema。模板的格式是有一些讲究的。

添加注释
模板中的内容也是提示

我们曾经尝试将UAModelCompiler 项目中的SampleDesign.xml (一个ModelDesign 的例子）上传给kimi，但是kimi无法构建模型。

模板的例子

实验中构建了一个基于ModelDesign格式的XML模板。

<! Object template -->
<Object SymbolicName="Name" TypeDefinition="TypeDefinition">
    <Children>
<! elements of The Object -->    
        <Children>
 <! Property template -->
            <Property SymbolicName="Value">
                <DefaultValue>
                  <!  the 'Float' is DataType  ,'0' is  DefaultValue ,should replaceed By DataType and DefaultValue Of the Property -->
                    <uax:Float>0</uax:Float>
                </DefaultValue>
            </Property>
<! Variable template -->
<Variable SymbolicName="Name" DataType="DataType" TypeDefinition="TypeDefinition"></Variable>

<! Method template -->
<Method SymbolicName="Name of Method ">
    <Description>Description of the Method</Description>
    <InputArguments>
      <Argument Name="Name" DataType="DataType">
        <Description>Description of the Argument</Description>
      </Argument>
    </InputArguments>
    <OutputArguments>
      <Argument Name="Name" DataType="DataType">
        <Description>Description of the Argument</Description>
      </Argument>
    </OutputArguments>
  </Method>
<! Refernses template -->
    <References>
      <Reference>
        <ReferenceType>Reference Type</ReferenceType>
        <TargetId>Target  of The reference </TargetId>
      </Reference>
    </References>
<! ObjectType Template -->
  <ObjectType SymbolicName="Name Of The Type" BaseType="BaseType Of The Type">
    <Children>
 <! elements of The ObjectType --> 
    </Children>
  </ObjectType> 

  <! VariableType template -->
    <opc:VariableType SymbolicName="Name of The Type" BaseType="BaseType of The Type" DataType="DataType Of The Type">
    <opc:Description>Description of The VariableType</opc:Description>
  </opc:VariableType>

自然语言描述的模型

第一个模型：
    类型：对象
    名称:传感器
    类型定义:BaseObject
    对象成员
        温度传感器
                类型：对象
                类型定义:SensorType
                名称:温度传感器
                Property：
                    名称:Temperature
                    初始值:12.23
                    数据类型:Double
                Method:
                    Name:Invert
                    Description: Result=-Arg1
                    InputArguments:
                        Argument
                            Name:"Arg1",
                            DataType:Double
                    OutputArguments:
                        Argument
                            Name:"Result",
                            DataType:Double
                References:
                Reference:
                        type：Connected
                        Target：Humidity
        湿度传感器
            类型:对象
            类型定义：SensorType
            名称：湿度传感器
            对象成员：
                类型：Variable   
                名称: Humidity
                数据类型  Float
                初始值：90

 
第二个模型： 
        名称：控制器类型
        类型：对象类型
        基类型：BaseObjectType
        描述：一个控制器类型
        Property：
                名称:Voltage
                初始值:0
                数据类型:Double

kimi 的提示

你是一个模型构建师，请根据提供的模板，构建信息模型

kimi的回答

<!-- 第一个模型：传感器 -->
<Object SymbolicName="Sensors" TypeDefinition="BaseObject">
    <Children>
        <!-- 温度传感器 -->
        <Object SymbolicName="TemperatureSensor" TypeDefinition="SensorType">
            <Children>
                <Property SymbolicName="Temperature" DataType="Double" ValueRank="Scalar">
                    <DefaultValue>
                        <uax:Double>12.23</uax:Double>
                    </DefaultValue>
                </Property>
                <Method SymbolicName="Invert">
                    <Description>Result=-Arg1</Description>
                    <InputArguments>
                        <Argument Name="Arg1" DataType="Double">
                            <Description>Input argument for the Invert method.</Description>
                        </Argument>
                    </InputArguments>
                    <OutputArguments>
                        <Argument Name="Result" DataType="Double">
                            <Description>Output argument for the Invert method.</Description>
                        </Argument>
                    </OutputArguments>
                </Method>
                <References>
                    <Reference ReferenceType="Connected">
                        <TargetId>Humidity</TargetId>
                    </Reference>
                </References>
            </Children>
        </Object>
        <!-- 湿度传感器 -->
        <Object SymbolicName="HumiditySensor" TypeDefinition="SensorType">
            <Children>
                <Variable SymbolicName="Humidity" DataType="Float" ValueRank="Scalar">
                    <DefaultValue>
                        <uax:Float>90</uax:Float>
                    </DefaultValue>
                </Variable>
            </Children>
        </Object>
    </Children>
</Object>

<!-- 第二个模型：控制器类型 -->
<ObjectType SymbolicName="ControllerType" BaseType="BaseObjectType" IsAbstract="false">
    <Children>
        <Property SymbolicName="Voltage" DataType="Double" ValueRank="Scalar">
            <DefaultValue>
                <uax:Double>0</uax:Double>
            </DefaultValue>
        </Property>
    </Children>
</ObjectType>

使用JSON 模板

我们也实验了使用JSON 模板构建信息模型。

模板

// Object template
{
    "Name": "The Name Of The Object",
    "Type": "Object",
    "Description": "Description of The Object",
    "Children": [
        //The Elements of the Object
    ]
}
// Property template 
{
    "Name": "The Name of Property",
    "DataType": "DataType of Property",
}
//Variable Template
{
    "Name": "The Name of Variable",
    "Type": "Variable",
    "Description": "Description of The Variable",
    "DataType": "The DataType of Variable",
    "Value": "The Default Value of The Variable"
}
//Method Template
{
    "Name": "The Name of The Method",
    "Type": "Method",
    "Arguments": {
        "InputArgument": [
            {
                "Name": "The Name Of the Argument",
                "DataType": "DataType of The Argument",
            }
        ],
        "OutputArgument": [
            {
                "Name": "The Name Of the Argument",
                "DataType": "DataType of The Argument",
            }
        ],
    }
}
//References Template
{
    "Type": "References",
    "Reference": [
        {
            "Type": "Type Of the Reference",
            "Target": " Name of Element  referenced"
        }
    ]
}

自然语言的信息


第一个模型：
    类型：对象
    名称:Sensor
    类型定义:BaseObject
    对象成员
        温度传感器
                类型：对象
                类型定义:SensorType
                名称:TemperatureSensor
                对象的成员：
                  1 属性
                    名称:Temperature
                    类型：Property
                    初始值:12.23
                    数据类型:Double
                  2 方法
                        名称:Invert
                        Description: Result=-Arg1
                        InputArguments:
                            Argument
                                Name:"Arg1",
                                DataType:Double,
                        OutputArguments:
                            Argument
                                Name:"Result",
                                DataType:Double
                   3 References:
                            type：Connected
                            Target：Humidity
        湿度传感器
            类型:对象
            类型定义：SensorType
            名称：湿度传感器
            对象成员：
                类型：Variable   
                名称: Humidity
                数据类型  Float
                初始值：90

 
第二个模型： 
        名称：控制器类型
        类型：对象类型
        基类型：BaseObjectType
        描述：一个控制器类型
        Property：
                名称:Voltage
                初始值:0
                数据类型:Double

kimi 的提示

根据JSON 模板，根据提供的信息构建信息模型

kimi 的回答

//第一个模型：Sensor对象
{
    "Name": "Sensor",
    "Type": "Object",
    "Description": "BaseObject",
    "Children": [
        {
            "Name": "TemperatureSensor",
            "Type": "Object",
            "Description": "SensorType",
            "Children": [
                {
                    "Name": "Temperature",
                    "Type": "Property",
                    "DataType": "Double",
                    "Value": "12.23"
                },
                {
                    "Name": "Invert",
                    "Type": "Method",
                    "Arguments": {
                        "InputArgument": [
                            {
                                "Name": "Arg1",
                                "DataType": "Double"
                            }
                        ],
                        "OutputArgument": [
                            {
                                "Name": "Result",
                                "DataType": "Double"
                            }
                        ]
                    },
                    "Description": "Result=-Arg1"
                },
                {
                    "Type": "References",
                    "Reference": [
                        {
                            "Type": "Connected",
                            "Target": "Humidity"
                        }
                    ]
                }
            ]
        },
        {
            "Name": "Humidity",
            "Type": "Variable",
            "Description": "Humidity Sensor",
            "DataType": "Float",
            "Value": "90"
        }
    ]
}
//第二个模型：控制器类型
{
    "Name": "ControllerType",
    "Type": "ObjectType",
    "BaseType": "BaseObjectType",
    "Description": "A controller type",
    "Children": [
        {
            "Name": "Voltage",
            "Type": "Property",
            "InitialValue": "0",
            "DataType": "Double"
        }
    ]
}

结果是正确的