毕业设计：2023-2024年计算机专业毕业设计选题汇总（建议收藏）
毕业设计：2023-2024年最新最全计算机专业毕设选题推荐汇总
🍅感兴趣的可以先收藏起来，点赞、关注不迷路，大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助同学们顺利毕业 。🍅
1、项目介绍
技术栈：Django框架、scrapy爬虫框架、Vue框架、apriori算法推荐关联商品
本系统通过scrapy爬虫框架抓取京东上的商品，存入本地数据库，用Django框架搭建后端用于提供数据，Vue搭建前端用于展示数据
功能有：
1. 商品检索
2. 商品详情
3. 加入购物车
4. 结算购买
5. 查看历史订单
6. 个人中心
7. 基于用户历史浏览来推荐商品
8. 当用户访问商品详情时，基于apriori算法推荐关联商品
2、项目界面
（1）系统首页
（2）推荐系统后台管理
（3）购物车功能
（4）商品推荐
（5）后台商品数据管理
（6）数据爬虫
3、项目说明
后端技术栈(python):
- django
- django-simpleui 后台ui框架
- apriori算法，网上搜搜资料很多
- mysql 数据库
- sqlite3 数据库
数据爬虫(python):
- scrapy 爬虫框架
- requests 轻量爬虫工具
- xpath 页面数据抽取
前端技术栈(nodejs+vue3):
- vue3
- element-plus vue3组件库
- element-plus-admin 页面框架
京东商品推荐系统的设计涉及多个步骤，其中Apriori算法可以用于关联规则的挖掘，以提供用户间商品关联的信息。以下是一个简单的Apriori算法在京东商品推荐系统中的介绍：
- 数据收集：
从京东的数据库中收集用户购物交易数据，包括购买商品的信息、购买时间等。 - 数据预处理：
整理收集到的数据，将其转化为适合Apriori算法处理的格式。每个交易可以看作是一个包含多个商品的集合。 - Apriori算法应用：
应用Apriori算法来挖掘频繁项集。频繁项集是指在交易记录中频繁出现的商品组合。设置一个最小支持度阈值，以过滤掉不频繁的项集。 - 关联规则挖掘：
从频繁项集中生成关联规则。关联规则是指商品之间的关系，例如，购买商品A的用户也有很大概率购买商品B。这些规则可以通过计算置信度等指标进行筛选。 - 推荐生成：
利用挖掘得到的关联规则，为用户生成推荐商品列表。例如，如果一个用户购买了商品A，根据关联规则，系统可以推荐购买商品B。 - 京东系统集成：
将推荐系统集成到京东的平台中，确保推荐结果能够顺利展示在用户界面上。这可能涉及到与现有系统的对接和用户体验的优化。 - 评估和优化：
定期评估推荐系统的性能，可能涉及到A/B测试以及用户反馈的收集。根据评估结果对推荐算法和系统进行优化。
需要注意的是，虽然Apriori算法是一种用于挖掘关联规则的经典方法，但在实际的电商推荐系统中，通常还会使用其他更先进的技术，例如基于协同过滤的方法、深度学习等，以提供更准确和个性化的推荐结果。因此，在设计推荐系统时，需要结合业务需求和实际情况选择合适的算法和技术。
4、核心代码
from numpy import *
import time
def loadDataSet():
return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
def createC1(dataSet):
C1 = []
for transaction in dataSet:
for item in transaction:
if not [item] in C1:
C1.append([item])
C1.sort()
return list(map(frozenset, C1))
def scanD(D, Ck, minSupport):
ssCnt = {}
for tid in D:
for can in Ck:
if can.issubset(tid):
if not can in ssCnt:
ssCnt[can] = 1
else:
ssCnt[can] += 1
numItems = float(len(D))
retList = []
supportData = {}
for key in ssCnt:
support = ssCnt[key] / numItems
if support >= minSupport:
# retList.insert(0,key)
retList.append(key)
supportData[key] = support
return retList, supportData
# def aprioriGen(Lk, k):
# retList = []
# lenLk = len(Lk)
# for i in range(lenLk):
# for j in range(i+1, lenLk):
# L1 = list(Lk[i])[:k-2]
# L2 = list(Lk[j])[:k-2]
# L1.sort()
# L2.sort()
# if L1 == L2:
# retList.append(Lk[i]|Lk[j])
# return retList
def aprioriGen(Lk, k):
lenLk = len(Lk)
temp_dict = {}
for i in range(lenLk):
for j in range(i + 1, lenLk):
L1 = Lk[i] | Lk[j]
if len(L1) == k:
if not L1 in temp_dict:
temp_dict[L1] = 1
return list(temp_dict)
def apriori(dataSet, minSupport=0.5):
C1 = createC1(dataSet)
# print("C1",C1)
D = list(map(set, dataSet))
L1, supportData = scanD(D, C1, minSupport)
# print("L1",L1)
L = [L1]
k = 2
while len(L[k - 2]) > 0:
Ck = aprioriGen(L[k - 2], k) # 生成候选项集
# print("生成的候选项集",Ck)
Lk, supK = scanD(D, Ck, minSupport) # 按支持度筛选候选项集
# print("筛选出频繁项集",Lk)
supportData.update(supK)
L.append(Lk)
k += 1
return L, supportData
def calcConf(freqSet, H, supportData, br1, minConf=0.7): # 筛选符合可信度要求的规则，并返回符合可信度要求的右件
prunedH = [] # 存储符合可信度的右件
for conseq in H: # conseq就是右件，freqSet是原始频繁项,freqSet-conseq是左件
conf = supportData[freqSet] / supportData[freqSet - conseq] # 计算可信度
if conf >= minConf:
print(freqSet - conseq, "-->", conseq, "\tconf:", conf)
br1.append((freqSet - conseq, conseq, conf))
else:
prunedH.append(conseq) # 不符合可信度的右件添加到列表中
return prunedH
# def rulesFromConseq(freqSet, H, supportData, br1, minConf=0.7): # 原版Apriori原理来减少创造的规则
# m = len(H[0])
# if (len(freqSet)>(m+1)):
# Hmp1 = aprioriGen(H, m+1)
# Hmp1 = calcConf(freqSet, Hmp1, supportData, br1, minConf)
# if (len(Hmp1) >1):
# rulesFromConseq(freqSet, Hmp1, supportData, br1,minConf)
def rulesFromConseq(freqSet, H, supportData, br1, minConf=0.7): # 新版Apriori原理来减少创造的规则
is_find = True # 循环标志
m = 1 # 先创造右件为一个元素的规则
Hmp1 = H # H是初始频繁项分散后的列表，[frozenset({2}),frozenset({3}),frozenset({5)],Hmp1是组合后的右件，因为我们的aprioriGen不能组建只有1个元素的右件，所以右件为1个元素的时候我们直接H赋值过去，当右件元素数是2以上的时候，再用aprioriGen组合出来
while is_find:
if (
len(freqSet) > m
): # 最多循环len(freqSet)-1次，因为右件最多len(freqSet)-1个元素，右件元素的数从1增长到len(freqSet)-1，故最多循环len(freqSet)-1次
if m > 1: # 我们改编的aprioriGen()函数至少产生C2,不能产生C1，因此这里加了if
Hmp1 = aprioriGen(H, m) # H里的元素自由组合成右件，右件的元素个数是m
H_no = calcConf(
freqSet, Hmp1, supportData, br1, minConf
) # 筛选符合可信度的规则,把不符合的右件存起来
if len(H_no) != 0: # 如果有不满足可信度的右件
H_no = list(
set(frozenset([item]) for row in Hmp1 for item in row)
) # 我们把列表中的每个元素都分割出来，比如[{2,3},{3,4}] 分割后为[{2},{3},{4}]，方便我们再次组合，这里也是Apriori原理的精髓所在，这么操作就是把不满足的右件及其超集提出来，然后后面做减法。
H = list(set(H) - set(H_no)) # 可组合的集合减去不满足可信度的右件的集合
m = m + 1 # 右件个数不断增加，第一次右件元素只有1个，第二次循环右件元素就有两个了
if (
len(H) < m
): # 如果剩余的可自由组合的元素个数少于新右件所需要的元素数，比如就剩两个元素可组合了，想要组成C3作右件，肯定是不可能的，那么结束循环
is_find = False
else: # 如果循环次数达到最大，也结束循环
is_find = False
def generateRules(L, supportData, minConf=0.7): # 产生规则
bigRuleList = []
for i in range(1, len(L)): # 从L2开始创造规则
for freqSet in L[i]:
H1 = [frozenset([item]) for item in freqSet]
if i > 1: # L3开始使用Apriori原理
rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
else: # L2不能使用Apriori原理，只能老老实实挨个创造规则
calcConf(freqSet, H1, supportData, bigRuleList, minConf)
return bigRuleList
if __name__ == "__main__":
dataSet = loadDataSet()
begin_time = time.time()
L, suppData = apriori(dataSet)
rules = generateRules(L, suppData, minConf=0.5)
end_time = time.time()
print("程序花费时间{}秒".format(end_time - begin_time))
print("L", L, end="\n" * 2)
print("suppData", suppData, end="\n" * 2)
print("rules", rules, end="\n" * 2)
5、源码获取方式
🍅由于篇幅限制，获取完整文章或源码、代做项目的，查看我的【用户名】、【专栏名称】、【顶部选题链接】就可以找到我啦🍅
感兴趣的可以先收藏起来，点赞、关注不迷路，下方查看👇🏻获取联系方式👇🏻
209
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
