行列演算の直感的理解——AIが使う数学の核心

import numpy as np

# 2x2 行列: 90度回転
A = np.array([
    [0, -1],
    [1,  0]
])

# 入力ベクトル
x = np.array([1, 0])

# 変換後のベクトル
y = A @ x
print(y)  # [0, 1] — 90度回転した

# 行列 A: 2倍に拡大
A = np.array([
    [2, 0],
    [0, 2]
])

# 行列 B: 45度回転
theta = np.pi / 4
B = np.array([
    [np.cos(theta), -np.sin(theta)],
    [np.sin(theta),  np.cos(theta)]
])

# 合成変換: まず回転、次に拡大
C = A @ B

x = np.array([1, 0])
print(C @ x)  # 回転してから2倍に拡大した結果

# 入力: 4次元ベクトル（バッチサイズ=1）
x = np.array([0.5, 0.3, 0.8, 0.1])

# 重み行列: 4入力 → 3出力
W = np.random.randn(3, 4)

# バイアス
b = np.zeros(3)

# 線形変換
z = W @ x + b
print(z.shape)  # (3,)

A = np.array([
    [1, 2, 3],
    [4, 5, 6]
])
print(A.shape)    # (2, 3)
print(A.T.shape)  # (3, 2)
print(A.T)
# [[1, 4],
#  [2, 5],
#  [3, 6]]

# ベクトルの内積（行ベクトル × 列ベクトル）
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
dot_product = a.T @ b  # = a @ b (1Dの場合は同じ)
print(dot_product)  # 32

# バッチ処理での行列積
# X: (バッチサイズ, 入力次元) = (32, 4)
X = np.random.randn(32, 4)
W = np.random.randn(3, 4)  # (出力次元, 入力次元)

# 正しい変換: X @ W.T → (32, 3)
output = X @ W.T
print(output.shape)  # (32, 3)

A = np.array([
    [2, 1],
    [1, 3]
])

A_inv = np.linalg.inv(A)
print(A @ A_inv)
# [[1, 0],
#  [0, 1]] ← 単位行列（近似）

# 連立方程式 Ax = b の解
b = np.array([5, 7])
x = A_inv @ b
print(x)  # 解ベクトル

# あるいは np.linalg.solve の方が数値的に安定
x = np.linalg.solve(A, b)
print(x)

# 特異行列（逆行列なし）
singular = np.array([
    [1, 2],
    [2, 4]  # 行が線形従属
])
print(np.linalg.det(singular))  # ≈ 0

try:
    np.linalg.inv(singular)
except np.linalg.LinAlgError as e:
    print(f"エラー: {e}")

I = np.eye(3)
x = np.array([1, 2, 3])
print(I @ x)  # [1, 2, 3] — 変化なし

# 共分散行列は常に対称
data = np.random.randn(100, 4)
cov = np.cov(data.T)
print(np.allclose(cov, cov.T))  # True

theta = np.pi / 3
R = np.array([
    [np.cos(theta), -np.sin(theta)],
    [np.sin(theta),  np.cos(theta)]
])
print(np.allclose(R @ R.T, np.eye(2)))  # True
x = np.array([3, 4])
print(np.linalg.norm(x))       # 5.0
print(np.linalg.norm(R @ x))   # 5.0 — 長さ不変

A = np.array([
    [3, 1],
    [1, 3]
])

eigenvalues, eigenvectors = np.linalg.eig(A)
print("固有値:", eigenvalues)     # [4. 2.]
print("固有ベクトル:\n", eigenvectors)

# 検証: A @ v = λ * v
v = eigenvectors[:, 0]
lam = eigenvalues[0]
print(np.allclose(A @ v, lam * v))  # True

from sklearn.decomposition import PCA

data = np.random.randn(200, 10)  # 200サンプル、10次元

pca = PCA(n_components=3)
reduced = pca.fit_transform(data)
print(reduced.shape)  # (200, 3) — 10次元 → 3次元に削減

print("説明分散比:", pca.explained_variance_ratio_)

def attention(Q, K, V):
    """
    Q: クエリ行列 (seq_len, d_k)
    K: キー行列   (seq_len, d_k)
    V: バリュー行列 (seq_len, d_v)
    """
    d_k = Q.shape[-1]

    # 類似度スコア: Q と K の内積
    scores = Q @ K.T / np.sqrt(d_k)  # (seq_len, seq_len)

    # ソフトマックスで正規化
    scores = np.exp(scores)
    scores = scores / scores.sum(axis=-1, keepdims=True)

    # 加重和
    output = scores @ V  # (seq_len, d_v)
    return output

# 例: 4トークン、8次元
seq_len, d_k = 4, 8
Q = np.random.randn(seq_len, d_k)
K = np.random.randn(seq_len, d_k)
V = np.random.randn(seq_len, d_k)

out = attention(Q, K, V)
print(out.shape)  # (4, 8)

import time

n = 2000
A = np.random.randn(n, n)
B = np.random.randn(n, n)

start = time.time()
C = A @ B
elapsed = time.time() - start
print(f"行列積 ({n}x{n}): {elapsed:.3f}秒")

# ループによる素朴な実装と比較（絶対やってはいけない）
# これは数百倍遅くなる