数据挖掘|关联分析与Apriori算法详解

数据挖掘|关联分析与Apriori算法

  • 1. 关联分析
    • 2. 关联规则相关概念
      • 2.1 项目
      • 2.2 事务
      • 2.3 项目集
      • 2.4 频繁项目集
      • 2.5 支持度
      • 2.6 置信度
      • 2.7 提升度
      • 2.8 强关联规则
      • 2.9 关联规则的分类
    • 3. Apriori算法
    • 3.1 Apriori算法的Python实现
    • 3.2 基于mlxtend库的Apriori算法的Python实现

1. 关联分析

关联规则分析(Association-rules Analysis)是数据挖掘领域的一个重要方法,它是以某种方式分析数据源,从数据样本集中发现一些潜在有用的信息和不同数据样本之间关系的过程。

关联是指在两个或多个变量之间存在某种规律性,但关联并不一定意味着因果关系。
关联规则是寻找在同一事件中出现的不同项目的相关性,关联分析是挖掘关联规则的过程。
比如在一次购买活动中所买不同商品的相关性。

关联分析即利用关联规则进行数据挖掘。
关联规则是形式如下的一种规则,“在购买计算机的顾客中,有30%的人也同时购买了打印机”。
从大量的商务事务记录中发现潜在的关联关系,可以帮助人们作出正确的商务决策。
关联规则分析于1993年由美国IBM Almaden Research Center 的 Rakesh Agrawal 等人在进行市场购物篮分析时首先提出的,用以发现超市销售数据库中的顾客购买模式,现在已经广泛应用于许多领域。
早期关联分析用于分析零售企业顾客的购物行为模式,所以关联分析又被称为购物篮分析。
关联规则也可用于商品货架布置、销售配置、存货安排、购物路线设计、商品陈列设计、交叉销售以及根据购买模式对用户进行分类等方面。
比较经典的关联规则是啤酒和尿布的故事。

在这里插入图片描述

2. 关联规则相关概念

2.1 项目

集合 I = i 1 , i 2 , . . . , i m I={i_1,i_2,...,i_m} I=i1,i2,...,im称为项集合,其中 m m m为正整数, i k ( k = 1 , 2 , … , m ) i_k(k=1,2,…,m) ikk=12,m)称为项目。
项目是一个从具体问题中抽象出的一个概念。在超市的关联规则挖掘问题中,项目表示各种商品,如旅游鞋等。

2.2 事务

由于在超市的关联规则挖掘中并不关心顾客购买的商品数量和价格等,因此顾客的一次购物可以用该顾客所购买的所有商品的名称来表示,称为事务,所有事务的集合构成关联规则挖掘的数据集,称为事务数据库。
关联规则挖掘的数据库记为 D D D,事务数据库 D D D中的每个元组称为事务。一条事务 T T T I I I中项目的集合。一条事务仅包含其涉及到的项目,而不包含项目的具体信息。在超级市场的关联规则挖掘问题中事务是顾客一次购物所购买的商品,但事务中并不包含这些商品的具体信息,如商品的数量、价格等。

2.3 项目集

项目集是由 I I I中项目构成的集合。若项目集包含的项目数为 k k k,则称此项目集为 k − k- k项目集。任意的项目集 X X X和事务 T T T若满足 T ⊇ X T\supseteq X TX,则称事务 T T T包含项目集 X X X。在超市的关联规则挖掘问题中项目集可以看成一个或多个商品的集合。若某顾客一次购买所对应的事务T包含项目集 X X X,就说该顾客在这次购物中购买了项目集 X X X中的所有商品。

2.4 频繁项目集

对任意的项目集 X X X,若事务数据库 D D D中的事务包含项目集 X X X的比例为 ε \varepsilon ε,则项目集的支持率为 ε \varepsilon ε,记为 s u p p o r t ( X ) = ε support(X)= \varepsilon support(X)=ε,其中包含项目集 X X X的事务数称为项目集 X X X的频度,记为 c o u n t ( X ) count(X) count(X)。若项目集 X X X的支持率大于或等于用户指定的最小支持率(minsupport),则项目集 X X X称为频繁项目集(或大项目集),否则项目集 X X X为非频繁项目集(或小项目集)。如果数据库 D D D中的事务数记为 ∣ D ∣ |D| D,频繁项目集是至少被 ε ∣ D ∣ \varepsilon |D| εD条事务包含的项目集.

2.5 支持度

关联规则是形如 U → V U\rightarrow V UV的规则,其中 U 、 V U、V UV为项集,且 U ∩ V = ∅ U\cap V = \emptyset UV=。项集 U 、 V U、V UV不一定包含于同一个项集合 I I I
关联规则的支持度 s ( U → V ) s(U\rightarrow V) s(UV)和置信度 c ( U → V ) c(U\rightarrow V) c(UV)是度量项目关联的重要指标,它们分别描述了一个关联规则的有用性和确定性。
在事务数据库 D D D中,关联规则 U → V U\rightarrow V UV的支持度为:
s ( U → V ) = s u p p o r t c o u n t ( U ∪ V ) ∣ D ∣ s(U\rightarrow V)= \frac{support_{count}(U\cup V)}{|D|} s(UV)=Dsupportcount(UV)
支持度描述了 X 、 Y X、Y XY这两个事务在事务集 D D D中同时出现(记为 X ∪ Y X\cup Y XY)的概率。

2.6 置信度

关联规则 U → V U\rightarrow V UV的置信度是指同时包含 X 、 V X、V XV的事务数与包含 V V V的事务数之比,它用来衡量关联规则的可信程度。记为:
c ( U → V ) = s u p p o r t c o u n t ( U ∪ V ) s u p p o r t c o u n t ( U ) c(U\rightarrow V)= \frac{support_{count}(U\cup V)}{support_{count}(U)} c(UV)=supportcount(U)supportcount(UV)
其中, s u p p o r t c o u n t ( U ∪ V ) support_{count}(U\cup V) supportcount(UV)是包含项集 U ∪ V U\cup V UV的事务数; s u p p o r t c o u n t ( U ) support_{count}(U) supportcount(U)是包含项集 U U U的事务数;
一般情况下,只有关联规则的置信度大于或等于预设的阈值,就说明了它们之间具有某种程度的相关性,这才是一条有价值的规则。
如果关联规则置信度大于或等于用户给定的最小置信度阈值,则称关联规则是可信的。

2.7 提升度

提升度(Lift)是指当销售一个商品A时,另一个商品B销售率会增加多少。计算公式为:
L i f t ( A → B ) = C d e n c e ( A → B ) s u p p o r t c o u n t ( A ) Lift(A \rightarrow B)=\frac{C_dence(A \rightarrow B)}{support_{count}(A)} Lift(AB)=supportcount(A)Cdence(AB)

假设关联规则’牛奶’ → \rightarrow ’鸡蛋’的置信度为C_dence(’牛奶’=>’鸡蛋’)=2/4,牛奶的支持度S_port(’牛奶’)=3/5,则’牛奶’和’鸡蛋’的支持度Lift(’牛奶’=>’鸡蛋’)=0.83。

  • 当关联规则A=>B的提升度值大于1的时候,说明商品A卖得越多,B也会卖得越多;
  • 当提升度等于1则意味着商品A和B之间没有关联;
  • 当提升度小于1则意味着购买商品A反而会减少B的销量。

2.8 强关联规则

若关联规则 X → Y X\rightarrow Y XY的支持度和置信度分别大于或等于用户指定的最小支持率 m i n s u p p o r t minsupport minsupport和最小置信度 m i n c o n f i d e n c e minconfidence minconfidence,则称关联规则 X → Y X\rightarrow Y XY为强关联规则,否则称关联规则 X → Y X\rightarrow Y XY为弱关联规则。
关联规则挖掘的核心就是要找出事务数据库 D D D中的所有强相关规则。

2.9 关联规则的分类

关联规则可以分为布尔型和数值型。
布尔型关联规则处理的项目都是离散的,显示了这些变量之间的关系。

例如,性别=“女”——>职业=“秘书”。

数值型关联规则可以和多维关联或多层关联规则结合起来。对数值型属性进行处理,参考连续属性离散化方法或统计方法对其进行分割,确定划分的区间个数和区间宽度。数值型关联规则中也可以包含可分类型变量。

例如,性别=“女”——>平均收入>2300, 这里的收入是数值类型,所以是一个数值型关联规则。
基于规则中项目的抽象层次,可以分为单层关联规则和多层关联规则。项目(概念)通常具有层次性。

例如:

  1. 牛奶——>面包[20%, 60%]
  2. 酸牛奶——>黄面包[6%, 50%]

基于规则包含的项目维数,关联规则可以分为单维和多维两种。

单维关联规则处理单个项目的关系,多维关联规则处理多个项目之间的某些关系。

例如:

  1. 单维关联规则:buys(x,“diapers”)——>buys(x,“beers”)[0.5%, 60%]
  2. 多维关联规则:major(x,“CS”)^takes(x,“DB”)——>grade(x,“A”)[1%, 75%]

分离关联规则(dissociation rule),也称为负相关模式。
分离关联规则与一般的关联规则相似,知识在关联规则中出现项目的反转项,在购物篮分析中可发现不在一起购买的商品。

例如,购买牛奶的顾客一般不购买汽水。

3. Apriori算法

Apriori算法的基本思想是找出所有的频繁项集,然后由频繁项集产生强关联规则,这些规则必须满足最小支持度和最小置信度。
Apriori算法一般分为以下两个阶段:

  • 第一阶段:找出所有超出最小支持度的项集,形成频繁项集。
    • 首先通过扫描数据集,产生一个大的候选项集,并计算每个候选项集发生的次数,然后基于预先给定的最小支持度生成一维项集 L 1 L_1 L1。再基于 L 1 L_1 L1和数据集中的事务,产生二维项集 L 2 L_2 L2;依此类推,直到生成 N N N维项集 L N L_N LN,并且已经不可能再生成满足最小支持度的 N + 1 N+1 N+1维项集。这样就依此产生项集 L 1 , L 2 , … , L N {L_1,L_2,…,L_N} L1,L2,,LN
  • 第二阶段:利用频繁项集产生所需的规则。
    • 对给定的 L L L,如果 L L L包含其非空子集 A A A,假设用户给定的最小支持度和最小置信度阈值分别为 m i n S _ p o r t minS\_port minS_port m i n C _ d e n c e minC\_dence minC_dence,并满足 m i n S _ p o r t ( L ) / m i n S _ p o r t ( A ) ≥ m i n C _ d e n c e minS\_port(L)/ minS\_port(A) \geq minC\_dence minS_port(L)/minS_port(A)minC_dence,则产生形式为 A = > L − A A=>L-A A=>LA的规则。

在这两个阶段中,第一阶段是算法的关键。一旦找到了项集,关联规则的导出是自然的。事实上,我们一般只对满足一定的支持度和可信度的关联规则感兴趣。挖掘关联规则的问题就是产生支持度和置信度分别大于用户给定的最小支持度和最小置信度的关联规则。
在这里插入图片描述

3.1 Apriori算法的Python实现

import numpy as np
data_set = np.array([['鸡蛋','面包','西红柿','葱','蒜','牛奶'],
['面包','牛奶'],['鸡蛋','牛奶','豆角'],
['鸡蛋','牛奶','芹菜'],['鸡蛋','西红柿','豆角']],dtype=object)
def get_C1(data_set):
    C1 = set()
    for item in data_set:
        for l in item:
            C1.add(frozenset([l]))
    return C1
#data_set -- 数据集;C-- 候选集;min_support -- 最小支持度
def getLByC(data_set, C, min_support):
    L = {} #频繁项集和支持数
    for c in C:
        for data in data_set:
            if c.issubset(data):
                if c not in L:
                    L[c] = 1
                else:
                    L[c] += 1
    errorKeys=[]
    for key in L:
        support = L[key] / float(len(data_set))
        if support < min_support: #未达到最小支持数
            errorKeys.append(key)
        else:
            L[key] = support
    for key in errorKeys:
        L.pop(key)
    return L
'''
    根据频繁(k-1)项集自身连接产生候选K项集Ck
    并剪去不符合条件的候选
    L -- 频繁K-1项集
'''
def getCByL(L, k):
    len_L = len(L) #获取L的频繁项集数量
    L_keys = list(L.keys()) #获取L的键值
    C = set()
    for i in range(len_L):
        for j in range(1,len_L):
            l1 = list(L_keys[i])
            l1.sort()
            l2 = list(L_keys[j])
            l2.sort()
            if(l1[0:k-2] == l2[0:k-2]):
                C_item = frozenset(l1).union(frozenset(l2)) #取并集
                flag = True
                #判断C_item的子集是否在L_keys中
                for item in C_item:
                    subC = C_item-frozenset([item])#获取C_item的子集
                    if subC not in L_keys:#不在
                        flag = False
                if flag == True:
                    C.add(C_item)
    return C
def get_L(data_set, k, min_support):
    #C1较为特殊,先求
    C1 = get_C1(data_set)
    L1 = getLByC(data_set, C1, min_support)
    support_data = {}
    L = []
    L.append(L1)
    tempL = L1
    for i in range(2, k+1):
        Ci = getCByL(tempL, i)
        tempL = getLByC(data_set,Ci,min_support)
        L.append(tempL)
    for l in L:
        for key in l:
            support_data[key] = l[key]
    return L,support_data
#获取关联规则
def get_rule(L, support_data, min_support, min_conf):
    big_rules = []
    sub_sets= []
    for i in range(0, len(L)):
        for fset in L[i]:
            for sub_set in sub_sets:
                if sub_set.issubset(fset):
                    conf = support_data[fset] / support_data[fset - sub_set]
                    big_rule = (fset - sub_set, sub_set, conf)
                    if conf >= min_conf and big_rule not in big_rules:
                        big_rules.append(big_rule)
            sub_sets.append(fset)
    return big_rules
if __name__ == "__main__":
    min_support = 0.4  #最小支持度
    min_conf = 0.6     #最小置信度
    L,support_data = get_L(data_set, 3, min_support)#获取所有的频繁项集
    big_rule = get_rule(L, support_data, min_support, min_conf) #获取强关联规则
    print('==========所有的频繁项集如下===========')
    for l in L:
        for l_item in l:
            print(l_item, end=' ')
            print('支持度为:%f'%l[l_item])
        print('===========================================')    
    for rule in big_rule:
        print(rule[0],'==>',rule[1],'\t\tconf = ',rule[2])

==========所有的频繁项集如下===========
frozenset({'面包'}) 支持度为:0.400000
frozenset({'豆角'}) 支持度为:0.400000
frozenset({'西红柿'}) 支持度为:0.400000
frozenset({'鸡蛋'}) 支持度为:0.800000
frozenset({'牛奶'}) 支持度为:0.800000
===========================================
frozenset({'西红柿', '鸡蛋'}) 支持度为:0.400000
frozenset({'鸡蛋', '牛奶'}) 支持度为:0.600000
frozenset({'牛奶', '面包'}) 支持度为:0.400000
frozenset({'豆角', '鸡蛋'}) 支持度为:0.400000
===========================================
===========================================
frozenset({'西红柿'}) ==> frozenset({'鸡蛋'}) 		conf =  1.0
frozenset({'牛奶'}) ==> frozenset({'鸡蛋'}) 		conf =  0.7499999999999999
frozenset({'鸡蛋'}) ==> frozenset({'牛奶'}) 		conf =  0.7499999999999999
frozenset({'面包'}) ==> frozenset({'牛奶'}) 		conf =  1.0
frozenset({'豆角'}) ==> frozenset({'鸡蛋'}) 		conf =  1.0

3.2 基于mlxtend库的Apriori算法的Python实现

Sklearn库中没有Apriori算法。但是可以采用Python的第三方库实现Aprior算法发掘关联规则。相关的库有mlxtend机器学习包等,首先需要导入包含Apriori算法的mlxtend包:pip install mlxtend
Apriori()函数常用形式为:
L,suppData=apriori(df, min_support=0.5,use_colnames=False,max_len=None)
参数说明:

  • (1) df:表示给定的数据集。
  • (2) min_support:表示给定的最小支持度。
  • (3) use_colnames:默认False,表示返回的项集,用编号显示。如果值为True则直接显示项名称。
  • (4) max_len:默认是None,表示最大项组合数,不做限制。如果只需要计算两个项集,可将这个值设置为2。

返回值:

  • (1)L:返回频繁项集。
  • (2)suppData:返回频繁项集的相应支持度。

示例代码如下:

from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori
from mlxtend.frequent_patterns import association_rules
import pandas as pd
df_arr = [['鸡蛋','面包','西红柿','葱','蒜','牛奶'],
['面包','牛奶'],['鸡蛋','牛奶','豆角'],
['鸡蛋','牛奶','芹菜'],['鸡蛋','西红柿','豆角']]
#转换为算法可接受模型(布尔值)
te = TransactionEncoder()
df_tf = te.fit_transform(df_arr)
df = pd.DataFrame(df_tf,columns=te.columns_)
#设置支持度求频繁项集
frequent_itemsets = apriori(df,min_support=0.4,use_colnames= True)
#求关联规则,设置最小置信度为0.15
rules = association_rules(frequent_itemsets,metric = 'confidence',min_threshold = 0.6)
#设置最小提升度
rules = rules.drop(rules[rules.lift <0.6].index)
#设置标题索引并打印结果
rules.rename(columns = {'antecedents':'from','consequents':'to','support':'sup','confidence':'conf'},inplace = True)
rules = rules[['from','to','sup','conf','lift']]
print(rules)

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/514536.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【ArcGIS微课1000例】0107:ArcGIS加载在线历史影像服务WMTS

文章目录 一、WMTS历史影像介绍二、ArcGIS加载WMTS服务三、Globalmapper加载WMTS服务一、WMTS历史影像介绍 通过访问历史影响WMTS服务,可以将全球范围内历史影像加载进来,如下所示: WMTS服务: https://wayback.maptiles.arcgis.com/arcgis/rest/services/World_Imagery/WM…

WebKit简介

1、简介&#xff08;WebKit&#xff09; WebKit 是一个开源的浏览器引擎&#xff0c;最初由苹果公司基于KHTML&#xff08;K Desktop Environment的HTML渲染引擎&#xff09;开发&#xff0c;并广泛应用于Safari浏览器&#xff0c;后来也被其他多款浏览器和应用采用。WebKit负…

Ps:匹配颜色

匹配颜色 Match Color命令可以将一个图像的颜色与另一个图像的颜色相匹配。 Ps菜单&#xff1a;图像/调整/匹配颜色 Adjustments/Match Color 匹配颜色命令可匹配多个图像之间、多个图层之间或者多个选区之间的颜色&#xff0c;还可以通过更改亮度和色彩范围以及中和色痕来调整…

MySQL 学习心得和知识总结(五)|MySQL的一般查询日志(general log)

目录结构 注&#xff1a;提前言明 本文借鉴了以下博主、书籍或网站的内容&#xff0c;其列表如下&#xff1a; 1、参考书籍&#xff1a;《PostgreSQL数据库内核分析》 2、参考书籍&#xff1a;《数据库事务处理的艺术&#xff1a;事务管理与并发控制》 3、PostgreSQL数据库仓库…

Java23种设计模式

本文主要是对Java中一些常用的设计模式进行讲解 后期会进行不断的更新&#xff0c;欢迎浏览 23种设计模式 创建型模式&#xff0c;共五种&#xff1a;工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式。结构型模式&#xff0c;共七种&#xff1a;适配器模式、桥接…

显示器and拓展坞PD底层协商

简介&#xff1a; PD显示器或者PD拓展坞方案中&#xff0c;连接显示设备的Type-C端口主要运行在DRP模式&#xff0c;在此模式下可以兼容Source&#xff08;显卡&#xff09;、Sink&#xff08;信号器&#xff09;、DRP&#xff08;手机、电脑&#xff09;模式的显示设备。 Sou…

OpenCASCADE源码分析:总论

OpenCASCADE是20世纪90年代由法国Matra Datavision公司开发的三维曲面/实体造型引擎&#xff0c;目前&#xff0c;国内许多CAE软件将其用作几何模块的开发。 本文拟从系统设计的角度&#xff0c;对OpenCASCADE架构(核心组件、关键流程等)进行概要性总结。 注1&#xff1a;限于…

C语言杂谈

努力扩大自己&#xff0c;以靠近&#xff0c;以触及自身以外的世界 文章目录 什么是定义&#xff1f;什么是声明&#xff1f;什么是赋值&#xff1f;什么是初始化&#xff1f;什么是生命周期&#xff1f;什么是作用域&#xff1f;全局变量&#xff1f;局部变量&#xff1f;size…

TCP/IP通信demo

TCP/IP&#xff08;Transmission Control Protocol/Internet Protocol&#xff09;是一组通信协议&#xff0c;用于在网络上实现数据传输。它是互联网的基础&#xff0c;也被广泛用于局域网和广域网中。TCP/IP协议族由多个协议组成&#xff0c;其中最重要的是TCP和IP。 IP&…

JAVAEE之Spring, Spring Boot 和Spring MVC的关系以及区别

1.Spring, Spring Boot 和Spring MVC的关系以及区别 Spring: 简单来说, Spring 是⼀个开发应⽤框架&#xff0c;什么样的框架呢&#xff0c;有这么⼏个标签&#xff1a;轻量级、⼀ 站式、模块化&#xff0c;其⽬的是⽤于简化企业级应⽤程序开发 Spring的主要功能: 管理对象&am…

【2024红明谷】三道Web题目的记录

红明谷 文章目录 红明谷Web1 | SOLVED LaterWeb2 | UNSOLVEDWeb3 | SOLVED 容器已经关咯&#xff0c;所以有些场景只能靠回忆描述啦&#xff0c;学习为主&#xff0c;题目只是一个载体~ 本次比赛学习为主&#xff0c;确实再一次感受到久违的web题目的魅力了&#xff0c;可能也是…

【SpringCloud】Ribbon 负载均衡

目 录 一.负载均衡原理二.源码跟踪1. LoadBalancerIntercepor2. LoadBalancerClient3. 负载均衡策略 IRule4. 总结 三.负载均衡策略1.负载均衡策略2.自定义负载均衡策略 四.饥饿加载 在 order-service 中 添加了 LoadBalanced 注解&#xff0c;即可实现负载均衡功能&#xff0c…

网络安全基础之网络协议与安全威胁

OSI(OpenSystem Interconnect)&#xff0c;即开放式系统互联。 一般都叫OSI参考模型&#xff0c;是ISO(国际标准化组织)组织在1985年研究的网络互联模型。 网络协议的简介&#xff1a; 定义&#xff1a;协议是网络中计算机或设备之间进行通信的一系列规则集合。 什么是规则?…

Leetcode442. 数组中重复的数据

Every day a Leetcode 题目来源&#xff1a;442. 数组中重复的数据 解法1&#xff1a;将元素交换到对应的位置 由于给定的 n 个数都在 [1,n] 的范围内&#xff0c;如果有数字出现了两次&#xff0c;就意味着 [1,n] 中有数字没有出现过。 因此&#xff0c;我们可以尝试将每一…

【Pt】马灯贴图绘制过程 04-玻璃脏迹

目录 效果 步骤 一、透明玻璃 二、烟熏痕迹 三、粗糙 四、浮尘 效果 步骤 一、透明玻璃 1. 打开纹理集设置&#xff0c;着色器链接选择“新的着色器链接” 在着色器设置中可以看到此时名称为“Main shader &#xff08;Copy&#xff09;” 这里修改名称为“玻璃” 在…

redis群集有三种模式

目录 redis群集有三种模式 redis群集有三种模式 分别是主从同步/复制、哨兵模式、Cluster ●主从复制&#xff1a;主从复制是高可用Redis的基础&#xff0c;哨兵和集群都是在主从复制基础上实现高可用的。主从复制主要实现了数据的多机备份&#xff0c;以及对于读操作的负载均…

C++ 静态库与动态库的生成和使用:基于 VS Studio 生成 newmat 矩阵库的静态库与动态库

文章目录 Part.I IntroductionChap.I 预备知识Chap.II 静态库与动态库区分 Part.II 静态库的生成与使用 (newmat)Chap.I 生成静态库Chap.II 使用静态库 Part.III 动态库的生成与使用 (newmat)Chap.I 生成动态库Chap.II 使用动态库 Part.IV 文件内容Chap.I test.cpp (静态库)Cha…

5G智慧地铁数字孪生可视化平台,推进铁路行业数字化转型

随着科技的快速发展&#xff0c;5G智慧地铁数字孪生可视化平台正逐渐成为铁路行业数字化转型的重要推动力。巨蟹数科数字孪生平台集成了5G通信技术、大数据分析、云计算和人工智能等先进技术&#xff0c;通过构建数字孪生模型&#xff0c;实现对地铁运营全过程的实时监控、预测…

rocketmq的运维

1. admintool创建topic的时候 -o 的用法含义 https://rocketmq.apache.org/zh/docs/4.x/producer/03message2/ 有关orderMessageEnable和returnOrderTopicConfigToBroker的设置可以参考 https://blog.csdn.net/sdaujsj1/article/details/115741572 -c configFile通过-c命令指…

大模型prompt技巧——思维链(Chain-of-Thought)

1、Zero-shot、One-shot、Few-shot 与fintune prompt的时候给出例子答案&#xff0c;然后再让模型回答。 2、zero-shot-CoT “Let’s think step by step”有奇迹效果 3、多数投票提高CoT性能——自洽性&#xff08;Self-consistency&#xff09; 多个思维链&#xff0c;然后取…