resolve conflict

COLAB_CONTINUE_FROM_TIMEOUT.py

@@ -1,229 +0,0 @@
-"""
-在 Colab 中从超时处继续处理的完整脚本
-直接复制到 Colab 代码单元格运行
-"""
-
-print("🚀 GraphRAG 超时恢复脚本")
-print("="*60)
-
-# ==================== 步骤 0: 检查前置条件 ====================
-print("\n📋 步骤 0: 检查前置条件...")
-
-import sys
-import os
-
-# 挂载 Google Drive（如果还没有挂载）
-try:
-    from google.colab import drive
-    if not os.path.exists('/content/drive'):
-        print("   挂载 Google Drive...")
-        drive.mount('/content/drive')
-    else:
-        print("   ✅ Google Drive 已挂载")
-except:
-    print("   ⚠️ 不在 Colab 环境中")
-
-# 设置路径
-project_path = '/content/drive/MyDrive/adaptive_RAG'
-sys.path.insert(0, project_path)
-
-print(f"   项目路径: {project_path}")
-
-# ==================== 步骤 1: 重启 Ollama ====================
-print("\n🔄 步骤 1: 重启 Ollama 服务...")
-
-import subprocess
-import time
-
-# 杀掉旧进程
-!pkill -9 ollama 2>/dev/null
-
-time.sleep(2)
-
-# 启动新进程
-print("   启动 Ollama 服务...")
-ollama_process = subprocess.Popen(
-    ["ollama", "serve"],
-    stdout=subprocess.PIPE,
-    stderr=subprocess.PIPE,
-    preexec_fn=os.setpgrp
-)
-
-time.sleep(5)
-
-# 验证服务
-import requests
-try:
-    response = requests.get('http://localhost:11434/api/tags', timeout=5)
-    if response.status_code == 200:
-        print("   ✅ Ollama 服务运行正常")
-    else:
-        print(f"   ⚠️ Ollama 响应异常: {response.status_code}")
-except Exception as e:
-    print(f"   ❌ Ollama 服务未响应: {e}")
-    print("   请检查 Ollama 是否正确安装")
-
-# ==================== 步骤 2: 加载配置和文档 ====================
-print("\n📚 步骤 2: 加载配置和文档...")
-
-# 导入配置
-from config import setup_environment
-
-try:
-    setup_environment()
-    print("   ✅ 环境配置加载成功")
-except Exception as e:
-    print(f"   ⚠️ 环境配置警告: {e}")
-
-# 检查是否已经有 doc_splits 变量
-if 'doc_splits' in dir():
-    print(f"   ✅ 检测到已有 doc_splits: {len(doc_splits)} 个文档")
-    use_existing_docs = True
-else:
-    print("   ⚠️ 未检测到 doc_splits，需要重新加载文档")
-    use_existing_docs = False
-
-# 如果没有 doc_splits，重新加载
-if not use_existing_docs:
-    print("\n   正在加载文档...")
-    from document_processor import DocumentProcessor
-    
-    doc_processor = DocumentProcessor()
-    
-    # 使用默认 URL 或自定义 URL
-    urls = [
-        "https://lilianweng.github.io/posts/2023-06-23-agent/",
-        "https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/",
-        "https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/"
-    ]
-    
-    vectorstore, retriever, doc_splits = doc_processor.setup_knowledge_base(
-        urls=urls,
-        enable_graphrag=True
-    )
-    
-    print(f"   ✅ 文档加载完成: {len(doc_splits)} 个文档片段")
-
-# ==================== 步骤 3: 修复超时配置 ====================
-print("\n⚙️ 步骤 3: 修复超时配置...")
-
-# 方案：直接修改 entity_extractor.py 文件内容
-entity_extractor_path = os.path.join(project_path, 'entity_extractor.py')
-
-# 读取原文件
-with open(entity_extractor_path, 'r', encoding='utf-8') as f:
-    content = f.read()
-
-# 检查是否已经修改过
-if 'timeout: int = 180' in content:
-    print("   ✅ entity_extractor.py 已经包含超时修复")
-else:
-    print("   📝 修改 entity_extractor.py...")
-    
-    # 替换初始化方法的签名
-    content = content.replace(
-        'def __init__(self, timeout: int = 60, max_retries: int = 3):',
-        'def __init__(self, timeout: int = 180, max_retries: int = 5):'
-    )
-    
-    # 保存修改
-    with open(entity_extractor_path, 'w', encoding='utf-8') as f:
-        f.write(content)
-    
-    print("   ✅ 已将默认超时时间改为 180 秒，重试次数改为 5 次")
-
-# 重新加载模块
-import importlib
-
-if 'entity_extractor' in sys.modules:
-    importlib.reload(sys.modules['entity_extractor'])
-    print("   🔄 entity_extractor 模块已重新加载")
-
-if 'graph_indexer' in sys.modules:
-    importlib.reload(sys.modules['graph_indexer'])
-    print("   🔄 graph_indexer 模块已重新加载")
-
-# ==================== 步骤 4: 确定继续处理的起点 ====================
-print("\n📊 步骤 4: 确定处理起点...")
-
-# 让用户选择从哪里开始
-print("\n请选择继续处理的方式:")
-print("  1. 从文档 #56 重新开始（包含 #56）")
-print("  2. 跳过文档 #56，从 #57 开始")
-print("  3. 从头开始处理所有文档")
-print("  4. 自定义起始位置")
-
-# 默认选项（可以修改）
-choice = 1  # 👈 修改这里来选择不同的选项
-
-if choice == 1:
-    start_index = 55  # 文档 #56 的索引
-    print(f"\n   ✅ 选择: 从文档 #56 开始（索引 {start_index}）")
-elif choice == 2:
-    start_index = 56  # 跳过 #56
-    print(f"\n   ✅ 选择: 跳过文档 #56，从 #57 开始（索引 {start_index}）")
-elif choice == 3:
-    start_index = 0
-    print(f"\n   ✅ 选择: 从头开始处理所有文档")
-else:
-    # 自定义
-    start_index = 55  # 👈 修改这里来自定义起始位置
-    print(f"\n   ✅ 选择: 自定义起始位置（索引 {start_index}）")
-
-remaining_docs = doc_splits[start_index:]
-print(f"   待处理文档数: {len(remaining_docs)} 个")
-
-# ==================== 步骤 5: 开始处理 ====================
-print("\n🚀 步骤 5: 开始处理文档...")
-print("="*60)
-
-from graph_indexer import GraphRAGIndexer
-
-# 创建索引器
-indexer = GraphRAGIndexer()
-
-# 开始索引
-try:
-    graph = indexer.index_documents(
-        documents=remaining_docs,
-        batch_size=3,  # 👈 可以调整批次大小（1-5 推荐）
-        save_path=os.path.join(project_path, "knowledge_graph_recovered.pkl")
-    )
-    
-    print("\n" + "="*60)
-    print("✅ 处理完成！")
-    print("="*60)
-    
-    # 显示统计信息
-    stats = graph.get_statistics()
-    print(f"\n📊 知识图谱统计:")
-    print(f"   • 节点数: {stats['num_nodes']}")
-    print(f"   • 边数: {stats['num_edges']}")
-    print(f"   • 社区数: {stats['num_communities']}")
-    print(f"   • 图密度: {stats['density']:.4f}")
-    
-except KeyboardInterrupt:
-    print("\n⚠️ 处理被用户中断")
-    print("   可以记录当前进度，稍后继续")
-    
-except Exception as e:
-    print(f"\n❌ 处理过程中出现错误:")
-    print(f"   {type(e).__name__}: {e}")
-    print("\n建议:")
-    print("   1. 检查上面的错误信息")
-    print("   2. 如果是某个文档超时，尝试跳过它")
-    print("   3. 如果是 Ollama 问题，重启服务")
-    
-    import traceback
-    print("\n完整错误堆栈:")
-    traceback.print_exc()
-
-# ==================== 完成 ====================
-print("\n" + "="*60)
-print("脚本执行完成")
-print("="*60)
-print("\n💡 提示:")
-print("   • 如果遇到超时，检查上面的错误信息")
-print("   • 可以修改 choice 变量来跳过问题文档")
-print("   • 可以修改 batch_size 来调整处理速度")
-print("   • 图谱已保存到: knowledge_graph_recovered.pkl")

COLAB_FILES_SUMMARY.md

@@ -1,305 +0,0 @@
-# 📦 Google Colab GPU测试文件总结
-
-## ✅ 已创建的文件
-
-| 文件名 | 类型 | 用途 | 推荐度 |
-|--------|------|------|--------|
-| **colab_gpu_demo.ipynb** | Jupyter Notebook | 完整的交互式GPU测试 | ⭐⭐⭐⭐⭐ |
-| **colab_quick_test.py** | Python脚本 | 一键快速GPU测试 | ⭐⭐⭐⭐⭐ |
-| **colab_gpu_test.py** | Python脚本 | 模块化GPU测试工具 | ⭐⭐⭐⭐ |
-| **COLAB_GPU_GUIDE.md** | 文档 | 详细使用指南 | ⭐⭐⭐⭐⭐ |
-
----
-
-## 🚀 快速开始（3种方式）
-
-### 方式1: Notebook交互式测试 ⭐推荐
-
-**适合**: 第一次使用，想要详细了解每个步骤
-
-```bash
-# 步骤1: 上传文件
-上传 colab_gpu_demo.ipynb 到 Google Colab
-
-# 步骤2: 启用GPU
-运行时 → 更改运行时类型 → GPU
-
-# 步骤3: 运行
-运行时 → 全部运行
-```
-
-**优势**:
-- ✅ 可视化输出
-- ✅ 分步执行，易于理解
-- ✅ 支持实时修改
-- ✅ Markdown说明清晰
-
----
-
-### 方式2: 快速一键测试 ⭐最快
-
-**适合**: 快速验证GPU性能
-
-```python
-# 在Colab新建笔记本，运行以下代码：
-
-# 1. 启用GPU (运行时 → GPU)
-
-# 2. 复制并运行
-!wget https://your-repo/colab_quick_test.py
-!python colab_quick_test.py
-
-# 或直接复制代码到单元格运行
-```
-
-**优势**:
-- ✅ 零配置
-- ✅ 自动安装依赖
-- ✅ 5分钟完成全部测试
-- ✅ 一次性输出完整报告
-
----
-
-### 方式3: 模块化测试工具
-
-**适合**: 开发者深度定制
-
-```python
-# 在Colab中
-!wget https://your-repo/colab_gpu_test.py
-!python colab_gpu_test.py
-```
-
-**优势**:
-- ✅ 代码结构清晰
-- ✅ 易于扩展
-- ✅ 可集成到其他项目
-
----
-
-## 📊 测试内容对比
-
-| 测试项目 | Notebook | Quick Test | GPU Test |
-|---------|----------|------------|----------|
-| GPU环境检测 | ✅ | ✅ | ✅ |
-| 矩阵运算测试 | ✅ | ✅ | ✅ |
-| 文本嵌入测试 | ✅ | ✅ | ✅ |
-| GraphRAG组件 | ✅ | ❌ | ❌ |
-| 显存监控 | ✅ | ✅ | ✅ |
-| 性能报告 | ✅ | ✅ | ✅ |
-| 交互式说明 | ✅ | ❌ | ❌ |
-| nvidia-smi | ✅ | ✅ | ✅ |
-
----
-
-## 🎯 使用场景推荐
-
-### 场景1: 首次测试GPU
-**推荐**: `colab_gpu_demo.ipynb`
-- 详细的说明文档
-- 分步执行，便于学习
-- 可视化效果好
-
-### 场景2: 快速验证性能
-**推荐**: `colab_quick_test.py`
-- 一键运行
-- 5分钟得到结果
-- 完整性能报告
-
-### 场景3: 集成到CI/CD
-**推荐**: `colab_gpu_test.py`
-- 模块化设计
-- 易于自动化
-- 返回标准化结果
-
-### 场景4: 学习GPU优化
-**推荐**: `COLAB_GPU_GUIDE.md` + `colab_gpu_demo.ipynb`
-- 理论+实践
-- 详细的性能分析
-- 优化建议
-
----
-
-## 📈 预期性能提升
-
-### Google Colab T4 GPU (免费版)
-
-| 任务 | CPU | GPU | 加速比 |
-|------|-----|-----|--------|
-| 矩阵运算 (5000x5000) | 8秒 | 0.3秒 | **25x** |
-| 文本嵌入 (1000条) | 35秒 | 6秒 | **6x** |
-| GraphRAG索引 (100文档) | 15分钟 | 4分钟 | **3.8x** |
-
-### Google Colab A100 GPU (Pro版)
-
-| 任务 | CPU | GPU | 加速比 |
-|------|-----|-----|--------|
-| 矩阵运算 | 8秒 | 0.2秒 | **40x** |
-| 文本嵌入 | 35秒 | 3秒 | **12x** |
-| GraphRAG索引 | 15分钟 | 2.5分钟 | **6x** |
-
----
-
-## 🔧 完整GraphRAG部署流程
-
-### 步骤1: GPU性能测试
-```python
-# 运行quick test验证GPU
-!python colab_quick_test.py
-```
-
-### 步骤2: 上传项目文件
-```python
-# 方式A: 从Google Drive
-from google.colab import drive
-drive.mount('/content/drive')
-!cp -r /content/drive/MyDrive/adaptive_RAG /content/
-%cd /content/adaptive_RAG
-
-# 方式B: 从GitHub
-!git clone YOUR_REPO_URL
-%cd adaptive_RAG
-```
-
-### 步骤3: 安装依赖
-```python
-!pip install -q -r requirements.txt
-!pip install -q -r requirements_graphrag.txt
-```
-
-### 步骤4: 配置API密钥
-```python
-import os
-from getpass import getpass
-os.environ['TAVILY_API_KEY'] = getpass('TAVILY_API_KEY: ')
-```
-
-### 步骤5: 运行GraphRAG
-```python
-!python main_graphrag.py
-```
-
-### 步骤6: 下载结果
-```python
-from google.colab import files
-files.download('data/knowledge_graph.json')
-```
-
----
-
-## 💡 优化技巧
-
-### 1. 批处理大小
-```python
-# config.py
-GRAPHRAG_BATCH_SIZE = 20  # GPU环境可增大
-```
-
-### 2. 嵌入模型选择
-```python
-# GPU环境使用更大模型
-EMBEDDING_MODEL = "sentence-transformers/all-mpnet-base-v2"
-```
-
-### 3. 混合精度训练
-```python
-import torch
-torch.set_float32_matmul_precision('medium')
-```
-
-### 4. 数据持久化
-```python
-# 定期保存到Drive
-import shutil
-shutil.copy(
-    'data/knowledge_graph.json',
-    '/content/drive/MyDrive/backup.json'
-)
-```
-
----
-
-## ⚠️ 注意事项
-
-### Colab免费版限制
-- ⏰ 连续使用: 最多12小时
-- 🔄 GPU配额: 每周有限
-- ⏸️ 闲置超时: 90分钟
-
-### 建议
-- 💾 定期保存进度
-- ⬇️ 及时下载结果
-- 🔄 使用后台任务保持活跃
-
----
-
-## 📚 文件使用优先级
-
-### 新手用户
-1. 📖 先阅读 `COLAB_GPU_GUIDE.md`
-2. 🚀 运行 `colab_gpu_demo.ipynb`
-3. ✅ 验证性能后部署完整项目
-
-### 高级用户
-1. ⚡ 直接运行 `colab_quick_test.py`
-2. 📊 查看性能报告
-3. 🔧 根据需求调整配置
-
-### 开发者
-1. 🔍 研究 `colab_gpu_test.py` 源码
-2. 🛠️ 根据需求定制功能
-3. 🔄 集成到自动化流程
-
----
-
-## 🎯 关键性能指标
-
-### 必须达到的基准
-- ✅ GPU检测: CUDA可用
-- ✅ 矩阵加速: >10x
-- ✅ 嵌入加速: >5x
-- ✅ 显存使用: <80%
-
-### 如果低于基准
-1. 检查GPU类型 (应该是T4或A100)
-2. 重启运行时
-3. 检查依赖版本
-
----
-
-## 📞 获取帮助
-
-### 常见问题
-- 查看 `COLAB_GPU_GUIDE.md` 的FAQ部分
-
-### 性能问题
-- 运行 `colab_quick_test.py` 获取诊断报告
-
-### 技术支持
-- 提供测试报告输出
-- 说明具体错误信息
-
----
-
-## ✅ 总结
-
-| 文件 | 何时使用 |
-|------|---------|
-| `colab_gpu_demo.ipynb` | 首次使用、学习、演示 |
-| `colab_quick_test.py` | 快速验证、CI/CD、批量测试 |
-| `colab_gpu_test.py` | 深度定制、集成开发 |
-| `COLAB_GPU_GUIDE.md` | 参考文档、问题排查 |
-
-**推荐流程**: 
-1. 阅读 `COLAB_GPU_GUIDE.md` (5分钟)
-2. 运行 `colab_quick_test.py` (5分钟)
-3. 如果性能符合预期，部署完整GraphRAG项目
-
-**预期结果**: 
-- GPU可用 ✅
-- 3-6倍整体加速 ✅
-- 节省10+分钟时间 ✅
-
----
-
-🚀 **立即开始**: 上传任一文件到 [Google Colab](https://colab.research.google.com/) 并启用GPU!

COLAB_GPU_GUIDE.md

@@ -1,271 +0,0 @@
-# 🚀 Google Colab GPU 测试指南
-
-## 📋 概述
-
-我为您创建了两个文件用于在Google Colab上测试GPU性能：
-
-1. **`colab_gpu_demo.ipynb`** - Jupyter Notebook版本（推荐）
-2. **`colab_gpu_test.py`** - Python脚本版本
-
-## 🎯 使用方法
-
-### 方法1: 使用Notebook（推荐）
-
-#### 步骤1: 上传到Colab
-
-1. 打开 [Google Colab](https://colab.research.google.com/)
-2. 点击 `文件` → `上传笔记本`
-3. 选择 `colab_gpu_demo.ipynb`
-
-#### 步骤2: 启用GPU
-
-1. 点击顶部菜单 `运行时` → `更改运行时类型`
-2. 硬件加速器选择 `GPU`
-3. GPU类型选择 `T4`（免费版）或 `A100`（Colab Pro）
-4. 点击 `保存`
-
-#### 步骤3: 运行测试
-
-1. 点击 `运行时` → `全部运行`
-2. 或者逐个单元格运行（Shift + Enter）
-
-### 方法2: 使用Python脚本
-
-#### 步骤1: 上传文件
-
-1. 在Colab中创建新笔记本
-2. 点击左侧文件夹图标
-3. 上传 `colab_gpu_test.py`
-
-#### 步骤2: 运行脚本
-
-```python
-# 在Colab单元格中运行
-!python colab_gpu_test.py
-```
-
-## 📊 测试内容
-
-### 1. GPU环境检测 ✅
-- CUDA可用性检查
-- GPU型号和显存信息
-- nvidia-smi输出
-
-### 2. 矩阵运算性能测试 ⚡
-- CPU vs GPU 5000x5000矩阵乘法
-- 预期加速比: **10-50x**
-
-### 3. 文本嵌入性能测试 📝
-- 使用sentence-transformers
-- 1000个文本的嵌入生成
-- CPU vs GPU对比
-- 预期加速比: **5-10x**
-
-### 4. GraphRAG组件测试 🔍
-- 简化版知识图谱构建
-- 实体和关系管理
-- GPU加速的向量检索
-
-### 5. 显存监控 💾
-- 实时显存使用情况
-- 内存分配统计
-
-## 📈 预期结果
-
-### Google Colab 免费版 (T4 GPU)
-
-| 测试项目 | CPU时间 | GPU时间 | 加速比 |
-|---------|---------|---------|--------|
-| 矩阵运算 (5000x5000) | ~8-10秒 | ~0.3-0.5秒 | 20-30x |
-| 文本嵌入 (1000文本) | ~30-40秒 | ~5-8秒 | 5-7x |
-| GraphRAG索引 (100文档) | ~15分钟 | ~3-5分钟 | 3-5x |
-
-### Google Colab Pro (A100 GPU)
-
-| 测试项目 | CPU时间 | GPU时间 | 加速比 |
-|---------|---------|---------|--------|
-| 矩阵运算 | ~8秒 | ~0.2秒 | 40x |
-| 文本嵌入 | ~35秒 | ~3秒 | 10-12x |
-| GraphRAG索引 | ~15分钟 | ~2-3分钟 | 5-7x |
-
-## 🔧 运行完整GraphRAG项目
-
-如果GPU测试成功，可以在Colab上运行完整的GraphRAG项目：
-
-### 步骤1: 上传项目文件
-
-在Colab中创建新的单元格：
-
-```python
-# 方式1: 从Google Drive加载
-from google.colab import drive
-drive.mount('/content/drive')
-
-# 复制项目文件
-!cp -r /content/drive/MyDrive/adaptive_RAG /content/
-%cd /content/adaptive_RAG
-```
-
-或者：
-
-```python
-# 方式2: 从GitHub克隆
-!git clone YOUR_GITHUB_REPO_URL
-%cd adaptive_RAG
-```
-
-### 步骤2: 安装依赖
-
-```python
-# 安装基础依赖
-!pip install -q -r requirements.txt
-
-# 安装GraphRAG依赖
-!pip install -q -r requirements_graphrag.txt
-```
-
-### 步骤3: 配置API密钥
-
-```python
-import os
-from getpass import getpass
-
-# 安全输入API密钥
-os.environ['TAVILY_API_KEY'] = getpass('输入 TAVILY_API_KEY: ')
-
-# 验证
-print("✅ API密钥已设置")
-```
-
-### 步骤4: 运行GraphRAG
-
-```python
-# 运行主程序
-!python main_graphrag.py
-```
-
-### 步骤5: 下载结果
-
-```python
-# 下载构建好的知识图谱
-from google.colab import files
-
-# 下载图谱文件
-files.download('data/knowledge_graph.json')
-
-print("✅ 图谱已下载到本地")
-```
-
-## 💡 优化建议
-
-### 1. 批处理大小优化
-
-在 `config.py` 中调整：
-
-```python
-# GPU优化配置
-GRAPHRAG_BATCH_SIZE = 20  # GPU可以处理更大批次
-```
-
-### 2. 使用GPU优化的模型
-
-```python
-# 使用更大的嵌入模型（GPU环境）
-EMBEDDING_MODEL = "sentence-transformers/all-mpnet-base-v2"
-```
-
-### 3. 启用混合精度
-
-```python
-# 在entity_extractor.py中
-import torch
-torch.set_float32_matmul_precision('medium')  # 提升性能
-```
-
-## ⚠️ 注意事项
-
-### Colab资源限制
-
-1. **免费版限制**:
-   - 连续使用时间: 最多12小时
-   - GPU使用配额: 每周有限
-   - 闲置超时: 90分钟自动断开
-
-2. **建议**:
-   - 定期保存进度到Google Drive
-   - 使用`files.download()`下载重要结果
-   - 避免长时间空闲
-
-### 数据持久化
-
-```python
-# 定期保存到Google Drive
-from google.colab import drive
-drive.mount('/content/drive')
-
-# 保存图谱
-import shutil
-shutil.copy(
-    'data/knowledge_graph.json',
-    '/content/drive/MyDrive/graphrag_backup.json'
-)
-```
-
-## 🐛 常见问题
-
-### Q1: GPU连接失败
-
-**A**: 检查运行时类型
-```python
-import torch
-print(f"CUDA可用: {torch.cuda.is_available()}")
-# 如果False，重新设置运行时类型
-```
-
-### Q2: 内存不足
-
-**A**: 减小批处理大小
-```python
-GRAPHRAG_BATCH_SIZE = 5  # 降低批次
-```
-
-### Q3: 会话超时
-
-**A**: 使用Colab Pro或定期运行代码保持活跃
-```python
-# 在后台定期执行
-import time
-while True:
-    print("Keep alive...")
-    time.sleep(300)  # 每5分钟执行一次
-```
-
-## 📚 参考资源
-
-- [Google Colab官方文档](https://colab.research.google.com/notebooks/intro.ipynb)
-- [GPU加速指南](https://colab.research.google.com/notebooks/gpu.ipynb)
-- [Colab Pro定价](https://colab.research.google.com/signup)
-
-## 🎓 下一步学习
-
-1. **理解GPU加速原理**: 查看测试代码中的性能对比
-2. **优化GraphRAG参数**: 根据GPU性能调整配置
-3. **扩展到生产环境**: 考虑使用AWS/GCP的GPU实例
-
----
-
-## ✅ 总结
-
-| 优势 | 说明 |
-|------|------|
-| 🆓 免费GPU | T4 GPU免费使用 |
-| ⚡ 高性能 | 3-10倍加速 |
-| 🔄 零配置 | 无需本地安装 |
-| 💾 自动保存 | 集成Google Drive |
-| 🌐 随时访问 | 仅需浏览器 |
-
-**推荐**: 在本地CPU环境速度慢时，使用Colab GPU可以大幅提升GraphRAG索引构建速度！
-
----
-
-**立即开始**: 上传 `colab_gpu_demo.ipynb` 到 [Google Colab](https://colab.research.google.com/) 并启用GPU! 🚀

COLAB_OLLAMA_GUIDE.md

@@ -1,421 +0,0 @@
-# GraphRAG Colab 完整运行指南
-
-## 🎯 在Colab中运行Ollama的3种方法
-
-### 方法1: 后台运行Ollama（推荐）⭐⭐⭐⭐⭐
-
-在Colab中，您可以在单个单元格中后台启动Ollama，然后在另一个单元格运行GraphRAG。
-
-#### 步骤1: 安装Ollama
-
-```bash
-# 单元格1: 安装Ollama
-!curl -fsSL https://ollama.com/install.sh | sh
-```
-
-#### 步骤2: 后台启动Ollama服务
-
-```python
-# 单元格2: 后台启动Ollama
-import subprocess
-import time
-import os
-
-# 启动Ollama服务（后台）
-ollama_process = subprocess.Popen(
-    ["ollama", "serve"],
-    stdout=subprocess.PIPE,
-    stderr=subprocess.PIPE,
-    preexec_fn=os.setpgrp
-)
-
-print("⏳ 等待Ollama服务启动...")
-time.sleep(5)
-
-# 验证服务是否启动
-!curl -s http://localhost:11434/api/tags | head -5
-
-print(f"✅ Ollama服务已启动 (PID: {ollama_process.pid})")
-```
-
-#### 步骤3: 下载Mistral模型
-
-```bash
-# 单元格3: 下载模型
-!ollama pull mistral
-```
-
-#### 步骤4: 安装Python依赖
-
-```bash
-# 单元格4: 安装依赖
-!pip install -q langchain langchain-community langchain-core langgraph
-!pip install -q chromadb sentence-transformers tiktoken
-!pip install -q tavily-python python-dotenv networkx python-louvain
-```
-
-#### 步骤5: 配置API密钥
-
-```python
-# 单元格5: 配置环境
-import os
-from getpass import getpass
-
-os.environ['TAVILY_API_KEY'] = getpass('输入TAVILY_API_KEY: ')
-print("✅ API密钥已设置")
-```
-
-#### 步骤6: 运行GraphRAG
-
-```python
-# 单元格6: 运行GraphRAG
-!python main_graphrag.py
-```
-
-#### 步骤7: 下载结果（可选）
-
-```python
-# 单元格7: 下载生成的图谱
-from google.colab import files
-files.download('data/knowledge_graph.json')
-```
-
----
-
-### 方法2: 使用tmux（高级）⭐⭐⭐⭐
-
-```bash
-# 单元格1: 安装tmux
-!apt-get install -y tmux
-
-# 单元格2: 在tmux会话中启动Ollama
-!tmux new-session -d -s ollama 'ollama serve'
-
-# 单元格3: 检查会话
-!tmux ls
-
-# 单元格4: 下载模型
-!ollama pull mistral
-
-# 单元格5: 运行GraphRAG
-!python main_graphrag.py
-
-# 单元格6: 停止tmux会话（清理）
-!tmux kill-session -t ollama
-```
-
----
-
-### 方法3: 使用nohup（简单）⭐⭐⭐
-
-```bash
-# 单元格1: 后台启动Ollama
-!nohup ollama serve > /tmp/ollama.log 2>&1 &
-
-# 单元格2: 等待启动
-import time
-time.sleep(5)
-
-# 单元格3: 检查日志
-!tail -20 /tmp/ollama.log
-
-# 单元格4: 下载模型
-!ollama pull mistral
-
-# 单元格5: 运行GraphRAG
-!python main_graphrag.py
-
-# 单元格6: 停止Ollama（清理）
-!pkill -f 'ollama serve'
-```
-
----
-
-## 🚀 一键运行脚本（最简单）⭐⭐⭐⭐⭐
-
-我已经为您创建了一个自动化脚本 `colab_setup_and_run.py`，它会：
-1. ✅ 自动安装Ollama
-2. ✅ 后台启动服务
-3. ✅ 下载Mistral模型
-4. ✅ 安装Python依赖
-5. ✅ 配置环境变量
-6. ✅ 运行GraphRAG
-
-### 使用方法:
-
-```bash
-# 方法A: 直接运行脚本
-!python colab_setup_and_run.py
-
-# 方法B: 或者在Python中
-import subprocess
-subprocess.run(["python", "colab_setup_and_run.py"])
-```
-
----
-
-## 📊 完整的Colab Notebook示例
-
-创建一个新的Colab笔记本，按顺序运行以下单元格：
-
-### 单元格1: 环境准备
-
-```python
-# 检测GPU
-import torch
-print(f"GPU可用: {torch.cuda.is_available()}")
-if torch.cuda.is_available():
-    print(f"GPU型号: {torch.cuda.get_device_name(0)}")
-```
-
-### 单元格2: 安装Ollama
-
-```bash
-%%bash
-curl -fsSL https://ollama.com/install.sh | sh
-echo "✅ Ollama安装完成"
-```
-
-### 单元格3: 后台启动Ollama
-
-```python
-import subprocess
-import time
-import os
-
-print("🔄 启动Ollama服务...")
-
-# 后台启动
-process = subprocess.Popen(
-    ["ollama", "serve"],
-    stdout=subprocess.PIPE,
-    stderr=subprocess.PIPE,
-    preexec_fn=os.setpgrp
-)
-
-# 等待启动
-time.sleep(5)
-
-# 验证
-import requests
-try:
-    response = requests.get("http://localhost:11434/api/tags", timeout=3)
-    if response.status_code == 200:
-        print(f"✅ Ollama服务运行正常 (PID: {process.pid})")
-    else:
-        print("⚠️  服务响应异常")
-except:
-    print("⚠️  无法连接服务，但进程已启动")
-
-# 保存进程ID（重要！）
-ollama_pid = process.pid
-print(f"📝 保存的PID: {ollama_pid}")
-```
-
-### 单元格4: 下载模型
-
-```bash
-%%bash
-echo "📥 下载Mistral模型..."
-ollama pull mistral
-echo "✅ 模型下载完成"
-ollama list
-```
-
-### 单元格5: 上传项目文件
-
-```python
-# 方式A: 从Google Drive
-from google.colab import drive
-drive.mount('/content/drive')
-
-# 复制项目文件
-!cp -r /content/drive/MyDrive/adaptive_RAG /content/
-%cd /content/adaptive_RAG
-
-# 方式B: 手动上传
-# from google.colab import files
-# uploaded = files.upload()
-```
-
-### 单元格6: 安装依赖
-
-```bash
-%%bash
-pip install -q -r requirements.txt
-pip install -q -r requirements_graphrag.txt
-echo "✅ 依赖安装完成"
-```
-
-### 单元格7: 配置环境
-
-```python
-import os
-from getpass import getpass
-
-# 设置API密钥
-if not os.path.exists('.env'):
-    api_key = getpass('输入TAVILY_API_KEY: ')
-    with open('.env', 'w') as f:
-        f.write(f'TAVILY_API_KEY={api_key}\n')
-    print("✅ .env文件已创建")
-else:
-    print("✅ 使用现有.env文件")
-```
-
-### 单元格8: 运行GraphRAG
-
-```python
-# 方式A: 直接运行
-!python main_graphrag.py
-
-# 方式B: 在Python中运行（可以捕获输出）
-import subprocess
-
-result = subprocess.run(
-    ["python", "main_graphrag.py"],
-    capture_output=True,
-    text=True
-)
-
-print(result.stdout)
-if result.returncode != 0:
-    print("错误信息:")
-    print(result.stderr)
-```
-
-### 单元格9: 下载结果
-
-```python
-# 下载生成的知识图谱
-from google.colab import files
-
-if os.path.exists('data/knowledge_graph.json'):
-    files.download('data/knowledge_graph.json')
-    print("✅ 文件已下载")
-else:
-    print("❌ 未找到图谱文件")
-
-# 保存到Google Drive
-import shutil
-shutil.copy(
-    'data/knowledge_graph.json',
-    '/content/drive/MyDrive/graphrag_backup.json'
-)
-print("✅ 已备份到Google Drive")
-```
-
-### 单元格10: 清理（可选）
-
-```python
-# 停止Ollama服务
-import os
-import signal
-
-try:
-    os.kill(ollama_pid, signal.SIGTERM)
-    print(f"✅ Ollama服务已停止 (PID: {ollama_pid})")
-except:
-    print("⚠️  停止服务失败，手动停止:")
-    !pkill -f 'ollama serve'
-```
-
----
-
-## ⚠️ 常见问题
-
-### Q1: Ollama服务启动后立即退出
-
-**A**: 使用 `subprocess.Popen` 而不是 `subprocess.run`:
-
-```python
-# ❌ 错误方式
-!ollama serve &  # 会立即退出
-
-# ✅ 正确方式
-import subprocess
-process = subprocess.Popen(["ollama", "serve"])
-```
-
-### Q2: 连接被拒绝 (Connection refused)
-
-**A**: 等待服务完全启动:
-
-```python
-import time
-time.sleep(10)  # 增加等待时间
-```
-
-### Q3: 进程管理困难
-
-**A**: 使用PID文件:
-
-```python
-# 保存PID
-with open('/tmp/ollama.pid', 'w') as f:
-    f.write(str(process.pid))
-
-# 后续停止
-with open('/tmp/ollama.pid', 'r') as f:
-    pid = int(f.read())
-os.kill(pid, signal.SIGTERM)
-```
-
-### Q4: 会话超时导致服务停止
-
-**A**: 定期执行代码保持活跃:
-
-```python
-import time
-while True:
-    print("Keep alive...")
-    time.sleep(300)  # 每5分钟
-```
-
----
-
-## 📚 推荐的完整流程
-
-1. ✅ **运行自动化脚本** - `!python colab_setup_and_run.py`
-2. ✅ **或按照Notebook示例** - 逐步执行每个单元格
-3. ✅ **定期保存结果** - 到Google Drive
-
----
-
-## 💡 最佳实践
-
-1. **始终保存Ollama的PID**: 方便后续管理
-2. **使用try-finally**: 确保清理后台进程
-3. **定期备份**: 保存中间结果到Drive
-4. **监控显存**: 避免OOM错误
-
-```python
-# 最佳实践示例
-import subprocess
-import atexit
-import signal
-
-# 启动Ollama
-ollama_process = subprocess.Popen(["ollama", "serve"])
-
-# 注册清理函数
-def cleanup():
-    try:
-        ollama_process.terminate()
-        print("✅ Ollama已停止")
-    except:
-        pass
-
-atexit.register(cleanup)
-
-# 运行您的代码
-try:
-    # ... 您的GraphRAG代码 ...
-    pass
-finally:
-    cleanup()
-```
-
----
-
-**推荐**: 直接使用 `colab_setup_and_run.py` 脚本，它已经处理了所有这些细节！🚀

COLAB_QUICK_CONTINUE.py

@@ -1,121 +0,0 @@
-"""
-Colab 快速继续脚本 - 从超时处恢复
-复制到 Colab 运行，会自动检测并继续处理
-"""
-
-print("🚀 GraphRAG 恢复脚本 v2.0")
-print("="*60)
-
-import sys
-import os
-
-# ==================== 1. 设置环境 ====================
-print("\n1️⃣ 设置环境...")
-
-# 设置项目路径
-project_path = '/content/drive/MyDrive/adaptive_RAG'
-if project_path not in sys.path:
-    sys.path.insert(0, project_path)
-print(f"   ✅ 项目路径: {project_path}")
-
-# ==================== 2. 重启 Ollama ====================
-print("\n2️⃣ 重启 Ollama...")
-
-import subprocess
-import time
-
-subprocess.run(['pkill', '-9', 'ollama'], stderr=subprocess.DEVNULL)
-time.sleep(2)
-
-ollama_process = subprocess.Popen(
-    ["ollama", "serve"],
-    stdout=subprocess.PIPE,
-    stderr=subprocess.PIPE
-)
-time.sleep(5)
-
-import requests
-try:
-    r = requests.get('http://localhost:11434/api/tags', timeout=5)
-    print(f"   ✅ Ollama 运行正常" if r.status_code == 200 else f"   ⚠️ 状态码: {r.status_code}")
-except:
-    print("   ❌ Ollama 未响应")
-
-# ==================== 3. 加载文档 ====================
-print("\n3️⃣ 加载文档...")
-
-from config import setup_environment
-from document_processor import DocumentProcessor
-
-setup_environment()
-
-# 创建文档处理器
-doc_processor = DocumentProcessor()
-
-# 加载文档（使用默认 URLs）
-vectorstore, retriever, doc_splits = doc_processor.setup_knowledge_base(
-    enable_graphrag=True
-)
-
-print(f"   ✅ 已加载 {len(doc_splits)} 个文档")
-
-# ==================== 4. 修改超时配置 ====================
-print("\n4️⃣ 增加超时时间...")
-
-entity_file = os.path.join(project_path, 'entity_extractor.py')
-with open(entity_file, 'r', encoding='utf-8') as f:
-    content = f.read()
-
-# 修改默认参数
-if 'timeout: int = 60' in content:
-    content = content.replace(
-        'timeout: int = 60, max_retries: int = 3',
-        'timeout: int = 180, max_retries: int = 5'
-    )
-    with open(entity_file, 'w', encoding='utf-8') as f:
-        f.write(content)
-    print("   ✅ 超时已改为 180 秒，重试改为 5 次")
-else:
-    print("   ℹ️ 已经是修改后的配置")
-
-# 重新加载模块
-import importlib
-for mod in ['entity_extractor', 'graph_indexer']:
-    if mod in sys.modules:
-        importlib.reload(sys.modules[mod])
-
-# ==================== 5. 继续处理 ====================
-print("\n5️⃣ 继续处理文档...")
-print("="*60)
-
-from graph_indexer import GraphRAGIndexer
-
-# 配置起始位置
-START_INDEX = 55  # 👈 从文档 #56 开始，修改这里可以跳过某些文档
-BATCH_SIZE = 3    # 👈 批次大小，可以改为 1-5
-
-print(f"\n   起始位置: 文档 #{START_INDEX + 1}")
-print(f"   批次大小: {BATCH_SIZE}")
-print(f"   待处理: {len(doc_splits) - START_INDEX} 个文档\n")
-
-remaining_docs = doc_splits[START_INDEX:]
-
-indexer = GraphRAGIndexer()
-
-try:
-    graph = indexer.index_documents(
-        documents=remaining_docs,
-        batch_size=BATCH_SIZE,
-        save_path=f"{project_path}/knowledge_graph_recovered.pkl"
-    )
-    
-    print("\n✅ 处理完成！")
-    stats = graph.get_statistics()
-    print(f"📊 节点: {stats['num_nodes']}, 边: {stats['num_edges']}, 社区: {stats['num_communities']}")
-    
-except Exception as e:
-    print(f"\n❌ 错误: {e}")
-    print("\n建议:")
-    print("   • 如果文档 #56 超时，修改 START_INDEX = 56 跳过它")
-    print("   • 如果 Ollama 崩溃，重新运行此脚本")
-    print("   • 减小 BATCH_SIZE 到 1 或 2")

colab_gpu_demo.ipynb

@@ -1,588 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 🚀 GraphRAG GPU检测与测试 - Google Colab版本\n",
-    "\n",
-    "本Notebook用于在Google Colab上检测GPU可用性并测试GraphRAG系统的性能。\n",
-    "\n",
-    "## 📋 使用步骤\n",
-    "\n",
-    "1. **启用GPU**: 运行时 → 更改运行时类型 → 硬件加速器 → GPU (T4)\n",
-    "2. **运行所有单元格**: 依次执行下面的代码\n",
-    "3. **查看结果**: 检查GPU加速效果\n",
-    "\n",
-    "---"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1️⃣ GPU环境检测"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 检测GPU可用性\n",
-    "import torch\n",
-    "import subprocess\n",
-    "import sys\n",
-    "\n",
-    "print(\"=\"*60)\n",
-    "print(\"🔍 GPU环境检测\")\n",
-    "print(\"=\"*60)\n",
-    "\n",
-    "# PyTorch GPU检测\n",
-    "cuda_available = torch.cuda.is_available()\n",
-    "print(f\"\\n✅ CUDA可用: {cuda_available}\")\n",
-    "\n",
-    "if cuda_available:\n",
-    "    print(f\"   GPU数量: {torch.cuda.device_count()}\")\n",
-    "    print(f\"   当前GPU: {torch.cuda.current_device()}\")\n",
-    "    print(f\"   GPU名称: {torch.cuda.get_device_name(0)}\")\n",
-    "    print(f\"   CUDA版本: {torch.version.cuda}\")\n",
-    "    \n",
-    "    # 显存信息\n",
-    "    total_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)\n",
-    "    print(f\"   总显存: {total_memory:.2f} GB\")\n",
-    "    \n",
-    "    # nvidia-smi信息\n",
-    "    print(\"\\n📊 nvidia-smi 输出:\")\n",
-    "    print(\"-\"*60)\n",
-    "    !nvidia-smi\n",
-    "else:\n",
-    "    print(\"\\n⚠️  警告: 未检测到GPU\")\n",
-    "    print(\"   请检查: 运行时 → 更改运行时类型 → 硬件加速器 → GPU\")\n",
-    "\n",
-    "print(\"\\n\" + \"=\"*60)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2️⃣ GPU性能基准测试"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# GPU vs CPU 性能对比\n",
-    "import time\n",
-    "import numpy as np\n",
-    "\n",
-    "print(\"=\"*60)\n",
-    "print(\"⚡ GPU vs CPU 矩阵运算性能测试\")\n",
-    "print(\"=\"*60)\n",
-    "\n",
-    "# 测试参数\n",
-    "matrix_size = 5000\n",
-    "\n",
-    "# CPU测试\n",
-    "print(f\"\\n🔵 CPU测试 (矩阵大小: {matrix_size}x{matrix_size})\")\n",
-    "a_cpu = torch.randn(matrix_size, matrix_size)\n",
-    "b_cpu = torch.randn(matrix_size, matrix_size)\n",
-    "\n",
-    "start = time.time()\n",
-    "c_cpu = torch.mm(a_cpu, b_cpu)\n",
-    "cpu_time = time.time() - start\n",
-    "print(f\"   CPU时间: {cpu_time:.2f} 秒\")\n",
-    "\n",
-    "# GPU测试\n",
-    "if cuda_available:\n",
-    "    print(f\"\\n🟢 GPU测试 (矩阵大小: {matrix_size}x{matrix_size})\")\n",
-    "    a_gpu = torch.randn(matrix_size, matrix_size).cuda()\n",
-    "    b_gpu = torch.randn(matrix_size, matrix_size).cuda()\n",
-    "    \n",
-    "    # 预热GPU\n",
-    "    _ = torch.mm(a_gpu, b_gpu)\n",
-    "    torch.cuda.synchronize()\n",
-    "    \n",
-    "    start = time.time()\n",
-    "    c_gpu = torch.mm(a_gpu, b_gpu)\n",
-    "    torch.cuda.synchronize()\n",
-    "    gpu_time = time.time() - start\n",
-    "    print(f\"   GPU时间: {gpu_time:.2f} 秒\")\n",
-    "    \n",
-    "    speedup = cpu_time / gpu_time\n",
-    "    print(f\"\\n🚀 加速比: {speedup:.2f}x\")\n",
-    "    print(f\"   GPU比CPU快 {speedup:.1f} 倍!\")\n",
-    "else:\n",
-    "    print(\"\\n⚠️  跳过GPU测试（GPU不可用）\")\n",
-    "\n",
-    "print(\"\\n\" + \"=\"*60)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3️⃣ 安装GraphRAG依赖"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 克隆项目（如果需要）\n",
-    "import os\n",
-    "\n",
-    "print(\"📦 安装GraphRAG依赖...\\n\")\n",
-    "\n",
-    "# 安装核心依赖\n",
-    "!pip install -q langchain langchain-community langchain-core langgraph\n",
-    "!pip install -q chromadb sentence-transformers transformers\n",
-    "!pip install -q tiktoken beautifulsoup4 requests\n",
-    "!pip install -q tavily-python python-dotenv\n",
-    "!pip install -q networkx python-louvain\n",
-    "!pip install -q torch --index-url https://download.pytorch.org/whl/cu118\n",
-    "\n",
-    "print(\"\\n✅ 依赖安装完成!\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4️⃣ 上传项目文件\n",
-    "\n",
-    "**选项A**: 从GitHub克隆\n",
-    "```python\n",
-    "!git clone https://github.com/your-repo/adaptive_RAG.git\n",
-    "%cd adaptive_RAG\n",
-    "```\n",
-    "\n",
-    "**选项B**: 手动上传文件到Colab\n",
-    "- 使用左侧文件浏览器上传以下核心文件：\n",
-    "  - `config.py`\n",
-    "  - `entity_extractor.py`\n",
-    "  - `knowledge_graph.py`\n",
-    "  - `graph_indexer.py`\n",
-    "  - `graph_retriever.py`\n",
-    "  - `.env` (包含API密钥)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 创建必要的目录\n",
-    "!mkdir -p data\n",
-    "\n",
-    "# 如果使用选项A，运行下面的命令\n",
-    "# !git clone YOUR_REPO_URL\n",
-    "# %cd adaptive_RAG\n",
-    "\n",
-    "print(\"✅ 目录准备完成\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5️⃣ 配置API密钥"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 设置API密钥（替换为您的真实密钥）\n",
-    "import os\n",
-    "from getpass import getpass\n",
-    "\n",
-    "print(\"🔑 配置API密钥\\n\")\n",
-    "\n",
-    "# 方式1: 直接设置（不安全，仅用于测试）\n",
-    "# os.environ['TAVILY_API_KEY'] = 'your_tavily_api_key_here'\n",
-    "\n",
-    "# 方式2: 安全输入\n",
-    "if 'TAVILY_API_KEY' not in os.environ:\n",
-    "    os.environ['TAVILY_API_KEY'] = getpass('输入 TAVILY_API_KEY: ')\n",
-    "    print(\"✅ TAVILY_API_KEY 已设置\")\n",
-    "else:\n",
-    "    print(\"✅ TAVILY_API_KEY 已存在\")\n",
-    "\n",
-    "print(\"\\n注意: GraphRAG在Colab上使用HuggingFace嵌入，不需要NOMIC_API_KEY\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6️⃣ 简化版GraphRAG测试代码"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 简化版GraphRAG核心组件\n",
-    "# 适用于Colab快速测试，无需完整项目文件\n",
-    "\n",
-    "from typing import List, Dict\n",
-    "import networkx as nx\n",
-    "from sentence_transformers import SentenceTransformer\n",
-    "import torch\n",
-    "\n",
-    "class SimpleGraphRAG:\n",
-    "    \"\"\"简化版GraphRAG用于GPU性能测试\"\"\"\n",
-    "    \n",
-    "    def __init__(self, use_gpu=True):\n",
-    "        print(\"🚀 初始化SimpleGraphRAG...\")\n",
-    "        \n",
-    "        # 检测设备\n",
-    "        self.device = 'cuda' if use_gpu and torch.cuda.is_available() else 'cpu'\n",
-    "        print(f\"   设备: {self.device.upper()}\")\n",
-    "        \n",
-    "        # 加载嵌入模型\n",
-    "        print(f\"   加载嵌入模型...\")\n",
-    "        self.embedder = SentenceTransformer(\n",
-    "            'sentence-transformers/all-MiniLM-L6-v2',\n",
-    "            device=self.device\n",
-    "        )\n",
-    "        \n",
-    "        # 知识图谱\n",
-    "        self.graph = nx.Graph()\n",
-    "        self.entities = {}\n",
-    "        \n",
-    "        print(\"✅ 初始化完成!\")\n",
-    "    \n",
-    "    def add_sample_data(self):\n",
-    "        \"\"\"添加示例数据\"\"\"\n",
-    "        print(\"\\n📊 添加示例数据...\")\n",
-    "        \n",
-    "        # 示例实体\n",
-    "        entities = [\n",
-    "            {\"name\": \"LLM\", \"type\": \"CONCEPT\", \"desc\": \"大语言模型\"},\n",
-    "            {\"name\": \"GPT\", \"type\": \"TECHNOLOGY\", \"desc\": \"生成式预训练转换器\"},\n",
-    "            {\"name\": \"Transformer\", \"type\": \"CONCEPT\", \"desc\": \"注意力机制架构\"},\n",
-    "            {\"name\": \"OpenAI\", \"type\": \"ORGANIZATION\", \"desc\": \"人工智能研究公司\"},\n",
-    "            {\"name\": \"Attention\", \"type\": \"CONCEPT\", \"desc\": \"注意力机制\"},\n",
-    "        ]\n",
-    "        \n",
-    "        for entity in entities:\n",
-    "            self.graph.add_node(\n",
-    "                entity[\"name\"],\n",
-    "                type=entity[\"type\"],\n",
-    "                description=entity[\"desc\"]\n",
-    "            )\n",
-    "            self.entities[entity[\"name\"]] = entity\n",
-    "        \n",
-    "        # 示例关系\n",
-    "        relations = [\n",
-    "            (\"GPT\", \"LLM\", \"IS_A\"),\n",
-    "            (\"GPT\", \"Transformer\", \"USES\"),\n",
-    "            (\"Transformer\", \"Attention\", \"CONTAINS\"),\n",
-    "            (\"OpenAI\", \"GPT\", \"DEVELOPS\"),\n",
-    "        ]\n",
-    "        \n",
-    "        for source, target, rel_type in relations:\n",
-    "            self.graph.add_edge(source, target, relation=rel_type)\n",
-    "        \n",
-    "        print(f\"   ✅ 添加了 {len(entities)} 个实体\")\n",
-    "        print(f\"   ✅ 添加了 {len(relations)} 个关系\")\n",
-    "    \n",
-    "    def test_gpu_embedding(self, texts: List[str]):\n",
-    "        \"\"\"测试GPU嵌入性能\"\"\"\n",
-    "        print(f\"\\n⚡ 测试嵌入性能 ({len(texts)} 个文本)...\")\n",
-    "        \n",
-    "        import time\n",
-    "        \n",
-    "        start = time.time()\n",
-    "        embeddings = self.embedder.encode(\n",
-    "            texts,\n",
-    "            show_progress_bar=True,\n",
-    "            batch_size=32\n",
-    "        )\n",
-    "        elapsed = time.time() - start\n",
-    "        \n",
-    "        print(f\"   ✅ 完成! 耗时: {elapsed:.2f}秒\")\n",
-    "        print(f\"   📊 嵌入维度: {embeddings.shape}\")\n",
-    "        print(f\"   🚀 速度: {len(texts)/elapsed:.1f} 文本/秒\")\n",
-    "        \n",
-    "        return embeddings\n",
-    "    \n",
-    "    def query(self, question: str):\n",
-    "        \"\"\"简单查询\"\"\"\n",
-    "        print(f\"\\n🔍 查询: {question}\")\n",
-    "        \n",
-    "        # 简单的关键词匹配\n",
-    "        results = []\n",
-    "        for entity_name in self.entities:\n",
-    "            if entity_name.lower() in question.lower():\n",
-    "                neighbors = list(self.graph.neighbors(entity_name))\n",
-    "                results.append({\n",
-    "                    \"entity\": entity_name,\n",
-    "                    \"info\": self.entities[entity_name],\n",
-    "                    \"neighbors\": neighbors\n",
-    "                })\n",
-    "        \n",
-    "        print(f\"\\n📋 找到 {len(results)} 个相关实体:\")\n",
-    "        for r in results:\n",
-    "            print(f\"   • {r['entity']} ({r['info']['type']})\")\n",
-    "            print(f\"     描述: {r['info']['desc']}\")\n",
-    "            print(f\"     关联: {', '.join(r['neighbors'])}\")\n",
-    "        \n",
-    "        return results\n",
-    "\n",
-    "print(\"✅ SimpleGraphRAG类定义完成\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7️⃣ 运行GPU性能测试"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 初始化GraphRAG（GPU版本）\n",
-    "print(\"=\"*60)\n",
-    "print(\"🎯 GraphRAG GPU性能测试\")\n",
-    "print(\"=\"*60)\n",
-    "\n",
-    "graph_rag = SimpleGraphRAG(use_gpu=True)\n",
-    "\n",
-    "# 添加示例数据\n",
-    "graph_rag.add_sample_data()\n",
-    "\n",
-    "# 准备测试文本\n",
-    "test_texts = [\n",
-    "    \"Large Language Models are transforming AI\",\n",
-    "    \"GPT uses Transformer architecture\",\n",
-    "    \"Attention mechanism is key to modern NLP\",\n",
-    "    \"OpenAI develops cutting-edge AI models\",\n",
-    "] * 25  # 100个文本\n",
-    "\n",
-    "print(f\"\\n准备了 {len(test_texts)} 个测试文本\")\n",
-    "\n",
-    "# GPU嵌入测试\n",
-    "embeddings = graph_rag.test_gpu_embedding(test_texts)\n",
-    "\n",
-    "# 测试查询\n",
-    "graph_rag.query(\"What is GPT?\")\n",
-    "graph_rag.query(\"Tell me about Transformer\")\n",
-    "\n",
-    "print(\"\\n\" + \"=\"*60)\n",
-    "print(\"✅ GPU性能测试完成!\")\n",
-    "print(\"=\"*60)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 8️⃣ CPU vs GPU 性能对比"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# CPU vs GPU 嵌入性能对比\n",
-    "import time\n",
-    "\n",
-    "print(\"=\"*60)\n",
-    "print(\"📊 CPU vs GPU 嵌入性能对比\")\n",
-    "print(\"=\"*60)\n",
-    "\n",
-    "# 准备大量测试文本\n",
-    "large_test_texts = test_texts * 10  # 1000个文本\n",
-    "print(f\"\\n测试数据: {len(large_test_texts)} 个文本\\n\")\n",
-    "\n",
-    "# CPU测试\n",
-    "print(\"🔵 CPU测试...\")\n",
-    "graph_rag_cpu = SimpleGraphRAG(use_gpu=False)\n",
-    "start = time.time()\n",
-    "embeddings_cpu = graph_rag_cpu.embedder.encode(\n",
-    "    large_test_texts,\n",
-    "    show_progress_bar=False,\n",
-    "    batch_size=32\n",
-    ")\n",
-    "cpu_time = time.time() - start\n",
-    "print(f\"   CPU时间: {cpu_time:.2f}秒\")\n",
-    "print(f\"   速度: {len(large_test_texts)/cpu_time:.1f} 文本/秒\")\n",
-    "\n",
-    "# GPU测试\n",
-    "if cuda_available:\n",
-    "    print(\"\\n🟢 GPU测试...\")\n",
-    "    graph_rag_gpu = SimpleGraphRAG(use_gpu=True)\n",
-    "    start = time.time()\n",
-    "    embeddings_gpu = graph_rag_gpu.embedder.encode(\n",
-    "        large_test_texts,\n",
-    "        show_progress_bar=False,\n",
-    "        batch_size=32\n",
-    "    )\n",
-    "    gpu_time = time.time() - start\n",
-    "    print(f\"   GPU时间: {gpu_time:.2f}秒\")\n",
-    "    print(f\"   速度: {len(large_test_texts)/gpu_time:.1f} 文本/秒\")\n",
-    "    \n",
-    "    speedup = cpu_time / gpu_time\n",
-    "    print(f\"\\n🚀 加速比: {speedup:.2f}x\")\n",
-    "    print(f\"   GPU比CPU快 {speedup:.1f} 倍!\")\n",
-    "    \n",
-    "    # 节省的时间\n",
-    "    time_saved = cpu_time - gpu_time\n",
-    "    print(f\"   ⏱️  节省时间: {time_saved:.2f}秒\")\n",
-    "else:\n",
-    "    print(\"\\n⚠️  GPU不可用，跳过GPU测试\")\n",
-    "\n",
-    "print(\"\\n\" + \"=\"*60)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 9️⃣ 显存使用监控"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 监控GPU显存使用\n",
-    "if cuda_available:\n",
-    "    print(\"=\"*60)\n",
-    "    print(\"💾 GPU显存使用情况\")\n",
-    "    print(\"=\"*60)\n",
-    "    \n",
-    "    allocated = torch.cuda.memory_allocated(0) / (1024**3)\n",
-    "    reserved = torch.cuda.memory_reserved(0) / (1024**3)\n",
-    "    total = torch.cuda.get_device_properties(0).total_memory / (1024**3)\n",
-    "    \n",
-    "    print(f\"\\n已分配: {allocated:.2f} GB\")\n",
-    "    print(f\"已保留: {reserved:.2f} GB\")\n",
-    "    print(f\"总显存: {total:.2f} GB\")\n",
-    "    print(f\"使用率: {(allocated/total)*100:.1f}%\")\n",
-    "    \n",
-    "    print(\"\\n详细信息:\")\n",
-    "    print(torch.cuda.memory_summary(0, abbreviated=True))\n",
-    "    \n",
-    "    print(\"\\n\" + \"=\"*60)\n",
-    "else:\n",
-    "    print(\"⚠️  GPU不可用\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 🔟 性能总结报告"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 生成性能报告\n",
-    "print(\"=\"*60)\n",
-    "print(\"📈 GraphRAG GPU性能测试报告\")\n",
-    "print(\"=\"*60)\n",
-    "\n",
-    "print(\"\\n🖥️  硬件信息:\")\n",
-    "if cuda_available:\n",
-    "    print(f\"   GPU型号: {torch.cuda.get_device_name(0)}\")\n",
-    "    print(f\"   显存: {torch.cuda.get_device_properties(0).total_memory / (1024**3):.2f} GB\")\n",
-    "    print(f\"   CUDA版本: {torch.version.cuda}\")\n",
-    "else:\n",
-    "    print(\"   ⚠️  GPU不可用\")\n",
-    "\n",
-    "print(f\"\\n   PyTorch版本: {torch.__version__}\")\n",
-    "print(f\"   Python版本: {sys.version.split()[0]}\")\n",
-    "\n",
-    "print(\"\\n⚡ 性能测试结果:\")\n",
-    "print(f\"   矩阵运算加速: ~{speedup if cuda_available else 'N/A'}x\")\n",
-    "print(f\"   文本嵌入加速: ~{cpu_time/gpu_time if cuda_available else 'N/A'}x\")\n",
-    "\n",
-    "print(\"\\n💡 建议:\")\n",
-    "if cuda_available:\n",
-    "    print(\"   ✅ GPU运行良好！建议在Colab上运行完整的GraphRAG索引构建\")\n",
-    "    print(\"   ✅ 预计索引构建时间将大幅缩短\")\n",
-    "    print(\"   ✅ 可以处理更大规模的文档集\")\n",
-    "else:\n",
-    "    print(\"   ⚠️  建议启用GPU以获得最佳性能\")\n",
-    "    print(\"   ⚠️  路径: 运行时 → 更改运行时类型 → GPU\")\n",
-    "\n",
-    "print(\"\\n\" + \"=\"*60)\n",
-    "print(\"✅ 测试完成!\")\n",
-    "print(\"=\"*60)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "\n",
-    "## 📚 下一步\n",
-    "\n",
-    "如果GPU测试成功，您可以：\n",
-    "\n",
-    "1. **上传完整项目**: 将整个adaptive_RAG项目上传到Colab\n",
-    "2. **运行GraphRAG索引**: 使用GPU加速构建知识图谱\n",
-    "3. **保存结果**: 将构建好的图谱下载到本地\n",
-    "\n",
-    "### 运行完整GraphRAG的命令:\n",
-    "\n",
-    "```python\n",
-    "# 上传项目后运行\n",
-    "!python main_graphrag.py\n",
-    "```\n",
-    "\n",
-    "### 预期加速效果:\n",
-    "\n",
-    "- 实体提取: 使用GPU的LLM推理会更快\n",
-    "- 文本嵌入: **5-10倍加速**\n",
-    "- 向量相似度计算: **10-20倍加速**\n",
-    "- 总体索引构建时间: **3-5倍加速**\n",
-    "\n",
-    "---"
-   ]
-  }
- ],
- "metadata": {
-  "accelerator": "GPU",
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "name": "python",
-   "version": "3.10.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 0
-}

colab_gpu_test.py

@@ -1,269 +0,0 @@
-#!/usr/bin/env python3
-"""
-Google Colab GPU检测和GraphRAG性能测试脚本
-可以直接在Colab中运行：python colab_gpu_test.py
-"""
-
-import sys
-import time
-import torch
-import numpy as np
-from typing import List, Dict
-
-def print_section(title: str):
-    """打印分节标题"""
-    print("\n" + "="*60)
-    print(f"{title}")
-    print("="*60 + "\n")
-
-
-def test_gpu_availability():
-    """测试GPU可用性"""
-    print_section("🔍 GPU环境检测")
-    
-    cuda_available = torch.cuda.is_available()
-    print(f"✅ CUDA可用: {cuda_available}")
-    
-    if cuda_available:
-        print(f"   GPU数量: {torch.cuda.device_count()}")
-        print(f"   当前GPU: {torch.cuda.current_device()}")
-        print(f"   GPU名称: {torch.cuda.get_device_name(0)}")
-        print(f"   CUDA版本: {torch.version.cuda}")
-        
-        total_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-        print(f"   总显存: {total_memory:.2f} GB")
-        
-        return True
-    else:
-        print("\n⚠️  警告: 未检测到GPU")
-        print("   在Colab中启用GPU: 运行时 → 更改运行时类型 → GPU")
-        return False
-
-
-def benchmark_matrix_multiplication(matrix_size=5000):
-    """GPU vs CPU 矩阵运算性能测试"""
-    print_section("⚡ GPU vs CPU 矩阵运算性能测试")
-    
-    print(f"矩阵大小: {matrix_size}x{matrix_size}\n")
-    
-    # CPU测试
-    print("🔵 CPU测试...")
-    a_cpu = torch.randn(matrix_size, matrix_size)
-    b_cpu = torch.randn(matrix_size, matrix_size)
-    
-    start = time.time()
-    c_cpu = torch.mm(a_cpu, b_cpu)
-    cpu_time = time.time() - start
-    print(f"   CPU时间: {cpu_time:.2f} 秒")
-    
-    # GPU测试
-    if torch.cuda.is_available():
-        print("\n🟢 GPU测试...")
-        a_gpu = torch.randn(matrix_size, matrix_size).cuda()
-        b_gpu = torch.randn(matrix_size, matrix_size).cuda()
-        
-        # 预热GPU
-        _ = torch.mm(a_gpu, b_gpu)
-        torch.cuda.synchronize()
-        
-        start = time.time()
-        c_gpu = torch.mm(a_gpu, b_gpu)
-        torch.cuda.synchronize()
-        gpu_time = time.time() - start
-        print(f"   GPU时间: {gpu_time:.2f} 秒")
-        
-        speedup = cpu_time / gpu_time
-        print(f"\n🚀 加速比: {speedup:.2f}x")
-        print(f"   GPU比CPU快 {speedup:.1f} 倍!")
-        
-        return speedup
-    else:
-        print("\n⚠️  跳过GPU测试（GPU不可用）")
-        return 1.0
-
-
-def test_text_embedding_performance():
-    """测试文本嵌入性能（需要sentence-transformers）"""
-    print_section("📝 文本嵌入性能测试")
-    
-    try:
-        from sentence_transformers import SentenceTransformer
-        
-        # 准备测试数据
-        test_texts = [
-            "Large Language Models are transforming AI",
-            "GraphRAG combines knowledge graphs with retrieval",
-            "GPU acceleration significantly improves performance",
-            "Natural language processing is advancing rapidly",
-        ] * 250  # 1000个文本
-        
-        print(f"测试数据: {len(test_texts)} 个文本\n")
-        
-        # CPU测试
-        print("🔵 CPU嵌入测试...")
-        model_cpu = SentenceTransformer(
-            'sentence-transformers/all-MiniLM-L6-v2',
-            device='cpu'
-        )
-        start = time.time()
-        embeddings_cpu = model_cpu.encode(test_texts, show_progress_bar=False, batch_size=32)
-        cpu_time = time.time() - start
-        print(f"   CPU时间: {cpu_time:.2f}秒")
-        print(f"   速度: {len(test_texts)/cpu_time:.1f} 文本/秒")
-        
-        # GPU测试
-        if torch.cuda.is_available():
-            print("\n🟢 GPU嵌入测试...")
-            model_gpu = SentenceTransformer(
-                'sentence-transformers/all-MiniLM-L6-v2',
-                device='cuda'
-            )
-            start = time.time()
-            embeddings_gpu = model_gpu.encode(test_texts, show_progress_bar=False, batch_size=32)
-            gpu_time = time.time() - start
-            print(f"   GPU时间: {gpu_time:.2f}秒")
-            print(f"   速度: {len(test_texts)/gpu_time:.1f} 文本/秒")
-            
-            speedup = cpu_time / gpu_time
-            print(f"\n🚀 加速比: {speedup:.2f}x")
-            print(f"   节省时间: {cpu_time - gpu_time:.2f}秒")
-            
-            return speedup
-        else:
-            print("\n⚠️  跳过GPU测试")
-            return 1.0
-            
-    except ImportError:
-        print("⚠️  sentence-transformers未安装")
-        print("   安装: pip install sentence-transformers")
-        return None
-
-
-def monitor_gpu_memory():
-    """监控GPU显存使用"""
-    if not torch.cuda.is_available():
-        return
-    
-    print_section("💾 GPU显存使用情况")
-    
-    allocated = torch.cuda.memory_allocated(0) / (1024**3)
-    reserved = torch.cuda.memory_reserved(0) / (1024**3)
-    total = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-    
-    print(f"已分配: {allocated:.2f} GB")
-    print(f"已保留: {reserved:.2f} GB")
-    print(f"总显存: {total:.2f} GB")
-    print(f"使用率: {(allocated/total)*100:.1f}%")
-
-
-def generate_performance_report(matrix_speedup, embedding_speedup):
-    """生成性能报告"""
-    print_section("📈 性能测试总结报告")
-    
-    print("🖥️  硬件信息:")
-    if torch.cuda.is_available():
-        print(f"   GPU型号: {torch.cuda.get_device_name(0)}")
-        print(f"   显存: {torch.cuda.get_device_properties(0).total_memory / (1024**3):.2f} GB")
-        print(f"   CUDA版本: {torch.version.cuda}")
-    else:
-        print("   ⚠️  GPU不可用")
-    
-    print(f"\n   PyTorch版本: {torch.__version__}")
-    print(f"   Python版本: {sys.version.split()[0]}")
-    
-    print("\n⚡ 性能测试结果:")
-    print(f"   矩阵运算加速: {matrix_speedup:.2f}x")
-    if embedding_speedup:
-        print(f"   文本嵌入加速: {embedding_speedup:.2f}x")
-    
-    print("\n💡 建议:")
-    if torch.cuda.is_available():
-        print("   ✅ GPU运行良好！")
-        print("   ✅ 建议在Colab上运行完整的GraphRAG索引构建")
-        print("   ✅ 预计索引构建时间将缩短 3-5 倍")
-        
-        # 估算时间节省
-        if embedding_speedup and embedding_speedup > 1:
-            print(f"\n⏱️  时间节省估算:")
-            print(f"   100文档CPU耗时: ~15分钟")
-            print(f"   100文档GPU耗时: ~{15/embedding_speedup:.1f}分钟")
-            print(f"   节省: ~{15 - 15/embedding_speedup:.1f}分钟")
-    else:
-        print("   ⚠️  建议启用GPU以获得最佳性能")
-        print("   ⚠️  Colab启用GPU: 运行时 → 更改运行时类型 → GPU")
-
-
-def install_dependencies():
-    """安装必要的依赖（仅在Colab中）"""
-    try:
-        import google.colab
-        is_colab = True
-    except:
-        is_colab = False
-    
-    if is_colab:
-        print_section("📦 安装依赖")
-        print("检测到Colab环境，安装必要的包...\n")
-        
-        import subprocess
-        packages = [
-            'sentence-transformers',
-            'networkx',
-            'python-louvain',
-        ]
-        
-        for package in packages:
-            try:
-                __import__(package.replace('-', '_'))
-                print(f"✅ {package} 已安装")
-            except ImportError:
-                print(f"📥 安装 {package}...")
-                subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', package])
-                print(f"✅ {package} 安装完成")
-
-
-def main():
-    """主函数"""
-    print("\n" + "="*60)
-    print("🚀 Google Colab GPU检测和GraphRAG性能测试")
-    print("="*60)
-    
-    # 检查是否在Colab中运行
-    try:
-        import google.colab
-        print("\n✅ 运行环境: Google Colab")
-    except:
-        print("\n⚠️  警告: 未检测到Colab环境")
-        print("   本脚本专为Google Colab设计")
-    
-    # 安装依赖
-    install_dependencies()
-    
-    # 1. GPU检测
-    gpu_available = test_gpu_availability()
-    
-    # 2. 矩阵运算性能测试
-    matrix_speedup = benchmark_matrix_multiplication(matrix_size=5000)
-    
-    # 3. 文本嵌入性能测试
-    embedding_speedup = test_text_embedding_performance()
-    
-    # 4. 显存监控
-    if gpu_available:
-        monitor_gpu_memory()
-    
-    # 5. 生成报告
-    generate_performance_report(matrix_speedup, embedding_speedup)
-    
-    print("\n" + "="*60)
-    print("✅ 测试完成!")
-    print("="*60)
-    
-    print("\n📚 下一步:")
-    print("   1. 如果GPU测试成功，可以上传完整的adaptive_RAG项目")
-    print("   2. 运行 main_graphrag.py 进行完整的知识图谱构建")
-    print("   3. 享受GPU带来的3-5倍速度提升!")
-
-
-if __name__ == "__main__":
-    main()

colab_install_deps.py

@@ -1,99 +0,0 @@
-#!/usr/bin/env python3
-"""
-Colab环境依赖安装脚本
-确保所有LangChain相关包都是最新版本，避免导入错误
-"""
-
-import subprocess
-import sys
-
-def install_package(package):
-    """安装单个包"""
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", package])
-
-def main():
-    print("="*70)
-    print("📦 Colab GraphRAG 依赖安装")
-    print("="*70)
-    
-    # 关键包列表（指定版本以确保兼容性）
-    packages = [
-        # LangChain核心包（最新版本）
-        "langchain>=0.1.0",
-        "langchain-core>=0.1.52",
-        "langchain-community>=0.0.38",
-        "langchain-text-splitters>=0.0.1",
-        "langgraph>=0.0.40",
-        
-        # Ollama支持
-        "langchain-ollama>=0.1.0",
-        
-        # 向量数据库和嵌入
-        "chromadb>=0.4.22",
-        "sentence-transformers>=2.2.0",
-        
-        # 文档处理
-        "tiktoken>=0.5.0",
-        "beautifulsoup4>=4.12.0",
-        "requests>=2.31.0",
-        
-        # 网络搜索
-        "tavily-python>=0.3.0",
-        
-        # 工具库
-        "python-dotenv>=1.0.0",
-        
-        # GraphRAG特定
-        "networkx>=3.1",
-        "python-louvain>=0.16",
-        
-        # PyTorch和Transformers
-        "torch>=2.0.0",
-        "transformers>=4.30.0",
-    ]
-    
-    print("\n🔄 开始安装依赖包...\n")
-    
-    for i, package in enumerate(packages, 1):
-        try:
-            print(f"[{i}/{len(packages)}] 安装 {package}...")
-            install_package(package)
-            print(f"    ✅ {package} 安装成功")
-        except Exception as e:
-            print(f"    ❌ {package} 安装失败: {e}")
-    
-    print("\n" + "="*70)
-    print("✅ 依赖安装完成!")
-    print("="*70)
-    
-    # 验证关键导入
-    print("\n🔍 验证关键导入...")
-    
-    imports_to_check = [
-        ("langchain", "LangChain"),
-        ("langchain_core", "LangChain Core"),
-        ("langchain_community", "LangChain Community"),
-        ("langchain_text_splitters", "LangChain Text Splitters"),
-        ("chromadb", "ChromaDB"),
-        ("sentence_transformers", "Sentence Transformers"),
-        ("networkx", "NetworkX"),
-    ]
-    
-    all_ok = True
-    for module, name in imports_to_check:
-        try:
-            __import__(module)
-            print(f"   ✅ {name}")
-        except ImportError as e:
-            print(f"   ❌ {name}: {e}")
-            all_ok = False
-    
-    if all_ok:
-        print("\n🎉 所有依赖验证通过!")
-    else:
-        print("\n⚠️  部分依赖验证失败，请检查错误信息")
-    
-    print("\n" + "="*70)
-
-if __name__ == "__main__":
-    main()

colab_quick_test.py

@@ -1,278 +0,0 @@
-#!/usr/bin/env python3
-"""
-Google Colab一键GPU测试脚本
-复制此文件内容到Colab单元格中直接运行
-
-使用方法:
-1. 在Colab中创建新笔记本
-2. 启用GPU (运行时 → 更改运行时类型 → GPU)
-3. 复制并运行此脚本
-"""
-
-# ============================================================
-# 🔧 自动安装依赖
-# ============================================================
-print("📦 检查并安装依赖...")
-import subprocess
-import sys
-
-def install(package):
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", package])
-
-# 检查必要的包
-required_packages = {
-    'torch': 'torch',
-    'sentence_transformers': 'sentence-transformers',
-    'networkx': 'networkx',
-    'numpy': 'numpy'
-}
-
-for import_name, package_name in required_packages.items():
-    try:
-        __import__(import_name)
-        print(f"✅ {package_name} 已安装")
-    except ImportError:
-        print(f"📥 安装 {package_name}...")
-        install(package_name)
-
-print("\n" + "="*70)
-print("🚀 Google Colab GPU性能测试 - GraphRAG加速验证")
-print("="*70)
-
-# ============================================================
-# 1️⃣ GPU检测
-# ============================================================
-import torch
-import time
-
-print("\n" + "="*70)
-print("🔍 步骤1: GPU环境检测")
-print("="*70)
-
-cuda_available = torch.cuda.is_available()
-print(f"\n{'✅' if cuda_available else '❌'} CUDA可用: {cuda_available}")
-
-if cuda_available:
-    print(f"   📊 GPU型号: {torch.cuda.get_device_name(0)}")
-    print(f"   💾 显存大小: {torch.cuda.get_device_properties(0).total_memory / (1024**3):.2f} GB")
-    print(f"   🔢 CUDA版本: {torch.version.cuda}")
-    print(f"   📈 PyTorch版本: {torch.__version__}")
-else:
-    print("\n⚠️  GPU未启用！")
-    print("   请按照以下步骤启用GPU:")
-    print("   1. 点击顶部菜单 '运行时'")
-    print("   2. 选择 '更改运行时类型'")
-    print("   3. 硬件加速器选择 'GPU'")
-    print("   4. 点击 '保存'")
-    print("   5. 重新运行此单元格")
-    print("\n⚠️  测试将继续，但GPU相关测试会被跳过")
-
-# ============================================================
-# 2️⃣ 矩阵运算性能测试
-# ============================================================
-print("\n" + "="*70)
-print("⚡ 步骤2: 矩阵运算性能测试")
-print("="*70)
-
-matrix_size = 5000
-print(f"\n测试配置: {matrix_size}x{matrix_size} 矩阵乘法\n")
-
-# CPU测试
-print("🔵 CPU性能测试...")
-a_cpu = torch.randn(matrix_size, matrix_size)
-b_cpu = torch.randn(matrix_size, matrix_size)
-
-start = time.time()
-c_cpu = torch.mm(a_cpu, b_cpu)
-cpu_time = time.time() - start
-
-print(f"   ⏱️  CPU耗时: {cpu_time:.3f}秒")
-
-# GPU测试
-if cuda_available:
-    print("\n🟢 GPU性能测试...")
-    a_gpu = torch.randn(matrix_size, matrix_size).cuda()
-    b_gpu = torch.randn(matrix_size, matrix_size).cuda()
-    
-    # 预热
-    _ = torch.mm(a_gpu, b_gpu)
-    torch.cuda.synchronize()
-    
-    start = time.time()
-    c_gpu = torch.mm(a_gpu, b_gpu)
-    torch.cuda.synchronize()
-    gpu_time = time.time() - start
-    
-    print(f"   ⏱️  GPU耗时: {gpu_time:.3f}秒")
-    
-    speedup = cpu_time / gpu_time
-    print(f"\n   🚀 性能提升: {speedup:.1f}x")
-    print(f"   💡 GPU比CPU快 {speedup:.1f} 倍!")
-    
-    matrix_speedup = speedup
-else:
-    print("\n⚠️  跳过GPU测试")
-    matrix_speedup = 1.0
-
-# ============================================================
-# 3️⃣ 文本嵌入性能测试
-# ============================================================
-print("\n" + "="*70)
-print("📝 步骤3: 文本嵌入性能测试 (GraphRAG核心组件)")
-print("="*70)
-
-try:
-    from sentence_transformers import SentenceTransformer
-    
-    # 准备测试数据
-    test_texts = [
-        "GraphRAG combines knowledge graphs with retrieval augmented generation",
-        "GPU acceleration significantly improves machine learning performance",
-        "Large language models benefit from efficient embedding computation",
-        "Knowledge graph construction requires entity and relation extraction",
-    ] * 250  # 1000条文本
-    
-    print(f"\n测试配置: {len(test_texts)}条文本嵌入\n")
-    
-    # CPU嵌入
-    print("🔵 CPU嵌入测试...")
-    model_cpu = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2', device='cpu')
-    
-    start = time.time()
-    embeddings_cpu = model_cpu.encode(test_texts, show_progress_bar=False, batch_size=32)
-    cpu_emb_time = time.time() - start
-    
-    print(f"   ⏱️  CPU耗时: {cpu_emb_time:.2f}秒")
-    print(f"   📊 处理速度: {len(test_texts)/cpu_emb_time:.1f} 文本/秒")
-    
-    # GPU嵌入
-    if cuda_available:
-        print("\n🟢 GPU嵌入测试...")
-        model_gpu = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2', device='cuda')
-        
-        start = time.time()
-        embeddings_gpu = model_gpu.encode(test_texts, show_progress_bar=False, batch_size=32)
-        gpu_emb_time = time.time() - start
-        
-        print(f"   ⏱️  GPU耗时: {gpu_emb_time:.2f}秒")
-        print(f"   📊 处理速度: {len(test_texts)/gpu_emb_time:.1f} 文本/秒")
-        
-        emb_speedup = cpu_emb_time / gpu_emb_time
-        print(f"\n   🚀 性能提升: {emb_speedup:.1f}x")
-        print(f"   ⏱️  节省时间: {cpu_emb_time - gpu_emb_time:.2f}秒")
-    else:
-        print("\n⚠️  跳过GPU测试")
-        emb_speedup = 1.0
-        
-except ImportError:
-    print("\n⚠️  sentence-transformers未安装，跳过此测试")
-    emb_speedup = None
-
-# ============================================================
-# 4️⃣ GraphRAG场景模拟
-# ============================================================
-print("\n" + "="*70)
-print("🔍 步骤4: GraphRAG实际场景模拟")
-print("="*70)
-
-if cuda_available and emb_speedup:
-    print("\n模拟GraphRAG索引构建过程...\n")
-    
-    # 假设100个文档块的索引构建
-    documents_count = 100
-    
-    # 实体提取时间 (每个文档约1秒)
-    entity_extraction_time = documents_count * 1.0
-    
-    # 文本嵌入时间 (基于实际测试)
-    # 假设每个文档平均产生10个实体，共1000个实体需要嵌入
-    entities_count = documents_count * 10
-    
-    cpu_total_time = entity_extraction_time + (entities_count / (len(test_texts)/cpu_emb_time))
-    gpu_total_time = entity_extraction_time + (entities_count / (len(test_texts)/gpu_emb_time))
-    
-    print(f"📊 场景: {documents_count}个文档的GraphRAG索引构建\n")
-    print(f"🔵 CPU预计时间:")
-    print(f"   - 实体提取: {entity_extraction_time/60:.1f}分钟")
-    print(f"   - 向量嵌入: {(entities_count / (len(test_texts)/cpu_emb_time))/60:.1f}分钟")
-    print(f"   - 总计: {cpu_total_time/60:.1f}分钟")
-    
-    print(f"\n🟢 GPU预计时间:")
-    print(f"   - 实体提取: {entity_extraction_time/60:.1f}分钟 (相同)")
-    print(f"   - 向量嵌入: {(entities_count / (len(test_texts)/gpu_emb_time))/60:.1f}分钟")
-    print(f"   - 总计: {gpu_total_time/60:.1f}分钟")
-    
-    total_speedup = cpu_total_time / gpu_total_time
-    time_saved = (cpu_total_time - gpu_total_time) / 60
-    
-    print(f"\n🚀 整体加速: {total_speedup:.1f}x")
-    print(f"⏱️  节省时间: {time_saved:.1f}分钟")
-
-# ============================================================
-# 5️⃣ GPU显存监控
-# ============================================================
-if cuda_available:
-    print("\n" + "="*70)
-    print("💾 步骤5: GPU显存使用监控")
-    print("="*70)
-    
-    allocated = torch.cuda.memory_allocated(0) / (1024**3)
-    reserved = torch.cuda.memory_reserved(0) / (1024**3)
-    total = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-    
-    print(f"\n   已分配: {allocated:.2f} GB")
-    print(f"   已保留: {reserved:.2f} GB")
-    print(f"   总显存: {total:.2f} GB")
-    print(f"   使用率: {(allocated/total)*100:.1f}%")
-
-# ============================================================
-# 6️⃣ 性能总结
-# ============================================================
-print("\n" + "="*70)
-print("📈 最终性能报告")
-print("="*70)
-
-print("\n🖥️  硬件配置:")
-if cuda_available:
-    print(f"   GPU: {torch.cuda.get_device_name(0)}")
-    print(f"   显存: {torch.cuda.get_device_properties(0).total_memory / (1024**3):.1f} GB")
-    print(f"   CUDA: {torch.version.cuda}")
-else:
-    print("   ⚠️  GPU未启用")
-
-print(f"\n⚡ 性能测试结果:")
-print(f"   矩阵运算加速: {matrix_speedup:.1f}x")
-if emb_speedup:
-    print(f"   文本嵌入加速: {emb_speedup:.1f}x")
-    if cuda_available:
-        print(f"   GraphRAG整体加速: {total_speedup:.1f}x")
-
-print("\n💡 结论和建议:")
-if cuda_available:
-    print("   ✅ GPU性能测试成功!")
-    print("   ✅ 强烈建议在Colab GPU环境运行GraphRAG")
-    print(f"   ✅ 预计可节省 {time_saved:.0f}+ 分钟的索引构建时间")
-    print("\n📚 下一步:")
-    print("   1. 上传adaptive_RAG项目文件到Colab")
-    print("   2. 运行 main_graphrag.py 构建完整知识图谱")
-    print("   3. 下载结果到本地使用")
-else:
-    print("   ⚠️  请启用GPU以获得最佳性能")
-    print("   ⚠️  路径: 运行时 → 更改运行时类型 → GPU")
-
-print("\n" + "="*70)
-print("✅ 测试完成! 感谢使用GraphRAG GPU测试工具")
-print("="*70)
-
-# ============================================================
-# 7️⃣ 可选: 显示nvidia-smi
-# ============================================================
-if cuda_available:
-    print("\n📊 nvidia-smi 详细信息:")
-    print("="*70)
-    import subprocess
-    try:
-        result = subprocess.run(['nvidia-smi'], capture_output=True, text=True)
-        print(result.stdout)
-    except:
-        print("⚠️  无法执行nvidia-smi命令")