recommend/recommend.py - G3Backend - Gitiles

 import os
 import time
 import jieba
 import fasttext
 import pandas as pd
 from flask import Flask, request, jsonify
 from sqlalchemy import create_engine
 from scipy.sparse import coo_matrix
 from sklearn.metrics.pairwise import cosine_similarity
 import pickle

 app = Flask(__name__)

 # === ✅ SQLAlchemy 数据库连接 ===
 engine = create_engine("mysql+pymysql://sy:sy_password@49.233.215.144:3306/pt_station")


 # === ✅ 用户标签行为矩阵构建 ===
 def get_user_tag_matrix():
     df = pd.read_sql("SELECT user_id, tag, score FROM user_tag_scores", engine)
     #print(df)
     df['user_id'] = df['user_id'].astype(str)
     user_map = {u: i for i, u in enumerate(df['user_id'].unique())}
     tag_map = {t: i for i, t in enumerate(df['tag'].unique())}
     df['user_index'] = df['user_id'].map(user_map)
     df['tag_index'] = df['tag'].map(tag_map)
     matrix = df.pivot_table(index='user_id', columns='tag', values='score', fill_value=0)
     sparse_matrix = coo_matrix((df['score'], (df['tag_index'], df['user_index'])))
     return df, matrix, sparse_matrix, user_map, tag_map

 # === ✅ 基于 fastText 的语义相似推荐方法 ===
 def semantic_recommend(user_id, topn=5):
     print(f"正在为用户 {user_id} 生成推荐...")

     # 读取数据
     df = pd.read_sql("SELECT user_id, tag, score FROM user_tag_scores", engine)

     # 统一类型转换
     df['user_id'] = df['user_id'].astype(str)  # 确保整个列转为字符串
     user_id = str(user_id)  # 要查询的ID也转为字符串

     # 现在查询应该正常工作了
     user_tags = df[df['user_id'] == user_id].sort_values(by="score", ascending=False)['tag'].tolist()
     print(f"用户 {user_id} 的标签（按分数排序）: {user_tags}")

     if not user_tags:
         print(f"用户 {user_id} 没有标签记录，返回空推荐结果。")
         return []
     else:
         user_tags = user_tags[:3]
         print(f"用户 {user_id} 的 Top 3 标签: {user_tags}")

     if not user_tags:
         print(f"用户 {user_id} 没有标签记录，返回空推荐结果。")
         return []

     # 截取前 3 个标签作为“兴趣标签”
     user_tags = user_tags[:3]
     print(f"用户 {user_id} 的 Top 3 标签: {user_tags}")

     # 构造所有标签的词向量
     all_tags = df['tag'].unique()
     print(f"所有唯一标签数量: {len(all_tags)}")

     tag_vectors = {}
     for tag in all_tags:
         vec = ft_model.get_word_vector(tag)
         tag_vectors[tag] = vec

     # 计算未出现过标签的相似度得分
     scores = {}
     for tag in all_tags:
         if tag in user_tags:
             continue
         vec = tag_vectors[tag]
         sim_total = 0.0
         for t in user_tags:
             sim = cosine_similarity([vec], [ft_model.get_word_vector(t)])[0][0]
             print(f"标签 [{tag}] 与用户标签 [{t}] 的相似度: {sim:.4f}")
             sim_total += sim
         avg_score = sim_total / len(user_tags)
         scores[tag] = avg_score
         print(f"标签 [{tag}] 的平均相似度得分: {avg_score:.4f}")

     # 排序并返回 topN 标签
     sorted_tags = sorted(scores.items(), key=lambda x: x[1], reverse=True)[:topn]
     print(f"\n最终推荐标签（前 {topn}）:")
     #for tag, score in sorted_tags:
       #  print(f"{tag}: {score:.4f}")

     return [tag for tag, _ in sorted_tags]

 # === ✅ ItemCF 推荐方法 ===
 import os
 import pickle

 def itemcf_recommend(user_id, matrix, sim_path="./models/itemcf_sim.pkl", topn=5):
     user_id = str(user_id)  # 确保 user_id 类型一致
     print(matrix.index.dtype)
     print(type(user_id))  # 应该是 str

     if user_id not in matrix.index:
         print(f"⚠️ 用户 {user_id} 不在评分矩阵中。")
         return []

     if not os.path.exists(sim_path):
         print(f"⚠️ 用户 {user_id} 不在评分矩阵中。")
         train_and_save_itemcf()

     with open(sim_path, "rb") as f:
         sim_df = pickle.load(f)

     user_row = matrix.loc[user_id]
     user_tags = user_row[user_row > 0]

     if user_tags.empty:
         print(f"⚠️ 用户 {user_id} 没有任何标签评分记录。")
         return []

     scores = {}
     for tag, val in user_tags.items():
         if tag not in sim_df:
             print(f"标签 {tag} 在相似度矩阵中不存在，跳过。")
             continue
         sims = sim_df[tag].drop(index=user_tags.index, errors="ignore")
         for sim_tag, sim_score in sims.items():
             scores[sim_tag] = scores.get(sim_tag, 0) + sim_score * val

     if not scores:
         print(f"⚠️ 用户 {user_id} 无法生成推荐，可能是标签相似度不足。")
         return []

     sorted_tags = sorted(scores.items(), key=lambda x: x[1], reverse=True)
     print(f"推荐得分（前{topn}）:\n", sorted_tags[:topn])

     return [tag for tag, _ in sorted_tags[:topn]]


 # === ✅ ItemCF 相似度训练 ===
 def train_and_save_itemcf(path="./models/itemcf_sim.pkl"):
     _, matrix, _, _, _ = get_user_tag_matrix()
     tag_sim = cosine_similarity(matrix.T)
     sim_df = pd.DataFrame(tag_sim, index=matrix.columns, columns=matrix.columns)
     with open(path, "wb") as f:
         pickle.dump(sim_df, f)
     print("ItemCF 相似度矩阵已保存 ✅")

 # === ✅ Flask 推荐接口 ===
 import random

 @app.route("/recommend_torrents", methods=["POST"])
 def recommend_torrents():
     data = request.get_json()
     user_id = data.get("user_id")

     if not user_id:
         return jsonify({"error": "缺少 user_id"}), 400

     df, matrix, _, _, _ = get_user_tag_matrix()

     # 获取推荐标签
     itemcf_result = itemcf_recommend(user_id, matrix)
     semantic_result = semantic_recommend(user_id)


     print(f"ItemCF 推荐标签: {itemcf_result}")
     print(f"Semantic 推荐标签: {semantic_result}")

     all_tags = df['tag'].unique().tolist()

     # 存储标签及其推荐得分
     combined = []
     used_tags = set()

     def add_unique_tags(tags, method_name):
         for tag in tags:
             if tag not in used_tags:
                 random_priority = random.uniform(0, 1)
                 if method_name == 'ItemCF':
                     combined.append((tag, 'ItemCF', random_priority))
                 elif method_name == 'Semantic':
                     combined.append((tag, 'Semantic', random_priority))
                 used_tags.add(tag)

     # 添加 ItemCF 和 Semantic 推荐
     add_unique_tags(itemcf_result, 'ItemCF')
     add_unique_tags(semantic_result, 'Semantic')

     # 添加随机标签
     random.shuffle(all_tags)
     add_unique_tags(all_tags, 'Random')

     # 排序：按推荐得分排序，加入的随机值也会影响排序
     combined.sort(key=lambda x: x[2], reverse=True)

     # 根据标签获取种子 ID
     final_tags = [tag for tag, _, _ in combined]
     print(f"最终推荐标签: {final_tags}")
     torrent_ids = get_torrent_ids_by_tags(final_tags)

     return jsonify({"torrent_ids": torrent_ids})


 from sqlalchemy.sql import text

 import random
 from sqlalchemy import text

 def get_torrent_ids_by_tags(tags, limit_per_tag=10):
     if not tags:
         tags = []
     print(f"传递给 get_torrent_ids_by_tags 的标签: {tags}")

     recommended_ids = set()
     with engine.connect() as conn:
         for tag in tags:
             query = text("""
                 SELECT torrent_id
                 FROM bt_torrent_tags
                 WHERE tag = :tag
                 LIMIT :limit
             """)
             result = conn.execute(query, {"tag": tag, "limit": limit_per_tag})
             print(f"标签 '{tag}' 的推荐结果:")
             for row in result:
                 print(row[0])  # 打印每个torrent_id
                 recommended_ids.add(row[0])

         # 获取数据库中所有 torrent_id
         all_query = text("SELECT DISTINCT torrent_id FROM bt_torrent")
         all_result = conn.execute(all_query)
         all_ids = set(row[0] for row in all_result)
         print("数据库中所有torrent_id:", all_ids)

     # 剩下的（非推荐）种子 ID
     remaining_ids = all_ids - recommended_ids
     print(remaining_ids)
     # 随机打乱推荐和剩下的 ID
     recommended_list = list(recommended_ids)
     remaining_list = list(remaining_ids)
     random.shuffle(recommended_list)
     random.shuffle(remaining_list)

     return recommended_list + remaining_list


 import os
 import time
 import jieba
 import fasttext
 from flask import Flask, request, jsonify
 import mysql.connector

 # ✅ 初始化数据库连接
 import mysql.connector
 from sklearn.metrics.pairwise import cosine_similarity
 import numpy as np

 def compute_similarity(vec1, vec2):
     """计算两个词向量之间的余弦相似度"""
     # 使用 cosine_similarity 计算相似度
     return cosine_similarity([vec1], [vec2])[0][0]

 db = mysql.connector.connect(
     host="49.233.215.144",
     port=3306,
     user="sy",
     password="sy_password",
     database="pt_station"
 )

 cursor = db.cursor()


 app = Flask(__name__)

 # ✅ 加载 fastText 模型
 fasttext_model_path = './models/cc.zh.300.bin'
 if not os.path.exists(fasttext_model_path):
     raise FileNotFoundError("fastText 模型文件不存在，请检查路径。")

 print("加载 fastText 模型中...")
 ft_model = fasttext.load_model(fasttext_model_path)
 print("模型加载完成 ✅")
 fasttext_vocab = set(ft_model.words)

 # ✅ 全局标签缓存（用于避免频繁查询）
 existing_tags = set()

 def refresh_existing_tags():
     """刷新数据库中已存在的标签集合"""
     global existing_tags
     cursor.execute("SELECT DISTINCT tag FROM user_tag_scores")
     existing_tags = set(tag[0] for tag in cursor.fetchall())
     print(f"已加载标签数: {len(existing_tags)}")

 # ✅ 启动时初始化标签缓存
 refresh_existing_tags()

 # ✅ 扩展函数：仅保留数据库已有标签
 def expand_tags_from_input(input_tags, topn=5, similarity_threshold=0.7):
     """
     扩展输入标签列表，查找与之语义相似的标签，返回相似度大于阈值或最相似的前 n 个标签。

     :param input_tags: 输入标签的列表，例如 ['电影', '动漫', '游戏', '1080p']
     :param topn: 返回的最相似标签的数量，默认为 5
     :param similarity_threshold: 相似度阈值，默认为 0.7
     :return: 返回与输入标签相关的扩展标签列表
     """
     # 用于存储所有扩展标签及其相似度
     tag_scores = {}

     for tag in input_tags:
         # 获取当前标签的词向量
         tag_vector = ft_model.get_word_vector(tag)

         # 遍历标签库中的所有标签并计算相似度
         for db_tag in existing_tags:
             db_tag_vector = ft_model.get_word_vector(db_tag)
             similarity = compute_similarity(tag_vector, db_tag_vector)

             if similarity >= similarity_threshold:
                 if db_tag not in tag_scores:
                     tag_scores[db_tag] = similarity
                 else:
                     tag_scores[db_tag] = max(tag_scores[db_tag], similarity)

     # 根据相似度排序并返回前 n 个标签
     sorted_tags = sorted(tag_scores.items(), key=lambda x: x[1], reverse=True)
     top_tags = [tag for tag, _ in sorted_tags[:topn]]

     return top_tags


 # ✅ 接口路由
 @app.route("/expand_tags", methods=["POST"])
 def expand_tags():
     start_time = time.time()

     # 从请求中获取数据
     data = request.get_json()
     input_tags = data.get("tags", [])
     user_id = data.get("user_id")
     rate = data.get("rate")

     topn = data.get("topn", 10)  # 默认为 5
     similarity_threshold =  0.4  # 默认阈值为 0.7

     if not input_tags or not user_id:
         return jsonify({"error": "缺少参数 tags 或 user_id"}), 400

     # 获取与输入标签最相关的标签
     expanded_tags = expand_tags_from_input(input_tags, topn=topn, similarity_threshold=similarity_threshold)

     # 打印日志
     print(f"[用户 {user_id}] 输入标签: {input_tags}")
     print(f"[用户 {user_id}] 匹配扩展标签: {expanded_tags}")

     # 数据写入打分逻辑
     token_set = set(input_tags)  # 用于确定哪些标签是用户输入的标签
     for tag in expanded_tags:
         score = 2.0 *  rate if tag in token_set else 2.0 *  rate
         try:
             cursor.execute("""
                 INSERT INTO user_tag_scores (user_id, tag, score)
                 VALUES (%s, %s, %s)
                 ON DUPLICATE KEY UPDATE score = score + VALUES(score)
             """, (user_id, tag, score))
         except Exception as e:
             print(f"插入失败 [{tag}]:", e)
     db.commit()
     # ⏳ 插入后立即查询该用户的所有标签和评分
     try:
         cursor.execute("""
             SELECT tag, score FROM user_tag_scores WHERE user_id = %s
         """, (user_id,))
         user_scores = [{"tag": tag, "score": float(score)} for tag, score in cursor.fetchall()]
         print(user_scores)
     except Exception as e:
         print(f"查询用户评分失败: {e}")

     duration = round(time.time() - start_time, 3)
     return jsonify({
         "expanded_tags": expanded_tags,
     })


 # ✅ 触发标签缓存刷新（可选：手动/接口/定时任务调用）
 @app.route("/refresh_tags", methods=["POST"])
 def refresh_tags():
     refresh_existing_tags()
     return jsonify({"status": "标签缓存已刷新", "count": len(existing_tags)})


 # === ✅ 启动服务 ===
 if __name__ == '__main__':
     #train_and_save_itemcf()
     from waitress import serve
     serve(app, host="0.0.0.0", port=5000, threads=16)
	import os
	import time
	import jieba
	import fasttext
	import pandas as pd
	from flask import Flask, request, jsonify
	from sqlalchemy import create_engine
	from scipy.sparse import coo_matrix
	from sklearn.metrics.pairwise import cosine_similarity
	import pickle

	app = Flask(__name__)

	# === ✅ SQLAlchemy 数据库连接 ===
	engine = create_engine("mysql+pymysql://sy:sy_password@49.233.215.144:3306/pt_station")


	# === ✅ 用户标签行为矩阵构建 ===
	def get_user_tag_matrix():
	df = pd.read_sql("SELECT user_id, tag, score FROM user_tag_scores", engine)
	#print(df)
	df['user_id'] = df['user_id'].astype(str)
	user_map = {u: i for i, u in enumerate(df['user_id'].unique())}
	tag_map = {t: i for i, t in enumerate(df['tag'].unique())}
	df['user_index'] = df['user_id'].map(user_map)
	df['tag_index'] = df['tag'].map(tag_map)
	matrix = df.pivot_table(index='user_id', columns='tag', values='score', fill_value=0)
	sparse_matrix = coo_matrix((df['score'], (df['tag_index'], df['user_index'])))
	return df, matrix, sparse_matrix, user_map, tag_map

	# === ✅ 基于 fastText 的语义相似推荐方法 ===
	def semantic_recommend(user_id, topn=5):
	print(f"正在为用户 {user_id} 生成推荐...")

	# 读取数据
	df = pd.read_sql("SELECT user_id, tag, score FROM user_tag_scores", engine)

	# 统一类型转换
	df['user_id'] = df['user_id'].astype(str) # 确保整个列转为字符串
	user_id = str(user_id) # 要查询的ID也转为字符串

	# 现在查询应该正常工作了
	user_tags = df[df['user_id'] == user_id].sort_values(by="score", ascending=False)['tag'].tolist()
	print(f"用户 {user_id} 的标签（按分数排序）: {user_tags}")

	if not user_tags:
	print(f"用户 {user_id} 没有标签记录，返回空推荐结果。")
	return []
	else:
	user_tags = user_tags[:3]
	print(f"用户 {user_id} 的 Top 3 标签: {user_tags}")

	if not user_tags:
	print(f"用户 {user_id} 没有标签记录，返回空推荐结果。")
	return []

	# 截取前 3 个标签作为“兴趣标签”
	user_tags = user_tags[:3]
	print(f"用户 {user_id} 的 Top 3 标签: {user_tags}")

	# 构造所有标签的词向量
	all_tags = df['tag'].unique()
	print(f"所有唯一标签数量: {len(all_tags)}")

	tag_vectors = {}
	for tag in all_tags:
	vec = ft_model.get_word_vector(tag)
	tag_vectors[tag] = vec

	# 计算未出现过标签的相似度得分
	scores = {}
	for tag in all_tags:
	if tag in user_tags:
	continue
	vec = tag_vectors[tag]
	sim_total = 0.0
	for t in user_tags:
	sim = cosine_similarity([vec], [ft_model.get_word_vector(t)])[0][0]
	print(f"标签 [{tag}] 与用户标签 [{t}] 的相似度: {sim:.4f}")
	sim_total += sim
	avg_score = sim_total / len(user_tags)
	scores[tag] = avg_score
	print(f"标签 [{tag}] 的平均相似度得分: {avg_score:.4f}")

	# 排序并返回 topN 标签
	sorted_tags = sorted(scores.items(), key=lambda x: x[1], reverse=True)[:topn]
	print(f"\n最终推荐标签（前 {topn}）:")
	#for tag, score in sorted_tags:
	# print(f"{tag}: {score:.4f}")

	return [tag for tag, _ in sorted_tags]

	# === ✅ ItemCF 推荐方法 ===
	import os
	import pickle

	def itemcf_recommend(user_id, matrix, sim_path="./models/itemcf_sim.pkl", topn=5):
	user_id = str(user_id) # 确保 user_id 类型一致
	print(matrix.index.dtype)
	print(type(user_id)) # 应该是 str

	if user_id not in matrix.index:
	print(f"⚠️ 用户 {user_id} 不在评分矩阵中。")
	return []

	if not os.path.exists(sim_path):
	print(f"⚠️ 用户 {user_id} 不在评分矩阵中。")
	train_and_save_itemcf()

	with open(sim_path, "rb") as f:
	sim_df = pickle.load(f)

	user_row = matrix.loc[user_id]
	user_tags = user_row[user_row > 0]

	if user_tags.empty:
	print(f"⚠️ 用户 {user_id} 没有任何标签评分记录。")
	return []

	scores = {}
	for tag, val in user_tags.items():
	if tag not in sim_df:
	print(f"标签 {tag} 在相似度矩阵中不存在，跳过。")
	continue
	sims = sim_df[tag].drop(index=user_tags.index, errors="ignore")
	for sim_tag, sim_score in sims.items():
	scores[sim_tag] = scores.get(sim_tag, 0) + sim_score * val

	if not scores:
	print(f"⚠️ 用户 {user_id} 无法生成推荐，可能是标签相似度不足。")
	return []

	sorted_tags = sorted(scores.items(), key=lambda x: x[1], reverse=True)
	print(f"推荐得分（前{topn}）:\n", sorted_tags[:topn])

	return [tag for tag, _ in sorted_tags[:topn]]


	# === ✅ ItemCF 相似度训练 ===
	def train_and_save_itemcf(path="./models/itemcf_sim.pkl"):
	_, matrix, _, _, _ = get_user_tag_matrix()
	tag_sim = cosine_similarity(matrix.T)
	sim_df = pd.DataFrame(tag_sim, index=matrix.columns, columns=matrix.columns)
	with open(path, "wb") as f:
	pickle.dump(sim_df, f)
	print("ItemCF 相似度矩阵已保存 ✅")

	# === ✅ Flask 推荐接口 ===
	import random

	@app.route("/recommend_torrents", methods=["POST"])
	def recommend_torrents():
	data = request.get_json()
	user_id = data.get("user_id")

	if not user_id:
	return jsonify({"error": "缺少 user_id"}), 400

	df, matrix, _, _, _ = get_user_tag_matrix()

	# 获取推荐标签
	itemcf_result = itemcf_recommend(user_id, matrix)
	semantic_result = semantic_recommend(user_id)


	print(f"ItemCF 推荐标签: {itemcf_result}")
	print(f"Semantic 推荐标签: {semantic_result}")

	all_tags = df['tag'].unique().tolist()

	# 存储标签及其推荐得分
	combined = []
	used_tags = set()

	def add_unique_tags(tags, method_name):
	for tag in tags:
	if tag not in used_tags:
	random_priority = random.uniform(0, 1)
	if method_name == 'ItemCF':
	combined.append((tag, 'ItemCF', random_priority))
	elif method_name == 'Semantic':
	combined.append((tag, 'Semantic', random_priority))
	used_tags.add(tag)

	# 添加 ItemCF 和 Semantic 推荐
	add_unique_tags(itemcf_result, 'ItemCF')
	add_unique_tags(semantic_result, 'Semantic')

	# 添加随机标签
	random.shuffle(all_tags)
	add_unique_tags(all_tags, 'Random')

	# 排序：按推荐得分排序，加入的随机值也会影响排序
	combined.sort(key=lambda x: x[2], reverse=True)

	# 根据标签获取种子 ID
	final_tags = [tag for tag, _, _ in combined]
	print(f"最终推荐标签: {final_tags}")
	torrent_ids = get_torrent_ids_by_tags(final_tags)

	return jsonify({"torrent_ids": torrent_ids})



	from sqlalchemy.sql import text

	import random
	from sqlalchemy import text

	def get_torrent_ids_by_tags(tags, limit_per_tag=10):
	if not tags:
	tags = []
	print(f"传递给 get_torrent_ids_by_tags 的标签: {tags}")

	recommended_ids = set()
	with engine.connect() as conn:
	for tag in tags:
	query = text("""
	SELECT torrent_id
	FROM bt_torrent_tags
	WHERE tag = :tag
	LIMIT :limit
	""")
	result = conn.execute(query, {"tag": tag, "limit": limit_per_tag})
	print(f"标签 '{tag}' 的推荐结果:")
	for row in result:
	print(row[0]) # 打印每个torrent_id
	recommended_ids.add(row[0])

	# 获取数据库中所有 torrent_id
	all_query = text("SELECT DISTINCT torrent_id FROM bt_torrent")
	all_result = conn.execute(all_query)
	all_ids = set(row[0] for row in all_result)
	print("数据库中所有torrent_id:", all_ids)

	# 剩下的（非推荐）种子 ID
	remaining_ids = all_ids - recommended_ids
	print(remaining_ids)
	# 随机打乱推荐和剩下的 ID
	recommended_list = list(recommended_ids)
	remaining_list = list(remaining_ids)
	random.shuffle(recommended_list)
	random.shuffle(remaining_list)

	return recommended_list + remaining_list


	import os
	import time
	import jieba
	import fasttext
	from flask import Flask, request, jsonify
	import mysql.connector

	# ✅ 初始化数据库连接
	import mysql.connector
	from sklearn.metrics.pairwise import cosine_similarity
	import numpy as np

	def compute_similarity(vec1, vec2):
	"""计算两个词向量之间的余弦相似度"""
	# 使用 cosine_similarity 计算相似度
	return cosine_similarity([vec1], [vec2])[0][0]

	db = mysql.connector.connect(
	host="49.233.215.144",
	port=3306,
	user="sy",
	password="sy_password",
	database="pt_station"
	)

	cursor = db.cursor()


	app = Flask(__name__)

	# ✅ 加载 fastText 模型
	fasttext_model_path = './models/cc.zh.300.bin'
	if not os.path.exists(fasttext_model_path):
	raise FileNotFoundError("fastText 模型文件不存在，请检查路径。")

	print("加载 fastText 模型中...")
	ft_model = fasttext.load_model(fasttext_model_path)
	print("模型加载完成 ✅")
	fasttext_vocab = set(ft_model.words)

	# ✅ 全局标签缓存（用于避免频繁查询）
	existing_tags = set()

	def refresh_existing_tags():
	"""刷新数据库中已存在的标签集合"""
	global existing_tags
	cursor.execute("SELECT DISTINCT tag FROM user_tag_scores")
	existing_tags = set(tag[0] for tag in cursor.fetchall())
	print(f"已加载标签数: {len(existing_tags)}")

	# ✅ 启动时初始化标签缓存
	refresh_existing_tags()

	# ✅ 扩展函数：仅保留数据库已有标签
	def expand_tags_from_input(input_tags, topn=5, similarity_threshold=0.7):
	"""
	扩展输入标签列表，查找与之语义相似的标签，返回相似度大于阈值或最相似的前 n 个标签。

	:param input_tags: 输入标签的列表，例如 ['电影', '动漫', '游戏', '1080p']
	:param topn: 返回的最相似标签的数量，默认为 5
	:param similarity_threshold: 相似度阈值，默认为 0.7
	:return: 返回与输入标签相关的扩展标签列表
	"""
	# 用于存储所有扩展标签及其相似度
	tag_scores = {}

	for tag in input_tags:
	# 获取当前标签的词向量
	tag_vector = ft_model.get_word_vector(tag)

	# 遍历标签库中的所有标签并计算相似度
	for db_tag in existing_tags:
	db_tag_vector = ft_model.get_word_vector(db_tag)
	similarity = compute_similarity(tag_vector, db_tag_vector)

	if similarity >= similarity_threshold:
	if db_tag not in tag_scores:
	tag_scores[db_tag] = similarity
	else:
	tag_scores[db_tag] = max(tag_scores[db_tag], similarity)

	# 根据相似度排序并返回前 n 个标签
	sorted_tags = sorted(tag_scores.items(), key=lambda x: x[1], reverse=True)
	top_tags = [tag for tag, _ in sorted_tags[:topn]]

	return top_tags


	# ✅ 接口路由
	@app.route("/expand_tags", methods=["POST"])
	def expand_tags():
	start_time = time.time()

	# 从请求中获取数据
	data = request.get_json()
	input_tags = data.get("tags", [])
	user_id = data.get("user_id")
	rate = data.get("rate")

	topn = data.get("topn", 10) # 默认为 5
	similarity_threshold = 0.4 # 默认阈值为 0.7

	if not input_tags or not user_id:
	return jsonify({"error": "缺少参数 tags 或 user_id"}), 400

	# 获取与输入标签最相关的标签
	expanded_tags = expand_tags_from_input(input_tags, topn=topn, similarity_threshold=similarity_threshold)

	# 打印日志
	print(f"[用户 {user_id}] 输入标签: {input_tags}")
	print(f"[用户 {user_id}] 匹配扩展标签: {expanded_tags}")

	# 数据写入打分逻辑
	token_set = set(input_tags) # 用于确定哪些标签是用户输入的标签
	for tag in expanded_tags:
	score = 2.0 * rate if tag in token_set else 2.0 * rate
	try:
	cursor.execute("""
	INSERT INTO user_tag_scores (user_id, tag, score)
	VALUES (%s, %s, %s)
	ON DUPLICATE KEY UPDATE score = score + VALUES(score)
	""", (user_id, tag, score))
	except Exception as e:
	print(f"插入失败 [{tag}]:", e)
	db.commit()
	# ⏳ 插入后立即查询该用户的所有标签和评分
	try:
	cursor.execute("""
	SELECT tag, score FROM user_tag_scores WHERE user_id = %s
	""", (user_id,))
	user_scores = [{"tag": tag, "score": float(score)} for tag, score in cursor.fetchall()]
	print(user_scores)
	except Exception as e:
	print(f"查询用户评分失败: {e}")

	duration = round(time.time() - start_time, 3)
	return jsonify({
	"expanded_tags": expanded_tags,
	})


	# ✅ 触发标签缓存刷新（可选：手动/接口/定时任务调用）
	@app.route("/refresh_tags", methods=["POST"])
	def refresh_tags():
	refresh_existing_tags()
	return jsonify({"status": "标签缓存已刷新", "count": len(existing_tags)})


	# === ✅ 启动服务 ===
	if __name__ == '__main__':
	#train_and_save_itemcf()
	from waitress import serve
	serve(app, host="0.0.0.0", port=5000, threads=16)