数据处理和分析之关联规则学习：Association Rule Mining：数据预处理与清洗

kkchenkx

于 2024-10-06 15:45:00 发布

阅读量425

点赞数 15

分类专栏：数据挖掘文章标签：算法数据挖掘关联规则开发语言

本文链接：https://blog.csdn.net/2401_87715305/article/details/142722177

版权

数据挖掘专栏收录该内容

146 篇文章 0 订阅

订阅专栏

数据处理和分析之关联规则学习：Association Rule Mining：数据预处理与清洗

在这里插入图片描述

数据预处理基础

数据清洗的重要性

在进行关联规则学习（Association Rule Mining）之前，数据预处理是至关重要的一步。数据清洗，作为预处理的一部分，旨在消除数据集中的噪声、不一致性和冗余，确保数据的质量，从而提高分析结果的准确性和可靠性。数据清洗的重要性体现在以下几个方面：

提高数据质量：通过清洗，可以去除错误、重复和不完整的数据，确保模型训练在高质量的数据集上。
减少计算资源消耗：清洗后的数据集更小、更精炼，可以减少计算资源的消耗，提高算法的运行效率。
增强模型的准确性：干净的数据可以减少模型的偏差，提高预测或分析的准确性。

缺失值处理方法

数据集中的缺失值是常见的问题，处理缺失值的方法有多种，包括删除、填充和预测。

删除

删除包含缺失值的记录是最简单直接的方法，但可能会导致数据量的减少，影响分析结果。

import pandas as pd

# 读取数据
data = pd.read_csv('data.csv')

# 删除包含缺失值的行
data_cleaned = data.dropna()

填充

填充缺失值可以使用平均值、中位数、众数或基于模型的预测值。

使用平均值填充

# 使用平均值填充缺失值
data['Age'].fillna(data['Age'].mean(), inplace=True)

使用中位数填充

# 使用中位数填充缺失值
data['Age'].fillna(data['Age'].median(), inplace=True)

使用众数填充

# 使用众数填充缺失值
data['Age'].fillna(data['Age'].mode()[0], inplace=True)

预测

使用机器学习模型预测缺失值，这种方法更为复杂，但可以提供更准确的填充值。

from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestRegressor

# 使用随机森林预测缺失值
imputer = SimpleImputer(strategy='mean')
data['Age'] = imputer.fit_transform(data[['Age']])

# 创建随机森林模型
rf = RandomForestRegressor()
rf.fit(data[['Age', 'Sex', 'Pclass']], data['Fare'])

# 预测并填充缺失的Fare值
data['Fare'].fillna(rf.predict(data[['Age', 'Sex', 'Pclass']]), inplace=True)

异常值检测与处理

异常值是指数据集中与其他数据点显著不同的值，它们可能由测量错误、数据录入错误或极端事件引起。异常值的检测和处理对于保持数据集的准确性和一致性至关重要。

箱线图检测

箱线图是一种常用的可视化工具，用于检测数据集中的异常值。

import matplotlib.pyplot as plt

# 绘制箱线图
plt.boxplot(data['Age'])
plt.show()

Z-Score检测

Z-Score是一种统计学方法，用于识别偏离平均值超过一定标准差的数据点。

from scipy import stats

# 计算Z-Score
z_scores = stats.zscore(data['Age'])

# 标记异常值
outliers = (z_scores > 3) | (z_scores < -3)

# 处理异常值，例如删除
data_cleaned = data[~outliers]

IQR检测

IQR（四分位数范围）是另一种检测异常值的有效方法，它基于数据的分布而不是平均值和标准差。

# 计算IQR
Q1 = data['Age'].quantile(0.25)
Q3 = data['Age'].quantile(0.75)
IQR = Q3 - Q1

# 定义异常值的边界
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# 处理异常值
data_cleaned = data[(data['Age'] > lower_bound) & (data['Age'] < upper_bound)]

数据标准化技术

数据标准化是将数据转换为统一尺度的过程，这对于许多机器学习算法的性能至关重要。

Min-Max标准化

Min-Max标准化将数据缩放到0到1的范围内。

# Min-Max标准化
data['Age'] = (data['Age'] - data['Age'].min()) / (data['Age'].max() - data['Age'].min())

Z-Score标准化

Z-Score标准化将数据转换为标准正态分布。

# Z-Score标准化
data['Age'] = (data['Age'] - data['Age'].mean()) / data['Age'].std()

小数定标标准化

小数定标标准化通过移动小数点来缩放数据。

# 小数定标标准化
max_abs = data['Age'].abs().max()
data['Age'] = data['Age'] / (10 ** int(np.floor(np.log10(max_abs))))

通过以上步骤，我们可以确保数据集的质量，为后续的关联规则学习提供坚实的基础。数据预处理是一个迭代过程，可能需要多次调整和优化，以达到最佳的数据质量。

关联规则学习简介

关联规则学习是一种在大数据集中发现有趣的关系或相关性的机器学习方法，主要用于市场篮子分析、推荐系统、以及生物信息学等领域。本教程将深入探讨Apriori算法、FP-growth算法，以及关联规则的评估指标，并通过一个市场篮子分析案例来具体说明这些概念的应用。

Apriori算法原理

Apriori算法是最早用于关联规则学习的算法之一，其核心思想是基于频繁项集的性质，即如果一个项集是频繁的，那么它的所有子集也应该是频繁的。算法通过迭代的方式，从1-项集开始，逐步构建k-项集，直到无法找到更多的频繁项集为止。

示例代码

# 导入所需库
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori

# 假设我们有以下交易数据
transactions = [
    ['牛奶', '面包', '黄油'],
    ['面包', '苹果'],
    ['牛奶', '面包', '苹果'],
    ['面包', '黄油'],
    ['牛奶', '苹果', '黄油']
]

# 使用TransactionEncoder对数据进行编码
te = TransactionEncoder()
te_ary = te.fit(transactions).transform(transactions)
df = pd.DataFrame(te_ary, columns=te.columns_)

# 应用Apriori算法
frequent_itemsets = apriori(df, min_support=0.4, use_colnames=True)
print(frequent_itemsets)

解释

在上述代码中，我们首先定义了一个交易数据集，然后使用TransactionEncoder将其转换为适合Apriori算法的格式。最后，我们调用apriori函数，设置最小支持度为0.4，以找出频繁项集。

FP-growth算法概述

FP-growth算法是另一种用于关联规则学习的高效算法，它通过构建一个FP树来压缩数据集，从而减少扫描数据集的次数。FP树是一种前缀树，能够存储交易数据的压缩版本，使得频繁项集的发现更加高效。

示例代码

from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import fpgrowth

# 使用与Apriori算法相同的交易数据
te_ary = te.fit(transactions).transform(transactions)
df = pd.DataFrame(te_ary, columns=te.columns_)

# 应用FP-growth算法
frequent_itemsets = fpgrowth(df, min_support=0.4, use_colnames=True)
print(frequent_itemsets)

解释

这段代码展示了如何使用FP-growth算法来发现频繁项集。与Apriori算法类似，我们首先对交易数据进行编码，然后调用fpgrowth函数，设置相同的最小支持度，以找出频繁项集。

关联规则的评估指标

关联规则的评估通常涉及两个主要指标：支持度（Support）和置信度（Confidence）。支持度表示一个项集在所有交易中出现的频率，而置信度则衡量一个规则的可靠性，即在包含前件的交易中，后件也出现的概率。

示例代码

from mlxtend.frequent_patterns import association_rules

# 使用Apriori算法找到的频繁项集
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.7)
print(rules)

解释

在找到频繁项集后，我们使用association_rules函数来生成关联规则。这里，我们设置了置信度的最小阈值为0.7，这意味着我们只保留那些置信度至少为70%的规则。

市场篮子分析案例

市场篮子分析是关联规则学习的一个典型应用，它帮助零售商理解顾客的购买行为，从而制定更有效的营销策略。

示例代码

# 假设我们有以下市场篮子数据
market_basket = [
    ['牛奶', '面包', '黄油'],
    ['面包', '苹果'],
    ['牛奶', '面包', '苹果'],
    ['面包', '黄油'],
    ['牛奶', '苹果', '黄油']
]

# 使用TransactionEncoder对数据进行编码
te = TransactionEncoder()
te_ary = te.fit(market_basket).transform(market_basket)
df = pd.DataFrame(te_ary, columns=te.columns_)

# 应用Apriori算法找到频繁项集
frequent_itemsets = apriori(df, min_support=0.4, use_colnames=True)

# 生成关联规则
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.7)

# 打印结果
print(rules)

解释

在这个案例中，我们使用了市场篮子数据集，首先通过TransactionEncoder进行编码，然后使用Apriori算法找到频繁项集，最后生成关联规则。通过分析这些规则，零售商可以发现哪些商品经常一起被购买，从而优化商品布局或推出捆绑销售策略。

通过以上内容，我们不仅了解了Apriori算法和FP-growth算法的基本原理，还掌握了如何使用这些算法进行关联规则学习，以及如何评估和应用这些规则。这为深入研究市场篮子分析和其他关联规则学习的应用提供了坚实的基础。

数据清洗实践

数据清洗是数据预处理的关键步骤，旨在提高数据质量，确保分析结果的准确性和可靠性。本教程将深入探讨数据清洗的几个核心方面：去除重复记录、数据类型转换、文本数据清洗、以及时间序列数据预处理。

去除重复记录

原理

数据集中经常会出现重复的记录，这可能是由于数据采集过程中的错误或数据源的重复性。重复记录的存在会误导分析结果，因此在数据预处理阶段，去除重复记录是必要的。

实践

在Python中，使用Pandas库可以轻松地识别和删除重复记录。

示例代码

import pandas as pd

# 创建一个包含重复记录的数据框
data = {
    'item': ['bread', 'milk', 'bread', 'butter', 'milk', 'bread'],
    'quantity': [2, 1, 2, 1, 1, 2],
    'date': ['2023-01-01', '2023-01-01', '2023-01-01', '2023-01-02', '2023-01-02', '2023-01-03']
}
df = pd.DataFrame(data)

# 打印原始数据框
print("原始数据框:")
print(df)

# 去除重复记录
df_unique = df.drop_duplicates()

# 打印去重后的数据框
print("去重后的数据框:")
print(df_unique)

解释

上述代码首先创建了一个包含重复记录的DataFrame。然后，使用drop_duplicates()函数去除重复记录。默认情况下，该函数会基于所有列来判断重复性，但也可以通过参数指定基于特定列去除重复。

数据类型转换

原理

数据类型转换是将数据从一种类型转换为另一种类型的过程，以满足特定分析或算法的要求。例如，将字符串转换为数值类型，或将日期字符串转换为日期时间对象。

实践

Pandas提供了多种方法来转换数据类型，包括astype()和to_datetime()。

示例代码

# 创建一个包含不同数据类型的数据框
data = {
    'item': ['bread', 'milk', 'butter'],
    'quantity': ['2', '1', '1'],
    'date': ['2023-01-01', '2023-01-02', '2023-01-03']
}
df = pd.DataFrame(data)

# 打印原始数据框
print("原始数据框:")
print(df.dtypes)

# 将quantity列从字符串转换为整数
df['quantity'] = df['quantity'].astype(int)

# 将date列从字符串转换为日期时间对象
df['date'] = pd.to_datetime(df['date'])

# 打印转换后的数据框
print("转换后的数据框:")
print(df.dtypes)

解释

在本例中，quantity列最初是字符串类型，使用astype(int)将其转换为整数类型。date列使用pd.to_datetime()转换为日期时间对象，这在处理时间序列数据时非常有用。

文本数据清洗

原理

文本数据清洗涉及去除文本中的噪声，如标点符号、停用词、数字等，以及将文本转换为小写，以提高文本分析的准确性。

实践

使用Python的re（正则表达式）库和NLTK库可以有效地清洗文本数据。

示例代码

import re
import nltk
from nltk.corpus import stopwords
nltk.download('stopwords')

# 创建一个包含文本数据的数据框
data = {
    'review': ["Great product, I love it!", "Not so good. Too expensive.", "1234567890"]
}
df = pd.DataFrame(data)

# 打印原始数据框
print("原始数据框:")
print(df)

# 清洗文本数据
def clean_text(text):
    # 转换为小写
    text = text.lower()
    # 去除数字
    text = re.sub(r'\d+', '', text)
    # 去除标点符号
    text = re.sub(r'[^\w\s]', '', text)
    # 去除停用词
    stop_words = set(stopwords.words('english'))
    text = ' '.join([word for word in text.split() if word not in stop_words])
    return text

df['clean_review'] = df['review'].apply(clean_text)

# 打印清洗后的数据框
print("清洗后的数据框:")
print(df)

解释

clean_text函数执行了多个文本清洗步骤：转换为小写、去除数字、去除标点符号、以及去除英语停用词。这些步骤有助于减少文本数据中的噪声，使其更适合进一步的文本分析。

时间序列数据预处理

原理

时间序列数据预处理通常包括将日期时间数据转换为可操作的格式，以及处理缺失值和异常值。这有助于确保时间序列分析的准确性和有效性。

实践

Pandas库提供了强大的时间序列处理功能，包括频率调整和缺失值填充。

示例代码

# 创建一个包含时间序列数据的数据框
data = {
    'date': ['2023-01-01', '2023-01-02', '2023-01-04', '2023-01-05'],
    'sales': [100, 150, 200, 250]
}
df = pd.DataFrame(data)

# 将date列转换为日期时间对象
df['date'] = pd.to_datetime(df['date'])

# 设置日期时间为索引
df.set_index('date', inplace=True)

# 打印原始数据框
print("原始数据框:")
print(df)

# 频率调整，填充缺失日期
df = df.asfreq('D').fillna(0)

# 打印频率调整后的数据框
print("频率调整后的数据框:")
print(df)

解释

在本例中，首先将date列转换为日期时间对象，并将其设置为数据框的索引。然后，使用asfreq('D')将数据框的频率调整为每天，fillna(0)用于填充缺失值，假设在缺失日期的销售量为0。

通过以上实践，我们可以看到数据清洗和预处理在数据处理和分析中的重要性。这些步骤确保了数据的质量，为后续的分析和建模奠定了坚实的基础。

关联规则学习应用

创建交易数据集

在进行关联规则学习之前，首先需要创建一个交易数据集。交易数据集通常由一系列交易组成，每个交易包含一组商品或项目的列表。这些数据集可以来自于零售业的销售记录、网站的用户点击流、或是任何可以被看作是“项目集合”的数据。

示例数据

假设我们有以下的交易数据集：

交易ID	商品列表
1	{牛奶, 面包, 黄油}
2	{牛奶, 面包, 尿布}
3	{面包, 尿布, 啤酒}
4	{牛奶, 尿布, 啤酒}
5	{牛奶, 面包, 黄油, 啤酒}

Python代码创建数据集

# 导入必要的库
from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori, fpgrowth

# 创建交易数据集
dataset = [['牛奶', '面包', '黄油'],
           ['牛奶', '面包', '尿布'],
           ['面包', '尿布', '啤酒'],
           ['牛奶', '尿布', '啤酒'],
           ['牛奶', '面包', '黄油', '啤酒']]

# 使用TransactionEncoder编码数据
te = TransactionEncoder()
te_ary = te.fit(dataset).transform(dataset)
df = pd.DataFrame(te_ary, columns=te.columns_)

应用Apriori算法

Apriori算法是一种用于挖掘频繁项集的算法，它基于一个简单的原理：如果一个项集是频繁的，那么它的所有子集也应该是频繁的。Apriori算法通过迭代地生成候选集并检查它们的频率来工作。

Python代码应用Apriori算法

# 应用Apriori算法
frequent_itemsets = apriori(df, min_support=0.4, use_colnames=True)
print(frequent_itemsets)

应用FP-growth算法

FP-growth算法是另一种用于挖掘频繁项集的算法，它通过构建一个FP树来减少数据扫描的次数，从而提高效率。FP树是一种压缩的、内存友好的数据结构，用于存储交易数据集的频繁项集。

Python代码应用FP-growth算法

# 应用FP-growth算法
frequent_itemsets_fp = fpgrowth(df, min_support=0.4, use_colnames=True)
print(frequent_itemsets_fp)

结果解释与规则优化

一旦我们得到了频繁项集，接下来可以使用这些项集来生成关联规则。关联规则通常表示为“如果A，则B”的形式，其中A和B是商品或项目的集合。规则的质量可以通过支持度、置信度和提升度等指标来评估。

生成关联规则

# 生成关联规则
from mlxtend.frequent_patterns import association_rules

rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.7)
print(rules)

规则优化

优化关联规则通常涉及调整算法的参数，如最小支持度和最小置信度，以找到更相关或更有意义的规则。此外，也可以通过过滤规则来去除那些不感兴趣的或不实用的规则。

# 过滤规则
# 例如，我们可能只对包含“牛奶”的规则感兴趣
milk_rules = rules[rules['antecedents'].apply(lambda x: '牛奶' in x)]
print(milk_rules)

通过上述步骤，我们可以有效地应用关联规则学习算法来发现数据集中的潜在关联，并通过规则优化来提高分析的实用性和相关性。

实战项目：零售数据分析

数据集导入与探索

在开始关联规则学习之前，首先需要导入数据集并进行初步的探索性分析。数据集通常包含顾客的购买记录，每一行代表一次交易，每一列代表一个商品是否被购买。

数据集导入

import pandas as pd

# 导入数据集
data = pd.read_csv('retail_dataset.csv')
# 显示数据集的前几行
print(data.head())

数据探索

# 查看数据集的基本信息
print(data.info())

# 统计每个商品的购买频率
item_frequencies = data.sum()
print(item_frequencies)

数据清洗与预处理

数据清洗是关联规则学习中至关重要的一步，它确保数据的质量，从而提高挖掘结果的准确性。

处理缺失值

# 检查并处理缺失值
print(data.isnull().sum())
data = data.fillna(0)

数据类型转换

确保数据集中的商品列是布尔类型，表示商品是否被购买。

# 将数据类型转换为布尔类型
data = data.astype(bool)

交易数据格式化

将数据集转换为适合关联规则学习的格式，即每一行是一个顾客的购买记录，每一列是一个商品。

# 转换数据格式
transactions = []
for index, row in data.iterrows():
    transaction = [item for item, bought in row.items() if bought]
    transactions.append(transaction)

关联规则挖掘

使用Apriori算法进行关联规则挖掘，Apriori算法是一种用于频繁项集和关联规则学习的算法。

导入Apriori算法

from mlxtend.preprocessing import TransactionEncoder
from mlxtend.frequent_patterns import apriori
from mlxtend.frequent_patterns import association_rules

# 使用TransactionEncoder对交易数据进行编码
te = TransactionEncoder()
te_ary = te.fit(transactions).transform(transactions)
df = pd.DataFrame(te_ary, columns=te.columns_)

# 应用Apriori算法
frequent_itemsets = apriori(df, min_support=0.05, use_colnames=True)
print(frequent_itemsets)

挖掘关联规则

# 生成关联规则
rules = association_rules(frequent_itemsets, metric="confidence", min_threshold=0.5)
print(rules)

规则分析与业务洞察

关联规则挖掘后，需要对规则进行分析，以获取业务洞察。

分析规则

# 分析规则，例如找出支持度和置信度最高的规则
top_rules = rules.sort_values(by=['support', 'confidence'], ascending=False).head(10)
print(top_rules)

业务洞察

支持度（Support）：表示规则出现的频率，即包含所有项集的交易占所有交易的比例。
置信度（Confidence）：表示在包含前提项集的交易中，同时包含结果项集的概率。
提升度（Lift）：表示规则提升的程度，即规则的支持度与前提项集和结果项集独立出现时的支持度的比值。

通过分析这些规则，零售商可以了解哪些商品经常一起被购买，从而制定更有效的营销策略，如商品摆放、促销活动等。

实例分析

假设挖掘出的规则之一是“购买面包的顾客有70%的概率也会购买牛奶”，且该规则的支持度为10%，提升度为1.5。这意味着在所有交易中，10%的交易同时包含了面包和牛奶，而购买面包的顾客购买牛奶的概率是不购买面包的顾客购买牛奶概率的1.5倍。这表明面包和牛奶之间存在较强的关联，零售商可以考虑将这两种商品摆放在相近的位置，以促进销售。

通过上述步骤，我们可以从零售数据中挖掘出有价值的关联规则，为业务决策提供数据支持。