高中觉得只是"带箭头的线段"的向量，其实是大模型把"意思"变成"方向"的地基

import torch

# 向量就是一串坐标 —— 空间里的一个"位置 / 方向"
v = torch.tensor([3.0, 4.0])
print("向量:", v)
print("模长（箭头有多长）:", v.norm())      # 5.0，正是高中的勾三股四

import torch

a = torch.tensor([1.0, 1.0])
b = torch.tensor([2.0, 2.1])     # 坐标不同，但和 a 几乎指同一个方向
c = torch.tensor([-1.0, -0.9])   # 和 a 几乎指相反方向

for name, v in [("a", a), ("b≈同向", b), ("c≈反向", c)]:
    print(f"{name} 的纯方向:", (v / v.norm()).round(decimals=2))
# a 和 b 归一化后几乎一样（同向）；c 是它的负方向（反向）

import torch

a = torch.tensor([1.0, 0.0])
for name, v in [("同向", torch.tensor([1.0, 0.0])),
                ("垂直", torch.tensor([0.0, 1.0])),
                ("反向", torch.tensor([-1.0, 0.0]))]:
    print(f"{name}: 点积 a·v = {torch.dot(a, v):+.1f}")
# 同向 -> +1（最相关）   垂直 -> 0（毫不相关）   反向 -> -1（最相反）

import torch
import torch.nn.functional as F

a = torch.tensor([2.0, 1.0])
b = torch.tensor([4.0, 2.0])                       # b 就是 2a，方向完全一致
print("余弦相似度:", F.cosine_similarity(a, b, dim=0).item())   # 1.0：方向一样就是 1

import torch
import torch.nn as nn

torch.manual_seed(0)
vocab = ["猫", "狗", "苹果"]
emb = nn.Embedding(len(vocab), 4)      # 3 个词，每个用一个 4 维向量表示
ids = torch.tensor([0, 1, 2])          # 词的编号
print(emb(ids).round(decimals=2))      # 取出每个词对应的那一行"坐标"

import torch
import torch.nn.functional as F

vec = {
    "猫":   torch.tensor([0.90, 0.10]),
    "狗":   torch.tensor([0.80, 0.20]),   # 和"猫"同为动物 -> 方向接近
    "苹果": torch.tensor([0.10, 0.90]),   # 水果 -> 指向另一个方向
}

def cos(x, y):
    return F.cosine_similarity(vec[x], vec[y], dim=0).item()

print("猫 vs 狗  :", round(cos("猫", "狗"), 3))    # 高：意思近，方向近
print("猫 vs 苹果:", round(cos("猫", "苹果"), 3))  # 低：意思远，方向远

import torch
import torch.nn.functional as F

king  = torch.tensor([0.90, 0.70, 0.20])
man   = torch.tensor([0.80, 0.10, 0.10])
woman = torch.tensor([0.20, 0.10, 0.80])
queen = torch.tensor([0.35, 0.72, 0.88])

guess = king - man + woman              # 向量加减 = 语义加减
print("king - man + woman =", guess.round(decimals=2))
print("和 queen 的余弦相似度:", round(F.cosine_similarity(guess, queen, dim=0).item(), 3))

import torch
import torch.nn.functional as F

torch.manual_seed(0)
X = torch.randn(3, 4)                 # 3 个词，每个 4 维向量

scores = X @ X.T                      # 两两做点积 -> 相关度矩阵
weights = F.softmax(scores, dim=-1)   # 每行归一化成"注意力分配"

print("相关度（点积）矩阵:\n", scores.round(decimals=2))
print("每个词该关注谁（softmax 后）:\n", weights.round(decimals=2))

import torch
import math

a = torch.tensor([3.0, 4.0])
b = torch.tensor([4.0, 3.0])

dot = torch.dot(a, b)
cos = dot / (a.norm() * b.norm())
print("点积 a·b       :", dot.item())                        # 24
print("= |a||b|cosθ   :", round((a.norm() * b.norm() * cos).item(), 2))  # 也是 24
print("夹角(度)       :", round(math.degrees(math.acos(cos.item())), 1)) # ≈16.3°

import torch

torch.manual_seed(0)
for d in [4, 64, 1024]:
    q, k = torch.randn(d), torch.randn(d)
    raw = torch.dot(q, k)
    print(f"d={d:5d}  原始点积≈{raw:7.2f}   除以√d 后≈{raw / d ** 0.5:6.2f}")
# 维度越高原始点积越大越野；除以 √d 后，各维度都被拉回 O(1) 的稳定范围

import torch
import torch.nn.functional as F

words = ["cat", "kitten", "car", "truck"]
X = torch.tensor([[1.0, 0.1],      # cat
                  [0.9, 0.2],      # kitten —— 和 cat 几乎同向
                  [0.1, 1.0],      # car
                  [0.2, 0.9]])     # truck  —— 和 car 几乎同向

scores = X @ X.T / X.shape[1] ** 0.5     # 点积 / √d
scores.fill_diagonal_(float("-inf"))     # 先不让词只顾自己
weights = F.softmax(scores, dim=-1)

for i, w in enumerate(words):
    print(f"{w:7s} 最关注 -> {words[weights[i].argmax()]}")
# cat 最关注 kitten，car 最关注 truck —— 点积让方向相近的词互相吸引

python word_vectors_visualization.py