Transformări matriciale

O matrice este un mecanism care remodelează spațiul. Dacă înțelegeți cum acționează asupra fiecărui punct, înțelegeți întreaga transformare.

Tip: Construire Limbaje: Python, Julia Cerințe preliminare: Faza 1, lecțiile 01–02 (Intuiție pentru algebra liniară; Vectori, matrice și operații) Durată: ~75 de minute

Obiective de învățare

• Construirea matricelor de rotație, scalare, forfecare și reflexie și aplicarea lor asupra punctelor din spațiul bidimensional și tridimensional
• Compunerea mai multor transformări prin înmulțirea matricelor și verificarea faptului că ordinea contează
• Calcularea valorilor și vectorilor proprii pentru matrice 2x2 pornind de la ecuația caracteristică
• Explicarea motivului pentru care valorile proprii determină direcțiile PCA, stabilitatea RNN și comportamentul clusterizării spectrale

Problema

Citiți despre PCA și întâlniți instrucțiunea „găsiți vectorii proprii corespunzători matricei de covarianță”. Citiți despre stabilitatea modelelor și vedeți recomandarea „verificați dacă toate valorile proprii au modulul mai mic decât 1”. Citiți despre augmentarea datelor și vi se spune „aplicați o rotație aleatorie”. Nimic din toate acestea nu capătă sens până când nu înțelegeți geometric ce efect au matricele asupra spațiului.

Matricele nu sunt doar tablouri de numere. Sunt mecanisme spațiale. O matrice de rotație rotește punctele. O matrice de scalare le dilată sau le contractă. O matrice de forfecare le înclină. Orice transformare liniară pe care o rețea neuronală o aplică datelor este una dintre aceste operații sau o compunere a lor; rețelele folosesc și transformări neliniare, precum funcțiile de activare și normalizarea. Această lecție concretizează operațiile liniare respective.

Notă tehnică a traducerii: Originalul extinde afirmația la orice transformare dintr-o rețea neuronală. Formularea de mai sus precizează distincția dintre transformările liniare reprezentate prin matrice și operațiile neliniare.

Conceptul

Transformări reprezentate prin matrice

Orice transformare liniară în spațiul bidimensional poate fi scrisă ca o matrice 2x2. Matricea indică exact unde ajung vectorii bazei [1, 0] și [0, 1]. Poziția tuturor celorlalți vectori decurge din aceasta.

Rotația

O rotație bidimensională cu unghiul theta păstrează distanțele și unghiurile. Ea deplasează fiecare punct de-a lungul unui arc de cerc.

În spațiul tridimensional, rotația are loc în jurul unei axe. Fiecare axă are propria matrice de rotație:

Rz(theta) = | cos  -sin  0 |     Rotație în jurul axei z
            | sin   cos  0 |     (planul x-y se rotește, z rămâne fix)
            |  0     0   1 |

Rx(theta) = | 1   0     0    |   Rotație în jurul axei x
            | 0  cos  -sin   |   (planul y-z se rotește, x rămâne fix)
            | 0  sin   cos   |

Ry(theta) = |  cos  0  sin |     Rotație în jurul axei y
            |   0   1   0  |     (planul x-z se rotește, y rămâne fix)
            | -sin  0  cos |

Scalarea

Scalarea dilată sau contractă independent de-a lungul fiecărei axe.

Forfecarea

Forfecarea înclină o axă, menținând-o fixă pe cealaltă. Transformă dreptunghiurile în paralelograme.

Matrice de forfecare:

• Shx = [[1, k], [0, 1]] deplasează x cu k * y
• Shy = [[1, 0], [k, 1]] deplasează y cu k * x

Reflexia

Reflexia oglindește punctele față de o axă sau o dreaptă.

Matrice de reflexie:

• Reflexie față de axa y: [[-1, 0], [0, 1]]
• Reflexie față de axa x: [[1, 0], [0, -1]]

Compunerea: înlănțuirea transformărilor

Aplicarea transformării A și apoi a transformării B este echivalentă cu înmulțirea matricelor lor: result = B @ A @ point. Ordinea contează. O rotație urmată de scalare produce un rezultat diferit de o scalare urmată de rotație.

Compunere: S @ R = [[0, -2], [0.5, 0]]

Compunere: R @ S = [[0, -0.5], [2, 0]]

Rezultatele sunt diferite. Înmulțirea matricelor nu este comutativă.

Valori proprii și vectori proprii

Majoritatea vectorilor își schimbă direcția atunci când li se aplică o matrice. Vectorii proprii sunt speciali: matricea doar îi scalează, fără să-i rotească vreodată. Factorul de scalare este valoarea proprie.

A @ v = lambda * v

v este vectorul propriu (direcția care se păstrează)
lambda este valoarea proprie (factorul de scalare)

Exemplu: A = | 2  1 |
             | 1  2 |

Vectorul propriu [1, 1] cu valoarea proprie 3:
  A @ [1,1] = [3, 3] = 3 * [1, 1]     (aceeași direcție, scalare cu 3)

Vectorul propriu [1, -1] cu valoarea proprie 1:
  A @ [1,-1] = [1, -1] = 1 * [1, -1]  (aceeași direcție, neschimbat)

Matricea dilată spațiul de 3 ori de-a lungul direcției [1, 1] și păstrează neschimbată direcția [1, -1]. Orice altă direcție este o combinație a acestora două.

Descompunerea în valori proprii

Dacă o matrice are n vectori proprii liniar independenți, ea poate fi descompusă astfel:

A = V @ D @ V^(-1)

V = matricea ale cărei coloane sunt vectorii proprii
D = matricea diagonală a valorilor proprii
V^(-1) = inversa matricei V

Interpretare: trecere la coordonatele vectorilor proprii, scalare de-a lungul fiecărei axe, apoi revenire la coordonatele inițiale.

De ce contează valorile proprii

PCA. Vectorii proprii ai matricei de covarianță definesc direcțiile principale. Valorile proprii măsoară varianța explicată pe fiecare direcție; după normalizarea prin suma lor, obțineți proporțiile de varianță explicată. Sortați după valoarea proprie, păstrați primele k componente și obțineți reducerea dimensionalității.

Stabilitate. Într-o recurență liniară, raza spectrală a matricei de tranziție descrie dacă starea tinde să crească sau să se contracte. În rețelele recurente neliniare, dispariția și explozia gradienților depind de produsele Jacobienelor și de valorile lor singulare, nu numai de valorile proprii ale unei singure matrice.

Metode spectrale. Metodele spectrale pentru grafuri folosesc de regulă spectrul matricei laplaciene sau al matricei de adiacență normalizate. Clusterizarea spectrală se bazează pe vectorii proprii ai unei matrice laplaciene, care dezvăluie structura grafului; unele arhitecturi GNN pot fi interpretate prin această perspectivă spectrală fără să calculeze explicit valorile proprii.

Notă tehnică a traducerii: Originalul simplifică relația dintre valorile proprii, stabilitatea RNN și GNN. Aceste trei paragrafe au fost precizate pentru a separa PCA, recurența liniară și metodele spectrale pe grafuri.

Determinantul ca factor de scalare a volumului

Determinantul unei matrice de transformare indică factorul cu care aceasta scalează aria (în 2D) sau volumul (în 3D).

det = 1:   aria se păstrează (rotație)
det = 2:   aria se dublează
det = 0:   spațiul se reduce la o dimensiune inferioară (matrice singulară)
det = -1:  aria se păstrează, dar orientarea se inversează (reflexie)

| det(Rotație) | = 1        (întotdeauna)
| det(Scalare sx, sy) | = sx * sy
| det(Forfecare) | = 1      (aria se păstrează)
| det(Reflexie) | = -1      (orientarea se inversează)

matrix-transform

Construirea implementării

Pasul 1: matrice de transformare de la zero (Python)

import math

def rotation_2d(theta):
    c, s = math.cos(theta), math.sin(theta)
    return [[c, -s], [s, c]]

def scaling_2d(sx, sy):
    return [[sx, 0], [0, sy]]

def shearing_2d(kx, ky):
    return [[1, kx], [ky, 1]]

def reflection_x():
    return [[1, 0], [0, -1]]

def reflection_y():
    return [[-1, 0], [0, 1]]

def mat_vec_mul(matrix, vector):
    return [
        sum(matrix[i][j] * vector[j] for j in range(len(vector)))
        for i in range(len(matrix))
    ]

def mat_mul(a, b):
    rows_a, cols_b = len(a), len(b[0])
    cols_a = len(a[0])
    return [
        [sum(a[i][k] * b[k][j] for k in range(cols_a)) for j in range(cols_b)]
        for i in range(rows_a)
    ]

point = [1.0, 0.0]
angle = math.pi / 4

rotated = mat_vec_mul(rotation_2d(angle), point)
print(f"Rotate (1,0) by 45 deg: ({rotated[0]:.4f}, {rotated[1]:.4f})")

scaled = mat_vec_mul(scaling_2d(2, 3), [1.0, 1.0])
print(f"Scale (1,1) by (2,3): ({scaled[0]:.1f}, {scaled[1]:.1f})")

sheared = mat_vec_mul(shearing_2d(1, 0), [1.0, 1.0])
print(f"Shear (1,1) kx=1: ({sheared[0]:.1f}, {sheared[1]:.1f})")

reflected = mat_vec_mul(reflection_y(), [2.0, 1.0])
print(f"Reflect (2,1) across y: ({reflected[0]:.1f}, {reflected[1]:.1f})")

Pasul 2: compunerea transformărilor

R = rotation_2d(math.pi / 2)
S = scaling_2d(2, 0.5)

rotate_then_scale = mat_mul(S, R)
scale_then_rotate = mat_mul(R, S)

point = [1.0, 0.0]
result1 = mat_vec_mul(rotate_then_scale, point)
result2 = mat_vec_mul(scale_then_rotate, point)

print(f"Rotate 90 then scale: ({result1[0]:.2f}, {result1[1]:.2f})")
print(f"Scale then rotate 90: ({result2[0]:.2f}, {result2[1]:.2f})")
print(f"Same? {result1 == result2}")

Pasul 3: valori proprii de la zero (2x2)

Pentru o matrice 2x2 [[a, b], [c, d]], valorile proprii sunt soluțiile ecuației caracteristice: lambda^2 - (a+d)*lambda + (ad - bc) = 0.

def eigenvalues_2x2(matrix):
    a, b = matrix[0]
    c, d = matrix[1]
    trace = a + d
    det = a * d - b * c
    discriminant = trace ** 2 - 4 * det
    if discriminant < 0:
        real = trace / 2
        imag = (-discriminant) ** 0.5 / 2
        return (complex(real, imag), complex(real, -imag))
    sqrt_disc = discriminant ** 0.5
    return ((trace + sqrt_disc) / 2, (trace - sqrt_disc) / 2)

def eigenvector_2x2(matrix, eigenvalue):
    a, b = matrix[0]
    c, d = matrix[1]
    if abs(b) > 1e-10:
        v = [b, eigenvalue - a]
    elif abs(c) > 1e-10:
        v = [eigenvalue - d, c]
    else:
        if abs(a - eigenvalue) < 1e-10:
            v = [1, 0]
        else:
            v = [0, 1]
    mag = (v[0] ** 2 + v[1] ** 2) ** 0.5
    return [v[0] / mag, v[1] / mag]

A = [[2, 1], [1, 2]]
vals = eigenvalues_2x2(A)
print(f"Matrix: {A}")
print(f"Eigenvalues: {vals[0]:.4f}, {vals[1]:.4f}")

for val in vals:
    vec = eigenvector_2x2(A, val)
    result = mat_vec_mul(A, vec)
    scaled = [val * vec[0], val * vec[1]]
    print(f"  lambda={val:.1f}, v={[round(x,4) for x in vec]}")
    print(f"    A@v = {[round(x,4) for x in result]}")
    print(f"    l*v = {[round(x,4) for x in scaled]}")

Pasul 4: determinantul ca factor de scalare a volumului

def det_2x2(matrix):
    return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]

print(f"det(rotation 45) = {det_2x2(rotation_2d(math.pi/4)):.4f}")
print(f"det(scale 2,3)   = {det_2x2(scaling_2d(2, 3)):.1f}")
print(f"det(shear kx=1)  = {det_2x2(shearing_2d(1, 0)):.1f}")
print(f"det(reflect y)   = {det_2x2(reflection_y()):.1f}")

singular = [[1, 2], [2, 4]]
print(f"det(singular)     = {det_2x2(singular):.1f}")
print("Singular: columns are proportional, space collapses to a line.")

Utilizarea implementării

NumPy efectuează toate aceste operații prin rutine optimizate.

import numpy as np

theta = np.pi / 4
R = np.array([[np.cos(theta), -np.sin(theta)],
              [np.sin(theta),  np.cos(theta)]])

point = np.array([1.0, 0.0])
print(f"Rotate (1,0) by 45 deg: {R @ point}")

S = np.diag([2.0, 3.0])
composed = S @ R
print(f"Scale(2,3) after Rotate(45): {composed @ point}")

A = np.array([[2, 1], [1, 2]], dtype=float)
eigenvalues, eigenvectors = np.linalg.eig(A)
print(f"\nEigenvalues: {eigenvalues}")
print(f"Eigenvectors (columns):\n{eigenvectors}")

for i in range(len(eigenvalues)):
    v = eigenvectors[:, i]
    lam = eigenvalues[i]
    print(f"  A @ v{i} = {A @ v}, lambda * v{i} = {lam * v}")

print(f"\ndet(R) = {np.linalg.det(R):.4f}")
print(f"det(S) = {np.linalg.det(S):.1f}")

B = np.array([[3, 1], [0, 2]], dtype=float)
vals, vecs = np.linalg.eig(B)
D = np.diag(vals)
V = vecs
reconstructed = V @ D @ np.linalg.inv(V)
print(f"\nEigendecomposition A = V @ D @ V^-1:")
print(f"Original:\n{B}")
print(f"Reconstructed:\n{reconstructed}")

Rotații 3D cu NumPy

def rotation_3d_z(theta):
    c, s = np.cos(theta), np.sin(theta)
    return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])

def rotation_3d_x(theta):
    c, s = np.cos(theta), np.sin(theta)
    return np.array([[1, 0, 0], [0, c, -s], [0, s, c]])

point_3d = np.array([1.0, 0.0, 0.0])
rotated_z = rotation_3d_z(np.pi / 2) @ point_3d
rotated_x = rotation_3d_x(np.pi / 2) @ point_3d

print(f"\n3D point: {point_3d}")
print(f"Rotate 90 around z: {np.round(rotated_z, 4)}")
print(f"Rotate 90 around x: {np.round(rotated_x, 4)}")

Livrarea rezultatului

Această lecție construiește fundamentul geometric pentru PCA (faza 2) și pentru analiza ponderilor rețelelor neuronale. Codul pentru valori și vectori proprii realizat aici folosește același algoritm care stă la baza reducerii dimensionalității, a clusterizării spectrale și a analizei stabilității în sistemele de învățare automată aflate în producție.

Exerciții

1. Aplicați rotația, scalarea și forfecarea unui pătrat unitate (cu vârfurile în [0,0], [1,0], [1,1], [0,1]). Afișați vârfurile transformate pentru fiecare operație. Verificați dacă rotația păstrează distanțele dintre vârfuri.

2. Calculați manual valorile proprii ale matricei [[4, 2], [1, 3]], folosind ecuația caracteristică. Apoi verificați-le cu funcția construită de la zero și cu NumPy.

3. Creați o compunere de trei transformări (rotație cu 30 de grade, scalare cu [1.5, 0.8], forfecare cu kx=0.3) și aplicați-o asupra a 8 puncte dispuse pe un cerc. Afișați coordonatele înainte și după transformare. Calculați determinantul matricei compuse și verificați dacă este egal cu produsul determinanților individuali.

Termeni-cheie

Termen	Cum îi spune lumea	Ce înseamnă de fapt
Matrice de rotație	„Rotește obiectele”	O matrice ortogonală care deplasează punctele de-a lungul arcelor de cerc, păstrând distanțele și unghiurile. Determinantul său este întotdeauna 1.
Matrice de scalare	„Mărește obiectele”	O matrice diagonală care produce dilatări sau contracții independente de-a lungul fiecărei axe. Determinantul este produsul factorilor de scalare.
Matrice de forfecare	„Înclină obiectele”	O matrice care deplasează o coordonată proporțional cu alta, transformând dreptunghiurile în paralelograme. Determinantul său este 1.
Reflexie	„Oglindește obiectele”	O matrice care inversează spațiul față de o axă sau un plan. Determinantul său este -1.
Compunere	„Face două lucruri”	Înmulțirea matricelor de transformare pentru înlănțuirea operațiilor. Ordinea contează: B @ A înseamnă că se aplică mai întâi A, apoi B.
Vector propriu	„Direcție specială”	O direcție pe care matricea doar o scalează, fără să o rotească. Este amprenta transformării.
Valoare proprie	„Cât de mult o întinde”	Factorul scalar cu care matricea își scalează vectorul propriu. Poate fi negativ (inversarea direcției) sau complex (rotație într-un subspațiu real bidimensional).
Descompunere în valori proprii	„Descompunerea matricei”	Scrierea unei matrice sub forma V @ D @ V^(-1), separând-o în direcțiile fundamentale și factorii de scalare corespunzători.
Determinant	„Un singur număr obținut dintr-o matrice”	Factorul cu care transformarea scalează aria (în 2D) sau volumul (în 3D). Valoarea zero înseamnă că transformarea nu este inversabilă.
Ecuație caracteristică	„De unde provin valorile proprii”	det(A - lambda * I) = 0. Polinomul ale cărui rădăcini sunt valorile proprii.

Lecturi suplimentare

• 3Blue1Brown: Linear Transformations – prezentare vizuală intuitivă a modului în care matricele remodelează spațiul
• 3Blue1Brown: Eigenvectors and Eigenvalues – cea mai bună explicație vizuală a semnificației geometrice a vectorilor proprii
• MIT 18.06 Lecture 21: Eigenvalues and Eigenvectors – prezentarea clasică a lui Gilbert Strang

---

Sursă: Matrix Transformations — original

Navigare: înapoi: 01.02 — Vectori, matrice și operații · Faza 1 — Fundamente matematice · Catalog complet · în continuare: 01.04 — Calcul diferențial și integral pentru învățarea automată.