MirandasTech Assinar

Matemática para IA 15/10/2026 24 min de leitura

Sistemas lineares, eliminação de Gauss e posto da matriz

Entender sistemas lineares como problemas matriciais, aprender eliminação de Gauss e compreender o posto (rank) como medida da quantidade de informação independente em uma matriz.

Capa: escada de vidro ciano com três degraus, um cubo brilhante em cada degrau, sob feixes de luz que se cruzam; título Sistemas lineares e posto
🎓
Matemática para IA · Álgebra Linear · Aula 09
Entender sistemas lineares como problemas matriciais, aprender eliminação de Gauss e compreender o posto (rank) como medida da quantidade de informação independente em uma matriz. Pré-requisito: Aula 08 — Matriz inversa.

Imagine uma planilha de imóveis com duas colunas de área: uma em metros quadrados, outra em pés quadrados. Você ajusta uma regressão linear para prever o preço e recebe pesos estranhos para as duas colunas. Troca o método de cálculo (ou passa do R para o Python) e os pesos mudam completamente, mas as previsões continuam idênticas. Nenhuma das duas está errada. A planilha tem duas colunas, mas só uma informação: a segunda é a primeira multiplicada por 10,7639.

O nome matemático para "quantas informações independentes uma matriz carrega" é posto (em inglês, rank). Para chegar a ele, o caminho passa pela ferramenta clássica para resolver sistemas lineares: a eliminação de Gauss. No artigo anterior da série, $Ax=b$ foi resolvido com a inversa, quando ela existe. Aqui a pergunta é mais geral: e quando a matriz não é quadrada, ou é singular?

Ao final, você vai conseguir escalonar um sistema à mão e ler os pivôs; dizer, só comparando dois postos, se um sistema tem nenhuma, uma ou infinitas soluções; usar o teorema do posto e da nulidade para contar variáveis livres; entender por que o computador troca linhas durante a eliminação; e reconhecer o posto por trás da multicolinearidade, dos mínimos quadrados e do LoRA, o método de ajuste fino de modelos de linguagem.

💡
Ideia-chave: a eliminação de Gauss reorganiza $Ax=b$ sem mudar suas soluções, até a estrutura do sistema ficar visível numa escada de pivôs. O número de pivôs é o posto: quantas direções independentes a matriz preserva. Comparar $\mathrm{posto}(A)$ com $\mathrm{posto}([A\,|\,b])$ e com o número de incógnitas responde se há solução e se ela é única.

1. O problema central: quando a inversa não basta

Na Aula 08, o sistema

$$ Ax=b $$

foi resolvido, quando $A$ é quadrada e invertível, por

$$ x=A^{-1}b $$

Em Machine Learning, porém, é comum a matriz não ser quadrada, ser singular ou ter muito mais equações do que incógnitas. Uma tabela com $1\,000\,000$ de observações e 50 variáveis dá uma matriz

$$ A\in\mathbb{R}^{1\,000\,000\times 50} $$

e uma matriz que não é quadrada não tem inversa. A própria fórmula $x=A^{-1}b$ só vale quando $A$ é quadrada e invertível, o que muitas vezes não acontece (Deisenroth, Faisal & Ong, 2020). O artigo anterior já mostrou que, mesmo quando a inversa existe, o código resolve o sistema com solve em vez de calculá-la. Agora entra a ferramenta mais geral, que funciona para qualquer formato de matriz e ainda diz por que um sistema não tem solução.

2. Sistema linear como matriz: os três destinos possíveis

Considere:

$$ \begin{cases} 2x+y=5\\ x+y=3 \end{cases} $$

Ele cabe na forma $Ax=b$ com

$$ A=\begin{bmatrix}2&1\\1&1\end{bmatrix},\quad x=\begin{bmatrix}x\\y\end{bmatrix},\quad b=\begin{bmatrix}5\\3\end{bmatrix} $$

Cada linha de $A$, junto com a entrada correspondente de $b$, é uma equação. Com duas incógnitas, cada equação é uma reta no plano, e a solução é o que as retas têm em comum. Isso pode ser um ponto, a reta inteira (quando as duas equações descrevem a mesma reta) ou nada (quando as retas são paralelas). Com três incógnitas, cada equação é um plano, e a interseção pode ser um plano, uma reta, um ponto ou o vazio (Deisenroth, Faisal & Ong, 2020).

Três painéis com pares de retas: no primeiro, 2x + y = 5 e x + y = 3 se cruzam no ponto (2, 1); no segundo, x + 2y = 4 e 2x + 4y = 8 coincidem; no terceiro, x + 2y = 4 e 2x + 4y = 10 são paralelas. Abaixo de cada painel, os postos de A e de [A b]
Um ponto, uma reta inteira ou nada: os três destinos de um sistema 2 × 2. Os postos embaixo de cada painel são o assunto da seção 7.

Por isso, um sistema linear real tem sempre um destes três destinos (Deisenroth, Faisal & Ong, 2020):

  • uma solução única;
  • infinitas soluções;
  • nenhuma solução.

Nunca duas, nunca cinco. Se duas soluções diferentes existem, todos os pontos da reta que passa por elas também são soluções.

Com três incógnitas, a mesma tricotomia aparece em 3D. No primeiro painel da figura abaixo está o sistema que será escalonado na seção 5, com solução única $(1, 2, 3)$. No painel do meio da figura abaixo, a terceira equação é a soma das duas primeiras e não acrescenta nada: o sistema de Deisenroth, Faisal e Ong (2020, eq. 2.6), $x_1+x_2+x_3=3$, $x_1-x_2+2x_3=2$ e $2x_1+3x_3=5$, tem como solução uma reta inteira. Trocando o 5 por 1, os três planos passam a se cortar dois a dois em retas paralelas, e não sobra ponto comum aos três.

Três painéis 3D com três planos cada: no primeiro, os planos se cruzam no ponto (1, 2, 3); no segundo, os três passam por uma mesma reta, destacada em branco; no terceiro, os planos se cortam dois a dois em três retas paralelas tracejadas e não há ponto comum
Três planos: um ponto, uma reta ou nada. No terceiro painel, cada par de planos se encontra, mas os três nunca se encontram juntos.

3. Matriz aumentada e operações elementares

Para resolver o sistema sem calcular inversa, junta-se $A$ e $b$ numa só tabela, a matriz aumentada $[A\,|\,b]$:

$$ \left[\begin{array}{cc|c} 2&1&5\\ 1&1&3 \end{array}\right] $$

Sobre ela valem três operações elementares de linha, que mudam a aparência do sistema sem mudar o conjunto de soluções (Deisenroth, Faisal & Ong, 2020):

  1. Trocar duas linhas: $L_1\leftrightarrow L_2$.
  2. Multiplicar uma linha por um escalar não nulo: $L_1\leftarrow cL_1$, com $c\neq0$.
  3. Somar a uma linha um múltiplo de outra: $L_2\leftarrow L_2+cL_1$.

Por que nenhuma delas muda as soluções? Trocar a ordem das equações obviamente não muda nada. Multiplicar uma equação por $c\neq0$ também não: $2x+y=5$ e $4x+2y=10$ são satisfeitas pelos mesmos pontos. E se $(x,y)$ satisfaz as duas equações, satisfaz também qualquer soma delas; como a operação pode ser desfeita (somando $-c$ vezes a mesma linha), nenhuma solução nova aparece e nenhuma se perde. O $c\neq0$ da segunda operação é essencial: multiplicar uma equação por zero apagaria a informação que ela carrega.

4. Eliminação de Gauss, passo a passo

Partindo de

$$ \left[\begin{array}{cc|c} 2&1&5\\ 1&1&3 \end{array}\right] $$

troque as linhas para deixar um 1 no canto, o que facilita as contas:

$$ \left[\begin{array}{cc|c} 1&1&3\\ 2&1&5 \end{array}\right] $$

Depois, zere o 2 abaixo do primeiro pivô com $L_2\leftarrow L_2-2L_1$:

$$ \left[\begin{array}{cc|c} 1&1&3\\ 0&-1&-1 \end{array}\right] $$

A segunda linha agora diz $-y=-1$, ou seja, $y=1$. Substituindo na primeira, $x+1=3$, e:

$$ \boxed{x=2,\;y=1} $$

Essa volta de baixo para cima chama-se substituição regressiva. A figura mostra o que cada passo fez com as retas: elas mudam, mas todas continuam passando por $(2, 1)$. É a seção 3 em imagem: as operações trocam o sistema por outro mais simples com exatamente as mesmas soluções.

Quatro colunas, cada uma com uma matriz aumentada em cima e duas retas embaixo: o sistema original, depois da troca de linhas, depois de L2 menos 2 L1 (a segunda reta vira horizontal, y = 1) e na forma reduzida (retas x = 2 e y = 1). Em todas, as retas se cruzam no mesmo ponto (2, 1)
Cada operação de linha troca as retas, mas não o ponto de encontro. No último passo, a forma reduzida já é a resposta: x = 2 e y = 1.

5. Forma escalonada, pivôs e Gauss-Jordan

O objetivo da eliminação é chegar a uma matriz em forma escalonada, com o formato de uma escada:

$$ \begin{bmatrix} *&*&*\\ 0&*&*\\ 0&0&* \end{bmatrix} $$

O primeiro elemento não nulo de cada linha é o pivô. Na forma escalonada, cada pivô fica estritamente à direita do pivô da linha de cima, e as linhas só de zeros ficam no fim; daí a "escada" (Deisenroth, Faisal & Ong, 2020). Se a eliminação continuar até cada pivô valer 1 e ser o único elemento não nulo da sua coluna, chega-se à forma escalonada reduzida (em inglês, RREF, de reduced row echelon form).

Um aviso de vocabulário: a aula do AI Lab chama de eliminação de Gauss o processo que para na forma escalonada e de Gauss-Jordan o que continua até a reduzida, uma divisão comum em livros-texto. Deisenroth, Faisal e Ong (2020) usam "eliminação de Gauss" para o algoritmo inteiro, até a forma reduzida. O conteúdo é o mesmo; muda só onde cada autor põe o nome.

Com três equações, o processo é o mesmo, só mais longo. O código abaixo escalona a matriz aumentada de

$$ \begin{cases} x+y+z=6\\ 2x+y-z=1\\ x-y+2z=5 \end{cases} $$

imprimindo cada operação, e depois faz a substituição regressiva:

import numpy as np

def escalonar(M, pivotear=False):
    """Eliminação de Gauss na matriz aumentada M = [A | b]; imprime cada passo."""
    M = M.astype(float).copy()
    linhas = M.shape[0]
    for k in range(linhas - 1):
        if pivotear:  # pivoteamento parcial: traz para cima o maior |valor| da coluna
            p = k + np.argmax(np.abs(M[k:, k]))
            if p != k:
                M[[k, p]] = M[[p, k]]
                print(f"L{k+1} <-> L{p+1}")
        for i in range(k + 1, linhas):
            fator = M[i, k] / M[k, k]
            if fator != 0:
                M[i] -= fator * M[k]
                print(f"L{i+1} <- L{i+1} - ({fator:g}) L{k+1}")
                print(M)
    return M

def substituir_de_tras_para_frente(U):
    n = U.shape[0]
    x = np.zeros(n)
    for i in range(n - 1, -1, -1):
        x[i] = (U[i, -1] - U[i, i+1:n] @ x[i+1:]) / U[i, i]
    return x

M = np.array([
    [1,  1,  1, 6],
    [2,  1, -1, 1],
    [1, -1,  2, 5],
])
U = escalonar(M)
print("pivôs:", np.diag(U)[:3])
print("x =", substituir_de_tras_para_frente(U))

Saída:

L2 <- L2 - (2) L1
[[  1.   1.   1.   6.]
 [  0.  -1.  -3. -11.]
 [  1.  -1.   2.   5.]]
L3 <- L3 - (1) L1
[[  1.   1.   1.   6.]
 [  0.  -1.  -3. -11.]
 [  0.  -2.   1.  -1.]]
L3 <- L3 - (2) L2
[[  1.   1.   1.   6.]
 [  0.  -1.  -3. -11.]
 [  0.   0.   7.  21.]]
pivôs: [ 1. -1.  7.]
x = [1. 2. 3.]

Três operações bastaram, e os pivôs são 1, −1 e 7. Uma ligação com a Aula 07: como não houve troca de linhas e a operação usada não altera o determinante, $\det(A)$ é o produto dos pivôs, $1\cdot(-1)\cdot7=-7$. Esse é justamente o jeito de calcular determinantes por eliminação, levando a matriz à forma triangular e multiplicando a diagonal (Deisenroth, Faisal & Ong, 2020).

Três matrizes aumentadas lado a lado: a original do sistema 3 × 3; a forma escalonada, com os pivôs 1, −1 e 7 destacados e uma linha tracejada em forma de escada separando os zeros; e a forma escalonada reduzida, que é a identidade com a coluna (1, 2, 3) à direita
Da matriz aumentada à escada: abaixo dos pivôs só há zeros. Na forma reduzida, a última coluna já é a solução.

6. Posto: quantas direções independentes existem?

Agora um caso em que a escada termina antes. Considere

$$ A=\begin{bmatrix}1&2\\2&4\end{bmatrix} $$

A segunda linha é o dobro da primeira. Aplicando $L_2\leftarrow L_2-2L_1$:

$$ \begin{bmatrix}1&2\\0&0\end{bmatrix} $$

Sobrou um único pivô. Esse número é o posto da matriz:

$$ \boxed{\mathrm{posto}(A)=\text{número de pivôs}} $$

O posto também é o número de colunas linearmente independentes de $A$, que é sempre igual ao número de linhas linearmente independentes (Deisenroth, Faisal & Ong, 2020). Aqui, $\mathrm{posto}(A)=1$: a segunda coluna, $(2, 4)$, é o dobro da primeira, $(1, 2)$.

Geometricamente, o posto conta quantas dimensões sobrevivem à transformação. As colunas de $A$ geram um subespaço, a imagem de $A$, cuja dimensão é exatamente o posto (Deisenroth, Faisal & Ong, 2020). Na figura, a matriz $B$ tem posto 2 e leva o plano a um plano; a matriz $A$ tem posto 1 e esmaga o plano inteiro sobre a reta $y=2x$.

Dois painéis com um quadriculado de pontos cinza e suas imagens em cor: à esquerda, B = [[1, 2], [3, 4]] espalha os pontos num paralelogramo do plano; à direita, A = [[1, 2], [2, 4]] leva todos os pontos para a reta y = 2x
Posto 2 preserva as duas direções do plano; posto 1 preserva só uma, e tudo cai numa reta.

Posto completo e o elo com o determinante

Para uma matriz $m\times n$, o posto nunca passa do menor dos dois lados:

$$ \boxed{\mathrm{posto}(A)\le\min(m,n)} $$

Quando atinge esse máximo, a matriz tem posto completo (full rank); quando não atinge, tem posto deficiente (Deisenroth, Faisal & Ong, 2020). Uma matriz $5\times3$ com posto 3, por exemplo, tem posto completo nas colunas: as três colunas são independentes.

Para matrizes quadradas $n\times n$, o posto fecha o círculo com as duas aulas anteriores (Deisenroth, Faisal & Ong, 2020):

$$ \boxed{\begin{aligned}\det(A)\neq0&\iff\mathrm{posto}(A)=n\\&\iff A\text{ é invertível}\end{aligned}} $$

Se $\det(A)=0$, o posto é menor que $n$, alguma coluna depende das outras e não há inversa. É a mesma perda de informação da Aula 07, agora contada em número de dimensões. Não por acaso, a mesma matriz $[[1,2],[2,4]]$ apareceu no artigo anterior como exemplo de matriz sem inversa.

7. Existe solução? É única?

Depois do escalonamento, uma linha como esta pode aparecer:

$$ \left[\begin{array}{cc|c} 1&2&3\\ 0&0&5 \end{array}\right] $$

A segunda linha diz $0x+0y=5$, ou seja, $0=5$. Impossível: o sistema não tem solução. Em termos de posto, o que aconteceu é que a coluna $b$ criou um pivô que $A$ sozinha não tinha, e o posto da matriz aumentada ficou maior que o de $A$. Daí o critério geral: $Ax=b$ tem solução se e somente se (Deisenroth, Faisal & Ong, 2020)

$$ \boxed{\mathrm{posto}(A)=\mathrm{posto}([A\,|\,b])} $$

Havendo solução, a unicidade depende de sobrar ou não alguma coluna sem pivô. Com $n$ incógnitas:

  • se $\mathrm{posto}(A)=\mathrm{posto}([A\,|\,b])=n$, há solução única;
  • se $\mathrm{posto}(A)=\mathrm{posto}([A\,|\,b])\lt n$, há infinitas soluções;
  • se $\mathrm{posto}(A)\lt\mathrm{posto}([A\,|\,b])$, nenhuma.
Fluxograma: escalone a matriz aumentada; se o posto de A for diferente do posto de [A b], nenhuma solução; se forem iguais e o posto de A for n, solução única; se forem iguais e menor que n, infinitas soluções com n menos posto variáveis livres
Duas perguntas, dois postos. À esquerda, como os três sistemas da figura 1 se encaixam no fluxo.

Variáveis pivô e variáveis livres

Depois do escalonamento, as colunas com pivô correspondem às variáveis pivô (ou básicas); as demais são variáveis livres (Deisenroth, Faisal & Ong, 2020). Na equação

$$ x+2y+3z=5 $$

o único pivô está na coluna de $x$, então

$$ x=5-2y-3z $$

e $y$ e $z$ são livres: cada escolha deles dá uma solução diferente. Por isso "infinitas soluções" vem sempre acompanhado de variáveis livres, e o número delas é $n-\mathrm{posto}(A)$. A conta abaixo aplica o critério aos três sistemas da figura 1:

import numpy as np

def classificar(A, b):
    n = A.shape[1]
    r = int(np.linalg.matrix_rank(A))
    r_aum = int(np.linalg.matrix_rank(np.column_stack([A, b])))
    if r < r_aum:
        tipo = "nenhuma solução"
    elif r == n:
        tipo = "solução única"
    else:
        tipo = f"infinitas soluções ({n - r} variável livre)"
    return r, r_aum, tipo

A1, b1 = np.array([[2., 1.], [1., 1.]]), np.array([5., 3.])
A2, b2 = np.array([[1., 2.], [2., 4.]]), np.array([4., 8.])
A3, b3 = np.array([[1., 2.], [2., 4.]]), np.array([4., 10.])

for nome, A, b in [("A1", A1, b1), ("A2", A2, b2), ("A3", A3, b3)]:
    print(nome, classificar(A, b))
A1 (2, 2, 'solução única')
A2 (1, 1, 'infinitas soluções (1 variável livre)')
A3 (1, 2, 'nenhuma solução')

8. Núcleo e o teorema do posto e da nulidade

As soluções de $Ax=0$ formam o núcleo de $A$ (em inglês, null space ou kernel). Com

$$ A=\begin{bmatrix}1&0\\0&0\end{bmatrix} \quad\text{e}\quad x=\begin{bmatrix}0\\7\end{bmatrix}, \qquad Ax=\begin{bmatrix}0\\0\end{bmatrix} $$

Todo o eixo vertical vai parar na origem: essa direção foi completamente destruída pela transformação. A dimensão do núcleo chama-se nulidade, e ela se relaciona com o posto por um dos resultados mais úteis da álgebra linear. Se $A$ tem $n$ colunas:

$$ \boxed{\mathrm{posto}(A)+\mathrm{nulidade}(A)=n} $$

É o teorema do posto e da nulidade, também chamado de teorema fundamental das aplicações lineares (Deisenroth, Faisal & Ong, 2020). A leitura é direta: as $n$ direções de entrada se dividem entre as que a matriz preserva e as que ela manda para o zero. Para uma matriz $5\times8$ com posto 5,

$$ \mathrm{nulidade}(A)=8-5=3 $$

e o sistema $Ax=0$ tem um espaço de soluções de dimensão 3.

À esquerda, a matriz [[1, 0], [0, 0]] leva o ponto (0, 7) à origem e o ponto (3, 2) a (3, 0); o eixo vertical, destacado, é o núcleo. À direita, oito caixas, cinco ciano rotuladas posto 5 e três violeta rotuladas nulidade 3, somando 8 colunas
O núcleo é o que a matriz apaga. Posto mais nulidade sempre dá o número de colunas.

Essa conta também explica a estrutura das soluções. Deisenroth, Faisal e Ong (2020) descrevem a solução geral de $Ax=b$ em três passos: achar uma solução particular, achar todas as soluções de $Ax=0$ e somar as duas coisas. Se o núcleo tem dimensão positiva, dá para somar qualquer vetor dele a uma solução e obter outra, e por isso as soluções são infinitas.

9. Determinados, superdeterminados e subdeterminados

O formato de $A$, com $m$ equações e $n$ incógnitas, já diz bastante sobre o sistema. Um aviso de vocabulário: aqui, "determinado", "superdeterminado" e "subdeterminado" seguem o uso em inglês e comparam $m$ com $n$. No ensino médio brasileiro, "sistema possível e determinado" (SPD) significa solução única, e a classificação SPD, SPI e SI corresponde aos três destinos da seção 7, decididos pelos postos e não pelo formato.

  • Determinado ($m=n$): mesmo número de equações e incógnitas. Se o posto for $n$, a solução é única.
  • Superdeterminado ($m\gt n$): mais equações que incógnitas, como $A\in\mathbb{R}^{1000\times10}$. É o caso típico de Machine Learning, com mais exemplos do que parâmetros, e em geral não existe solução exata.
  • Subdeterminado ($m\lt n$): menos equações que incógnitas, como $A\in\mathbb{R}^{3\times10}$. Como o posto é no máximo 3, sobram pelo menos 7 variáveis livres; se o sistema for consistente, as soluções são infinitas.
Três retângulos: um quadrado ciano rotulado determinado (m = n, exemplo 2 × 2), um retângulo alto e estreito violeta rotulado superdeterminado (m maior que n, exemplo 1000 × 10) e um retângulo largo e baixo cinza rotulado subdeterminado (m menor que n, exemplo 3 × 10)
Quadrado, alto ou largo. O formato limita o posto, e o posto decide o resto.

O caso subdeterminado sai direto do teorema da seção 8: com 10 colunas e posto no máximo 3, a nulidade é pelo menos 7.

10. Mínimos quadrados: quando não há solução exata

No caso superdeterminado, em regressão, o sistema é

$$ Xw=y $$

com milhares de observações e poucos pesos. Em geral não existe $w$ que satisfaça todas as equações ao mesmo tempo, porque o ruído dos dados coloca $y$ fora da imagem de $X$. Então se troca a pergunta "qual $w$ resolve?" por "qual $w$ erra menos?":

$$ \boxed{\min_w\|Xw-y\|^2} $$

Esse é o problema de mínimos quadrados. Deisenroth, Faisal e Ong (2020) apontam a regressão linear justamente como a saída quando o sistema não tem solução. A mesma ideia em miniatura: três equações, duas incógnitas, nenhum ponto comum.

import numpy as np

# três equações, duas incógnitas: x + y = 2,  x - y = 0,  2x + y = 4
A = np.array([[1., 1.], [1., -1.], [2., 1.]])
b = np.array([2., 0., 4.])

print("posto de A:", np.linalg.matrix_rank(A))
print("posto de [A|b]:", np.linalg.matrix_rank(np.column_stack([A, b])))

x, residuos, posto, s = np.linalg.lstsq(A, b, rcond=None)
print("x de mínimos quadrados:", np.round(x, 4))
print("soma dos quadrados dos resíduos:", np.round(residuos, 4))
print("A @ x:", np.round(A @ x, 4))
posto de A: 2
posto de [A|b]: 3
x de mínimos quadrados: [1.2857 1.1429]
soma dos quadrados dos resíduos: [0.2857]
A @ x: [2.4286 0.1429 3.7143]

O posto denuncia a inconsistência: 2 para $A$ e 3 para $[A\,|\,b]$, o critério da seção 7. A função np.linalg.lstsq devolve o $x$ que minimiza $\|Ax-b\|^2$; a soma dos quadrados dos resíduos, $2/7\approx0{,}2857$, é o menor erro possível. A documentação do NumPy descreve exatamente isso: lstsq aceita sistemas sub, bem ou superdeterminados e, havendo mais de um minimizador, devolve o de menor norma (NumPy, 2026).

Três retas, x + y = 2, x − y = 0 e 2x + y = 4, que se cruzam duas a duas nos pontos (1, 1), (2, 0) e (4/3, 4/3), sem ponto comum; um ponto branco marca a solução de mínimos quadrados (9/7, 8/7)
Sem ponto comum às três retas, mínimos quadrados escolhe (9/7, 8/7). Atenção: o critério é a soma dos quadrados dos resíduos das equações, não a distância geométrica até as retas.

Este artigo não refaz a regressão: as equações normais, a projeção ortogonal e o ajuste com dados reais estão no post Regressão linear e mínimos quadrados. O que interessa aqui é o papel do posto, que aparece na próxima seção.

11. Multicolinearidade: o posto escondido na planilha

Voltemos à planilha da abertura. A fórmula fechada da regressão, $w=(X^\top X)^{-1}X^\top y$, exige que $X^\top X$ seja invertível, e isso acontece exatamente quando $X$ tem posto completo nas colunas, isto é, quando as colunas de $X$ são linearmente independentes (Deisenroth, Faisal & Ong, 2020). Com uma coluna em metros quadrados e outra em pés quadrados, essa condição quebra. Cinco imóveis sintéticos:

import numpy as np

m2 = np.array([50., 70., 85., 100., 120.])
pes2 = m2 * 10.7639                # a mesma área, em pés quadrados
X = np.column_stack([m2, pes2])    # 5 imóveis, 2 colunas
y = np.array([160., 215., 262., 305., 362.])  # preço em milhares de reais

print("posto de X:", np.linalg.matrix_rank(X))
print("número de condição de X^T X: %.1e" % np.linalg.cond(X.T @ X))

w_min, *_ = np.linalg.lstsq(X, y, rcond=None)
print("w de menor norma:", np.round(w_min, 4))

# somar um vetor do núcleo de X não muda nenhuma previsão
nucleo = np.array([10.7639, -1.0])
print("X @ nucleo:", np.round(X @ nucleo, 10))
w_outro = w_min + 2.0 * nucleo
print("outro w:", np.round(w_outro, 4))
print("mesmas previsões?", np.allclose(X @ w_min, X @ w_outro))
posto de X: 1
número de condição de X^T X: 5.3e+16
w de menor norma: [0.0262 0.2815]
X @ nucleo: [0. 0. 0. 0. 0.]
outro w: [21.554  -1.7185]
mesmas previsões? True

Duas colunas, posto 1. Pelo teorema da seção 8, a nulidade é 1: existe uma direção, $(10{,}7639;\,-1)$, que $X$ manda para o zero. Somar qualquer múltiplo dela aos pesos não muda nenhuma previsão. Por isso há infinitos $w$ igualmente bons, e cada biblioteca devolve o que o seu algoritmo escolher. O lstsq escolhe o de menor norma. O número de condição de $X^\top X$, da ordem de $10^{16}$, é o sinal numérico de que essa matriz é, na prática, singular (o valor exato pode variar com a biblioteca de álgebra linear instalada).

Plano dos pesos w1 e w2 com uma reta violeta de soluções; um ponto ciano marca o w de menor norma (0,0262; 0,2815) e um ponto branco marca outro w (21,554; −1,7185) sobre a mesma reta
Todos os pontos da reta violeta fazem exatamente as mesmas previsões. O posto deficiente de X é o que cria essa reta.

Em dados reais, a dependência raramente é exata: duas colunas quase proporcionais deixam $X$ com posto completo no papel, mas com $X^\top X$ quase singular, o problema de condicionamento do artigo anterior. A regularização é uma das saídas. Na regressão ridge, somar $\lambda I$ a $X^\top X$ torna a matriz simétrica e estritamente positiva definida, e portanto invertível, o que faz a solução voltar a ser única (Deisenroth, Faisal & Ong, 2020). O assunto está desenvolvido no post Ridge, Lasso e Elastic Net.

12. Estabilidade numérica e pivoteamento

Na teoria, qualquer pivô diferente de zero serve. No computador, não. Dividir por um pivô minúsculo produz um multiplicador gigante, e os arredondamentos que seriam desprezíveis passam a engolir os números originais. Moler (2004) mostra isso num sistema 3 × 3 com aritmética de cinco dígitos e resume: a matriz não estava perto de ser singular, a dificuldade veio de escolher um pivô pequeno. Com números de 64 bits, um exemplo 2 × 2 basta:

import numpy as np

def gauss_2x2(A, b, pivotear):
    A, b = A.astype(float).copy(), b.astype(float).copy()
    if pivotear and abs(A[1, 0]) > abs(A[0, 0]):   # troca as linhas
        A[[0, 1]], b[[0, 1]] = A[[1, 0]], b[[1, 0]]
    fator = A[1, 0] / A[0, 0]
    A[1] -= fator * A[0]
    b[1] -= fator * b[0]
    y = b[1] / A[1, 1]
    x = (b[0] - A[0, 1] * y) / A[0, 0]
    return np.array([x, y])

A = np.array([[1e-20, 1.0],
              [1.0,   1.0]])
b = np.array([1.0, 2.0])

print("sem pivoteamento:", gauss_2x2(A, b, pivotear=False))
print("com pivoteamento:", gauss_2x2(A, b, pivotear=True))
print("np.linalg.solve: ", np.linalg.solve(A, b))
print("número de condição de A: %.1f" % np.linalg.cond(A))
sem pivoteamento: [0. 1.]
com pivoteamento: [1. 1.]
np.linalg.solve:  [1. 1.]
número de condição de A: 2.6

A matriz é bem comportada: o número de condição é 2,6, longe do território perigoso da Aula 08. Mesmo assim, sem troca de linhas o resultado é $(0, 1)$, quando a resposta certa é praticamente $(1, 1)$. O multiplicador $1/10^{-20}=10^{20}$ faz $1-10^{20}$ e $2-10^{20}$ virarem o mesmo número em ponto flutuante, e a informação da segunda equação desaparece.

A correção é o pivoteamento parcial: a cada passo, escolher como pivô o elemento de maior valor absoluto na parte ainda não reduzida da coluna e trazer a linha dele para cima. Assim os multiplicadores ficam com valor absoluto no máximo 1, e Moler (2004) afirma que, nessa condição, a solução calculada é comprovadamente satisfatória. É o que o np.linalg.solve faz por baixo: a documentação informa que ele usa a rotina _gesv do LAPACK (NumPy, 2026), e a documentação do LAPACK descreve essa rotina como uma decomposição LU com pivoteamento parcial e troca de linhas (LAPACK, 2026).

Duas colunas comparando o mesmo sistema: sem troca de linhas, o multiplicador é 10 elevado a 20, os números 1 e 2 somem no arredondamento e o resultado é (0, 1); com pivoteamento parcial, o multiplicador é 10 elevado a menos 20 e o resultado é (1, 1), igual ao de np.linalg.solve
Mesma matriz, mesmo computador. A única diferença é a ordem das linhas.

Há ainda uma questão de escala. Deisenroth, Faisal e Ong (2020) observam que a eliminação de Gauss resolve com tranquilidade sistemas de milhares de variáveis, mas fica impraticável com milhões, porque o número de operações cresce com o cubo do número de equações. Nesses casos, usam-se métodos iterativos.

Posto numérico

O mesmo cuidado vale para o posto. Em ponto flutuante, uma coluna que é combinação exata das outras raramente produz um zero exato. Por isso o np.linalg.matrix_rank não escalona: ele calcula os valores singulares da matriz e conta quantos ficam acima de uma tolerância, por padrão o maior valor singular vezes o maior entre o número de linhas e o de colunas vezes o épsilon da máquina (NumPy, 2026). O posto calculado depende dessa tolerância:

import numpy as np

quase = np.array([[1., 2.],
                  [2., 4. + 1e-10]])

print("posto (tolerância padrão):", np.linalg.matrix_rank(quase))
print("posto com tol=1e-6:      ", np.linalg.matrix_rank(quase, tol=1e-6))
print("valores singulares:", np.linalg.svd(quase, compute_uv=False))
posto (tolerância padrão): 2
posto com tol=1e-6:       1
valores singulares: [5.00000000e+00 2.00000895e-11]

Para a tolerância padrão, a matriz tem posto 2; com uma tolerância mais frouxa, posto 1. Qual resposta é a certa depende de quanto ruído os dados carregam. A documentação do NumPy discute exatamente esse ponto, inclusive tolerâncias alternativas (NumPy, 2026).

13. Posto em IA: embeddings, pesos e LoRA

A interpretação mais útil do posto para quem trabalha com IA é esta:

O posto mede quantas direções independentes de informação uma transformação consegue preservar ou representar.

A camada $y=Wx+b$

Na camada linear da Aula 05, se

$$ W\in\mathbb{R}^{100\times100},\qquad\mathrm{posto}(W)=10 $$

a saída tem 100 posições, mas $Wx$ vive num subespaço de no máximo 10 dimensões, a imagem de $W$. A dimensão aparente é 100; a dimensionalidade efetiva da transformação é 10. Do mesmo modo, um embedding com 768 dimensões não garante que os dados usem todas essas direções com a mesma importância: o número de coordenadas é um limite superior para o posto, não uma medida dele.

LoRA: o nome vem do posto

O exemplo mais direto está no ajuste fino de modelos de linguagem. Hu et al. (2022) observam que as matrizes de pesos das camadas densas costumam ter posto completo, mas levantam a hipótese de que a atualização dessas matrizes durante a adaptação a uma tarefa tenha um "posto intrínseco" baixo. A proposta, chamada LoRA (Low-Rank Adaptation), congela a matriz pré-treinada $W_0\in\mathbb{R}^{d\times k}$ e escreve a atualização como um produto:

$$ \begin{aligned}&W_0+\Delta W=W_0+BA\\[4pt]&B\in\mathbb{R}^{d\times r},\quad A\in\mathbb{R}^{r\times k}\\[4pt]&r\ll\min(d,k)\end{aligned} $$

Só $B$ e $A$ são treinadas (Hu et al., 2022). Como $\Delta W=BA$ passa por uma dimensão interna $r$, seu posto é no máximo $r$, por mais que a matriz tenha milhares de linhas e colunas. É a origem matemática do nome:

import numpy as np

rng = np.random.default_rng(0)
d, k, r = 1024, 1024, 8

B = rng.normal(size=(d, r))
A = rng.normal(size=(r, k))
delta_W = B @ A                      # 1024 x 1024, mas feita de 8 direções

print("forma de delta_W:", delta_W.shape)
print("posto de delta_W:", np.linalg.matrix_rank(delta_W))

for d, k in [(1024, 1024), (4096, 4096)]:
    cheio = d * k
    lora = r * (d + k)
    print(f"{d}x{k}: matriz cheia {cheio:,} parâmetros; B e A com r={r}: {lora:,} ({cheio // lora}x menos)")
forma de delta_W: (1024, 1024)
posto de delta_W: 8
1024x1024: matriz cheia 1,048,576 parâmetros; B e A com r=8: 16,384 (64x menos)
4096x4096: matriz cheia 16,777,216 parâmetros; B e A com r=8: 65,536 (256x menos)
À esquerda, um grande quadrado violeta representando Delta W, 4096 por 4096, com 16.777.216 parâmetros; à direita, um retângulo alto e fino B (4096 por 8) vezes um retângulo baixo e largo A (8 por 4096), com 65.536 parâmetros, 256 vezes menos
Com r = 8, uma atualização 4096 × 4096 sai de 16,8 milhões para 65,5 mil parâmetros treináveis. O preço é o posto: no máximo 8.

O ganho em escala real é grande. Comparado ao ajuste fino completo do GPT-3 175B com Adam, o LoRA reduz o número de parâmetros treináveis em 10 000 vezes e o uso de memória de GPU em 3 vezes, com qualidade igual ou melhor que o ajuste fino completo em RoBERTa, DeBERTa, GPT-2 e GPT-3, segundo os autores (Hu et al., 2022). A conta deste artigo é mais modesta, uma única matriz, mas mostra de onde vem a economia: a atualização é guardada pelas suas $r$ direções independentes.

Caminho para PCA e SVD

O passo seguinte é descobrir, a partir dos dados, quais direções importam. Se dados com 500 características estiverem aproximadamente concentrados num subespaço de 20 dimensões, técnicas como a PCA podem identificar essas direções principais. A ferramenta por trás disso é a decomposição em valores singulares,

$$ \boxed{A=U\Sigma V^\top} $$

que revela o posto (o matrix_rank da seção 12 já conta valores singulares), as direções importantes, quanta informação cada uma carrega e quanto dá para comprimir. SVD e PCA têm aulas próprias mais adiante na série.

14. Na prática com NumPy

Os comandos essenciais da aula, com as saídas reais.

Resolver um sistema quadrado

import numpy as np

A = np.array([
    [2.0, 1.0],
    [1.0, 1.0]
])
b = np.array([5.0, 3.0])

x = np.linalg.solve(A, b)
print(x)
[2. 1.]

O solve exige matriz quadrada de posto completo; se não for o caso, a própria documentação manda usar lstsq (NumPy, 2026).

Calcular o posto

import numpy as np
A = np.array([[1.0, 2.0], [2.0, 4.0]])
print(np.linalg.matrix_rank(A))
1

Mínimos quadrados

Com o $A$ (3 × 2) e o $b$ da seção 10:

x, residuals, rank, s = np.linalg.lstsq(A, b, rcond=None)

A função devolve a solução, a soma dos quadrados dos resíduos, o posto de $A$ e seus valores singulares; a saída completa está na seção 10. Atenção: se $A$ não tiver posto completo nas colunas, como a matriz $[[1,2],[2,4]]$ do bloco anterior, residuals volta vazio (NumPy, 2026).

Mini laboratório: posto e determinante

Antes de executar, tente prever os resultados e relacionar determinante e posto para matrizes quadradas.

import numpy as np

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

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

print("Rank A:", np.linalg.matrix_rank(A))
print("Rank B:", np.linalg.matrix_rank(B))
print("Det A:", np.linalg.det(A))
print("Det B:", np.linalg.det(B))
Rank A: 1
Rank B: 2
Det A: 0.0
Det B: -2.0000000000000004

A matriz $A$, de posto 1, tem determinante zero; $B$, de posto completo, tem determinante $-2$. O $-2{,}0000000000000004$ é arredondamento de ponto flutuante, e não um erro de conta.

15. Exercícios

1. Resolva por eliminação:

$$ \begin{cases} x+y=5\\ 2x+y=8 \end{cases} $$

2. Para $A=\begin{bmatrix}1&2\\2&4\end{bmatrix}$, qual é $\mathrm{posto}(A)$? Explique sem software.

3. Para

$$ A=\begin{bmatrix}1&0&2\\0&1&3\\0&0&0\end{bmatrix} $$

quantos pivôs existem e qual é o posto?

4. Uma matriz $7\times4$ pode ter posto máximo igual a quanto?

5. Uma matriz $1000\times10$ representando 1000 equações e 10 incógnitas é determinada, superdeterminada ou subdeterminada?

6. O sistema representado por

$$ \left[\begin{array}{cc|c}1&2&4\\0&0&3\end{array}\right] $$

possui solução?

7. Se $A\in\mathbb{R}^{5\times8}$ e $\mathrm{posto}(A)=5$, qual é a nulidade?

8. Explique o que significa dizer que duas colunas são linearmente dependentes.

9. Se $W\in\mathbb{R}^{1000\times1000}$ e $\mathrm{posto}(W)=20$, qual é a interpretação sobre a dimensionalidade efetiva da transformação?

10. Explique a diferença entre dimensão da matriz e posto. Exemplo: $A\in\mathbb{R}^{100\times100}$ com $\mathrm{posto}(A)=5$. O que isso significa geometricamente e em termos de informação?

O que guardar

O mapa da aula cabe numa linha que termina num número:

Mapa mental em fluxo: Ax = b, matriz aumentada, eliminação de Gauss, forma escalonada, pivôs, posto; do posto saem dois ramos, posto completo (informação independente) e posto reduzido (redundância, compressão, perda de dimensão)
Do sistema ao posto, e do posto à leitura de informação.

Ao olhar para $Ax=b$, pense: estou procurando uma entrada que, transformada por $A$, produza $b$. A eliminação de Gauss reorganiza o sistema para revelar sua estrutura, os pivôs mostram as direções independentes, e:

$$ \boxed{\begin{aligned}\mathrm{posto}(A)=\;&\text{quantidade de dimensões}\\&\text{independentes preservadas}\\&\text{pela matriz}\end{aligned}} $$

  • Operações elementares de linha não mudam as soluções; escalonar é trocar o sistema por outro mais fácil de ler.
  • Posto = número de pivôs = colunas independentes = linhas independentes.
  • Existe solução se $\mathrm{posto}(A)=\mathrm{posto}([A\,|\,b])$; ela é única se, além disso, o posto é $n$.
  • $\mathrm{posto}(A)+\mathrm{nulidade}(A)=n$: o que a matriz não preserva, ela apaga.
  • No computador, troque linhas (pivoteamento parcial) e trate o posto como numérico, dependente de uma tolerância.
  • Colunas dependentes em $X$ tornam os pesos da regressão não únicos; uma atualização de posto baixo é a ideia do LoRA.

Com esta aula, a sequência da série fica assim:

Na Aula 10, Independência linear, span, base e dimensão, o assunto é o que ficou implícito aqui: o que exatamente significa um conjunto de vetores ser independente, o que é o espaço gerado por eles, base, dimensão, mudança de base e a relação entre base e posto. É o caminho para autovalores, autovetores, PCA e SVD.

Referências

  1. Deisenroth, Marc Peter; Faisal, A. Aldo; Ong, Cheng Soon. Mathematics for Machine Learning. Cambridge University Press, 2020. §2.1, §2.3, §2.6.2, Teorema 2.24, §4.1 (Teorema 4.3) e §9.2; numeração de seções, equações e teoremas conferida no PDF público (draft de 15/01/2024). doi.org/10.1017/9781108679930
  2. Moler, Cleve B. Numerical Computing with MATLAB. SIAM, 2004. Cap. 2, Linear Equations, §2.6. doi.org/10.1137/1.9780898717952
  3. Hu, Edward J.; Shen, Yelong; Wallis, Phillip; Allen-Zhu, Zeyuan; Li, Yuanzhi; Wang, Shean; Wang, Lu; Chen, Weizhu. LoRA: Low-Rank Adaptation of Large Language Models. International Conference on Learning Representations (ICLR), 2022. arxiv.org/abs/2106.09685
  4. LAPACK. DGESV: solução de sistemas lineares A·X = B. Documentação de referência (explore-html), netlib. Acesso em 9 out. 2026. netlib.org/lapack/explore-html/d8/da6/group__gesv_ga831ce6a40e7fd16295752d18aed2d541.html
  5. NumPy. numpy.linalg.solve, numpy.linalg.matrix_rank e numpy.linalg.lstsq. Documentação oficial do NumPy. Acesso em 9 out. 2026. numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html; numpy.org/doc/stable/reference/generated/numpy.linalg.matrix_rank.html; numpy.org/doc/stable/reference/generated/numpy.linalg.lstsq.html
Gostou do artigo? Compartilhe. Conhecimento ganha força quando circula.

Esta aula faz parte do AI Lab, o laboratório aberto de estudo da MirandasTech. Código, notebooks e exercícios: 01-math/aulas/09-sistemas-lineares-gauss-posto.md.

Newsletter

Um texto por semana, com fonte.

Sem spam. Só o que foi revisado e tem referência.

Pronto. Confira a caixa de entrada para confirmar.