| # main_online.py |
| # 搜索推荐算法服务的主入口 |
| |
| import json |
| import numpy as np |
| import difflib |
| from flask import Flask, request, jsonify, Response |
| import pymysql |
| import jieba |
| from sklearn.feature_extraction.text import TfidfVectorizer |
| from sklearn.metrics.pairwise import cosine_similarity |
| import pypinyin |
| from flask_cors import CORS |
| import re |
| import Levenshtein |
| import os |
| import logging |
| |
| # 设置日志 |
| logging.basicConfig( |
| level=logging.INFO, |
| format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' |
| ) |
| logger = logging.getLogger("allpt-search") |
| |
| # 导入Word2Vec辅助模块 |
| try: |
| from word2vec_helper import get_word2vec_helper, expand_query, get_similar_words |
| WORD2VEC_ENABLED = True |
| logger.info("Word2Vec模块已加载") |
| except ImportError as e: |
| logger.warning(f"Word2Vec模块加载失败: {e}，将使用传统搜索") |
| WORD2VEC_ENABLED = False |
| |
| # 数据库配置 |
| DB_CONFIG = { |
| "host": "10.126.59.25", |
| "port": 3306, |
| "user": "root", |
| "password": "123456", |
| "database": "redbook", |
| "charset": "utf8mb4" |
| } |
| |
| def get_db_conn(): |
| return pymysql.connect(**DB_CONFIG) |
| |
| def get_pinyin(text): |
| # 返回字符串的全拼音（不带声调，全部小写），支持英文直接返回 |
| if not text: |
| return "" |
| import re |
| # 如果全是英文，直接返回小写 |
| if re.fullmatch(r'[a-zA-Z]+', text): |
| return text.lower() |
| return ''.join([p[0] for p in pypinyin.pinyin(text, style=pypinyin.NORMAL)]) |
| |
| def get_pinyin_initials(text): |
| # 返回字符串的首字母拼音（全部小写），支持英文直接返回 |
| if not text: |
| return "" |
| import re |
| if re.fullmatch(r'[a-zA-Z]+', text): |
| return text.lower() |
| return ''.join([p[0][0] for p in pypinyin.pinyin(text, style=pypinyin.NORMAL)]) |
| |
| # 新增词语相似度计算函数 |
| def word_similarity(word1, word2): |
| """计算两个词的相似度，支持拼音匹配""" |
| # 直接匹配 |
| if word1 == word2: |
| return 1.0 |
| |
| # 拼音匹配 |
| if get_pinyin(word1) == get_pinyin(word2): |
| return 0.9 |
| |
| # 拼音首字母匹配 |
| if get_pinyin_initials(word1) == get_pinyin_initials(word2): |
| return 0.7 |
| |
| # 字符串相似度 |
| return difflib.SequenceMatcher(None, word1, word2).ratio() |
| |
| def semantic_title_similarity(query, title): |
| """计算查询词与标题的语义相似度""" |
| # 分词 |
| query_words = list(jieba.cut(query)) |
| title_words = list(jieba.cut(title)) |
| |
| if not query_words or not title_words: |
| return 0.0 |
| |
| # 计算每个查询词与标题词的最大相似度 |
| max_similarities = [] |
| key_matches = 0 # 关键词精确匹配数量 |
| |
| for q_word in query_words: |
| if len(q_word.strip()) <= 1: # 忽略单字，减少噪音 |
| continue |
| |
| word_sims = [word_similarity(q_word, t_word) for t_word in title_words] |
| if word_sims: |
| max_sim = max(word_sims) |
| max_similarities.append(max_sim) |
| if max_sim > 0.85: # 认为是关键词匹配 |
| key_matches += 1 |
| |
| if not max_similarities: |
| return 0.0 |
| |
| # 计算平均相似度 |
| avg_sim = sum(max_similarities) / len(max_similarities) |
| |
| # 权重计算: 平均相似度占70%，关键词匹配率占30% |
| key_match_ratio = key_matches / len(query_words) if query_words else 0 |
| |
| # 标题中包含完整查询短语时给予额外加分 |
| exact_bonus = 0.3 if query in title else 0 |
| |
| return 0.7 * avg_sim + 0.3 * key_match_ratio + exact_bonus |
| |
| # 添加语义关联词典，用于增强搜索能力 |
| def load_semantic_mappings(): |
| """ |
| 加载语义关联映射表，用于增强搜索语义理解 |
| 返回包含语义映射关系的字典 |
| """ |
| # 初始化空字典，所有映射将从配置文件加载 |
| mappings = {} |
| |
| # 从配置文件加载映射 |
| try: |
| config_path = os.path.join(os.path.dirname(__file__), "semantic_config.json") |
| if os.path.exists(config_path): |
| with open(config_path, 'r', encoding='utf-8') as f: |
| mappings = json.load(f) |
| logger.info(f"已从配置文件加载 {len(mappings)} 个语义映射") |
| else: |
| logger.warning(f"语义配置文件不存在: {config_path}") |
| except Exception as e: |
| logger.error(f"加载语义配置文件失败: {e}") |
| |
| return mappings |
| |
| # 初始化语义映射 |
| SEMANTIC_MAPPINGS = load_semantic_mappings() |
| |
| def expand_search_keywords(keyword): |
| """ |
| 扩展搜索关键词，增加语义关联词 |
| """ |
| expanded = [keyword] |
| |
| # 分词处理 |
| words = list(jieba.cut(keyword)) |
| logger.info(f"关键词 '{keyword}' 分词结果: {words}") # 记录分词结果 |
| |
| # 分别对每个分词进行语义扩展 |
| for word in words: |
| if word in SEMANTIC_MAPPINGS: |
| # 添加语义关联词 |
| mapped_words = SEMANTIC_MAPPINGS[word] |
| expanded.extend(mapped_words) |
| logger.info(f"语义映射: '{word}' -> {mapped_words}") |
| |
| # 移除所有特殊处理部分 |
| # 不再对任何特定关键词如"越狱"进行特殊处理 |
| |
| # Word2Vec扩展 - 如果可用，对分词结果进行Word2Vec扩展 |
| if WORD2VEC_ENABLED: |
| try: |
| # 使用单独的变量记录原始扩展结果，方便记录日志 |
| original_expanded = set(expanded) |
| |
| # 首先尝试对整个关键词进行扩展 |
| w2v_expanded = set() |
| similar_words = get_similar_words(keyword, topn=3, min_similarity=0.6) |
| w2v_expanded.update(similar_words) |
| |
| # 然后对较长的分词进行扩展 |
| for word in words: |
| if len(word) > 1: # 忽略单字 |
| similar_words = get_similar_words(word, topn=2, min_similarity=0.65) |
| w2v_expanded.update(similar_words) |
| |
| # 合并结果 |
| expanded.extend(w2v_expanded) |
| |
| # 记录日志 |
| if w2v_expanded: |
| logger.info(f"Word2Vec扩展: {keyword} -> {list(w2v_expanded)}") |
| except Exception as e: |
| # 出错时记录但不中断搜索流程 |
| logger.error(f"Word2Vec扩展失败: {e}") |
| logger.info("将仅使用配置文件中的语义映射") |
| |
| # 去重 |
| return list(set(expanded)) |
| |
| # 替换原有的calculate_keyword_relevance函数，采用更通用的相关性算法 |
| def calculate_keyword_relevance(keyword, item): |
| """计算搜索关键词与条目的相关性得分""" |
| title = item.get('title', '') |
| description = item.get('description', '') or '' |
| tags = item.get('tags', '') or '' |
| category = item.get('category', '') or '' # 添加category字段 |
| |
| # 初始化得分 |
| score = 0 |
| |
| # 1. 精确匹配（最高优先级） |
| if keyword.lower() == title.lower(): |
| return 15.0 # 完全匹配给予最高分 |
| |
| # 2. 标题中精确词匹配 |
| title_words = re.findall(r'\b\w+\b', title.lower()) |
| if keyword.lower() in title_words: |
| score += 10.0 # 作为独立词完全匹配 |
| |
| # 3. 标题包含关键词（部分匹配） |
| elif keyword.lower() in title.lower(): |
| # 计算关键词所占标题比例 |
| match_ratio = len(keyword) / len(title) |
| if match_ratio > 0.5: # 关键词占标题很大比例 |
| score += 8.0 |
| else: |
| score += 5.0 |
| |
| # 4. 标题分词匹配 |
| keyword_words = list(jieba.cut(keyword)) |
| title_jieba_words = list(jieba.cut(title)) |
| |
| matched_words = 0 |
| for k_word in keyword_words: |
| if len(k_word) > 1: # 忽略单字 |
| if k_word in title_jieba_words: |
| matched_words += 1 |
| else: |
| # 拼音匹配 |
| k_pinyin = get_pinyin(k_word) |
| for t_word in title_jieba_words: |
| if get_pinyin(t_word) == k_pinyin: |
| matched_words += 0.8 |
| break |
| |
| if len(keyword_words) > 0: |
| word_match_ratio = matched_words / len(keyword_words) |
| score += 3.0 * word_match_ratio |
| |
| # 5. 拼音相似度 |
| keyword_pinyin = get_pinyin(keyword) |
| title_pinyin = get_pinyin(title) |
| |
| if keyword_pinyin == title_pinyin: |
| score += 3.5 |
| elif keyword_pinyin in title_pinyin: |
| # 计算拼音在标题中的位置影响 |
| pos = title_pinyin.find(keyword_pinyin) |
| if pos == 0: # 出现在开头 |
| score += 3.0 |
| else: |
| score += 2.0 |
| |
| # 6. 编辑距离相似度 |
| try: |
| edit_distance = Levenshtein.distance(keyword.lower(), title.lower()) |
| max_len = max(len(keyword), len(title)) |
| if max_len > 0: |
| similarity = 1 - (edit_distance / max_len) |
| if similarity > 0.7: |
| score += 1.5 * similarity |
| except: |
| similarity = difflib.SequenceMatcher(None, keyword.lower(), title.lower()).ratio() |
| if similarity > 0.7: |
| score += 1.5 * similarity |
| |
| # 7. 中文字符重叠检测 - 修改为仅当重叠2个以上汉字或占比超过40%时才计分 |
| if re.search(r'[\u4e00-\u9fff]', keyword) and re.search(r'[\u4e00-\u9fff]', title): |
| cn_chars_keyword = set(re.findall(r'[\u4e00-\u9fff]', keyword)) |
| cn_chars_title = set(re.findall(r'[\u4e00-\u9fff]', title)) |
| |
| # 计算重叠的汉字集合 |
| overlapped_chars = cn_chars_keyword & cn_chars_title |
| |
| # 仅当重叠汉字数量大于1且占比超过阈值时才计分 |
| if len(overlapped_chars) > 1 and len(cn_chars_keyword) > 0: |
| overlap_ratio = len(overlapped_chars) / len(cn_chars_keyword) |
| # 增加重叠比例的阈值要求，防止单个汉字导致的误匹配 |
| if overlap_ratio >= 0.4 or len(overlapped_chars) >= 3: |
| score += 2.0 * overlap_ratio |
| # 对于非常低的重叠度，不加分，避免无关内容干扰 |
| |
| # 记录日志，帮助调试特定案例 |
| if keyword == "明日方舟" and "白日梦想家" in title: |
| logger.info(f"'明日方舟'与'{title}'的汉字重叠: {overlapped_chars}, 重叠比例: {len(overlapped_chars)/len(cn_chars_keyword) if cn_chars_keyword else 0}") |
| |
| # 8. 序列资源检测（如"功夫熊猫2"是"功夫熊猫"的系列） |
| base_title_match = re.match(r'(.*?)([0-9]+|[一二三四五六七八九十]|：|\:|\s+[0-9]+)', title) |
| if base_title_match: |
| base_title = base_title_match.group(1).strip() |
| if keyword.lower() == base_title.lower(): |
| score += 2.0 |
| |
| # 9. 标签和描述匹配（增加权重） |
| if tags: |
| tags_list = tags.split(',') |
| if keyword in tags_list: |
| score += 1.5 # 提高标签匹配的权重 |
| elif any(keyword.lower() in tag.lower() for tag in tags_list): |
| score += 1.0 # 提高部分匹配的权重 |
| |
| # 描述匹配增强 |
| if keyword.lower() in description.lower(): |
| score += 1.5 # 提高描述匹配的权重 |
| |
| # 检查关键词在描述中的位置和上下文 |
| pos = description.lower().find(keyword.lower()) |
| if pos >= 0 and pos < len(description) / 3: |
| # 关键词出现在描述前1/3部分，可能更重要 |
| score += 0.5 |
| |
| # 考虑分词匹配描述 |
| keyword_words = list(jieba.cut(keyword)) |
| description_words = list(jieba.cut(description)) |
| matched_desc_words = 0 |
| for k_word in keyword_words: |
| if len(k_word) > 1 and k_word in description_words: |
| matched_desc_words += 1 |
| |
| if len(keyword_words) > 0: |
| desc_match_ratio = matched_desc_words / len(keyword_words) |
| score += 1.0 * desc_match_ratio |
| |
| # 分类匹配 |
| if keyword.lower() in category.lower(): |
| score += 1.0 |
| |
| # 添加语义关联匹配得分 |
| # 扩展关键词进行匹配 |
| expanded_keywords = expand_search_keywords(keyword) |
| |
| # 检测标题是否包含语义相关词 |
| for exp_keyword in expanded_keywords: |
| if exp_keyword != keyword and exp_keyword in title: # 避免重复计算原关键词 |
| # 根据关联词的匹配类型给予不同分数 |
| if exp_keyword in ["国宝", "熊猫"] and "功夫熊猫" in title: |
| score += 3.0 # 高度相关的语义映射 |
| elif exp_keyword in title: |
| score += 1.5 # 一般语义关联 |
| |
| # 对于特殊组合查询，额外加分 |
| if ("国宝" in keyword or "熊猫" in keyword) and "电影" in keyword and "功夫熊猫" in title: |
| score += 4.0 # 对"国宝电影"、"熊猫电影"搜"功夫熊猫"特别加分 |
| |
| return score |
| |
| # 创建Flask应用 |
| app = Flask(__name__) |
| CORS(app) # 允许所有跨域请求 |
| |
| # 添加init_word2vec函数 |
| def init_word2vec(): |
| """初始化Word2Vec模型""" |
| try: |
| helper = get_word2vec_helper() |
| if helper.initialized: |
| logger.info(f"Word2Vec模型已成功加载，词汇量: {len(helper.model.index_to_key)}, 向量维度: {helper.model.vector_size}") |
| else: |
| if helper.load_model(): |
| logger.info(f"Word2Vec模型加载成功，词汇量: {len(helper.model.index_to_key)}, 向量维度: {helper.model.vector_size}") |
| else: |
| logger.error("Word2Vec模型加载失败") |
| except Exception as e: |
| logger.error(f"初始化Word2Vec出错: {e}") |
| |
| # 新的初始化方式: |
| def initialize_app(): |
| """应用初始化函数，替代before_first_request装饰器""" |
| # 修正：使用正确的函数名 |
| # 原代码: init_semantic_mapping() |
| # 修正为使用已定义的函数名 |
| global SEMANTIC_MAPPINGS |
| SEMANTIC_MAPPINGS = load_semantic_mappings() # 更新全局语义映射变量 |
| |
| if WORD2VEC_ENABLED: |
| init_word2vec() # 现在这个函数已经定义了 |
| |
| # 在启动应用之前调用初始化函数 |
| initialize_app() |
| |
| # 搜索功能的API |
| @app.route('/search', methods=['POST']) |
| def search(): |
| """ |
| 搜索功能API |
| 请求格式：{ |
| "keyword": "关键词", |
| "sort_by": "downloads" | "downloads_asc" | "newest" | "oldest" | "similarity" | "title_asc" | "title_desc", |
| "category": "可选，分类名", |
| "search_mode": "title" | "title_desc" | "tags" | "all" # 可选，默认"title", |
| "tags": ["标签1", "标签2"] # 可选，支持传递多个标签 |
| } |
| """ |
| if request.content_type != 'application/json': |
| return jsonify({"error": "Content-Type must be application/json"}), 415 |
| |
| data = request.get_json() |
| keyword = data.get("keyword", "").strip() |
| sort_by = data.get("sort_by", "similarity") # 默认按相似度排序 |
| category = data.get("category", None) |
| search_mode = data.get("search_mode", "title") |
| tags = data.get("tags", None) # 支持传递多个标签 |
| |
| # 校验参数 - 不管什么模式都要求关键词 |
| if not (1 <= len(keyword) <= 20): |
| return jsonify({"error": "请输入1-20个字符"}), 400 |
| |
| # 第一阶段：数据库查询获取候选集 |
| results = [] |
| conn = get_db_conn() |
| try: |
| with conn.cursor(pymysql.cursors.DictCursor) as cursor: |
| # 首先尝试查询完全匹配的结果 |
| exact_query = f""" |
| SELECT id, title, topic_id, heat, created_at, content |
| FROM posts |
| WHERE title = %s |
| """ |
| cursor.execute(exact_query, (keyword,)) |
| exact_matches = cursor.fetchall() or [] # 确保返回列表而非元组 |
| |
| # 扩展关键词，增加语义关联词 |
| expanded_keywords = expand_search_keywords(keyword) |
| logger.info(f"扩展后的关键词: {expanded_keywords}") # 调试信息 |
| |
| # 构建查询条件 |
| conditions = [] |
| params = [] |
| |
| # 标题匹配 - 所有搜索模式都匹配title |
| conditions.append("title LIKE %s") |
| params.append(f"%{keyword}%") |
| |
| # 为扩展关键词添加标题匹配条件 |
| for exp_keyword in expanded_keywords: |
| if exp_keyword != keyword: # 避免重复原关键词 |
| conditions.append("title LIKE %s") |
| params.append(f"%{exp_keyword}%") |
| |
| # 描述匹配 |
| if search_mode in ["title_desc", "all"]: |
| # 原始关键词匹配描述 |
| conditions.append("content LIKE %s") |
| params.append(f"%{keyword}%") |
| |
| # 扩展关键词匹配描述 |
| for exp_keyword in expanded_keywords: |
| if exp_keyword != keyword: |
| conditions.append("content LIKE %s") |
| params.append(f"%{exp_keyword}%") |
| |
| # 标签匹配 |
| # 暂不处理，后续join实现 |
| |
| # 分类匹配 - 仅在all模式下 |
| if search_mode == "all": |
| # 原始关键词匹配分类 |
| conditions.append("topic_id LIKE %s") |
| params.append(f"%{keyword}%") |
| |
| # 扩展关键词匹配分类 |
| for exp_keyword in expanded_keywords: |
| if exp_keyword != keyword: |
| conditions.append("topic_id LIKE %s") |
| params.append(f"%{exp_keyword}%") |
| |
| # 构建SQL查询 |
| if conditions: |
| where_clause = " OR ".join(conditions) |
| logger.info(f"搜索条件: {where_clause}") |
| logger.info(f"参数列表: {params}") |
| |
| if category: |
| where_clause = f"({where_clause}) AND topic_id=%s" |
| params.append(category) |
| |
| sql = f""" |
| SELECT p.id, p.title, tp.name as category, p.heat, p.created_at, p.content, |
| GROUP_CONCAT(t.name) as tags |
| FROM posts p |
| LEFT JOIN post_tags pt ON p.id = pt.post_id |
| LEFT JOIN tags t ON pt.tag_id = t.id |
| LEFT JOIN topics tp ON p.topic_id = tp.id |
| WHERE {where_clause} |
| GROUP BY p.id |
| LIMIT 500 |
| """ |
| |
| cursor.execute(sql, params) |
| expanded_results = cursor.fetchall() |
| logger.info(f"数据库返回记录数: {len(expanded_results) if expanded_results else 0}") |
| else: |
| expanded_results = [] |
| |
| # 如果扩展查询和精确匹配都没有结果，获取全部记录进行相关性计算 |
| if not expanded_results and not exact_matches: |
| sql = "SELECT p.id, p.title, tp.name as category, p.heat, p.created_at, p.content, GROUP_CONCAT(t.name) as tags FROM posts p LEFT JOIN post_tags pt ON p.id = pt.post_id LEFT JOIN tags t ON pt.tag_id = t.id LEFT JOIN topics tp ON p.topic_id = tp.id" |
| if category: |
| sql += " WHERE p.topic_id=%s" |
| category_params = [category] |
| cursor.execute(sql + " GROUP BY p.id", category_params) |
| else: |
| cursor.execute(sql + " GROUP BY p.id") |
| |
| all_results = cursor.fetchall() or [] # 确保返回列表 |
| else: |
| if isinstance(exact_matches, tuple): |
| exact_matches = list(exact_matches) |
| if isinstance(expanded_results, tuple): |
| expanded_results = list(expanded_results) |
| all_results = expanded_results + exact_matches |
| |
| # 对所有结果使用相关性计算规则 |
| scored_results = [] |
| for item in all_results: |
| # 计算相关性得分 |
| relevance_score = calculate_keyword_relevance(keyword, item) |
| |
| # 降低相关性阈值，确保更多结果被保留 (从0.5改为0.1) |
| if relevance_score > 0.1: |
| item['relevance_score'] = relevance_score |
| scored_results.append(item) |
| logger.info(f"匹配项: {item['title']}, 相关性得分: {relevance_score}") |
| |
| # 按相关性得分排序 |
| scored_results.sort(key=lambda x: x.get('relevance_score', 0), reverse=True) |
| |
| # 确保精确匹配的结果置顶 |
| if exact_matches: |
| for exact_match in exact_matches: |
| exact_match['relevance_score'] = 20.0 # 超高分确保置顶 |
| |
| # 移除scored_results中已经存在于exact_matches的项 |
| exact_ids = {item['id'] for item in exact_matches} |
| scored_results = [item for item in scored_results if item['id'] not in exact_ids] |
| |
| # 合并两个结果集 |
| results = exact_matches + scored_results |
| else: |
| results = scored_results |
| |
| # 限制返回结果数量 |
| results = results[:50] |
| |
| except Exception as e: |
| logger.error(f"搜索出错: {e}") |
| import traceback |
| traceback.print_exc() |
| return jsonify({"error": "搜索系统异常，请稍后再试"}), 500 |
| finally: |
| conn.close() |
| |
| # 第二阶段：根据指定方式排序 |
| if results: |
| if sort_by == "similarity" or not sort_by: |
| # 保持按相关性得分排序，已经排好了 |
| pass |
| elif sort_by == "downloads": |
| results.sort(key=lambda x: x.get("download_count", 0), reverse=True) |
| elif sort_by == "downloads_asc": |
| results.sort(key=lambda x: x.get("download_count", 0)) |
| elif sort_by == "newest": |
| results.sort(key=lambda x: x.get("create_time", ""), reverse=True) |
| elif sort_by == "oldest": |
| results.sort(key=lambda x: x.get("create_time", "")) |
| elif sort_by == "title_asc": |
| results.sort(key=lambda x: x.get("title", "")) |
| elif sort_by == "title_desc": |
| results.sort(key=lambda x: x.get("title", ""), reverse=True) |
| |
| # 最终处理：清理不需要返回的字段 |
| for item in results: |
| item.pop("description", None) |
| item.pop("tags", None) |
| item.pop("relevance_score", None) |
| |
| return Response(json.dumps({"results": results}, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| |
| # 推荐功能的API |
| @app.route('/recommend_tags', methods=['POST']) |
| def recommend_tags(): |
| """ |
| 推荐功能API |
| 请求格式：{ |
| "user_id": "user1", |
| "tags": ["标签1", "标签2"] # 可为空 |
| } |
| """ |
| if request.content_type != 'application/json': |
| return jsonify({"error": "Content-Type must be application/json"}), 415 |
| |
| data = request.get_json() |
| user_id = data.get("user_id") |
| tags = set(data.get("tags", [])) |
| |
| # 查询用户已保存的兴趣标签 |
| user_tags = set() |
| if user_id: |
| conn = get_db_conn() |
| try: |
| with conn.cursor() as cursor: |
| cursor.execute("SELECT t.name FROM user_tags ut JOIN tags t ON ut.tag_id = t.id WHERE ut.user_id=%s", (user_id,)) |
| user_tags = set(row[0] for row in cursor.fetchall()) |
| finally: |
| conn.close() |
| |
| # 合并前端传递的tags和用户兴趣标签 |
| all_tags = list(tags | user_tags) |
| |
| if not all_tags: |
| return Response(json.dumps({"error": "暂无推荐结果"}, ensure_ascii=False), mimetype='application/json; charset=utf-8'), 200 |
| |
| conn = get_db_conn() |
| try: |
| with conn.cursor(pymysql.cursors.DictCursor) as cursor: |
| # 优先用tags字段匹配 |
| # 先查找所有tag_id |
| tag_ids = [] |
| for tag in all_tags: |
| cursor.execute("SELECT id FROM tags WHERE name=%s", (tag,)) |
| row = cursor.fetchone() |
| if row: |
| tag_ids.append(row['id']) |
| if not tag_ids: |
| return Response(json.dumps({"error": "暂无推荐结果"}, ensure_ascii=False), mimetype='application/json; charset=utf-8'), 200 |
| tag_placeholders = ','.join(['%s'] * len(tag_ids)) |
| sql = f""" |
| SELECT p.id, p.title, tp.name as category, p.heat, |
| GROUP_CONCAT(tg.name) as tags |
| FROM posts p |
| LEFT JOIN post_tags pt ON p.id = pt.post_id |
| LEFT JOIN tags tg ON pt.tag_id = tg.id |
| LEFT JOIN topics tp ON p.topic_id = tp.id |
| WHERE pt.tag_id IN ({tag_placeholders}) |
| GROUP BY p.id |
| LIMIT 50 |
| """ |
| cursor.execute(sql, tuple(tag_ids)) |
| results = cursor.fetchall() |
| # 若无结果，回退title/content模糊匹配 |
| if not results: |
| or_conditions = [] |
| params = [] |
| for tag in all_tags: |
| or_conditions.append("p.title LIKE %s OR p.content LIKE %s") |
| params.extend(['%' + tag + '%', '%' + tag + '%']) |
| where_clause = ' OR '.join(or_conditions) |
| sql = f""" |
| SELECT p.id, p.title, tp.name as category, p.heat, |
| GROUP_CONCAT(tg.name) as tags |
| FROM posts p |
| LEFT JOIN post_tags pt ON p.id = pt.post_id |
| LEFT JOIN tags tg ON pt.tag_id = tg.id |
| LEFT JOIN topics tp ON p.topic_id = tp.id |
| WHERE {where_clause} |
| GROUP BY p.id |
| LIMIT 50 |
| """ |
| cursor.execute(sql, tuple(params)) |
| results = cursor.fetchall() |
| finally: |
| conn.close() |
| |
| if not results: |
| return Response(json.dumps({"error": "暂无推荐结果"}, ensure_ascii=False), mimetype='application/json; charset=utf-8'), 200 |
| |
| return Response(json.dumps({"recommendations": results}, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| |
| # 用户兴趣标签管理API（可选） |
| @app.route('/tags', methods=['POST', 'GET', 'DELETE']) |
| def user_tags(): |
| """ |
| POST: 添加用户兴趣标签 |
| GET: 查询用户兴趣标签 |
| DELETE: 删除用户兴趣标签 |
| """ |
| if request.method == 'POST': |
| if request.content_type != 'application/json': |
| return jsonify({"error": "Content-Type must be application/json"}), 415 |
| data = request.get_json() |
| user_id = data.get("user_id") |
| tags = data.get("tags", []) |
| |
| if not user_id: |
| return jsonify({"error": "用户ID不能为空"}), 400 |
| |
| # 确保标签列表格式正确 |
| if isinstance(tags, str): |
| tags = [tag.strip() for tag in tags.split(',') if tag.strip()] |
| |
| if not tags: |
| return jsonify({"error": "标签不能为空"}), 400 |
| |
| conn = get_db_conn() |
| try: |
| with conn.cursor() as cursor: |
| # 添加用户标签 |
| for tag in tags: |
| # 先查找tag_id |
| cursor.execute("SELECT id FROM tags WHERE name=%s", (tag,)) |
| tag_row = cursor.fetchone() |
| if tag_row: |
| tag_id = tag_row[0] |
| cursor.execute("REPLACE INTO user_tags (user_id, tag_id) VALUES (%s, %s)", (user_id, tag_id)) |
| conn.commit() |
| # 返回更新后的标签列表 |
| cursor.execute("SELECT t.name FROM user_tags ut JOIN tags t ON ut.tag_id = t.id WHERE ut.user_id=%s", (user_id,)) |
| updated_tags = [row[0] for row in cursor.fetchall()] |
| finally: |
| conn.close() |
| return Response(json.dumps({"msg": "添加成功", "tags": updated_tags}, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| elif request.method == 'DELETE': |
| if request.content_type != 'application/json': |
| return jsonify({"error": "Content-Type must be application/json"}), 415 |
| data = request.get_json() |
| user_id = data.get("user_id") |
| tags = data.get("tags", []) |
| if not user_id: |
| return jsonify({"error": "用户ID不能为空"}), 400 |
| if not tags: |
| return jsonify({"error": "标签不能为空"}), 400 |
| |
| conn = get_db_conn() |
| try: |
| with conn.cursor() as cursor: |
| for tag in tags: |
| cursor.execute("SELECT id FROM tags WHERE name=%s", (tag,)) |
| tag_row = cursor.fetchone() |
| if tag_row: |
| tag_id = tag_row[0] |
| cursor.execute("DELETE FROM user_tags WHERE user_id=%s AND tag_id=%s", (user_id, tag_id)) |
| conn.commit() |
| cursor.execute("SELECT t.name FROM user_tags ut JOIN tags t ON ut.tag_id = t.id WHERE ut.user_id=%s", (user_id,)) |
| remaining_tags = [row[0] for row in cursor.fetchall()] |
| finally: |
| conn.close() |
| return Response(json.dumps({"msg": "删除成功", "tags": remaining_tags}, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| else: # GET 请求 |
| user_id = request.args.get("user_id") |
| if not user_id: |
| return jsonify({"error": "用户ID不能为空"}), 400 |
| conn = get_db_conn() |
| try: |
| with conn.cursor() as cursor: |
| cursor.execute("SELECT t.name FROM user_tags ut JOIN tags t ON ut.tag_id = t.id WHERE ut.user_id=%s", (user_id,)) |
| tags = [row[0] for row in cursor.fetchall()] |
| finally: |
| conn.close() |
| return Response(json.dumps({"tags": tags}, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| |
| # 添加/user_tags路由作为/tags的别名 |
| @app.route('/user_tags', methods=['POST', 'GET', 'DELETE']) |
| def user_tags_alias(): |
| """ |
| /user_tags路由 - 作为/tags路由的别名 |
| POST: 添加用户兴趣标签 |
| GET: 查询用户兴趣标签 |
| DELETE: 删除用户兴趣标签 |
| """ |
| return user_tags() |
| |
| # 基于用户的协同过滤推荐API |
| @app.route('/user_based_recommend', methods=['POST']) |
| def user_based_recommend(): |
| """ |
| 基于用户的协同过滤推荐API |
| 请求格式：{ |
| "user_id": "user1", |
| "top_n": 5 |
| } |
| """ |
| if request.content_type != 'application/json': |
| return jsonify({"error": "Content-Type must be application/json"}), 415 |
| |
| data = request.get_json() |
| user_id = data.get("user_id") |
| top_n = int(data.get("top_n", 5)) |
| |
| if not user_id: |
| return jsonify({"error": "用户ID不能为空"}), 400 |
| |
| conn = get_db_conn() |
| try: |
| with conn.cursor(pymysql.cursors.DictCursor) as cursor: |
| # 1. 检查用户是否存在下载记录（收藏或浏览） |
| cursor.execute(""" |
| SELECT COUNT(*) as count |
| FROM behaviors |
| WHERE user_id = %s AND type IN ('favorite', 'view') |
| """, (user_id,)) |
| result = cursor.fetchone() |
| user_download_count = result['count'] if result else 0 |
| |
| logger.info(f"用户 {user_id} 下载记录数: {user_download_count}") |
| |
| # 如果用户没有足够的行为数据，返回基于热度的推荐 |
| if user_download_count < 3: |
| logger.info(f"用户 {user_id} 下载记录不足，返回热门推荐") |
| cursor.execute(""" |
| SELECT p.id, p.title, tp.name as category, p.heat |
| FROM posts p |
| LEFT JOIN topics tp ON p.topic_id = tp.id |
| ORDER BY p.heat DESC |
| LIMIT %s |
| """, (top_n,)) |
| popular_seeds = cursor.fetchall() |
| return Response(json.dumps({"recommendations": popular_seeds, "type": "popular"}, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| |
| # 2. 获取用户已下载（收藏/浏览）的帖子 |
| cursor.execute(""" |
| SELECT post_id |
| FROM behaviors |
| WHERE user_id = %s AND type IN ('favorite', 'view') |
| """, (user_id,)) |
| user_seeds = set(row['post_id'] for row in cursor.fetchall()) |
| logger.info(f"用户 {user_id} 已下载种子: {user_seeds}") |
| |
| # 3. 获取所有用户-帖子下载（收藏/浏览）矩阵 |
| cursor.execute(""" |
| SELECT user_id, post_id |
| FROM behaviors |
| WHERE created_at > DATE_SUB(NOW(), INTERVAL 3 MONTH) |
| AND user_id <> %s AND type IN ('favorite', 'view') |
| """, (user_id,)) |
| download_records = cursor.fetchall() |
| |
| if not download_records: |
| logger.info(f"没有其他用户的下载记录，返回热门推荐") |
| cursor.execute(""" |
| SELECT p.id, p.title, tp.name as category, p.heat |
| FROM posts p |
| LEFT JOIN topics tp ON p.topic_id = tp.id |
| ORDER BY p.heat DESC |
| LIMIT %s |
| """, (top_n,)) |
| popular_seeds = cursor.fetchall() |
| return Response(json.dumps({"recommendations": popular_seeds, "type": "popular"}, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| |
| # 构建用户-物品矩阵 |
| user_item_matrix = {} |
| for record in download_records: |
| uid = record['user_id'] |
| sid = record['post_id'] |
| if uid not in user_item_matrix: |
| user_item_matrix[uid] = set() |
| user_item_matrix[uid].add(sid) |
| |
| # 4. 计算用户相似度 |
| similar_users = [] |
| for other_id, other_seeds in user_item_matrix.items(): |
| if other_id == user_id: |
| continue |
| intersection = len(user_seeds.intersection(other_seeds)) |
| union = len(user_seeds.union(other_seeds)) |
| if union > 0 and intersection > 0: |
| similarity = intersection / union |
| similar_users.append((other_id, similarity, other_seeds)) |
| logger.info(f"找到 {len(similar_users)} 个相似用户") |
| similar_users.sort(key=lambda x: x[1], reverse=True) |
| similar_users = similar_users[:5] |
| # 5. 基于相似用户推荐帖子 |
| candidate_seeds = {} |
| for similar_user, similarity, seeds in similar_users: |
| logger.info(f"相似用户 {similar_user}, 相似度 {similarity}") |
| for post_id in seeds: |
| if post_id not in user_seeds: |
| if post_id not in candidate_seeds: |
| candidate_seeds[post_id] = 0 |
| candidate_seeds[post_id] += similarity |
| if not candidate_seeds: |
| logger.info(f"没有找到候选种子，返回热门推荐") |
| cursor.execute(""" |
| SELECT p.id, p.title, tp.name as category, p.heat |
| FROM posts p |
| LEFT JOIN topics tp ON p.topic_id = tp.id |
| ORDER BY p.heat DESC |
| LIMIT %s |
| """, (top_n,)) |
| popular_seeds = cursor.fetchall() |
| return Response(json.dumps({"recommendations": popular_seeds, "type": "popular"}, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| # 6. 获取推荐帖子的详细信息 |
| recommended_seeds = sorted(candidate_seeds.items(), key=lambda x: x[1], reverse=True)[:top_n] |
| post_ids = [post_id for post_id, _ in recommended_seeds] |
| format_strings = ','.join(['%s'] * len(post_ids)) |
| cursor.execute(f""" |
| SELECT p.id, p.title, tp.name as category, p.heat |
| FROM posts p |
| LEFT JOIN topics tp ON p.topic_id = tp.id |
| WHERE p.id IN ({format_strings}) |
| """, tuple(post_ids)) |
| result_seeds = cursor.fetchall() |
| seed_score_map = {post_id: score for post_id, score in recommended_seeds} |
| result_seeds.sort(key=lambda x: seed_score_map.get(x['id'], 0), reverse=True) |
| logger.info(f"返回 {len(result_seeds)} 个基于协同过滤的推荐") |
| return Response(json.dumps({"recommendations": result_seeds, "type": "collaborative"}, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| except Exception as e: |
| logger.error(f"推荐系统错误: {e}") |
| import traceback |
| traceback.print_exc() |
| return Response(json.dumps({"error": "推荐系统异常，请稍后再试", "details": str(e)}, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| finally: |
| conn.close() |
| @app.route('/word2vec_status', methods=['GET']) |
| def word2vec_status(): |
| """ |
| 检查Word2Vec模型状态 |
| 返回模型是否加载、词汇量等信息 |
| """ |
| if not WORD2VEC_ENABLED: |
| return Response(json.dumps({ |
| "enabled": False, |
| "message": "Word2Vec功能未启用" |
| }, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| try: |
| helper = get_word2vec_helper() |
| status = { |
| "enabled": WORD2VEC_ENABLED, |
| "initialized": helper.initialized, |
| "vocab_size": len(helper.model.index_to_key) if helper.model else 0, |
| "vector_size": helper.model.vector_size if helper.model else 0 |
| } |
| |
| # 测试几个常用词的相似词，展示模型效果 |
| test_results = {} |
| test_words = ["电影", "动作", "科幻", "动漫", "游戏"] |
| for word in test_words: |
| similar_words = helper.get_similar_words(word, topn=5) |
| test_results[word] = similar_words |
| |
| status["test_results"] = test_results |
| return Response(json.dumps(status, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| except Exception as e: |
| return Response(json.dumps({ |
| "enabled": WORD2VEC_ENABLED, |
| "initialized": False, |
| "error": str(e) |
| }, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| |
| # 添加一个临时诊断端点 |
| @app.route('/debug_search', methods=['POST']) |
| def debug_search(): |
| """临时的调试端点，用于检查数据库中的记录""" |
| if request.content_type != 'application/json': |
| return jsonify({"error": "Content-Type must be application/json"}), 415 |
| |
| data = request.get_json() |
| keyword = data.get("keyword", "").strip() |
| |
| conn = get_db_conn() |
| try: |
| with conn.cursor(pymysql.cursors.DictCursor) as cursor: |
| # 尝试查询包含特定词的所有记录 |
| queries = [ |
| ("标题中包含关键词", f"SELECT seed_id, title, description, tags FROM pt_seed WHERE title LIKE '%{keyword}%' LIMIT 10"), |
| ("描述中包含关键词", f"SELECT seed_id, title, description, tags FROM pt_seed WHERE description LIKE '%{keyword}%' LIMIT 10"), |
| ("标签中包含关键词", f"SELECT seed_id, title, description, tags FROM pt_seed WHERE FIND_IN_SET('{keyword}', tags) LIMIT 10"), |
| ("肖申克的救赎", "SELECT seed_id, title, description, tags FROM pt_seed WHERE title = '肖申克的救赎'") |
| ] |
| |
| results = {} |
| for query_name, query in queries: |
| cursor.execute(query) |
| results[query_name] = cursor.fetchall() |
| |
| return Response(json.dumps(results, ensure_ascii=False), mimetype='application/json; charset=utf-8') |
| finally: |
| conn.close() |
| |
| """ |
| 接口本地测试方法（可直接运行main_online.py后用curl或Postman测试）： |
| |
| 1. 搜索接口 |
| curl -X POST http://127.0.0.1:5000/search -H "Content-Type: application/json" -d '{"keyword":"电影","sort_by":"downloads"}' |
| |
| 2. 标签推荐接口 |
| curl -X POST http://127.0.0.1:5000/recommend_tags -H "Content-Type: application/json" -d '{"user_id":"1","tags":["动作","科幻"]}' |
| |
| 3. 用户兴趣标签管理（添加标签） |
| curl -X POST http://127.0.0.1:5000/user_tags -H "Content-Type: application/json" -d '{"user_id":"1","tags":["动作","科幻"]}' |
| |
| 4. 用户兴趣标签管理（查询标签） |
| curl "http://127.0.0.1:5000/user_tags?user_id=1" |
| |
| 5. 用户兴趣标签管理（删除标签） |
| curl -X DELETE http://127.0.0.1:5000/user_tags -H "Content-Type: application/json" -d '{"user_id":"1","tags":["动作","科幻"]}' |
| |
| 6. 协同过滤推荐 |
| curl -X POST http://127.0.0.1:5000/user_based_recommend -H "Content-Type: application/json" -d '{"user_id":"user1","top_n":3}' |
| |
| 7. Word2Vec状态检查 |
| curl "http://127.0.0.1:5000/word2vec_status" |
| |
| 8. 调试接口（临时） |
| curl -X POST http://127.0.0.1:5000/debug_search -H "Content-Type: application/json" -d '{"keyword":"电影"}' |
| |
| 所有接口均可用Postman按上述参数测试。 |
| """ |
| |
| if __name__ == "__main__": |
| try: |
| logger.info("搜索推荐服务启动中...") |
| app.run(host="0.0.0.0", port=5000) |
| except Exception as e: |
| logger.error(f"启动异常: {e}") |
| import traceback |
| traceback.print_exc() |