import requests
import json
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain.schema import Document
import warnings
warnings.filterwarnings('ignore')
import os

# 1. 文檔加載和預處理
fake_document_text = """
機器學習是人工智能的一個子領域，它使計算機系統能夠從數據中學習並改進，而無需顯式編程。
機器學習算法通常分為三類：監督學習、無監督學習和強化學習。
監督學習使用標記數據來訓練模型，例如用於圖像分類。無監督學習在未標記數據中尋找隱藏模式，例如客户細分。強化學習則通過與環境交互並獲得獎勵來學習最佳策略，例如AlphaGo。
深度學習是機器學習的一個分支，它使用稱為神經網絡的多層模型。這些網絡能夠從大量數據中學習複雜的特徵層次結構。
卷積神經網絡（CNN）特別適用於圖像處理任務，而循環神經網絡（RNN）則擅長處理序列數據，如文本或時間序列。
"""
documents = [Document(page_content=fake_document_text, metadata={"source": "ml_textbook_chapter1"})]

# 2. 定義文本分割器
# 創建"大"塊的分割器
big_size = 300
big_overlap = 50
big_splitter = RecursiveCharacterTextSplitter(
    chunk_size=big_size,
    chunk_overlap=big_overlap,
)

# 創建"小"塊的分割器
small_size = 100
small_overlap = 20
small_splitter = RecursiveCharacterTextSplitter(
    chunk_size=small_size,
    chunk_overlap=small_overlap,
)

# 3. 切分文檔並建立映射關係
all_small_chunks = []
all_big_chunks = []
mapping_dict = {} # 用於存儲小塊ID到父大塊的映射

# 首先，將文檔切分成"大"塊
big_chunks = big_splitter.split_documents(documents)

for big_chunk_index, big_chunk in enumerate(big_chunks):
    # 將每個"大"塊進一步切分成"小"塊
    small_chunks_from_big = small_splitter.split_documents([big_chunk])
    
    # 為每個"小"塊創建唯一ID並存儲映射關係
    for small_chunk in small_chunks_from_big:
        # 給小塊一個ID（這裏用內容哈希簡化演示）
        small_chunk_id = hash(small_chunk.page_content)
        mapping_dict[small_chunk_id] = {
            "big_chunk_content": big_chunk.page_content,
            "big_chunk_index": big_chunk_index
        }
        all_small_chunks.append(small_chunk)
    
    all_big_chunks.append(big_chunk)

print(f"切分出 {len(all_big_chunks)} 個大塊")
print(f"切分出 {len(all_small_chunks)} 個小塊")

# 4. 為"小"塊創建向量庫（Faiss）
# 選擇嵌入模型
model_name = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
embeddings = HuggingFaceEmbeddings(model_name=model_name)

# 使用所有"小"塊構建向量索引
vector_db = FAISS.from_documents(all_small_chunks, embeddings)

# 5. 定義QWen API調用函數
def call_qwen_api(prompt, api_key, model="qwen-max", temperature=0.1):
    """
    調用通義千問API
    參數:
        prompt: 輸入的提示文本
        api_key: 你的API密鑰
        model: 使用的模型名稱，默認為qwen-max
        temperature: 生成温度，控制創造性
    """
    url = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"
    
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    
    data = {
        "model": model,
        "input": {
            "messages": [
                {
                    "role": "user",
                    "content": prompt
                }
            ]
        },
        "parameters": {
            "temperature": temperature,
            "top_p": 0.8,
            "result_format": "text"
        }
    }
    
    try:
        response = requests.post(url, headers=headers, data=json.dumps(data))
        response.raise_for_status()
        result = response.json()
        return result["output"]["text"]
    except Exception as e:
        print(f"API調用出錯: {e}")
        return None

# 6. 檢索和生成過程
def rag_query(query, api_key, k=3):
    # a) 使用查詢檢索最相關的"小"塊
    retrieved_small_docs = vector_db.similarity_search(query, k=k)
    print("\n--- 檢索到的最相關'小'塊 ---")
    for i, doc in enumerate(retrieved_small_docs):
        print(f"[Small Chunk {i+1}]: {doc.page_content}\n")

    # b) 根據映射字典，找到這些"小"塊對應的父"大"塊
    retrieved_big_contents = set() # 使用集合自動去重
    for small_doc in retrieved_small_docs:
        small_id = hash(small_doc.page_content)
        if small_id in mapping_dict:
            retrieved_big_contents.add(mapping_dict[small_id]["big_chunk_content"])
        else:
            # 如果找不到映射，使用小塊本身
            retrieved_big_contents.add(small_doc.page_content)

    # 將去重後的大塊內容合併為上下文
    context = "\n\n---\n\n".join(retrieved_big_contents)

    # c) 構建Prompt，調用QWen API生成答案
    prompt_template = f"""
請根據以下上下文信息回答問題。如果上下文不包含答案，請如實告知。

上下文：
{context}

問題：{query}

請給出準確、簡潔的回答：
"""
    print("\n--- 發送給QWen API的Prompt ---")
    print(prompt_template)

    # 調用API
    answer = call_qwen_api(prompt_template, api_key)
    return answer

# 7. 使用示例
if __name__ == "__main__":
    # 替換為你的API密鑰
    API_KEY = os.environ.get("DASHSCOPE_API_KEY", "") 
    
    # 查詢示例
    query = "CNN神經網絡主要用於什麼任務？"
    
    # 執行RAG查詢
    result = rag_query(query, API_KEY)
    
    print("\n--- 最終答案 ---")
    print(result)

切分出 1 個大塊
切分出 4 個小塊

--- 檢索到的最相關'小'塊 ---
[Small Chunk 1]: 卷積神經網絡（CNN）特別適用於圖像處理任務，而循環神經網絡（RNN）則擅長處理序列數據，如文本或
時間序列。

[Small Chunk 2]: 深度學習是機器學習的一個分支，它使用稱為神經網絡的多層模型。這些網絡能夠從大量數據中學習複雜
的特徵層次結構。

[Small Chunk 3]: 機器學習是人工智能的一個子領域，它使計算機系統能夠從數據中學習並改進，而無需顯式編程。       
機器學習算法通常分為三類：監督學習、無監督學習和強化學習。


--- 發送給QWen API的Prompt ---

請根據以下上下文信息回答問題。如果上下文不包含答案，請如實告知。

上下文：
機器學習是人工智能的一個子領域，它使計算機系統能夠從數據中學習並改進，而無需顯式編程。
機器學習算法通常分為三類：監督學習、無監督學習和強化學習。
監督學習使用標記數據來訓練模型，例如用於圖像分類。無監督學習在未標記數據中尋找隱藏模式，例如客户細分。強化學習
則通過與環境交互並獲得獎勵來學習最佳策略，例如AlphaGo。
深度學習是機器學習的一個分支，它使用稱為神經網絡的多層模型。這些網絡能夠從大量數據中學習複雜的特徵層次結構。  
卷積神經網絡（CNN）特別適用於圖像處理任務，而循環神經網絡（RNN）則擅長處理序列數據，如文本或時間序列。        
深度學習是機器學習的一個分支，它使用稱為神經網絡的多層模型。這些網絡能夠從大量數據中學習複雜的特徵層次結構。  
深度學習是機器學習的一個分支，它使用稱為神經網絡的多層模型。這些網絡能夠從大量數據中學習複雜的特徵層次結構。  
卷積神經網絡（CNN）特別適用於圖像處理任務，而循環神經網絡（RNN）則擅長處理序列數據，如文本或時間序列。        

問題：CNN神經網絡主要用於什麼任務？

請給出準確、簡潔的回答：

--- 最終答案 ---
CNN神經網絡主要用於圖像處理任務。

import requests  # 用於發送HTTP請求到QWen API
import json  # 用於處理JSON數據
from langchain.text_splitter import RecursiveCharacterTextSplitter  # 文本分割工具
from langchain_community.vectorstores import FAISS  # 向量數據庫
from langchain_community.embeddings import HuggingFaceEmbeddings  # 文本嵌入模型
from langchain.schema import Document  # 文檔數據結構
import warnings  # 警告管理
warnings.filterwarnings('ignore')  # 忽略警告
import os  # 操作系統接口，用於讀取環境變量

fake_document_text = """機器學習是人工智能的一個子領域..."""  # 示例文檔內容
documents = [Document(page_content=fake_document_text, metadata={"source": "ml_textbook_chapter1"})]

# 創建"大"塊的分割器 (用於生成上下文)
big_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=50)

# 創建"小"塊的分割器 (用於檢索)
small_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=20)

# 首先將文檔切分成"大"塊
big_chunks = big_splitter.split_documents(documents)

# 為每個大塊創建對應的小塊，並建立映射關係
for big_chunk_index, big_chunk in enumerate(big_chunks):
    small_chunks_from_big = small_splitter.split_documents([big_chunk])
    
    for small_chunk in small_chunks_from_big:
        small_chunk_id = hash(small_chunk.page_content)  # 使用哈希值作為小塊ID
        mapping_dict[small_chunk_id] = {
            "big_chunk_content": big_chunk.page_content,
            "big_chunk_index": big_chunk_index
        }
        all_small_chunks.append(small_chunk)
    
    all_big_chunks.append(big_chunk)

# 選擇嵌入模型
model_name = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
embeddings = HuggingFaceEmbeddings(model_name=model_name)

# 使用所有"小"塊構建向量索引
vector_db = FAISS.from_documents(all_small_chunks, embeddings)

def call_qwen_api(prompt, api_key, model="qwen-max", temperature=0.1):
    url = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"
    
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    
    data = {
        "model": model,
        "input": {"messages": [{"role": "user", "content": prompt}]},
        "parameters": {"temperature": temperature, "top_p": 0.8, "result_format": "text"}
    }
    
    try:
        response = requests.post(url, headers=headers, data=json.dumps(data))
        response.raise_for_status()
        result = response.json()
        return result["output"]["text"]
    except Exception as e:
        print(f"API調用出錯: {e}")
        return None

def rag_query(query, api_key, k=3):
    # a) 使用查詢檢索最相關的"小"塊
    retrieved_small_docs = vector_db.similarity_search(query, k=k)
    
    # b) 根據映射字典，找到這些"小"塊對應的父"大"塊
    retrieved_big_contents = set()  # 使用集合自動去重
    for small_doc in retrieved_small_docs:
        small_id = hash(small_doc.page_content)
        if small_id in mapping_dict:
            retrieved_big_contents.add(mapping_dict[small_id]["big_chunk_content"])
        else:
            retrieved_big_contents.add(small_doc.page_content)  # 回退方案

    # 將去重後的大塊內容合併為上下文
    context = "\n\n---\n\n".join(retrieved_big_contents)

    # c) 構建Prompt，調用QWen API生成答案
    prompt_template = f"""請根據以下上下文信息回答問題..."""
    
    # 調用API
    answer = call_qwen_api(prompt_template, api_key)
    return answer

if __name__ == "__main__":
    API_KEY = os.environ.get("DASHSCOPE_API_KEY", "")  # 從環境變量獲取API密鑰
    
    query = "CNN神經網絡主要用於什麼任務？"  # 用户查詢
    
    result = rag_query(query, API_KEY)  # 執行RAG查詢
    
    print("\n--- 最終答案 ---")
    print(result)

import numpy as np
import faiss
from sentence_transformers import SentenceTransformer
from typing import List
import dashscope
from dashscope import Generation
import os

# 1. 設置Key（請替換成你的實際API Key）
dashscope.api_key = os.environ.get("DASHSCOPE_API_KEY", "") 

# 2. 加載嵌入模型（用於文本轉向量）
embed_model = SentenceTransformer('GanymedeNil/text2vec-large-chinese') # 一個優秀的中文嵌入模型

# 3. 假設我們有一個簡單的知識庫文檔（實際應用中應從文件加載）
knowledge_base = [
    "牛頓第一定律，又稱為慣性定律，指出：任何物體在沒有外力作用時，總保持勻速直線運動狀態或靜止狀態。",
    "牛頓第二定律指出，物體的加速度與所受合外力成正比，與質量成反比，公式為 F=ma。",
    "牛頓第三定律，又稱作用與反作用定律，指出兩個物體之間的作用力和反作用力總是大小相等，方向相反，作用在同一直線上。",
    "愛因斯坦的質能方程是 E=mc²，其中E代表能量，m代表質量，c代表光速。",
    "深度學習是機器學習的一個分支，它使用名為深度神經網絡的模型。",
]
# 為知識庫生成向量並構建Faiss索引
knowledge_vectors = embed_model.encode(knowledge_base)
dimension = knowledge_vectors.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(knowledge_vectors.astype('float32'))

# 4. 定義HyDE生成函數（使用Qwen）
def generate_hyde_query(original_query: str) -> str:
    """
    使用Qwen根據用户問題生成一個假設性的答案。
    這個答案可能不準確，但其表述方式更接近知識庫中的文本。
    """
    prompt = f"""請根據以下問題，生成一個假設性的、詳細的答案。即使你不確定正確答案，也請模仿百科知識的風格和語氣來寫。
問題：{original_query}
假設性答案："""
    
    response = Generation.call(
        model='qwen-max',
        prompt=prompt,
        seed=12345,
        top_p=0.8
    )
    hyde_text = response.output['text'].strip()
    print(f"原始查詢: {original_query}")
    print(f"HyDE生成: {hyde_text}")
    return hyde_text

# 5. 定義檢索函數
def retrieve_with_hyde(user_query: str, top_k: int = 3) -> List[str]:
    """
    1. 使用HyDE生成假設答案。
    2. 將假設答案編碼為向量。
    3. 用該向量在Faiss中檢索最相似的文檔。
    """
    # 生成HyDE查詢
    hyde_query = generate_hyde_query(user_query)
    # 將HyDE查詢編碼為向量
    query_vector = embed_model.encode([hyde_query])
    # 在Faiss中搜索
    distances, indices = index.search(query_vector.astype('float32'), top_k)
    # 返回檢索到的文本
    retrieved_docs = [knowledge_base[i] for i in indices[0]]
    return retrieved_docs

# 6. 定義最終答案生成函數（使用Qwen）
def generate_final_answer(user_query: str, contexts: List[str]) -> str:
    """
    將用户查詢和檢索到的上下文組合成Prompt，讓Qwen生成最終答案。
    """
    context_str = "\n".join([f"- {doc}" for doc in contexts])
    prompt = f"""請根據以下提供的上下文信息，回答用户的問題。如果上下文信息不包含答案，請直接説你不知道。

上下文信息：
{context_str}

用户問題：{user_query}
請直接給出答案："""
    
    response = Generation.call(
        model='qwen-max',
        prompt=prompt,
        seed=12345,
        top_p=0.8
    )
    final_answer = response.output['text'].strip()
    return final_answer

# 7. 主流程：完整的RAG with HyDE
def rag_with_hyde(user_query: str):
    # 第一步：通過HyDE檢索相關文檔
    retrieved_docs = retrieve_with_hyde(user_query)
    print("\n檢索到的相關文檔：")
    for i, doc in enumerate(retrieved_docs):
        print(f"{i+1}. {doc}")
    
    # 第二步：合成最終答案
    final_answer = generate_final_answer(user_query, retrieved_docs)
    print(f"\n最終答案：\n{final_answer}")

# 8. 測試
if __name__ == "__main__":
    user_question = "牛頓第一定律是什麼？"
    rag_with_hyde(user_question)

No sentence-transformers model found with name GanymedeNil/text2vec-large-chinese. Creating a new one with mean pooling.
原始查詢: 牛頓第一定律是什麼？
HyDE生成: 牛頓第一定律，也被稱為慣性定律，是經典力學中的基礎之一。這一定律由艾薩克·牛頓在17世紀提出，並收錄於他著名的《自然哲學的數學原理》一書中。牛頓第一定律指出，在沒有外力作用的情況下，一個物體將保持其靜止狀態或勻速直線運動的狀態不變。

換句話説，如果一個物體處於靜止，則它將繼續保持靜止；若該物體正在以恆定速度沿直線移動，則它將以相同的速度繼續沿同一直線移動，除非受到外部力量的作用。這裏的“外力”指的是任何能夠改變物體當前運動狀態的力量，比如摩擦力、重力等。

牛頓第一定律揭示了自然界中物體運動的基本規律之一——慣性。慣性是指物體抵抗其運動狀態變化（即加速或減速）的一種性質。質量越大的物體，其慣性也就越大，因此需要更大的力才能改變它的運動狀態。

這條定律不僅對於理解日常生活中物體的行為至關重要，而且也是現代物理學、工程學等多個領域研究的基礎。通過牛頓的第一定律，我們可以更好地預測和解釋周圍世界的物理現象。

檢索到的相關文檔：
1. 牛頓第一定律，又稱為慣性定律，指出：任何物體在沒有外力作用時，總保持勻速直線運動狀態或靜止狀態。
2. 牛頓第二定律指出，物體的加速度與所受合外力成正比，與質量成反比，公式為 F=ma。
3. 牛頓第三定律，又稱作用與反作用定律，指出兩個物體之間的作用力和反作用力總是大小相等，方向相反，作用在同一直線上。

最終答案：
牛頓第一定律，又稱為慣性定律，指出：任何物體在沒有外力作用時，總保持勻速直線運動狀態或靜止狀態。

import numpy as np
import faiss
from sentence_transformers import SentenceTransformer
import requests
import json
import os

# 初始化嵌入模型
embedding_model = SentenceTransformer('BAAI/bge-small-zh-v1.5')

# Qwen API配置
QWEN_API_KEY = os.environ.get("DASHSCOPE_API_KEY", "")  # 替換為您的實際API密鑰
QWEN_API_URL = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"

def call_qwen(prompt):
    """調用Qwen API"""
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {QWEN_API_KEY}"
    }
    
    payload = {
        "model": "qwen-turbo",
        "input": {
            "messages": [
                {
                    "role": "user",
                    "content": prompt
                }
            ]
        },
        "parameters": {
            "temperature": 0.7
        }
    }
    
    try:
        response = requests.post(QWEN_API_URL, headers=headers, json=payload)
        response.raise_for_status()
        result = response.json()
        return result['output']['text']
    except Exception as e:
        print(f"API調用失敗: {e}")
        return None

# 1. 準備文檔數據
documents = [
    "員工報銷需要提供發票和審批單，15個工作日內完成報銷。",
    "請假需提前在OA系統申請，緊急情況可事後補辦手續。",
    "密碼必須包含字母、數字和特殊字符，且長度至少8位。",
    "新產品發佈流程包括需求評審、設計、開發、測試和發佈五個階段。"
]

# 2. 生成查詢問題 (Doc2Query)
print("為文檔生成查詢問題...")
doc_queries = []
for doc in documents:
    prompt = f"請為以下文本生成3個用户可能會提出的問題:\n\n文本: {doc}\n\n生成的問題:"
    response = call_qwen(prompt)
    if response:
        queries = [q.strip() for q in response.split('\n') if q.strip()]
        doc_queries.append(queries[:3])
        print(f"文檔: {doc[:20]}...")
        print(f"生成的問題: {queries[:3]}")
    else:
        # 如果API調用失敗，使用簡單的問題
        doc_queries.append([f"關於{doc[:10]}...", f"如何{doc[:10]}...", f"{doc[:10]}有什麼要求..."])
    
    print()

# 3. 創建FAISS索引
# 合併文檔和生成的問題
all_texts = documents.copy()
for queries in doc_queries:
    all_texts.extend(queries)

# 生成嵌入向量
embeddings = embedding_model.encode(all_texts)

# 創建FAISS索引
dimension = embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(np.array(embeddings).astype('float32'))

# 4. 查詢改寫函數 (Query2Doc)
def rewrite_query(query):
    prompt = f"請根據以下問題生成一段詳細的答案文檔:\n\n問題: {query}\n\n生成的答案文檔:"
    response = call_qwen(prompt)
    return response if response else query

# 5. 檢索函數
def search(query):
    print(f"原始查詢: {query}")
    
    # 策略1: 直接檢索
    query_embedding = embedding_model.encode([query])
    distances, indices = index.search(np.array(query_embedding).astype('float32'), 3)
    
    print("直接檢索結果:")
    for i, idx in enumerate(indices[0]):
        if idx < len(all_texts):
            print(f"  {i+1}. {all_texts[idx]}")
    
    # 策略2: 查詢改寫後檢索
    expanded_query = rewrite_query(query)
    if expanded_query != query:
        print(f"改寫後的查詢: {expanded_query}")
        
        expanded_embedding = embedding_model.encode([expanded_query])
        distances, indices = index.search(np.array(expanded_embedding).astype('float32'), 3)
        
        print("改寫後檢索結果:")
        for i, idx in enumerate(indices[0]):
            if idx < len(all_texts):
                print(f"  {i+1}. {all_texts[idx]}")
    
    print("-" * 50)

# 6. 測試查詢
queries = ["怎麼報銷", "如何請假", "密碼要求", "發佈流程"]
for query in queries:
    search(query)

5.2 輸出結果 
為文檔生成查詢問題...
文檔: 員工報銷需要提供發票和審批單，15個工作...
生成的問題: ['1. 員工報銷需要哪些必備的材料？', '2. 報銷流程需要多長時間？', '3. 如果超過15個工作日還沒收到報 
銷款怎麼辦？']

文檔: 請假需提前在OA系統申請，緊急情況可事後...
生成的問題: ['1. 請假必須提前在OA系統申請嗎？', '2. 如果有緊急情況，是否可以先請假再補辦手續？', '3. 事後補辦 
請假手續需要哪些流程？']

文檔: 密碼必須包含字母、數字和特殊字符，且長度...
生成的問題: ['1. 密碼需要滿足哪些要求？', '2. 特殊字符包括哪些類型？', '3. 如果密碼只有7位，是否符合要求？']  

文檔: 新產品發佈流程包括需求評審、設計、開發、...
生成的問題: ['1. 新產品發佈流程有哪些主要階段？', '2. 需求評審在新產品發佈中起到什麼作用？', '3. 測試階段在新 
產品發佈流程中的重要性是什麼？']

原始查詢: 怎麼報銷
直接檢索結果:
  1. 2. 報銷流程需要多長時間？
  2. 3. 如果超過15個工作日還沒收到報銷款怎麼辦？
  3. 1. 員工報銷需要哪些必備的材料？
改寫後的查詢: **報銷流程説明文檔**---（中間省略8000字）---**備註：具體執行以公司最新通知為準。**
改寫後檢索結果:
  1. 2. 報銷流程需要多長時間？
  2. 員工報銷需要提供發票和審批單，15個工作日內完成報銷。
  3. 1. 員工報銷需要哪些必備的材料？
--------------------------------------------------
原始查詢: 如何請假
直接檢索結果:
  1. 3. 事後補辦請假手續需要哪些流程？
  2. 2. 如果有緊急情況，是否可以先請假再補辦手續？
  3. 1. 請假必須提前在OA系統申請嗎？
改寫後的查詢: **如何請假**---（中間省略8000字）---**備註**：本文檔僅供參考，具體請假流程請以所在單位或學校的規定為準。
改寫後檢索結果:
  1. 3. 事後補辦請假手續需要哪些流程？
  2. 請假需提前在OA系統申請，緊急情況可事後補辦手續。
  3. 1. 請假必須提前在OA系統申請嗎？
--------------------------------------------------
原始查詢: 密碼要求
直接檢索結果:
  1. 1. 密碼需要滿足哪些要求？
  2. 密碼必須包含字母、數字和特殊字符，且長度至少8位。
  3. 3. 如果密碼只有7位，是否符合要求？
改寫後的查詢: **密碼要求文檔**---（中間省略8000字）---**更新日期：2025年4月5日**
改寫後檢索結果:
  1. 1. 密碼需要滿足哪些要求？
  2. 密碼必須包含字母、數字和特殊字符，且長度至少8位。
  3. 3. 如果密碼只有7位，是否符合要求？
--------------------------------------------------
原始查詢: 發佈流程
直接檢索結果:
  1. 1. 新產品發佈流程有哪些主要階段？
  2. 新產品發佈流程包括需求評審、設計、開發、測試和發佈五個階段。
  3. 3. 測試階段在新產品發佈流程中的重要性是什麼？
改寫後的查詢: **發佈流程**---（中間省略8000字）---不斷優化和迭代發佈流程，以適應快速變化的市場需求。  
改寫後檢索結果:
  1. 新產品發佈流程包括需求評審、設計、開發、測試和發佈五個階段。
  2. 1. 新產品發佈流程有哪些主要階段？
  3. 3. 測試階段在新產品發佈流程中的重要性是什麼？
--------------------------------------------------