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

已于 2024-05-10 19:17:20 修改
阅读量1.1k 收藏 26
点赞数 17
文章标签： 语言模型 人工智能 自然语言处理
于 2024-05-09 17:37:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaojiawan/article/details/138595107
版权

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

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

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

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

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

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

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

中间语言的选择

  1. JSON
  2. 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。模板的格式是有一些讲究的。

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

        我们 曾经尝试将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"
        }
    ]
}

结果是正确。

第二个JSON 模板的实验

添加了Device 模板，构建一个远程IO 模块的模型

// device template
{
    "Name": "Name of device",
    "Type": "Device",
    "Description": "description of the device ",
    "Children": [
        // Components of the Device
    ]
}
//Component Template
{
    "Name": "Name Of The Component",
    "Type": "ComponentType",
    "Description": "Description of The Component",
    "Children": [
        //FunctionGroup ,ParameterSet ,MethodSet of Component.if exist
    ],
    "References": [
        {
            "Type": "Organizes",
            "Target": " Name of Component  referenced "
        }
    ]
}
//FunctionGroup Template
{
    "Name": "Name of FunctionGroup ",
    "Description": "description of the FunctionGroup",
    "Type": "FunctionGroupType",
    "References": [
        {
            "Type": "Organizes",
            "Target": " Name of Property，Variable Method in the referenced  TopologyElement "
        }
    ]
},
//Parameterset Template
{
    "Name": "Parameterset",
    "Type": "ObjectType",
    "Description": "the parameters of the component",
    "Parameters": []
}
//Methodset Template
{
    "Name": "Methodset",
    "Type": "ObjectType",
    "Description": "the methods of the component",
    "Methods": []
}

 产品信息

这一次我们使用类似技术手册的方式编写产品的信息

远程IO模块的设备
该远程IO模块的名称是ABC_Controller ，是ABC 公司生产的AT232 远程IO控制器。
ABC_Controller 包含了三个组件，它们分别是DIO_16,DIN_16,DOUT_16和AIN_8组件
组件
1 DIO_16 组件
  该组件没有参数集，功能组和方法集，只有两个引用，引用的类型是Orgnazie，引用的对象分别是 DIN_16 和DOUT_16
2 DIN_16 组件
  它是一个16 通道 数字输入模块，其中包含了参数集，功能组和方法集
  功能组的名称是Operation，包含了两个引用，分别指向 Read和Configuration 方法
  参数集中包含了一个变量，称为DigitalRead Bool 类型
  方法集中包含了两个方法，分别的 Read和Configuration。
  其中
   Read方法 的输入参数为Index， 数据类型是Int16
   Configuration 方法没有输入参数，输出参数为 Status，数据类型是String
 2 DOUT_16 组件
  它是一个16 通道 数字输出模块，其中包含了参数集，功能组和方法集
  功能组的名称是Operation，包含了两个引用，分别指向 Read和Configuration 方法
  参数集中包含了一个变量，称为DigitalOutput, Bool 类型
  方法集中包含了两个方法，分别的 Write和Configuration。
  其中
   Write方法 有两个输入参数分别为
       Index， 数据类型是Int16
       Value   数据类型是Bool
   Configuration 方法没有输入参数，输出参数为 Status，数据类型是String  
3 AIN_8 组件
   它是一个8 通道模拟量输入模块，其中包含了参数集和方法集
   参数集中包含了一个变量，名称为Analog ,它是一个数组类型，数组单元的类型是Double，数组的维度是1，数组的长度为8
   方法集中包含了两个方法，分别的 Read和Configuration。
     其中
   Read方法 的输入参数为Index， 数据类型是Int16，输出参数为ReadOut，Double 类型
   Configuration 方法没有输入参数，输出参数为 Status，数据类型是String

结果

{
  "Name": "ABC_Controller",
  "Type": "Device",
  "Description": "AT232 Remote IO Controller by ABC Company",
  "Children": [
    {
      "Name": "DIO_16",
      "Type": "ComponentType",
      "Description": "Virtual Component including DIN_16 and DOUT_16",
      "Children": [
        {
          "Name": "Operation",
          "Description": "Function group for DIO_16 component",
          "Type": "FunctionGroupType",
          "References": [
            {
              "Type": "Organizes",
              "Target": "Read"
            },
            {
              "Type": "Organizes",
              "Target": "Configuration"
            }
          ]
        },
        {
          "Name": "Parameterset",
          "Type": "ObjectType",
          "Description": "Parameters of DIO_16 component",
          "Parameters": [
            {
              "Name": "DigitalRead",
              "DataType": "Bool"
            }
          ]
        },
        {
          "Name": "Methodset",
          "Type": "ObjectType",
          "Description": "Methods of DIO_16 component",
          "Methods": [
            {
              "Name": "Read",
              "Arguments": {
                "InputArgument": [
                  {
                    "Name": "Index",
                    "DataType": "Int16"
                  }
                ]
              }
            },
            {
              "Name": "Configuration",
              "Arguments": {
                "OutputArgument": [
                  {
                    "Name": "Status",
                    "DataType": "String"
                  }
                ]
              }
            }
          ]
        }
      ],
      "References": [
        {
          "Type": "Organizes",
          "Target": "DIN_16"
        },
        {
          "Type": "Organizes",
          "Target": "DOUT_16"
        }
      ]
    },
    {
      "Name": "DIN_16",
      "Type": "ComponentType",
      "Description": "16-channel Digital Input Module",
      "Children": [
        {
          "Name": "Operation",
          "Description": "Function group for DIN_16 component",
          "Type": "FunctionGroupType",
          "References": [
            {
              "Type": "Organizes",
              "Target": "Read"
            },
            {
              "Type": "Organizes",
              "Target": "Configuration"
            }
          ]
        },
        {
          "Name": "Parameterset",
          "Type": "ObjectType",
          "Description": "Parameters of DIN_16 component",
          "Parameters": [
            {
              "Name": "DigitalRead",
              "DataType": "Bool"
            }
          ]
        },
        {
          "Name": "Methodset",
          "Type": "ObjectType",
          "Description": "Methods of DIN_16 component",
          "Methods": [
            {
              "Name": "Read",
              "Arguments": {
                "InputArgument": [
                  {
                    "Name": "Index",
                    "DataType": "Int16"
                  }
                ]
              }
            },
            {
              "Name": "Configuration",
              "Arguments": {
                "OutputArgument": [
                  {
                    "Name": "Status",
                    "DataType": "String"
                  }
                ]
              }
            }
          ]
        }
      ]
    },
    {
      "Name": "DOUT_16",
      "Type": "ComponentType",
      "Description": "16-channel Digital Output Module",
      "Children": [
        {
          "Name": "Operation",
          "Description": "Function group for DOUT_16 component",
          "Type": "FunctionGroupType",
          "References": [
            {
              "Type": "Organizes",
              "Target": "Write"
            },
            {
              "Type": "Organizes",
              "Target": "Configuration"
            }
          ]
        },
        {
          "Name": "Parameterset",
          "Type": "ObjectType",
          "Description": "Parameters of DOUT_16 component",
          "Parameters": [
            {
              "Name": "DigitalOutput",
              "DataType": "Bool"
            }
          ]
        },
        {
          "Name": "Methodset",
          "Type": "ObjectType",
          "Description": "Methods of DOUT_16 component",
          "Methods": [
            {
              "Name": "Write",
              "Arguments": {
                "InputArgument": [
                  {
                    "Name": "Index",
                    "DataType": "Int16"
                  },
                  {
                    "Name": "Value",
                    "DataType": "Bool"
                  }
                ]
              }
            },
            {
              "Name": "Configuration",
              "Arguments": {
                "OutputArgument": [
                  {
                    "Name": "Status",
                    "DataType": "String"
                  }
                ]
              }
            }
          ]
        }
      ]
    },
    {
      "Name": "AIN_8",
      "Type": "ComponentType",
      "Description": "8-channel Analog Input Module",
      "Children": [
        {
          "Name": "Parameterset",
          "Type": "ObjectType",
          "Description": "Parameters of AIN_8 component",
          "Parameters": [
            {
              "Name": "Analog",
              "DataType": "Double[8]"
            }
          ]
        },
        {
          "Name": "Methodset",
          "Type": "ObjectType",
          "Description": "Methods of AIN_8 component",
          "Methods": [
            {
              "Name": "Read",
              "Arguments": {
                "InputArgument": [
                  {
                    "Name": "Index",
                    "DataType": "Int16"
                  }
                ],
                "OutputArgument": [
                  {
                    "Name": "ReadOut",
                    "DataType": "Double"
                  }
                ]
              }
            },
            {
              "Name": "Configuration",
              "Arguments": {
                "OutputArgument": [
                  {
                    "Name": "Status",
                    "DataType": "String"
                  }
                ]
              }
            }
          ]
        }
      ]
    }
  ]
}

 感觉大模型更加理解文本描述的内容。

结论

   自然语言生成形式化语言是令人兴奋的课题，具体实现过程中，设计模板是关键。模板中应该包含描述和提示信息。设计模板的工作需要对OPC UA 的信息模型有十分详细的了解。

  实验表明，XML 的模板看来要比JSON 模板更好一点。

姚家湾
关注
  • 17
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[2] OPC UA信息建模
Kunaly
05-29 8521
OPC UA信息建模为什么要对信息建模OPC UA信息建模的基础原则节点和引用对象、变量和方法对象和变量类型 为什么要对信息建模 OPC UA的基础是数据传输和信息建模。 相对于传统的OPC,数据传输已经是艺术级的、平台独立的、安全的、技术可靠的技术了,同时信息建模的能力也获得了大幅度提高。传统OPC只能提供纯数据,例如,由温度传感器测量出来的温度。要了解已提供的数据是什么语义,可以利用的信息就只是测点的名称和一些类似测量值的工程单位的基本信息。OPC UA提供更有效的展示数据语义的可能性。除了由传统OPC
OPC UA简介
宁静致远的博客
10-22 1万+
OPC UA 的本质前言面向对象程序设计分布式对象OPC 协议重新认识OPC UA1 信息模型(Information model)使用OPC UA的几大原因1. 组件对象模型（COM）/分布式组件对象模型（DCOM）的终止2. COM 的局限3. OPC 通信穿过防火墙4. 在非视窗平台使用OPC5.通过Web服务实现跨平台的OPC通信6. 统一数据模型7. 支持复杂数据结构8. 保证通信不丢失数据9. 对非授权数据访问而增加的保护10. 支持新的命令调用 原文链接：https://blog.csdn.n
《OPC UA实践》 - 阅读笔记 2 OPC UA信息模型及建模
参谋谋的博客
09-23 2567
系列目录 - 阅读笔记 1 工业4.0基础与OPC UA的实践 目录系列目录第二章 OPC UA理论基础2.5 OPC UA信息模型及建模信息模型实例信息模型创建步骤：2.6 在生产线中的引入 第二章 OPC UA理论基础 2.5 OPC UA信息模型及建模 关于信息模型的基础二手知识可以看我之前的一篇博文：OPC UA 学习笔记(总览介绍与信息模型相关) OPC UA服务器的地址空间是一个完全互联的、以图状拓扑呈现的信息模型。 信息模型：包括节点、节点本身特性以及之间的相互连接。 节点集合：一组
OPC UA 信息模型云库简介
姚家湾博客
02-06 878
OPC基金会宣布推出与清洁能源和智能制造创新研究所（CESMII）共同开发的全球可用的UA云库。凭借其多云架构，UA 云库见证了所有主要云供应商利用开放接口的贡献，并可用于共享、查找和协作 OPC UA 信息模型。如今，UA云库已经包含超过65个OPC UA信息模型，这些模型由各个公司以及AutoID、DEXPI、MDIS、MTConnect等国际标准组织创建，以及30多个VDMA工作组创建，作为其OPC UA配套规范工作的一部分。双方成立“OPC UA 云库”联合工作组 （JWG）。
OPC_OPC UA规范_概述与概念
三千幻想乡
07-06 3532
OPC UA是广泛适用于工业领域（industrial domains）的组件，例如工业传感器和致动器（actuator）、控制系统、制造执行系统和企业信息化系统，包括IIoT（Industrial Internet of Things，工业物联网）、机器对机器通信（Machine to machine，M2M），以及工业4.0和中国制造2025。这些系统旨在交换信息，并对工业过程发送命令和控制。OPC UA定义了一个通用的基础模型，以使这种信息交换更便捷。
KIMI大模型浏览器插件
04-25
本插件为kimi在谷歌浏览器上的插件，添加插件后可以使用kimi的AIGC功能。
基于 LLM 大语言模型的知识库问答系统，1Panel 官方出品
05-28
MaxKB 是一款基于 LLM 大语言模型的...多模型支持：支持对接主流的大模型，包括 Ollama 本地私有大模型（如 Meta Llama 3、qwen 等）、通义千问、OpenAI、Azure OpenAI、Kimi、智谱 AI、讯飞星火和百度千帆大模型等。
《AI大模型应用》--一个 Obsidian 插件，支持 Kimi、豆包、阿里千问、百度千帆、智谱 等等.zip
最新发布
07-19
个人深耕AI大模型应用领域积累的成果，希望对您有所帮助。有大模型账号、环境问题、AI大模型技术应用落地方案等相关问题，欢迎详聊，能为您解决问题是我的荣幸！ 个人深耕AI大模型应用领域积累的成果，希望对您有所...
基于 LLM 大语言模型的知识库问答系统 MaxKB =Max Knowledge Base，旨在成为企业的最强大脑
06-29
MaxKB 是一款基于 LLM 大语言模型的...多模型支持：支持对接主流的大模型，包括 Ollama 本地私有大模型（如 Meta Llama 3、qwen 等）、通义千问、OpenAI、Azure OpenAI、Kimi、智谱 AI、讯飞星火和百度千帆大模型等。
ChatMASTER支持一键切换主流大模型ChatGPT(3.54.0)模型月之暗面(Kimi)文心一言通义千问讯飞
04-15
**ChatMASTER：一键切换主流大语言模型**ChatMASTER 是一款强大的语言处理工具，它允许用户在多个主流大语言模型之间无缝切换，包括：* ChatGPT (3.54.0) * 月之暗面 (Kimi)* 文心一言* 通义千问* 讯飞**一键切换**...
opc统一架构（opc ua）server-client SDK及实例
05-14
OPC统一架构 (OPC UA)， 涵盖了OPC 实时数据访问规范 (OPC DA)、OPC历史数据访问规范 (OPC HDA)、 OPC 报警事件访问规范 (OPC A&E) 和OPC安全协议 (OPC Security) 的不同方面， 但在其基础之上进行了功能扩展。 OPC UA，是在传统OPC技术取得很大成功之后的又一个突破，让数据采集、信息模型化以及工厂底层与企业层面之间的通讯更加安全、可靠。
OPCUA2AAS:可以从其信息模型生成Industry 4.0 Asset Admin Shell的OPC UA服务器
03-13
OPCUA2AAS 可以从其信息模型生成Industry 4.0 Asset Admin Shell的OPC UA服务器
OPC UA 学习笔记(总览介绍与信息模型相关)
参谋谋的博客
05-24 3258
目录一 简介常用缩写术语：历史特征信息模型地址空间与节点网络结点属性Meta ModelCNC基本信息模型Robotics 信息模型参考目录 一 简介 本位将我前段时间所作分享PPT改成博文，文字数量会比较少，参考内容见文末。 因为对工业互联网领域不熟，所以有任何疑问或者问题欢迎指出。 OPC UA是由 OPC基金会提出的一套工业标准。 OPC是OLE for Process Control的缩写。 OLE（Object Linking and Embedding）。 该标准分为三大部分，13份文档，如图
构建OPC UA 可执行模型（1）
姚家湾博客
07-31 1551
当OPC UA 信息模型来构建行为模型时，需要在OPC UA基础上构建描述行为逻辑的信息模型。可以参考IEC61131-3 PLCopen以及IEC61499 的建模方法。在行为模型的背后需要一个运行时（RunTIme）。通过运行时能够使OPC UA 行为模型中的数据和计算方法流动起来。本文介绍了我们构建IEC61499 OPCUA 运行时的方案和某些考虑。 将IEC61499 基于事件的功能块建模方法融入OPC UA 信息模型。有助于IEC61499 以一种全新的方式进入工程应用领域。 ..
OPC UA 信息模型
h_sn9999的专栏
09-13 1610
信息模型(Information model) OPC UA 使用了对象（objects）作为过程系统表示数据和活动的基础。对象包含了变量，事件和方法，它们通过引用（reference）来互相连接。这个概念和面向对象程序设计方法非常相似。 OPC UA 信息模型是节点的网络（Network of Node,），或者称为结构化图（graph），由节点(node)和引用(References)组成，这种结构图称之为OPC UA 的地址空间。这种图形结构可以描述各种各样的结构化信息(对象)。 节点(n.
OPC UA基本概念结构
热门推荐
fsnAltria的博客
01-30 1万+
OPC UA基本概念结构 标签（空格分隔）： 工控 OPC 本文摘自《OPC统一架构》，作者：Wolfgang Mahnke • Stefan-Helmut Leitner•Matthias Damm OPC UA建模的基本概念是节点以及节点之间的引用。节点可以根据不同的用途归属于不同的节点类别(NodeClass)，一些节点代表实例，另一些代表类型等等。 属性(Attritu
opc ua 开源库实现
my393661的博客
05-14 3593
open62541 mark 留待后用
OPC UA学习心得 — 3 对象、变量和方法
hbin5110209161的博客
09-05 8888
对象，变量和方法 在OPC UA中，最重要的节点类别是对象，变量和方法。 1. 节点类别为对象 节点类别为对象的节点用于（构成）地址空间结构。 对象不包含数据，使用变量为对象公开数值。 对象可用于分组管理对象、变量或方法（变量和方法总属于一个对象）。 对象也可以是一个事件通知器（设定EventNotifier属性），客户端可以订阅事件通知器来接收事件（事件在地址空间中是不可见的，被绑定到对象）。...
KIMI大模型架构图
04-26
KIMI大模型是CSDN自主研发的一个基于深度学习的文本生成模型，用于生成高质量的技术问答。以下是KIMI大模型的架构图： 1. 输入处理层：接收用户输入的问题，并进行预处理，例如分词、去除停用词等。 2. 特征提取层：将预处理后的问题转化为向量表示，常用的方法包括词嵌入（Word Embedding）和句子嵌入（Sentence Embedding）。 3. 知识检索层：使用倒排索引等技术，从海量的技术知识库中检索出相关的问题与答案。 4. 答案生成层：基于检索到的相关问题与答案，结合用户输入的问题，通过序列到序列模型（Sequence-to-Sequence Model）生成候选答案。 5. 答案排序层：对生成的候选答案进行排序，选择最优的答案作为最终输出。 6. 输出处理层：将最终答案进行格式化处理，返回给用户。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值