基于python的机器学习（三）—— 关联规则与推荐算法

慕卿扬2024-11-22 8:37

目录

一、关联规则挖掘

[1.1 基本概念](#1.1 基本概念)

[1.2 Apriori算法](#1.2 Apriori算法)

[1.2.1 Apriori算法的原理](#1.2.1 Apriori算法的原理)

[1.2.2 Apriori算法的实例](#1.2.2 Apriori算法的实例)

[1.2.3 Apriori算法的程序实现（efficient-apriori模块）](#1.2.3 Apriori算法的程序实现（efficient-apriori模块）)

[1.3 FP-Growth算法](#1.3 FP-Growth算法)

[1.3.1 FP-Growth算法的原理](#1.3.1 FP-Growth算法的原理)

[1.3.2 FP-Growth算法的实例](#1.3.2 FP-Growth算法的实例)

二、推荐系统及算法

[2.1 协调过滤推荐算法](#2.1 协调过滤推荐算法)

[2.1.1 两种协调过滤推荐算法](#2.1.1 两种协调过滤推荐算法)

[2.1.2 协同过滤推荐算法的优缺点](#2.1.2 协同过滤推荐算法的优缺点)

[2.1.3 协同过滤推荐算法实例](#2.1.3 协同过滤推荐算法实例)

一、关联规则挖掘

关联规则挖掘（Association Rule Mining）是一种常用的数据挖掘技术，用于发现数据集中项集之间的关联关系。关联规则通常用于市场篮子分析，可以发现在消费者购买商品时，某些项集的购买行为之间的相关性。

关联规则由两个部分组成：前项和后项 。前项 表示规则的前提条件，后项表示规则的结论。关联规则的形式如下：

python 复制代码 
X → Y

其中，X和Y分别表示项集，用{item1, item2, ...}表示，箭头表示两个项集之间的关联关系。

1.1 基本概念

在关联规则挖掘中，常用的指标有支持度和置信度。支持度衡量一个规则在数据集中出现的频率，置信度衡量一个规则在给定前项的条件下出现的概率。

关联规则挖掘的算法包括Apriori算法和FP-growth算法。Apriori算法通过迭代方式生成候选项集，并利用剪枝策略来减少计算量。FP-growth算法通过构建频繁模式树来高效地发现频繁项集。

关联规则中的基本概念如下：

  1. 项与项集 ：数据库中不可分割的最小信息单位（即记录）称为项（或项目），用符号 i 表示，项的集合称为项集。设集合 I = { i1，i2，...，ik }为项集，I 中项的个数为 k，则集合 I 称为 k-项集。例如，集合 {啤酒，尿布，奶粉｝是一个 3-项集，而奶粉就是一个项。
  2. 事务 ：每一个事务都是一个项集。设 I = { i1，i2，...，ik } 是由数据库中所有项构成的全集，则每一个事务 ti 对应的项集都是 I 的子集。事务数据库 T = { t1，t2，...，tk } 是由一系列具有唯一标识的事务组成的集合。例如，如果把超市中的所有商品看成 I ，则每个顾客每张小票中的商品集合就是一个事务，很多顾客的购物小票就构成一个事务数据库。
  3. 项集的频数 ：包含某个项集的事务在事务数据库中出现的次数称为项集的频数。例如，事务数据库中有且仅有 3 个事务 t1 = { 啤酒，奶粉 } 、t2 = { 啤酒，尿布，奶粉，面包} 、t3 = { 啤酒，尿布，奶粉} ，它们都包含了项集 I1 = {啤酒，奶粉} ，则称项集 I1 的频数为 3 ，项集的频数代表了支持度计数。
  4. 关联规则：关联规则由两部分组成：前项（Antecedent）和后项（Consequent）。前项是规则的条件部分，后项是规则的结果部分。关联规则的形式通常为A -> B，表示当某个事物或事件发生时，会伴随着另一个事物或事件的发生。
  5. 支持度：支持度（support）是指某一规则在数据集中出现的频率。支持度越高，表示该规则在数据集中出现的频率越高，反之则表示规则的出现频率较低。支持度可以通过以下公式计算： 支持度 = (规则出现次数) / (总记录数)
  6. 置信度：置信度是衡量规则强度的指标之一，表示在前提条件成立的情况下，后续事件发生的概率。置信度的计算公式为： 置信度 = 支持度（前提条件和后续事件同时发生的次数）/ 支持度（前提条件发生的次数）。
  7. 最小支持度与最小置信度：
    1. 最小支持度（Minimum Support）是指在关联规则挖掘中，一个频繁项集中的项出现的最小次数或比例。支持度是指项集在所有交易中出现的频率，通常用百分比来表示。最小支持度用来筛选出频繁项集，即在所有交易中出现次数超过最小支持度的项集。
    2. 最小置信度（Minimum Confidence）是指在关联规则挖掘中，一个关联规则的可信度不低于的最小值。置信度是指关联规则的条件项和结论项同时出现的频率与条件项出现的频率之比。最小置信度用来筛选出具有一定可信度的关联规则。
  8. 强关联规则：一条关联规则可以表示为A -> B，其中A和B分别称为前项（Antecedent）和后项（Consequent），表示两个项集之间的关联关系。置信度是指在前项出现的情况下，后项也出现的概率，可以表示为P(B|A)。如果置信度高于设定的阈值，那么这条关联规则就被认为是强关联规则。
  9. 频繁项集：频繁项集是指在一个数据集中，经常同时出现的一组项目的集合。频繁项集可以用于发现数据集中的潜在关联规则。确定一个项集是否是频繁项集，需要计算它在整个数据集中的支持度。

1.2 Apriori算法

Apriori算法 是一种用于挖掘频繁项集和关联规则的算法。它是由Agrawal和Srikant于1994年提出的。

1.2.1 Apriori算法的原理

Apriori算法的基本原理是利用频繁项集的性质，通过迭代的方式逐渐生成更大的频繁项集，然后再使用这些频繁项集来发现关联规则。

Apriori算法的执行过程如下：

  1. 扫描事务数据库，统计每个项的支持度，并根据设定的最小支持度阈值找出所有的频繁1项集。

  2. 根据频繁1项集，生成候选2项集，即由两个频繁1项集组合而成的项集。再次扫描事务数据库，统计候选2项集的支持度，并根据设定的最小支持度阈值找出所有的频繁2项集。

  3. 以此类推，根据频繁k-1项集，生成候选k项集，并找出所有的频繁k项集，直到无法再生成更大的频繁项集为止。

  4. 根据频繁项集，生成关联规则。对于频繁项集中的每个项，将其拆分成左部和右部，然后计算关联规则的置信度。筛选出满足设定的最小置信度阈值的关联规则。

Apriori算法具有以下优点和缺点：

优点：

  • 简单易懂，容易实现。
  • 通过剪枝操作，减少了候选项集的生成和计数的数量，提高了算法的效率。

缺点：

  • 需要多次扫描事务数据库，对于大规模数据集，性能较差。
  • 生成大量的候选项集，会占用大量的内存空间。
1.2.2 Apriori算法的实例

我们想要利用Apriori算法找出频繁项集。假设我们的销售记录如下：

python 复制代码 
Transaction 1: {牛奶, 尿布, 面包, 鸡蛋}
Transaction 2: {牛奶, 啤酒, 尿布}
Transaction 3: {牛奶, 面包, 啤酒, 尿布}
Transaction 4: {牛奶, 面包, 可乐, 啤酒}
Transaction 5: {尿布, 面包, 可乐}

现在我们来使用Apriori算法找出频繁项集。

1.2.3 Apriori算法的程序实现（efficient-apriori模块）

efficient-apriori是一个python模块，用于频繁项集挖掘和关联规则生成。它实现了Apriori算法的高效版本，能够快速地从大规模数据集中找出频繁项集，并根据设置的最小置信度生成关联规则。

使用efficient-apriori模块可以实现以下功能：

  • 从给定的数据集中找出频繁项集
  • 根据最小置信度生成关联规则
  • 设置最小支持度和最小置信度的阈值
  • 控制最大项集大小
  • 支持多线程运算，加快处理速度

安装efficient-apriori模块： 在终端或命令行中运行以下命令安装：

python 复制代码 
pip install efficient-apriori

使用efficient-apriori模块示例代码：

python 复制代码 
from efficient_apriori import apriori

# 定义数据集
data = [('牛奶', '面包', '尿布'),
        ('可乐', '面包', '尿布', '啤酒'),
        ('牛奶', '尿布', '啤酒', '鸡蛋'),
        ('可乐', '面包', '牛奶', '尿布'),
        ('面包', '牛奶', '尿布', '啤酒')]

# 执行Apriori算法
itemsets, rules = apriori(data, min_support=0.5, min_confidence=0.7)

# 输出频繁项集
print(itemsets)

# 输出关联规则
for rule in rules:
    print(rule)

运行结果：

更多详细信息和用法示例可以参考efficient-apriori的官方文档：efficient-apriori · PyPI

1.3 FP-Growth算法

FP-Growth算法是一种用于频繁项集挖掘的算法。它通过构建一种称为FP树的数据结构，来高效地发现数据集中的频繁项集。

FP-Growth算法的优点：

  1. FP-Growth算法采用了基于频繁项集的数据结构FP树来高效地挖掘频繁项集，相对于传统的Apriori算法，可以大大减少扫描数据库的次数，提高了算法的效率。
  2. FP-Growth算法将数据集转化为FP树的过程只需要两次扫描数据库，因此对于大规模的数据集来说，可以减少I/O操作，进一步提升了算法的效率。
  3. FP-Growth算法可以发现所有的频繁项集，不仅能够挖掘出频繁项集，还可以挖掘出关联规则。
  4. FP-Growth算法具有很强的可扩展性，可以应用于大规模的数据挖掘任务。

FP-Growth算法的缺点：

  1. FP-Growth算法在构建FP树的过程中需要使用大量的内存来存储FP树，因此对于较大的数据集来说，可能会导致内存不足的问题。
  2. FP-Growth算法在构建FP树的过程中需要进行多次遍历数据集，因此对于处理大规模数据集来说，可能会占用较长的时间。
  3. FP-Growth算法只能用于处理离散型数据，对于连续型数据需要进行离散化处理才能使用。
  4. FP-Growth算法在某些情况下可能会产生过多的频繁项集，导致关联规则过多和冗余，需要进行进一步的剪枝操作。
1.3.1 FP-Growth算法的原理

FP-Growth算法的流程如下：

  1. 构建频繁模式树：首先扫描数据库，统计每个项的支持计数。然后，根据支持计数对项进行排序，并且移除不满足最小支持阈值的项。接下来，根据数据集的频繁项集顺序，构建频繁模式树。
  2. 构建条件模式基：通过对每个频繁项的条件模式基进行递归，构建条件模式树。条件模式基是指给定频繁项的前缀路径。
  3. 递归地挖掘频繁项集：从频繁模式树的叶节点开始，逐层遍历树的节点，生成频繁项集。

在FP-Growth算法中，频繁模式树是一种紧凑的数据结构，能够有效地存储和处理大规模数据集。它的每个节点都表示一个频繁项，节点的链接指向具有相同项的下一个节点。通过频繁模式树的构建和频繁项集的递归挖掘，FP-Growth算法能够高效地发现频繁项集。

1.3.2 FP-Growth算法的实例

下面是一个使用 FP-Growth 算法的实例：

假设有一个交易数据库，包含了多个交易记录，每个交易记录是一个物品集合。我们想要寻找频繁模式，即经常一起出现的物品集合。

交易数据库如下所示：

python 复制代码 
Transaction 1: {A, B, C, D}
Transaction 2: {A, B, D}
Transaction 3: {B, C}
Transaction 4: {A, E}

首先，我们统计每个物品的频率，得到以下频繁项集：

python 复制代码 
A: 3
B: 3
C: 2
D: 2
E: 1

然后，根据频率对物品进行排序，得到排序后的频繁项集：

python 复制代码 
[A, B, C, D, E]

接着，我们构建 FP 树：

  1. 创建一个空的根节点。
  2. 对每个事务记录进行处理：
    • 对于每个物品，按照频率排序后的顺序添加到树中。
    • 如果物品已经存在于树中的某个节点的子节点中，则增加该节点的计数。
    • 否则，创建一个新节点，并将其添加为当前节点的子节点。
  3. 删除树中的非频繁项，得到以下 FP 树：
python 复制代码 
       null 
        |
        A
     /  |  \
    B   C   E
  /  \  
 D    F

接下来，我们利用 FP 树来寻找频繁模式：

  1. 从频繁项集中选择一项作为条件模式基，以该项为后缀的路径构成一个条件模式基。
  2. 对于每个条件模式基，构建条件 FP 树。
  3. 在条件 FP 树上递归应用 FP-Growth 算法，直到找到所有的频繁项集。

在上述例子中，以频繁项集 [A] 为条件模式基，可以得到以下条件 FP 树：

python 复制代码 
  null 
   |
   B
  / \  
 D   F

然后，从条件 FP 树中寻找频繁项集，得到以下频繁项集：

python 复制代码 
[A, B]: 2
[A, B, D]: 1

同样地，以频繁项集 [B] 为条件模式基，可以得到以下条件 FP 树：

       null 
        |
        D

从条件 FP 树中寻找频繁项集，得到以下频繁项集：

[B, D]: 1

最后，我们可以得到所有的频繁模式：

python 复制代码 
[A]: 3
[B]: 3
[C]: 2
[D]: 2
[E]: 1
[A, B]: 2
[A, B, D]: 1
[B, D]: 1

或

二、推荐系统及算法

推荐系统是一种根据用户的兴趣和行为，向用户推荐他们可能感兴趣的内容或产品的技术。推荐系统广泛应用于电子商务、社交媒体、新闻媒体和音乐流媒体等领域。

推荐系统的算法可以分为以下几种：

  1. 基于内容的推荐算法：根据用户对物品的历史行为和对物品的内容特征进行推荐。例如，根据用户对电影的历史评分记录和电影的类型、导演等内容特征，推荐给用户可能喜欢的电影。

  2. 协同过滤算法：基于用户与物品的相似性来推荐物品。分为两种类型，一种是基于用户的协同过滤算法，根据用户之间的行为相似性来推荐物品；另一种是基于物品的协同过滤算法，根据物品之间的相似性来推荐物品。

  3. 矩阵分解算法：将用户和物品的关系表示为一个矩阵，通过对矩阵进行分解，得到用户和物品的低维度表示，从而进行推荐。

  4. 深度学习算法：使用神经网络等深度学习模型来进行推荐。深度学习算法可以学习到更复杂的用户和物品的表示，从而提高推荐的准确性。

  5. 基于规则的推荐算法：根据预先定义的规则或规则库，来推荐物品。例如，根据用户的购买历史和用户的个人信息等规则，来推荐商品。

2.1 协调过滤推荐算法

协调过滤推荐算法（Collaborative Filtering Recommendation Algorithm）是一种基于用户行为数据的推荐算法，它通过分析用户历史行为数据，比如购买记录、评分数据、浏览记录等，找到与当前用户兴趣相似的其他用户或物品，并根据这些相似性来预测用户对未知物品的喜好程度。

2.1.1 两种协调过滤推荐算法

下面介绍两种常见的协调过滤推荐算法：

  1. 基于用户的协调过滤推荐算法(User-based Collaborative Filtering)： 基于用户的协调过滤推荐算法通过计算用户之间的相似度来进行推荐。算法的步骤如下：

    • 计算用户之间的相似度：可以使用余弦相似度或皮尔森相似度等方法来计算用户之间的相似度。
    • 根据相似度找到相似用户：对于目标用户，找到与其相似度最高的用户。
    • 推荐给目标用户未曾观看过的物品：根据相似用户的行为，推荐目标用户未曾观看过的物品。

  2. 基于物品的协调过滤推荐算法(Item-based Collaborative Filtering)： 基于物品的协调过滤推荐算法通过计算物品之间的相似度来进行推荐。算法的步骤如下：

    • 计算物品之间的相似度：可以使用余弦相似度或皮尔森相似度等方法来计算物品之间的相似度。
    • 根据相似度找到相似物品：对于用户历史行为中的某个物品，找到与之相似度最高的物品。
    • 推荐与用户历史行为中的物品相似度较高的其他物品：根据用户历史行为中的物品，推荐与之相似度较高的其他物品给用户。
2.1.2 协同过滤推荐算法的优缺点

协同过滤推荐算法的优点：

  1. 算法简单、直观，实现容易。
  2. 不依赖商品内容和属性，适用于各种类型的商品推荐。
  3. 可以发现用户的偏好和兴趣，从而提供个性化的推荐结果。
  4. 可以发现潜在的兴趣和相关性，引导用户发现新的商品。
  5. 可以利用用户对商品的评分和行为进行推荐，更能刻画用户的兴趣。

协同过滤推荐算法的缺点：

  1. 算法在大规模数据集上的计算复杂度较高，处理效率较低。
  2. 对于新用户和新商品，缺乏足够的历史数据进行准确的推荐。
  3. 没有考虑商品的内容和属性信息，可能导致推荐结果的多样性不够。
  4. 用户间的兴趣相似度难以准确度量，容易受到冷启动问题的影响。
2.1.3 协同过滤推荐算法实例

**MovieLens数据集包含许多用户对很多部电影的评分数据，也包括电影元数据信息和用户属性信息。这个数据集经常用来做推荐系统、机器学习算法的测试数据集。**根据这些电影评分数据，就可计算出电影的相似度或用户的相似度，然后根据相似度推荐相似电影给用户。

该数据集的下载地址为：http://files.grouplens.org/datasets/movielens/http://files.grouplens.org/datasets/movielens/

使用两种协同过滤推荐算法进行电影推荐并评估两种算法的推荐结果：

提醒：ratings.csv数据集380万+行，完全使用需运行内存40G+，根据自身情况删减。

python 复制代码 
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics.pairwise import cosine_similarity

# 读取MovieLens数据集
ratings_data = pd.read_csv('ratings.csv')
# movies_data = pd.read_csv('movies.csv')

# 获取用户对电影的评分矩阵
ratings_matrix = ratings_data.pivot(index='userId', columns='movieId', values='rating').fillna(0)

# 使用train_test_split函数将数据集划分为训练集和测试集
train_data, test_data = train_test_split(ratings_matrix.values, test_size=0.2, random_state=42)

# 使用余弦相似度计算用户相似度矩阵
user_similarity = cosine_similarity(train_data)

# 使用余弦相似度计算电影相似度矩阵
movie_similarity = cosine_similarity(train_data.T)

# 定义基于用户的协同过滤推荐算法
def user_based_recommendation(user_index, top_n=5):
    user_ratings = train_data[user_index]
    similar_users_indices = np.argsort(user_similarity[user_index])[::-1]
    recommended_movies = []
    for similar_user_index in similar_users_indices:
        similar_user_ratings = train_data[similar_user_index]
        non_rated_movies_indices = np.where(user_ratings == 0)[0]
        sorted_indices = np.argsort(similar_user_ratings[non_rated_movies_indices])[::-1]
        top_movie_indices = non_rated_movies_indices[sorted_indices][:top_n]
        recommended_movies.extend(top_movie_indices)
        if len(recommended_movies) >= top_n:
            break
    return recommended_movies

# 定义基于物品的协同过滤推荐算法
def item_based_recommendation(user_index, top_n=5):
    user_ratings = train_data[user_index]
    similar_movies_indices = np.argsort(movie_similarity[user_index])[::-1]
    recommended_movies = []
    for similar_movie_index in similar_movies_indices:
        if user_ratings[similar_movie_index] == 0:
            recommended_movies.append(similar_movie_index)
        if len(recommended_movies) >= top_n:
            break
    return recommended_movies

# 评估基于用户的协同过滤推荐算法
def evaluate_user_based_recommendation(test_data, top_n=5):
    num_users = test_data.shape[0]
    total_precision = 0
    total_recall = 0
    for user_index in range(num_users):
        true_movies_indices = np.where(test_data[user_index] > 0)[0]
        recommended_movies_indices = user_based_recommendation(user_index, top_n)
        num_true_movies = len(true_movies_indices)
        num_recommended_movies = len(recommended_movies_indices)
        num_common_movies = len(set(true_movies_indices).intersection(set(recommended_movies_indices)))
        precision = num_common_movies / num_recommended_movies
        recall = num_common_movies / num_true_movies
        total_precision += precision
        total_recall += recall
    avg_precision = total_precision / num_users
    avg_recall = total_recall / num_users
    return avg_precision, avg_recall

# 评估基于物品的协同过滤推荐算法
def evaluate_item_based_recommendation(test_data, top_n=5):
    num_users = test_data.shape[0]
    total_precision = 0
    total_recall = 0
    for user_index in range(num_users):
        true_movies_indices = np.where(test_data[user_index] > 0)[0]
        recommended_movies_indices = item_based_recommendation(user_index, top_n)
        num_true_movies = len(true_movies_indices)
        num_recommended_movies = len(recommended_movies_indices)
        num_common_movies = len(set(true_movies_indices).intersection(set(recommended_movies_indices)))
        precision = num_common_movies / num_recommended_movies
        recall = num_common_movies / num_true_movies
        total_precision += precision
        total_recall += recall
    avg_precision = total_precision / num_users
    avg_recall = total_recall / num_users
    return avg_precision, avg_recall

# 测试基于用户的协同过滤推荐算法
precision, recall = evaluate_user_based_recommendation(test_data)
print("User-based Collaborative Filtering:")
print("Precision:", precision)
print("Recall:", recall)

# 测试基于物品的协同过滤推荐算法
precision, recall = evaluate_item_based_recommendation(test_data)
print("Item-based Collaborative Filtering:")
print("Precision:", precision)
print("Recall:", recall)

运行结果：

注意：

上面的代码中假设Ratings数据保存在名为ratings.csv的CSV文件中。此外，代码中使用了sklearn库的函数进行数据集划分和余弦相似度计算。

相关推荐
测试老哥8 分钟前
Python自动化测试图片比对算法
自动化测试·软件测试·python·测试工具·程序人生·职场和发展·测试用例
爱数学的程序猿9 分钟前
Python入门：1.Python介绍
开发语言·python
今天你比昨天博学了吗10 分钟前
CFD POST导出动画
学习
γ..11 分钟前
基于MATLAB的图像增强
开发语言·深度学习·神经网络·学习·机器学习·matlab·音视频
小王爱吃月亮糖21 分钟前
C++进阶-1-单继承、多继承、虚继承
开发语言·c++·笔记·学习·visual studio
zxguan39 分钟前
Springboot 学习 之 logback-spring.xml 日志压缩 .tmp 临时文件问题
spring boot·学习·spring
纪伊路上盛名在40 分钟前
爬虫1：uniprot蛋白质序列数据+canvas图片
数据库·学习·知识图谱·学习方法
小王爱吃月亮糖42 分钟前
补充--C++的项目结构和管理
数据结构·c++·笔记·学习
檀越剑指大厂2 小时前
【Python系列】Python中的`any`函数：检查“至少有一个”条件满足
开发语言·python
程序员黄同学3 小时前
如何使用 Python 连接 MySQL 数据库？
数据库·python·mysql
热门推荐
01VSCode插件 —— Cody AI （免费AI助手！）02YOLOv8训练好模型后，追加轮数继续训练、或者提前终止训练，缩减训练轮数03玄机平台应急响应—webshell查杀04SQL 主从数据库实时备份05HCIA-datacom数通题库和录播视频资料06Docker 夺命连环 15 问07ARM学习（31）编译器对overlay方式的支持08校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10组基轨迹建模 GBTM的介绍与实现（Stata 或 R）