【数据挖掘实战】——中医证型的关联规则挖掘(Apriori算法)

2023-02-27 09:41 414人阅读评论(0)

一、背景和挖掘目标

项目地址：Datamining_project: 数据挖掘实战项目代码

一、背景和挖掘目标

1、问题背景

中医药治疗乳腺癌有着广泛的适应证和独特的优势。从整体出发，调整机体气血、阴阳、脏腑功能的平衡，根据不同的临床证候进行辨证论治。确定“先证而治”的方向：即后续证侯尚未出现之前，需要截断恶化病情的哪些后续证侯。
找出中医症状间的关联关系和诸多症状间的规律性，并且依据规则分析病因、预测病情发展以及为未来临床诊治提供有效借鉴。能够帮助乳腺癌患者手术后体质的恢复、生存质量的改善，有利于提高患者的生存机率。

2、传统方法的缺陷

中医辨证极为灵活，虽能够处理患者的复杂多变的临床症状，体现出治疗优势。但缺乏统一的规范，难以做到诊断的标准化。
疾病的复杂性和体质的差异性，造成病人大多是多种证素兼夹复合。临床医师可能会被自身的经验所误导，单纯对症治疗，违背了中医辨证论治的原则。
同一种疾病的辨证分型，往往都有不同见解，面对临床症状不典型的患者，初学者很难判断。

3、原始数据情况

患者信息属性说明：针对患者的信息，对每个属性进行相应说明。

患者信息数据：包含患者的基本信息以及病理症状等。

4、挖掘目标

借助三阴乳腺癌患者的病理信息，挖掘患者的症状与中医证型之间的关联关系；
对截断治疗提供依据，挖掘潜性证素。

二、分析方法和过程

1、初步分析

针对乳腺癌患者，可运用中医截断疗法进行治疗，在辨病的基础上围绕各个病程的特殊证候先证而治型；
依据医学指南，将乳腺癌辨证统一化，为六种证型。且患者在围手术期、围化疗期、围放疗期和内分泌治疗期等各个病程阶段，基本都会出现特定的临床症状。
通过关联规则算法，挖掘各中医证素与乳腺癌TNM分期之间的关系。探索不同分期阶段的三阴乳腺癌患者的中医证素分布规律，以及截断病变发展、先期干预的治疗思路，指导三阴乳腺癌的中医临床治疗。

2、总体过程

第1步：数据获取

采用调查问卷的形式对数据进行搜集。

拟定调查问卷表并形成原始指标表；
定义纳入标准与排除标准；
将收集回来的问卷表整理成原始数据。

问卷调查需要满足两个条件:

问卷信息采集者均要求有中医诊断学基础，能准确识别病人的舌苔脉象，用通俗的语言解释医学术语，并确保患者信息填写准确；
问卷调查对象必须是三阴乳腺癌患者，他们是某省中医院以及肿瘤医院等各大医院各病程阶段1253位三阴乳腺癌患者。

拟定调查问卷表并形成原始指标表:

定义纳入标准与排除标准:

标准	详细信息
纳入标准	病理诊断为乳腺癌。病历完整，能提供既往接受检查、治疗等相关信息，包括发病年龄、月经状态、原发肿瘤大小、区域淋巴结状态、组织学类型、组织学分级、 P53 表达、 VEGF 表达等，作为临床病理及肿瘤生物学的特征指标。没有精神类疾病，能自主回答问卷调查者。
排除标准	本研究中临床、病理、肿瘤生物学指标不齐全者。存在第二肿瘤（非乳腺癌转移）。精神病患者或不能自主回答问卷调查者。不愿意参加本次调查者或中途退出本次调查者。填写的资料无法根据诊疗标准进行分析者。

第2步：数据预处理

1. 数据清洗：收回的问卷中，存在无效的问卷，为了便于模型分析，需要对其进行清洗处理。

2.属性规约：删除不相关属性，选取其中六种证型得分、患者编号和TNM分期属性。

患者编号	肝气郁结证得分	热毒蕴结证得分	冲任失调证得分	气血两虚证得分	脾胃虚弱证得分	肝肾阴虚证得分	TNM分期
20140001	7	30	7	23	18	17	H4
20140179	12	34	12	16	19	5	H4
……	……	……	……	……	……	……	……
20140930	4	4	12	12	7	15	H4

3. 数据变换

属性构造：为了更好的反应出中医证素分布的特征，采用证型系数代替具体单证型的证素得分，证型相关系数计算公式如下：证型系数 = 该证型得分／该证型总分。

数据离散化：Apriori关联规则算法无法处理连续性数值变量，对数据进行离散化。本例采用聚类算法对各个证型系数进行离散化处理，将每个属性聚成四类。

聚类离散化，最后的result的格式为：

      1           2           3           4
A     0    0.178698    0.257724    0.351843
An  240  356.000000  281.000000   53.000000
即(0, 0.178698]有240个，(0.178698, 0.257724]有356个，依此类推。


  
   
    
     
    
    
     
      from __future__ 
      import print_function
     
    
   
    
     
    
    
     
      import pandas 
      as pd
     
    
   
    
     
    
    
     
      from sklearn.cluster 
      import KMeans  
      # 导入K均值聚类算法
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      datafile = 
      '../data/data.xls'  
      # 待聚类的数据文件
     
    
   
    
     
    
    
     
      processedfile = 
      '../tmp/data_processed.xls'  
      # 数据处理后文件
     
    
   
    
     
    
    
     
      typelabel = {
      u'肝气郁结证型系数': 
      'A', 
      u'热毒蕴结证型系数': 
      'B', 
      u'冲任失调证型系数': 
      'C', 
      u'气血两虚证型系数': 
      'D',
     
    
   
    
     
    
    
                  
      u'脾胃虚弱证型系数': 
      'E', 
      u'肝肾阴虚证型系数': 
      'F'}
     
    
   
    
     
    
    
     
      k = 
      4  
      # 需要进行的聚类类别数
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # 读取数据并进行聚类分析
     
    
   
    
     
    
    
     
      data = pd.read_excel(datafile)  
      # 读取数据
     
    
   
    
     
    
    
     
      keys = 
      list(typelabel.keys())
     
    
   
    
     
    
    
     
      result = pd.DataFrame()
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      if __name__ == 
      '__main__':  
      # 判断是否主窗口运行，如果是将代码保存为.py后运行，则需要这句，如果直接复制到命令窗口运行，则不需要这句。
     
    
   
    
     
    
    
         
      for i 
      in 
      range(
      len(keys)):
     
    
   
    
     
    
    
             
      # 调用k-means算法，进行聚类离散化
     
    
   
    
     
    
    
             
      print(
      u'正在进行“%s”的聚类...' % keys[i])
     
    
   
    
     
    
    
     
              kmodel = KMeans(n_clusters=k, n_jobs=
      4)  
      # n_jobs是并行数，一般等于CPU数较好
     
    
   
    
     
    
    
     
              kmodel.fit(data[[keys[i]]].as_matrix())  
      # 训练模型
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              r1 = pd.DataFrame(kmodel.cluster_centers_, columns=[typelabel[keys[i]]])  
      # 聚类中心
     
    
   
    
     
    
    
     
              r2 = pd.Series(kmodel.labels_).value_counts()  
      # 分类统计
     
    
   
    
     
    
    
     
              r2 = pd.DataFrame(r2, columns=[typelabel[keys[i]] + 
      'n'])  
      # 转为DataFrame，记录各个类别的数目
     
    
   
    
     
    
    
     
              r = pd.concat([r1, r2], axis=
      1).sort(typelabel[keys[i]])  
      # 匹配聚类中心和类别数目
     
    
   
    
     
    
    
     
              r.index = [
      1, 
      2, 
      3, 
      4]
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              r[typelabel[keys[i]]] = pd.rolling_mean(r[typelabel[keys[i]]], 
      2)  
      # rolling_mean()用来计算相邻2列的均值，以此作为边界点。
     
    
   
    
     
    
    
     
              r[typelabel[keys[i]]][
      1] = 
      0.0  
      # 这两句代码将原来的聚类中心改为边界点。
     
    
   
    
     
    
    
     
              result = result.append(r.T)
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
          result = result.sort()  
      # 以Index排序，即以A,B,C,D,E,F顺序排
     
    
   
    
     
    
    
     
          result.to_excel(processedfile)

第3步：构建模型

1、中医证型关联模型：

采用关联规则算法，输入建模参数，探索乳腺癌患者 TNM 分期与中医证型系数之间的关系，挖掘他们之间的关联关系。注：结合实际业务分析且需要多次设置，确定最小支持度与最小置信度。本例的输入参数为：最小支持度6% 、最小置信度 75%。


  
   
    
     
    
    
     
      import pandas 
      as pd
     
    
   
    
     
    
    
     
      from sklearn.cluster 
      import KMeans
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      datafile = 
      'data.xls'  
      # 待聚类的数据文件
     
    
   
    
     
    
    
     
      processedfile = 
      'data_processed.xlsx'  
      # 处理后的文件
     
    
   
    
     
    
    
     
      typelabel = {
      '肝气郁结证型系数':
      'A', 
      '热毒蕴结证型系数':
      'B', 
      '冲任失调证型系数':
      'C', 
      '气血两虚证型系数':
      'D', 
      '脾胃虚弱证型系数':
      'E',
     
    
   
    
     
    
    
                  
      '肝肾阴虚证型系数':
      'F'}
     
    
   
    
     
    
    
     
      k = 
      4  
      # 需要的聚类类别数
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # 读取数据并且进行聚类
     
    
   
    
     
    
    
     
      data = pd.read_excel(datafile)
     
    
   
    
     
    
    
     
      keys = 
      list(typelabel.keys())
     
    
   
    
     
    
    
     
      result = pd.DataFrame()
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      if __name__ == 
      '__main__':  
      # 判断是否主窗口运行
     
    
   
    
     
    
    
         
      '''
     
    
   
    
     
    
    
     
       当.py文件被直接运行时，if __name__ == '__main__'之下的代码块将被运行；
     
    
   
    
     
    
    
     
       当.py文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。
     
    
   
    
     
    
    
     
       '''
     
    
   
    
     
    
    
         
      for i 
      in 
      range(
      len(keys)): 
      # 调用k-means算法,进行聚类离散化
     
    
   
    
     
    
    
             
      print(
      '正在进行 "%s" 的聚类...' % keys[i])
     
    
   
    
     
    
    
     
              kmodel = KMeans(n_clusters=k)
     
    
   
    
     
    
    
     
              kmodel.fit(data[[keys[i]]].values)  
      # 训练模型
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              r1 = pd.DataFrame(kmodel.cluster_centers_, columns=[typelabel[keys[i]]])  
      # 聚类中心
     
    
   
    
     
    
    
     
              r2 = pd.Series(kmodel.labels_).value_counts()  
      # 分类统计
     
    
   
    
     
    
    
     
              r2 = pd.DataFrame(r2, columns=[typelabel[keys[i]]+
      'n'])  
      # 转为DataFrame，记录各个类别的数目
     
    
   
    
     
    
    
     
              r = pd.concat([r1, r2], axis=
      1).sort_values(by= typelabel[keys[i]])  
      # 匹配聚类中心和类别数目,并按值排序
     
    
   
    
     
    
    
     
              r.index = [
      1, 
      2, 
      3, 
      4]
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
              r[typelabel[keys[i]]] = r[typelabel[keys[i]]].rolling(
      2).mean()  
      # rolling().mean()用来计算相邻2列的均值，以此作为边界点
     
    
   
    
     
    
    
     
              r[typelabel[keys[i]]][
      1] = 
      0.0  
      # 将原来的聚类中心改为边界点
     
    
   
    
     
    
    
     
              result = result.append(r.T)
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
          result = result.sort_index()  
      # 以index排序，即以ABCDEF排序
     
    
   
    
     
    
    
     
          result.to_excel(processedfile)

聚类之后的结果：

Apriori关联规则算法


  
   
    
     
    
    
     
      #-*- coding: utf-8 -*-
     
    
   
    
     
    
    
     
      from __future__ 
      import print_function
     
    
   
    
     
    
    
     
      import pandas 
      as pd
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      #自定义连接函数，用于实现L_{k-1}到C_k的连接
     
    
   
    
     
    
    
     
      def 
      connect_string(
      x, ms):
     
    
   
    
     
    
    
     
        x = 
      list(
      map(
      lambda i:
      sorted(i.split(ms)), x))
     
    
   
    
     
    
    
     
        l = 
      len(x[
      0])
     
    
   
    
     
    
    
     
        r = []
     
    
   
    
     
    
    
       
      for i 
      in 
      range(
      len(x)):
     
    
   
    
     
    
    
         
      for j 
      in 
      range(i,
      len(x)):
     
    
   
    
     
    
    
           
      if x[i][:l-
      1] == x[j][:l-
      1] 
      and x[i][l-
      1] != x[j][l-
      1]:
     
    
   
    
     
    
    
     
              r.append(x[i][:l-
      1]+
      sorted([x[j][l-
      1],x[i][l-
      1]]))
     
    
   
    
     
    
    
       
      return r
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      #寻找关联规则的函数
     
    
   
    
     
    
    
     
      def 
      find_rule(
      d, support, confidence, ms = u'--'):
     
    
   
    
     
    
    
     
        result = pd.DataFrame(index=[
      'support', 
      'confidence']) 
      #定义输出结果
     
    
   
    
     
    
    
       
     
    
   
    
     
    
    
     
        support_series = 
      1.0*d.
      sum()/
      len(d) 
      #支持度序列
     
    
   
    
     
    
    
     
        column = 
      list(support_series[support_series > support].index) 
      #初步根据支持度筛选
     
    
   
    
     
    
    
     
        k = 
      0
     
    
   
    
     
    
    
       
     
    
   
    
     
    
    
       
      while 
      len(column) > 
      1:
     
    
   
    
     
    
    
     
          k = k+
      1
     
    
   
    
     
    
    
         
      print(
      u'\n正在进行第%s次搜索...' %k)
     
    
   
    
     
    
    
     
          column = connect_string(column, ms)
     
    
   
    
     
    
    
         
      print(
      u'数目：%s...' %
      len(column))
     
    
   
    
     
    
    
     
          sf = 
      lambda i: d[i].prod(axis=
      1, numeric_only = 
      True) 
      #新一批支持度的计算函数
     
    
   
    
     
    
    
         
     
    
   
    
     
    
    
         
      #创建连接数据，这一步耗时、耗内存最严重。当数据集较大时，可以考虑并行运算优化。
     
    
   
    
     
    
    
     
          d_2 = pd.DataFrame(
      list(
      map(sf,column)), index = [ms.join(i) 
      for i 
      in column]).T
     
    
   
    
     
    
    
         
     
    
   
    
     
    
    
     
          support_series_2 = 
      1.0*d_2[[ms.join(i) 
      for i 
      in column]].
      sum()/
      len(d) 
      #计算连接后的支持度
     
    
   
    
     
    
    
     
          column = 
      list(support_series_2[support_series_2 > support].index) 
      #新一轮支持度筛选
     
    
   
    
     
    
    
     
          support_series = support_series.append(support_series_2)
     
    
   
    
     
    
    
     
          column2 = []
     
    
   
    
     
    
    
         
     
    
   
    
     
    
    
         
      for i 
      in column: 
      #遍历可能的推理，如{A,B,C}究竟是A+B-->C还是B+C-->A还是C+A-->B？
     
    
   
    
     
    
    
     
            i = i.split(ms)
     
    
   
    
     
    
    
           
      for j 
      in 
      range(
      len(i)):
     
    
   
    
     
    
    
     
              column2.append(i[:j]+i[j+
      1:]+i[j:j+
      1])
     
    
   
    
     
    
    
         
     
    
   
    
     
    
    
     
          cofidence_series = pd.Series(index=[ms.join(i) 
      for i 
      in column2]) 
      #定义置信度序列
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      for i 
      in column2: 
      #计算置信度序列
     
    
   
    
     
    
    
     
            cofidence_series[ms.join(i)] = support_series[ms.join(
      sorted(i))]/support_series[ms.join(i[:
      len(i)-
      1])]
     
    
   
    
     
    
    
         
     
    
   
    
     
    
    
         
      for i 
      in cofidence_series[cofidence_series > confidence].index: 
      #置信度筛选
     
    
   
    
     
    
    
     
            result[i] = 
      0.0
     
    
   
    
     
    
    
     
            result[i][
      'confidence'] = cofidence_series[i]
     
    
   
    
     
    
    
     
            result[i][
      'support'] = support_series[ms.join(
      sorted(i.split(ms)))]
     
    
   
    
     
    
    
       
     
    
   
    
     
    
    
     
        result = result.T.sort_values([
      'confidence',
      'support'], ascending = 
      False) 
      #结果整理，输出
     
    
   
    
     
    
    
       
      print(
      u'\n结果为：')
     
    
   
    
     
    
    
       
      print(result)
     
    
   
    
     
    
    
       
     
    
   
    
     
    
    
       
      return result

首先设置建模参数最小支持度、最小置信度，输入建模样本数据。然后采用Apriori关联规则算法对建模的样本数据进行分析，以模型参数设置的最小支持度、最小置信度以及分析目标作为条件，如果所有的规则都不满足条件，则需要重新调整模型参数，否则输出关联规则结果。


  
   
    
     
    
    
     
      import pandas 
      as pd
     
    
   
    
     
    
    
     
      # from apriori import * # 导入自行编写的高效的Apriori函数
     
    
   
    
     
    
    
     
      import time  
      # 导入时间库用来计算用时
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      inputfile = 
      'apriori.txt'  
      # 输入事务集文件
     
    
   
    
     
    
    
     
      data = pd.read_csv(inputfile, header=
      None, dtype=
      object)
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      start = time.perf_counter()  
      # 计时开始(新版本不支持clock，用time.perf_counter()替换)
     
    
   
    
     
    
    
     
      print(
      '\n转换原始数据至0-1矩阵')
     
    
   
    
     
    
    
     
      ct = 
      lambda x : pd.Series(
      1, index=x[pd.notnull(x)])  
      # 转换0-1矩阵的过渡函数，即将标签数据转换为1
     
    
   
    
     
    
    
     
      b = 
      map(ct, data.values)  
      # 用map方式执行
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # Dataframe参数不能是迭代器
     
    
   
    
     
    
    
     
      c = 
      list(b)
     
    
   
    
     
    
    
     
      data = pd.DataFrame(c).fillna(
      0)  
      # 实现矩阵转换，除了1外，其余为空，空值用0填充
     
    
   
    
     
    
    
     
      end = time.perf_counter()  
      # 计时结束
     
    
   
    
     
    
    
     
      print(
      '\n转换完毕,用时:%0.2f秒' % (end-start))
     
    
   
    
     
    
    
     
      del b  
      # 删除中间变量b，节省内存
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      support = 
      0.06  
      # 最小支持度
     
    
   
    
     
    
    
     
      confidence = 
      0.75  
      # 最小置信度
     
    
   
    
     
    
    
     
      ms = 
      '---'  
      # 连接符，默认'--'，用来区分不同元素，如A--B，需要保证原始表格不含有该字符
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      start = time.perf_counter()  
      # 计时开始
     
    
   
    
     
    
    
     
      print(
      '\n开始搜索关联规则')
     
    
   
    
     
    
    
     
      find_rule(data, support, confidence, ms)
     
    
   
    
     
    
    
     
      end = time.perf_counter()  
      # 计时结束
     
    
   
    
     
    
    
     
      print(
      '\n转换完毕,用时:%0.2f秒' % (end-start))

2、模型分析

TNM分期为H4期的三阴乳腺癌患者证型主要为肝肾阴虚证、热毒蕴结证、肝气郁结证和冲任失调，H4期患者肝肾阴虚证和肝气郁结证的临床表现较为突出，其置信度最大达到87.96%。

3、模型应用

根据关联结果，结合实际情况，为患者未来的症治提供有效的帮助。

a)IV期患者出现肝肾阴虚证之表现时，应当以滋养肝肾为补，清热解毒为攻，攻补兼施，截断热毒蕴结证的出现。

b)患者多有肝气郁结证的表现，治疗时须重视心理调适，对其进行身心一体的综合治疗。

三、思考和总结

1、Python的流行库中都没有自带的关联规则函数，相应的关联规则函数，函数依赖于Pandas库。该函数是很高效的（就实现Apriori算法而言），可作为工具函数在需要时使用。

2、Apriori算法的关键两步为找频繁集与根据置信度筛选规则，明白这两步过程后，才能清晰的编写相应程序。
3、本案例采用聚类的方法进行数据离散化，其他的离散化方法如：等距、等频、决策树、基于卡方检验等，试比较各个方法的优缺点。

转载：https://blog.csdn.net/lxwssjszsdnr_/article/details/129108557

查看评论

飞道的博客

飞道的博客

个人资料

文章分类

文章存档

阅读排行

评论排行

推荐文章

【数据挖掘实战】——中医证型的关联规则挖掘(Apriori算法)

一、背景和挖掘目标

1、问题背景

2、传统方法的缺陷

3、原始数据情况

4、挖掘目标

二、分析方法和过程

1、初步分析

2、总体过程

第1步：数据获取

第2步：数据预处理

第3步：构建模型

三、思考和总结

* 以上用户言论只代表其个人观点，不代表本网站的观点或立场