python灰色关联度分析_灰色关联分析的Python实例

基本思想

确定参考数据列和若干个比较数据列的几何形状相似程度来判断其联系是否紧密,它反映了曲线之间的关联程度

写在前面pd.read_csv不需要去头

pd.DataFrame用于定义如字面意思的数据框架,数据结构,也就是有几列,列的index是什么,列名是什么,其中的数据是什么等等

pd.DataFrame赋予变量的iloc方法是按数字索引来取值,loc是按索引名来取值

输入:四个以上样本容量的数据

输出:这几个变量之间的关联程度

实例代码# 佛了。不总结了,把它当黑箱处理吧

# 反正我能得到结果就行┑( ̄Д  ̄)┍

import pandas as pd

import numpy as np

def gra_one(data_frame, m=0):

gray = data_frame

gray = (gray - gray.min()) / (gray.max() - gray.min())

# 标准要素,iloc取列

std = gray.iloc[:, m]

# 比较要素

ce = gray.iloc[:, 0:]

n = ce.shape[0]

m = ce.shape[1]

# 与标准要素比较,相减

a = np.zeros([m, n])

for i in range(m):

for j in range(n):

a[i, j] = abs(ce.iloc[j, i] - std[j])

# 取出矩阵中最大值和最小值

c = np.amax(a)

d = np.amin(a)

# 计算值

result = np.zeros([m, n])

for i in range(m):

for j in range(n):

result[i, j] = (d+0.5*c)/(a[i, j]+0.5*c)

# 求均值,得到灰色关联值

result2 = np.zeros(m)

for i in range(m):

result2[i] = np.mean(result[i, :])

RT = pd.DataFrame(result2)

return RT

def gra(data_frame):

list_columns = [str(s) for s in range(len(data_frame.columns)) if s not in [None]]

df_local = pd.DataFrame(columns=list_columns)

for i in range(len(data_frame.columns)):

# 按列进行的操作

df_local.iloc[:, i] = gra_one(data_frame, i)[0]

return df_local

if __name__ == '__main__':

wine = pd.read_csv("1.csv")

data_wine_gra = gra(wine)

data_wine_gra.to_csv("C:/Users/Herrrb/Desktop/result1.csv")

效果图

处理前:

5-1.png

样本容量为63

处理后这七个量的关联程度

5-2.png

参考文章

  • 0
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是一个简单的 Python 实现 Apriori 关联规则算法的示例代码: ```python def create_C1(data_set): """ 生成候选项集 C1 :param data_set: 数据集 :return: 候选项集 C1 """ C1 = [] for transaction in data_set: for item in transaction: if [item] not in C1: C1.append([item]) C1.sort() return list(map(frozenset, C1)) def scan_D(D, Ck, min_support): """ 计算候选项集 Ck 中的项集在数据集 D 中的支持度,并返回支持度大于等于 min_support 的项集 :param D: 数据集 :param Ck: 候选项集 :param min_support: 最小支持度 :return: 支持度大于等于 min_support 的项集,以及所有项集的支持度字典 """ ss_cnt = {} for tid in D: for can in Ck: if can.issubset(tid): ss_cnt[can] = ss_cnt.get(can, 0) + 1 num_items = float(len(D)) ret_list = [] support_data = {} for key in ss_cnt: support = ss_cnt[key] / num_items if support >= min_support: ret_list.insert(0, key) support_data[key] = support return ret_list, support_data def apriori_gen(Lk, k): """ 根据频繁项集 Lk 生成候选项集 Ck+1 :param Lk: 频繁项集 Lk :param k: 项集大小 :return: 候选项集 Ck+1 """ ret_list = [] len_Lk = len(Lk) for i in range(len_Lk): for j in range(i + 1, len_Lk): L1 = list(Lk[i])[:k - 2] L2 = list(Lk[j])[:k - 2] L1.sort() L2.sort() if L1 == L2: ret_list.append(Lk[i] | Lk[j]) return ret_list def apriori(data_set, min_support=0.5): """ Apriori 算法主函数 :param data_set: 数据集 :param min_support: 最小支持度 :return: 所有频繁项集,以及所有项集的支持度字典 """ C1 = create_C1(data_set) D = list(map(set, data_set)) L1, support_data = scan_D(D, C1, min_support) L = [L1] k = 2 while len(L[k - 2]) > 0: Ck = apriori_gen(L[k - 2], k) Lk, sup_k = scan_D(D, Ck, min_support) support_data.update(sup_k) L.append(Lk) k += 1 return L, support_data def generate_rules(L, support_data, min_confidence=0.7): """ 根据频繁项集及其支持度字典,生成关联规则 :param L: 频繁项集列表 :param support_data: 支持度字典 :param min_confidence: 最小置信度 :return: 满足最小置信度的关联规则 """ big_rule_list = [] for i in range(1, len(L)): for freq_set in L[i]: H1 = [frozenset([item]) for item in freq_set] if i > 1: rules_from_conseq(freq_set, H1, support_data, big_rule_list, min_confidence) else: calc_confidence(freq_set, H1, support_data, big_rule_list, min_confidence) return big_rule_list def calc_confidence(freq_set, H, support_data, brl, min_confidence=0.7): """ 计算置信度并筛选出满足最小置信度要求的关联规则 :param freq_set: 频繁项集 :param H: 可出现在规则右部的项集列表 :param support_data: 支持度字典 :param brl: 关联规则列表 :param min_confidence: 最小置信度 """ pruned_h = [] for conseq in H: conf = support_data[freq_set] / support_data[freq_set - conseq] if conf >= min_confidence: print(freq_set - conseq, '-->', conseq, 'conf:', conf) brl.append((freq_set - conseq, conseq, conf)) pruned_h.append(conseq) return pruned_h def rules_from_conseq(freq_set, H, support_data, brl, min_confidence=0.7): """ 根据当前规则右部的项集列表,生成新的候选规则右部的项集列表 :param freq_set: 频繁项集 :param H: 可出现在规则右部的项集列表 :param support_data: 支持度字典 :param brl: 关联规则列表 :param min_confidence: 最小置信度 """ m = len(H[0]) if len(freq_set) > (m + 1): Hmp1 = apriori_gen(H, m + 1) Hmp1 = calc_confidence(freq_set, Hmp1, support_data, brl, min_confidence) if len(Hmp1) > 1: rules_from_conseq(freq_set, Hmp1, support_data, brl, min_confidence) ``` 以上代码实现了 Apriori 算法的主要功能,包括生成候选项集、计算支持度、生成频繁项集、计算置信度、生成关联规则等。通过调用 `apriori()` 函数和 `generate_rules()` 函数,可以得到所有频繁项集和满足最小置信度要求的关联规则。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值