Vetores (vectors), Matrizes (matrices), Tensores (tensors)

Por que vetores, matrizes e tensores aparecem em todo lugar em IA

O aprendizado de máquina (machine learning) moderno é em grande parte “álgebra linear + otimização + não linearidade”. Mesmo quando um modelo é altamente não linear (redes profundas, atenção, modelos de difusão), a maior parte da computação é construída a partir de um pequeno conjunto de objetos fundamentais:

  • Vetores (arrays 1D): vetores de características, embeddings, gradientes
  • Matrizes (arrays 2D): conjuntos de dados, camadas lineares, mapas de atenção, matrizes de covariância
  • Tensores (arrays ND): lotes de dados, imagens, sequências, parâmetros do modelo, ativações intermediárias

Entender suas formas, operações e significado geométrico ajuda você a:

  • depurar incompatibilidades de forma e problemas de desempenho,
  • raciocinar sobre capacidade do modelo e invariâncias,
  • interpretar embeddings e projeções,
  • conectar “tensores no nível do código” a “aplicações lineares no nível da matemática”.

Este artigo foca nos objetos centrais, suas operações, convenções de forma e intuição geométrica.

Vetores

O que é um vetor

Um vetor é uma lista ordenada de números, tipicamente escrita como:

  • Como vetor coluna: (x \in \mathbb{R}^n)
  • Componentes: (x = (x_1, x_2, \dots, x_n))

Em aprendizado de máquina, vetores comumente representam:

  • Vetores de características: um exemplo com (n) características
  • Embeddings: uma representação aprendida de um token/usuário/item em (\mathbb{R}^d)
  • Gradientes: derivada de uma perda escalar em relação (w.r.t.) aos parâmetros

Forma e indexação

Em código, um vetor frequentemente tem forma:

  • NumPy: (n,) (1D)
  • PyTorch: (n,) ou (n, 1), dependendo da convenção

Atenção: a matemática distingue vetores linha vs. coluna, mas muitas bibliotecas tratam arrays 1D como ambíguos em forma até que você os redimensione.

Operações fundamentais com vetores

Operações elemento a elemento

Para vetores (x, y \in \mathbb{R}^n):

  • Soma: (x + y)
  • Escalonamento: (\alpha x)

Produto escalar (produto interno) (dot product (inner product))

O produto escalar (produto interno) mapeia dois vetores para um escalar: [ x \cdot y = \sum_{i=1}^n x_i y_i ] Geometricamente: [ x \cdot y = |x||y|\cos\theta ] Então, ele mede alinhamento (ângulo) assim como magnitude.

Usos comuns em aprendizado de máquina:

  • pontuação de similaridade (especialmente com vetores normalizados)
  • modelos lineares: (w^\top x)

Normas (comprimento)

A norma mais comum é a norma L2: [ |x|_2 = \sqrt{\sum_i x_i^2} ] Outras importam em aprendizado de máquina:

  • norma (L1) para esparsidade (regularização estilo lasso)
  • norma (L\infty) para limites no pior caso

Similaridade do cosseno (cosine similarity)

Para embeddings (u, v): [ \text{cos_sim}(u,v) = \frac{u \cdot v}{|u||v|} ] Isso é amplamente usado em recuperação (retrieval) e aprendizado de representações porque foca na direção, não na magnitude.

Exemplo prático: similaridade de embeddings

import numpy as np

u = np.array([1.0, 2.0, 0.0])
v = np.array([2.0, 1.0, 0.0])

cos_sim = u @ v / (np.linalg.norm(u) * np.linalg.norm(v))
print(cos_sim)

Matrizes

O que é uma matriz

Uma matriz é um array 2D de números: [ A \in \mathbb{R}^{m \times n} ] Você pode pensar em uma matriz de duas formas complementares:

  1. Como uma tabela de valores (visão de dados)

    • Um conjunto de dados (X) com (m) exemplos e (n) características: (X \in \mathbb{R}^{m \times n})

  2. Como uma transformação linear (visão de função)

    • Um mapeamento de (\mathbb{R}^n \to \mathbb{R}^m): (x \mapsto Ax)

A visão de transformação geralmente é a mais poderosa para a intuição.

Multiplicação matriz-vetor

Se (A \in \mathbb{R}^{m \times n}) e (x \in \mathbb{R}^n), então: [ Ax \in \mathbb{R}^m ] Interpretações:

  • Cada componente de saída é um produto escalar de uma linha de (A) com (x)
  • As colunas de (A) definem para onde os vetores de base vão sob a transformação

Multiplicação matriz-matriz

Se (A \in \mathbb{R}^{m \times n}), (B \in \mathbb{R}^{n \times p}): [ AB \in \mathbb{R}^{m \times p} ] Ideia-chave: composição de aplicações lineares. Aplicar (B) e depois (A) equivale a (AB).

Isso é central em aprendizado profundo (deep learning): empilhar camadas lineares é multiplicação de matrizes (com não linearidades entre elas).

Transposta

A transposta inverte eixos: [ A^\top \in \mathbb{R}^{n \times m}, \quad (A^\top){ij} = A{ji} ] Usos comuns:

  • alternar entre convenções de linha/coluna
  • formar matrizes simétricas como (X^\top X)
  • expressar produtos escalares: (x \cdot y = x^\top y)

Identidade e inversa (e por que a inversa raramente é usada diretamente)

  • Identidade (I): (Ix = x)
  • Inversa (A^{-1}) (se existir): (A^{-1}Ax = x)

Na prática de aprendizado de máquina, você normalmente evita inversão explícita por razões numéricas e de eficiência. Em vez disso, você resolve sistemas como: [ Ax = b ] com rotinas estáveis (veja Álgebra Linear Numérica).

Exemplo prático: uma camada linear é uma multiplicação de matriz

Uma camada densa em uma rede neural calcula: [ y = Wx + b ] onde (W \in \mathbb{R}^{d_{\text{out}} \times d_{\text{in}}}).

import torch

x = torch.randn(64)                 # (d_in,)
W = torch.randn(128, 64)            # (d_out, d_in)
b = torch.randn(128)                # (d_out,)

y = W @ x + b                       # (d_out,)
print(y.shape)

Em forma de lote (batch), você frequentemente verá:

  • X: (batch, d_in)
  • W.T: (d_in, d_out) (dependendo da convenção do framework)
X = torch.randn(32, 64)             # (B, d_in)
W = torch.randn(128, 64)            # (d_out, d_in)
Y = X @ W.T                         # (B, d_out)

Tensores

Dois significados de “tensor”

A palavra tensor é usada de duas maneiras relacionadas, mas diferentes:

  1. Tensores matemáticos: aplicações multilineares que generalizam escalares/vetores/matrizes de forma livre de coordenadas.
  2. “Tensores” em aprendizado profundo: arrays N-dimensionais (ndarrays) que armazenam parâmetros e ativações.

A maior parte do código de aprendizado de máquina usa o significado (2). A intuição geométrica frequentemente se beneficia de vislumbres de (1), mas você pode ser muito eficaz com a visão de ndarray.

Ordem (número de eixos) e forma

A ordem (ou “grau”) de um tensor é o número de eixos:

  • Escalar: ordem 0, forma ()
  • Vetor: ordem 1, forma (n,)
  • Matriz: ordem 2, forma (m, n)
  • Tensor de ordem 3: forma (a, b, c), etc.

Em aprendizado de máquina, as formas carregam semântica via o significado dos eixos. Exemplos:

  • Um lote de vetores: (B, D)
  • Um lote de sequências de embeddings: (B, T, D)
  • Um lote de imagens: (B, C, H, W) (PyTorch) ou (B, H, W, C) (TensorFlow/JAX)
  • Kernel de convolução: (C_out, C_in, K_h, K_w) (PyTorch)

Operações fundamentais com tensores

Redimensionar / view (reshape / view)

Mudar como você interpreta os mesmos dados:

  • reshape muda a forma se o número total de elementos permanecer constante.
  • Algumas mudanças de forma exigem memória contígua; caso contrário, uma cópia pode ocorrer.

Permutar / transpor (generalizado) (permute / transpose)

Trocar ou reordenar eixos:

  • A transposta de uma matriz troca dois eixos.
  • permute em tensores reorganiza muitos eixos (por exemplo, canal-primeiro ↔ canal-último).

Broadcasting

Broadcasting é um conjunto de regras que permite combinar tensores de formas diferentes ao expandir implicitamente dimensões de tamanho 1.

Exemplo: somar um vetor de viés a um lote:

  • X: (B, D)
  • b: (D,)
  • X + b: (B, D) via broadcasting ao longo do eixo de lote

Isso é conveniente, mas pode esconder erros se os eixos estiverem desalinhados.

Operações de redução (reduction operations)

Operações que colapsam um eixo:

  • sum, mean, max sobre dimensões especificadas
  • Usadas para pooling, cálculo de perda, estatísticas de normalização

Contração (produto escalar generalizado) (contraction)

Muitas “multiplicações de tensor” são, na verdade, contrações: somas sobre um ou mais eixos compartilhados.

Os casos familiares são:

  • produto escalar: soma sobre um eixo
  • multiplicação de matrizes: soma sobre um eixo (a dimensão interna)
  • multiplicação de matrizes em lote: soma sobre um eixo, repetida sobre eixos de lote

Uma forma flexível de expressar contrações é a soma de Einstein (einsum).

Exemplo prático: formas em atenção (intuição de Transformer)

Em uma Arquitetura Transformer, a atenção usa tensores com formas como:

  • Q, K, V: (B, H, T, D_head)
  • pontuações de atenção: (B, H, T, T) a partir de Q @ K^T
  • saída: (B, H, T, D_head) a partir de scores @ V

Em pseudocódigo ao estilo PyTorch:

# Q, K, V: (B, H, T, Dh)
scores = torch.matmul(Q, K.transpose(-2, -1))  # (B, H, T, T)
weights = torch.softmax(scores, dim=-1)        # (B, H, T, T)
out = torch.matmul(weights, V)                 # (B, H, T, Dh)

Isso é “apenas” contração de tensor mais softmax, mas a disciplina de formas é essencial.

Formas como uma linguagem: eixos, semântica e convenções

Padrões comuns de eixos em aprendizado de máquina

  • Eixo de lote B: exemplos independentes processados juntos
  • Eixo de tempo/sequência T: tokens ou passos de tempo
  • Eixo de características/embedding D
  • Eixo de cabeças H: atenção multi-cabeças (multi-head attention)
  • Eixos espaciais H, W para imagens
  • Eixo de canais C

Um bom hábito: quando você vê um tensor, anotá-lo como (B, T, D) etc. em comentários (ou usar tensores nomeados, onde disponível).

Ordem por linhas vs ordem por colunas (por que você deve se importar) (row-major vs column-major)

As bibliotecas armazenam arrays na memória com um layout específico:

  • NumPy usa, por padrão, ordem por linhas (C-order)
  • Alguns sistemas preferem ordem por colunas (Fortran-order)
  • Kernels de GPU frequentemente esperam layouts específicos por desempenho

O layout afeta:

  • se view/reshape é barato,
  • se transpose/permute causa tensores não contíguos,
  • o desempenho de grandes multiplicações de matrizes e convoluções.

Essa é uma das razões pelas quais decisões de forma/eixo não são apenas “estilo”, mas podem afetar o throughput.

Intuição geométrica

Vetores como pontos e direções

Um vetor (x \in \mathbb{R}^n) pode representar:

  • um ponto em um espaço (n)-dimensional (posição)
  • uma direção e magnitude (deslocamento)

Em espaços de embeddings, frequentemente tratamos vetores como pontos em que:

  • distâncias correspondem a similaridade,
  • direções podem codificar relações semânticas (de forma imperfeita, mas às vezes útil).

Matrizes como aplicações lineares

Uma matriz (A) transforma o espaço:

  • Ela mapeia retas que passam pela origem em retas que passam pela origem.
  • Ela preserva soma e escalonamento: (A(x+y)=Ax+Ay), (A(\alpha x)=\alpha Ax).

Em 2D/3D, você pode visualizar:

  • rotações (matrizes ortogonais),
  • escalonamento (matrizes diagonais),
  • cisalhamentos,
  • projeções em subespaços.

Importante: aplicações lineares podem esticar algumas direções mais do que outras. As direções que são escaladas (não rotacionadas) estão relacionadas a autovetores; os fatores de escala se relacionam a autovalores. Na prática, valores singulares (a partir de SVD) frequentemente são mais úteis em aprendizado de máquina; veja Autovalores & SVD.

Normas, ângulos e similaridade

  • O produto escalar codifica ângulos.
  • Normas codificam comprimentos.
  • Normalizar vetores foca na direção (comum em aprendizado métrico e recuperação).

Uma ideia geométrica frequente: o aprendizado tenta posicionar dados em um espaço de representações em que:

  • itens similares se agrupam,
  • classes são linearmente separáveis,
  • fatores importantes se alinham com eixos ou subespaços.

Projeções e mínimos quadrados

Muitos problemas de aprendizado de máquina se reduzem à “melhor aproximação em um subespaço”. Por exemplo, a regressão linear encontra pesos (w) minimizando: [ |Xw - y|_2^2 ] Geometricamente, (Xw) é a projeção de (y) no espaço coluna de (X) (quando (X) tem posto completo). Isso se conecta diretamente a condicionamento e estabilidade numérica; veja Álgebra Linear Numérica.

Tensores como geometria multi-eixos (e por que é mais difícil)

Um tensor pode representar:

  • uma pilha de vetores (lote),
  • uma sequência de matrizes (tempo),
  • uma grade de características (imagens),
  • uma interação multi-vias.

A intuição geométrica generaliza, mas a visualização se torna difícil além de 3D. Na prática:

  • você raciocina sobre o papel de cada eixo,
  • você usa contrações para “eliminar por soma” eixos,
  • você interpreta operações com tensores como álgebra linear estruturada.

Computação prática: as operações que você mais usará

Operações elemento a elemento vs operações de álgebra linear

Uma fonte comum de confusão: * pode significar multiplicação elemento a elemento, enquanto @ (ou matmul) significa multiplicação de matrizes.

  • Elemento a elemento: a forma deve aceitar broadcasting, e a forma de saída é a forma após broadcasting.
  • matmul: dimensões internas devem coincidir, e a saída segue as regras da álgebra linear.

`einsum` como uma ferramenta unificadora

A soma de Einstein expressa muitas operações de forma concisa.

Exemplos (a sintaxe PyTorch/NumPy é similar):

import torch
A = torch.randn(3, 4)
x = torch.randn(4)

y = torch.einsum('ij,j->i', A, x)   # matrix-vector: (3,)
G = torch.einsum('i,j->ij', x, x)   # outer product: (4,4)
C = torch.einsum('ik,kj->ij', A, A.T)  # matrix-matrix: (3,3)

Ela é especialmente útil em atenção, fatoração de tensores e camadas personalizadas.

Gradientes também são vetores/matrizes/tensores

Em Retropropagação, gradientes correspondem à forma dos parâmetros:

  • Se (W) é (d_out, d_in), então dW também é (d_out, d_in).
  • Sistemas de diferenciação automática (autodiff) evitam formar matrizes Jacobianas enormes explicitamente; eles calculam produtos vetor-Jacobiano/Jacobiano-vetor eficientes.

Essa é uma razão pela qual letramento em formas de tensores melhora diretamente sua capacidade de depurar o treinamento.

Onde esses objetos aparecem em sistemas modernos de IA

Embeddings e busca por similaridade

  • Embeddings de tokens: matriz E com forma (V, D), onde V é o tamanho do vocabulário.
  • Recuperadores (retrievers) comparam embeddings de consulta e documento via produto escalar ou similaridade do cosseno. Isso é fundamental em RAG e sistemas de busca.

Camadas de redes neurais

  • Camadas densas são multiplicações de matrizes.
  • CNNs usam tensores 4D para imagens e kernels; convolução é uma contração estruturada.
  • Camadas de normalização calculam estatísticas sobre eixos selecionados.

Veja também: Redes Neurais.

Atenção e modelos de sequência

Transformers são dominados por:

  • matmuls em lote,
  • reshapes/permutações ao longo de (B, T, H, D_head),
  • softmax no eixo correto.

Isso torna as formas dos tensores parte da “API conceitual” dos transformers, não apenas um detalhe de implementação.

Redução de dimensionalidade e estrutura de baixo posto

Matrizes que representam dados frequentemente têm posto baixo aproximado. Técnicas como SVD sustentam:

  • compressão,
  • remoção de ruído (denoising),
  • pré-processamento estilo PCA,
  • aproximações eficientes.

Veja Autovalores & SVD.

Otimização e estabilidade em escala

O treinamento depende de operações repetidas de álgebra linear sob precisão finita:

  • aritmética float16/bfloat16,
  • erro de acumulação,
  • matrizes mal condicionadas,
  • overflow/underflow.

Esses tópicos vivem em Álgebra Linear Numérica e importam no treinamento em grande escala.

Checklist mental: como raciocinar sobre um tensor em código de aprendizado de máquina

Quando você vê um objeto como X em um modelo, pergunte:

  1. Qual é sua forma? (anote: (B, T, D) etc.)
  2. O que cada eixo significa? (lote/tempo/características/cabeças/canais)
  3. Qual operação está sendo aplicada?
    • elemento a elemento? redução? contração/matmul? reshape/permute?
  4. Qual deve ser a forma da saída? (derive antes de rodar)
  5. Qual é o significado geométrico?
    • similaridade (produto escalar), projeção (mínimos quadrados), transformação (aplicação linear), agregação (redução)

Dominar vetores, matrizes e tensores é menos sobre memorizar fórmulas e mais sobre se tornar fluente nesse triângulo “forma + operação + significado” — a letramento central por trás da maior parte do aprendizado de máquina moderno.