第4章：基础概念解析 - 嵌入、维度、相似度度量¶

# 向量化示例
from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')

# 文本嵌入
texts = ["我想买一部iPhone手机", "iPhone拍照效果很好", "今天天气真不错"]
embeddings = model.encode(texts)

print(f"向量形状: {embeddings.shape}")  # (3, 384) - 3个文本，每个384维
print(f"第一个文本的向量: {embeddings[0][:5]}...")  # [0.12, -0.34, 0.56, ...]

# 语义相似 → 向量距离近
result = cosine_similarity(
    embed("国王"),    # [0.8, 0.2, 0.1, ...]
    embed("王后")     # [0.7, 0.3, 0.2, ...]
)
print(f"国王 vs 王后: {result:.3f}")  # ~0.95 (很接近)

result = cosine_similarity(
    embed("国王"),
    embed("汽车")
)
print(f"国王 vs 汽车: {result:.3f}")  # ~0.1 (距离远)

# 著名的 king - man + woman ≈ queen
# 这个例子完美展示了向量嵌入的语义空间

king = embed("king")
man = embed("man")
woman = embed("woman")

# 向量运算
result = king - man + woman

# 验证结果与 queen 的相似度
queen = embed("queen")
similarity = cosine_similarity(result, queen)
print(f"king - man + woman 接近 queen: {similarity:.3f}")  # ~0.8

# 不同嵌入模型对比
from sentence_transformers import SentenceTransformer

# 轻量级模型
light_model = SentenceTransformer('all-MiniLM-L6-v2')
light_dim = light_model.get_sentence_embedding_dimension()  # 384

# 高质量模型
quality_model = SentenceTransformer('all-mpnet-base-v2')
quality_dim = quality_model.get_sentence_embedding_dimension()  # 768

print(f"轻量模型维度: {light_dim}, 质量模型维度: {quality_dim}")

# 一维向量
v1 = [0.5]  # 1维

# 二维向量（平面上的点）
v2 = [0.3, 0.7]  # 2维

# 三维向量（空间中的点）
v3 = [0.2, 0.5, 0.8]  # 3维

# 高维向量（AI中的常见形式）
v384 = [0.1] * 384  # 384维
v1536 = [0.1] * 1536  # 1536维

# 计算向量存储空间
def calculate_storage(num_vectors, dimension, bytes_per_float=4):
    """计算存储空间"""
    total_bytes = num_vectors * dimension * bytes_per_float
    return total_bytes / (1024**3)  # 转换为GB

print(f"1M向量 x 384维 = {calculate_storage(1_000_000, 384):.2f} GB")
print(f"1M向量 x 1536维 = {calculate_storage(1_000_000, 1536):.2f} GB")

# 维度灾难示意
import numpy as np

def avg_distance_in_unit_hyperball(dim, n_samples=10000):
    """计算单位超球体中随机点的平均距离"""
    points = np.random.uniform(-1, 1, (n_samples, dim))
    # 随机计算一些距离
    distances = []
    for i in range(min(1000, n_samples)):
        for j in range(i+1, min(1000, n_samples)):
            distances.append(np.linalg.norm(points[i] - points[j]))
    return np.mean(distances)

dims = [2, 10, 50, 100, 500, 1000, 5000]
for d in dims:
    avg_dist = avg_distance_in_unit_hyperball(d)
    print(f"维度 {d:4d}: 平均距离 {avg_dist:.3f}")

# 维度越高，所有点之间的距离差异越小
# 这使得区分"相似"和"不相似"变得困难

import numpy as np

def euclidean_distance(a, b):
    """欧氏距离"""
    return np.linalg.norm(a - b)

# 示例
a = np.array([1, 2, 3])
b = np.array([4, 6, 3])

dist = euclidean_distance(a, b)
print(f"欧氏距离: {dist:.2f}")  # 4.47

# 几何解释：在二维空间中，这是两点之间的直线距离

def cosine_similarity(a, b):
    """余弦相似度"""
    dot = np.dot(a, b)
    norm_a = np.linalg.norm(a)
    norm_b = np.linalg.norm(b)
    return dot / (norm_a * norm_b)

# 示例
a = np.array([1, 1, 0])
b = np.array([1, 1, 1])
c = np.array([-1, -1, 0])

print(f"a与b: {cosine_similarity(a, b):.3f}")  # 0.816 (夹角45°)
print(f"a与c: {cosine_similarity(a, c):.3f}")  # -1.000 (夹角180°)

def dot_product(a, b):
    """点积"""
    return np.dot(a, b)

# 示例
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

dot = dot_product(a, b)
print(f"点积: {dot}")  # 32 (1*4 + 2*5 + 3*6)

def normalized_dot_product(a, b):
    """归一化后的点积 = 余弦相似度"""
    a_norm = a / np.linalg.norm(a)
    b_norm = b / np.linalg.norm(b)
    return np.dot(a_norm, b_norm)

a = np.array([3, 4])  # 模长=5
b = np.array([4, 3])  # 模长=5

print(f"余弦相似度: {cosine_similarity(a, b):.3f}")  # 0.896
print(f"归一化点积: {normalized_dot_product(a, b):.3f}")  # 0.896

# 实际选择示例

# 场景1: 语义文本搜索
query = "推荐好用的笔记本电脑"
doc_embeddings = model.encode(corpus)
query_embedding = model.encode(query)

# 使用余弦相似度
similarities = cosine_similarity([query_embedding], doc_embeddings)[0]
top_k = np.argsort(similarities)[-5:][::-1]

# 场景2: 推荐系统
user_preference = user_embedding  # 用户偏好向量
item_features = item_embeddings   # 物品特征向量

# 使用点积（考虑强度）
scores = np.dot(user_preference, item_features.T)
top_k = np.argsort(scores)[-5:][::-1]

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')

# 单条处理（慢）
texts = ["文本1", "文本2", "文本3"]
for text in texts:
    embedding = model.encode(text)  # 每条单独编码

# 批量处理（快）
batch_embeddings = model.encode(texts, batch_size=32)  # 一次性编码
print(f"批量形状: {batch_embeddings.shape}")  # (3, 384)