# 初始化和基本使用示例
import faiss
import numpy as np

dimension = 128  # 向量维度
n_vectors = 1000  # 向量数量

# 创建随机向量数据
vectors = np.random.random((n_vectors, dimension)).astype('float32')

# 创建索引
index = faiss.IndexFlatL2(dimension)  # L2距离的暴力搜索索引
index.add(vectors)  # 添加向量到索引中

# 执行搜索
k = 5  # 返回最相似的k个结果
# shape为(1, dimension)，表示1个查询向量，每个向量维度为dimension
# 如果要同时查询多个向量，可以用(n, dimension)，n为查询向量数量
query_vector = np.random.random((1, dimension)).astype('float32')
distances, indices = index.search(query_vector, k)

# 创建IVF索引
nlist = 100  # 聚类中心数量
quantizer = faiss.IndexFlatL2(dimension)
index = faiss.IndexIVFFlat(quantizer, dimension, nlist)

# 训练索引
index.train(vectors)
index.add(vectors)

# 设置搜索参数
index.nprobe = 10  # 搜索时检查的聚类数量
distances, indices = index.search(query_vector, k)

# 创建PQ索引
n_bits = 8
n_subvectors = 16  # 将向量分成16个子向量
index = faiss.IndexPQ(dimension, n_subvectors, n_bits)

# 训练和添加向量
index.train(vectors)
index.add(vectors)

# 搜索
distances, indices = index.search(query_vector, k)

# 将索引转移到GPU
res = faiss.StandardGpuResources()
gpu_index = faiss.index_cpu_to_gpu(res, 0, index)

# 在GPU上执行搜索
distances, indices = gpu_index.search(query_vector, k)

# 为文档创建多个向量表示的实际场景
dimension = 128
documents = [
    # 文档1：包含3个文本块
    [
        "这是第一个文档的开头部分",
        "这是文档中间的内容",
        "这是文档的结尾部分"
    ],
    # 文档2：包含2个文本块
    [
        "另一个文档的第一部分",
        "另一个文档的第二部分"
    ]
]

# 假设这是文本转向量的函数（实际项目中使用embedding模型）
def text_to_vector(text):
    # 这里用随机向量模拟，实际中使用embedding模型
    return np.random.random(dimension).astype('float32')

# 为每个文档的每个文本块生成向量
doc_vectors = []  # 存储所有向量
doc_ids = []     # 存储向量对应的文档ID
for doc_id, doc in enumerate(documents):
    for text_chunk in doc:
        vec = text_to_vector(text_chunk)
        doc_vectors.append(vec)
        doc_ids.append(doc_id)

# 转换为numpy数组
doc_vectors = np.array(doc_vectors).astype('float32')  # shape: (n_total_chunks, dimension)
doc_ids = np.array(doc_ids)                           # shape: (n_total_chunks,)

# 创建索引
index = faiss.IndexFlatL2(dimension)
index.add(doc_vectors)

# 搜索时的查询也可能需要分块处理
query = [
    "查询的第一部分",
    "查询的第二部分"
]

# 为查询的每个部分生成向量
query_vectors = []
for query_chunk in query:
    vec = text_to_vector(query_chunk)
    query_vectors.append(vec)
query_vectors = np.array(query_vectors).astype('float32')  # shape: (n_query_chunks, dimension)

# 对每个查询向量进行搜索
k = 10
all_distances = []
all_indices = []
for query_vec in query_vectors:
    # faiss需要shape为(1, dimension)，因为每次search输入一个查询
    distances, indices = index.search(query_vec.reshape(1, -1), k)
    all_distances.append(distances[0])
    all_indices.append(indices[0])

# 合并多个查询向量的结果
retrieved_docs = {}
for distances, indices in zip(all_distances, all_indices):
    for dist, idx in zip(distances, indices):
        doc_id = doc_ids[idx]
        # 对于每个文档，保留最小距离（最相似）的结果
retrieved_docs = {}
for dist, idx in zip(distances[0], indices[0]):
    doc_id = doc_ids[idx]
    if doc_id not in retrieved_docs or dist < retrieved_docs[doc_id]:
        retrieved_docs[doc_id] = dist

# 按距离排序获取最终的文档列表
final_results = sorted(retrieved_docs.items(), key=lambda x: x[1])[:5]

# 在后端开发中，我们经常这样分割字符串：
text = "hello world"
words = text.split(" ")  # ["hello", "world"]

# 但在NLP中，分词更复杂：
text = "我爱编程"
tokens = tokenizer(text)  # ["我", "爱", "编", "程"]

# 为什么要这样做？
# 1. 处理不同语言（中文需要字符级分割）
# 2. 处理特殊词（如URL、表情符号）
# 3. 控制词表大小（通过子词切分）

# 在后端开发中，我们用枚举表示类别：
class UserType(Enum):
    ADMIN = 0
    USER = 1

# 在NLP中，我们用向量表示词：
word_vectors = {
    "我": [0.2, -0.5, 0.8, ...],  # 512维向量
    "爱": [0.7, 0.3, -0.4, ...],
    "编程": [-0.1, 0.9, 0.2, ...]
}

# 为什么要用向量？
# 1. 捕捉词的语义（相似的词有相似的向量）
# 2. 可以计算相似度（通过向量点积或余弦相似度）
# 3. 神经网络需要数值输入

# 在后端开发中，我们经常编解码数据：
# JSON编解码
json_str = json.dumps(data)    # 编码
data = json.loads(json_str)    # 解码

# Base64编解码
encoded = base64.b64encode(data)    # 编码
decoded = base64.b64decode(encoded) # 解码

# Transformer中的编解码：
class Translator:
    def translate(self, text):
        # 编码：理解输入文本
        understanding = self.encoder(text)
        # 理解 = {
        #   "主语": "天气",
        #   "谓语": "很好",
        #   "时态": "现在时"
        # }
        
        # 解码：生成目标语言
        translation = self.decoder(understanding)
        # 解码过程 = [
        #   "The",
        #   "The weather",
        #   "The weather is",
        #   "The weather is good"
        # ]
        
        return translation

# 在后端开发中，我们经常计算百分比：
total = sum(values)
percentages = [v/total for v in values]

# Softmax做类似的事，但保证结果更平滑：
def softmax(values):
    exp_values = [math.exp(v) for v in values]
    total = sum(exp_values)
    return [exp/total for exp in exp_values]

# 例如：
scores = [1.0, 2.0, 0.5]
probs = softmax(scores)  # [0.24, 0.65, 0.11]

# 特点：
# 1. 结果总和为1
# 2. 保持大小关系
# 3. 突出大的值

# 在后端处理数据时，我们可能这样标准化：
def normalize(values):
    min_val = min(values)
    max_val = max(values)
    return [(v - min_val)/(max_val - min_val) for v in values]

# 层归一化类似，但用均值和方差：
def layer_norm(values, epsilon=1e-5):
    mean = sum(values) / len(values)
    variance = sum((x - mean) ** 2 for x in values) / len(values)
    return [(x - mean) / math.sqrt(variance + epsilon) for x in values]

# 为什么要归一化？
# 1. 让训练更稳定
# 2. 防止数值太大或太小
# 3. 类似于数据库中的字段标准化

# 在后端开发中，我们可能计算加权和：
def weighted_sum(values, weights):
    return sum(v * w for v, w in zip(values, weights))

# 向量点积就是这样的加权和：
def dot_product(vec1, vec2):
    return sum(v1 * v2 for v1, v2 in zip(vec1, vec2))

# 例如，计算两个词的相关度：
word1_vector = [0.2, 0.5, -0.1]
word2_vector = [0.3, 0.4, -0.2]
similarity = dot_product(word1_vector, word2_vector)

# 为什么用点积？
# 1. 可以衡量相似度
# 2. 计算效率高（可以用矩阵运算加速）
# 3. 捕捉向量方向的一致性

# 在后端开发中，我们用配置文件保存设置：
config = {
    "db_host": "localhost",
    "db_port": 5432,
    "cache_size": 1000
}

# 预训练模型类似，但保存的是学习到的知识：
model = {
    "vocabulary": {
        "我": {"vector": [0.1, 0.2, ...], "freq": 10000},
        "爱": {"vector": [0.3, -0.1, ...], "freq": 5000}
    },
    "weights": {
        "layer1": numpy.array([[...], ...]),
        "layer2": numpy.array([[...], ...])
    }
}

# 为什么用预训练？
# 1. 复用已学习的知识（类似代码复用）
# 2. 节省训练时间和资源
# 3. 利用大规模数据的学习成果

# 在后端开发中，我们用不同维度的数据结构：
# 0维：标量
count = 42

# 1维：数组/列表
scores = [95, 88, 72]

# 2维：矩阵/表格
matrix = [
    [1, 2, 3],
    [4, 5, 6]
]

# 张量是更高维的推广：
# 3维张量（批次 x 序列长度 x 特征维度）
batch_data = [
    # 第1个样本
    [
        [0.1, 0.2, 0.3],  # 第1个词的特征
        [0.4, 0.5, 0.6]   # 第2个词的特征
    ],
    # 第2个样本
    [
        [0.7, 0.8, 0.9],
        [0.2, 0.3, 0.4]
    ]
]

# 为什么用张量？
# 1. 批量处理数据（提高效率）
# 2. 保存多维特征
# 3. GPU优化计算

# 简化的Transformer使用示例
from transformers import AutoTokenizer, AutoModelForSeq2SeqTransformation

# 1. 加载预训练模型
tokenizer = AutoTokenizer.from_pretrained("t5-small")
model = AutoModelForSeq2SeqTransformation.from_pretrained("t5-small")

# 2. 准备输入
text = "translate English to Chinese: I love programming"
inputs = tokenizer(text, return_tensors="pt")

# 3. 生成翻译
outputs = model.generate(inputs.input_ids)
result = tokenizer.decode(outputs[0])
print(result)  # 输出: "我爱编程"

# 编译器词法分析
"int main()" -> ["int", "main", "(", ")"]

# Transformer分词
"I love programming" -> ["▁I", "▁love", "▁progra", "mming"]

# 代码依赖分析示例
def analyze_dependencies(code_lines):
    attention_scores = {}
    
    # 示例代码行
    code_lines = [
        "user = User.objects.get(id=1)",           # line 1
        "orders = user.get_orders()",              # line 2
        "total = calculate_total(orders)",         # line 3
        "if total > 1000:",                        # line 4
        "    user.set_vip_status(True)"           # line 5
    ]
    
    # 分析每行代码与其他行的关联度（注意力分数）
    for i, line in enumerate(code_lines):
        scores = {}
        for j, other_line in enumerate(code_lines):
            # 检查变量复用
            score = 0
            if "user" in line and "user" in other_line:
                score += 0.5
            if "orders" in line and "orders" in other_line:
                score += 0.5
            if "total" in line and "total" in other_line:
                score += 0.5
            scores[j] = score
            
        attention_scores[i] = scores
    
    return attention_scores

# 分析结果示例：
# line 1 (user定义) 与 line 2和5最相关（使用了user变量）
# line 2 (orders定义) 与 line 3最相关（使用了orders变量）
# line 3和4 (total相关) 相互关联

# 代码审查示例
class CodeReview:
    def __init__(self, code):
        self.code = code
        self.reviewers = [
            SecurityReviewer(),    # 安全审查员
            PerformanceReviewer(), # 性能审查员
            StyleReviewer()        # 代码风格审查员
        ]
    
    def parallel_review(self):
        review_results = []
        # 每个审查员从自己专注的角度进行分析
        for reviewer in self.reviewers:
            results = reviewer.analyze(self.code)
            review_results.append(results)
        
        # 合并所有审查结果
        final_report = self.combine_reviews(review_results)
        return final_report

# 使用示例
code = """
def process_user_data(user_input):
    data = json.loads(user_input)    # 安全审查：需要输入验证
    result = []                      # 性能审查：考虑预分配大小
    for item in data:               # 风格审查：考虑使用列表推导式
        result.append(item * 2)
    return result
"""

review = CodeReview(code)
report = review.parallel_review()

class MultiHeadAttention:
    def __init__(self, num_heads=8, head_dim=64):
        self.heads = num_heads
        self.head_dim = head_dim
        # 初始化查询(Q)、键(K)、值(V)的权重矩阵
        self.W_q = np.random.randn(num_heads, head_dim)  # 查询权重
        self.W_k = np.random.randn(num_heads, head_dim)  # 键权重
        self.W_v = np.random.randn(num_heads, head_dim)  # 值权重
    
    def attention(self, query, key, value):
        # 1. 计算注意力分数
        # 类比：计算每个翻译专家对不同单词的关注程度
        scores = np.dot(query, key.T)  # Q和K的点积
        
        # 2. 归一化分数（使用softmax）
        # 类比：将关注度转换为百分比
        attention_weights = self.softmax(scores)
        
        # 3. 加权求和
        # 类比：根据关注度获取最终理解
        output = np.dot(attention_weights, value)
        return output
    
    def split_heads(self, x):
        # 将输入分给多个注意力头处理
        # 类比：将文本分配给多个翻译专家
        batch_size = x.shape[0]
        return x.reshape(batch_size, self.heads, -1, self.head_dim)

class TransformerLayer:
    def __init__(self, dim=512, num_heads=8):
        self.attention = MultiHeadAttention(num_heads, dim//num_heads)
        self.feed_forward = self.create_ffn(dim)
        self.norm1 = LayerNorm()
        self.norm2 = LayerNorm()
    
    def create_ffn(self, dim):
        # 创建前馈神经网络
        # 类比：每个翻译专家的个人思考过程
        return {
            'layer1': {
                'weight': np.random.randn(dim, dim*4),
                'bias': np.zeros(dim*4)
            },
            'layer2': {
                'weight': np.random.randn(dim*4, dim),
                'bias': np.zeros(dim)
            }
        }
    
    def forward(self, x):
        # 1. 自注意力层
        # 类比：理解句子中词语之间的关系
        attention_output = self.attention.forward(x)
        x = self.norm1(x + attention_output)  # 残差连接
        
        # 2. 前馈网络
        # 类比：深入思考和处理信息
        ffn_output = self.feed_forward_pass(x)
        x = self.norm2(x + ffn_output)  # 残差连接
        return x

class Transformer:
    def __init__(self):
        # 初始化编码器和解码器层
        self.encoder_layers = [TransformerLayer() for _ in range(6)]
        self.decoder_layers = [TransformerLayer() for _ in range(6)]
        # 词嵌入层
        self.embedding = self.create_embedding(vocab_size=50000, dim=512)
    
    def translate(self, text):
        """翻译过程的详细步骤"""
        # 1. 词嵌入
        # 类比：将每个词转换为计算机理解的形式
        tokens = self.tokenize(text)  # "I love you" -> [24, 56, 789]
        embedded = self.embed_tokens(tokens)
        
        # 2. 位置编码
        # 类比：为每个词添加位置信息
        positions = self.add_position_encoding(embedded)
        
        # 3. 编码器处理
        # 类比：多个翻译专家反复理解原文
        encoder_output = positions
        for encoder in self.encoder_layers:
            # attention的三个输入都是encoder_output
            # 因为自注意力是分析同一段文本内部的关系
            encoder_output = encoder.forward(encoder_output)
        
        # 4. 解码器处理
        # 类比：基于理解生成译文
        decoder_output = self.decode(encoder_output)
        
        # 5. 生成翻译
        translation = self.generate_text(decoder_output)
        return translation

# 使用示例
transformer = Transformer()
text = "The weather is good today"
translation = transformer.translate(text)  # 天气很好

"""
核心组件说明：

1. MultiHeadAttention（多头注意力）
   - 每个"头"都有自己的QKV权重矩阵
   - 可以理解为多个翻译专家并行工作
   - 最后合并所有专家的理解

2. TransformerLayer（Transformer层）
   - 包含注意力机制和前馈网络
   - 通过残差连接保留原始信息
   - 使用层归一化确保数据分布稳定

3. Transformer（整体架构）
   - 词嵌入：将词转换为向量
   - 位置编码：添加位置信息
   - 多层编码器和解码器：逐层加深理解
"""

rainbow_example = {
    "query": "What causes rainbows?",
    "ground_truth_refs": [
        "Rainbows occur when sunlight is refracted through raindrops, splitting light into colors.",
        "They appear opposite the sun and require water droplets in the atmosphere.",
        "The colors of a rainbow range from red to violet in a specific order."
    ],
    "retrieved_texts": [
        "Sunlight bending through rain droplets creates rainbows with colorful bands.",
        "Rainbows appear when water droplets and sunlight combine opposite the sun.",
        "A rainbow shows colors from red to violet."
    ]
}

photosynthesis_example = {
    "query": "Explain photosynthesis.",
    "ground_truth_refs": [
        "Photosynthesis is a process where plants convert carbon dioxide and water into glucose.",
        "It requires sunlight and chlorophyll to capture energy.",
        "Oxygen is released as a byproduct during photosynthesis."
    ],
    "retrieved_texts": [
        "Plants use sunlight and chlorophyll to turn CO2 and water into sugar.",
        "Oxygen is produced when plants photosynthesize.",
        "Photosynthesis transforms sunlight into chemical energy in plants."
    ]
}

def exact_match_evaluation(ground_truth_refs, retrieved_texts):
    matches = []
    for retrieved in retrieved_texts:
        # 检查每个检索文本是否与任何参考文本完全匹配（normalized先）
        match_found = any(retrieved == ref for ref in ground_truth_refs)
        matches.append(match_found)
    
    # 计算准确率
    accuracy = sum(matches) / len(retrieved_texts)
    return accuracy

# 彩虹示例结果
rainbow_accuracy = exact_match_evaluation(
    rainbow_example["ground_truth_refs"], 
    rainbow_example["retrieved_texts"]
)  # 结果：0.0（没有完全相同的文本）

# 解释：虽然内容相似，但由于表达方式不同，没有一个检索结果与参考答案完全相同

from rapidfuzz import fuzz

def similarity_evaluation(ground_truth_refs, retrieved_texts, threshold=80):
    similarities = []
    for retrieved in retrieved_texts:
        # 计算与每个参考文本的相似度，取最高值
        max_similarity = max(
            fuzz.token_sort_ratio(retrieved, ref)
            for ref in ground_truth_refs
        )
        similarities.append(max_similarity >= threshold)
    
    # 计算高于阈值的比例
    score = sum(similarities) / len(similarities)
    return score, similarities

# 彩虹示例分析
score, details = similarity_evaluation(
    rainbow_example["ground_truth_refs"],
    rainbow_example["retrieved_texts"]
)
"""
结果：0.67（2/3的文本相似度超过阈值）
- "Sunlight bending..." vs "Rainbows occur when sunlight..." ≈ 85%
- "Rainbows appear when..." vs "They appear opposite..." ≈ 90%
- "A rainbow shows..." vs "The colors of a rainbow..." ≈ 75%
"""

def bow_evaluation(ground_truth_refs, retrieved_text):
    # 对单个检索文本的评估
    retrieved_words = set(retrieved_text.lower().split())
    
    max_recall = 0
    max_precision = 0
    
    for ref in ground_truth_refs:
        ref_words = set(ref.lower().split())
        common_words = retrieved_words & ref_words
        
        recall = len(common_words) / len(ref_words)
        precision = len(common_words) / len(retrieved_words)
        
        # 取最佳匹配分数
        max_recall = max(max_recall, recall)
        max_precision = max(max_precision, precision)
    
    return max_recall, max_precision

# 光合作用示例分析
retrieved = photosynthesis_example["retrieved_texts"][0]  # "Plants use sunlight..."
recall, precision = bow_evaluation(
    photosynthesis_example["ground_truth_refs"],
    retrieved
)
"""
分析第一条检索文本：
参考文本1对比：
- 共同词：plants, sunlight, water, into
- 参考词总数：11，共同词数：4，召回率=0.36
- 检索词总数：10，共同词数：4，精确率=0.40

参考文本2对比：
- 共同词：sunlight
- 参考词总数：8，共同词数：1，召回率=0.13
- 检索词总数：10，共同词数：1，精确率=0.10

参考文本3对比：
- 没有共同词
- 召回率=0，精确率=0

最终取最高分：
召回率=0.36，精确率=0.40
"""

import tiktoken

def tiktoken_evaluation(ground_truth_refs, retrieved_text):
    # 初始化分词器
    encoder = tiktoken.get_encoding("cl100k_base")
    
    # 对检索文本进行分词
    retrieved_tokens = set(encoder.encode(retrieved_text))
    
    max_recall = 0
    max_precision = 0
    
    for ref in ground_truth_refs:
        # 对参考文本进行分词
        ref_tokens = set(encoder.encode(ref))
        common_tokens = retrieved_tokens & ref_tokens
        
        recall = len(common_tokens) / len(ref_tokens)
        precision = len(common_tokens) / len(retrieved_tokens)
        
        max_recall = max(max_recall, recall)
        max_precision = max(max_precision, precision)
    
    return max_recall, max_precision

# 彩虹示例分析
retrieved = rainbow_example["retrieved_texts"][0]
recall, precision = tiktoken_evaluation(
    rainbow_example["ground_truth_refs"],
    retrieved
)
"""
第一条检索文本的token分析：
"Sunlight bending through rain droplets creates rainbows with colorful bands."
↓ tiktoken分词
[sun, light, bend, ing, through, rain, drop, lets, creates, rainbow, s, with, color, ful, bands]

对比参考文本1：
"Rainbows occur when sunlight is refracted through raindrops, splitting light into colors."
↓ tiktoken分词
[Rainbow, s, occur, when, sun, light, is, refract, ed, through, rain, drop, s, split, ing, light, into, color, s]

共同tokens: {sun, light, through, rain, drop, s, color}
召回率 = 7/19 = 0.37
精确率 = 7/15 = 0.47
"""