15.3 Transposed convolution mint adjungált

15.3.1 Cél, előismeret és induló kérdés

A 15.2. Inputgradiens és átfedő recepciós mezők egységben indexszinten levezettük, hogy a konvolúciós réteg bemeneti gradiense az upstream gradiensből scatter-add művelettel áll elő. Most ezt a műveletet egyetlen matematikai objektumként vizsgáljuk: a forward konvolúció lineáris operátor, a backwardban számolt bemeneti gradiens pedig ennek az operátornak az adjungáltja, azaz mátrixreprezentációban a transzponáltja. A könyvtári ConvTranspose2d nem az inverz, hanem éppen ezt az adjungált utat valósítja meg. A [D11] könyvtári leírását a következőkben saját mátrixos levezetéssel vetjük össze, és különválasztjuk az adjungált műveletet az inverz leképezéstől.

Induló kérdés: ha egy 4 hosszú 1D jelet egy 2 hosszú kernel valid, stride=1 cross-correlationje 3 hosszúvá képez, akkor a 3 hosszú gradiensből a 4 hosszú bemeneti gradienst a kernel megfordításával vagy a kernel eredeti sorrendjével, de a mátrixtranszponált oszlopaiból kapjuk? A válasz a mátrixtranszponált: a szummákban az indexeltolás és a kernel együtthatóinak párosítása változik meg, nem a kernel mint vektor sorrendje.

15.3.2 Lineáris operátor, adjungált és mátrixtranszponált

Legyen $V=\mathbb R^{d_{in}}$ és $W=\mathbb R^{d_{out}}$ a standard euklideszi skalárszorzattal: $\langle a,b\rangle=a^\top b$. Egy $C:V\to W$ leképezés lineáris operátor, ha minden $x_1,x_2\in V$ és $\alpha,\beta\in\mathbb R$ esetén

$$C(\alpha x_1+\beta x_2)=\alpha C(x_1)+\beta C(x_2).$$

Rögzített bázisban $C$ egy $d_{out}\times d_{in}$ mátrixszal reprezentálható; a továbbiakban ugyanazt a jelet használjuk a leképezésre és a mátrixára.

Definíció (adjungált). A $C^*:W\to V$ leképezés a $C$ adjungáltja, ha minden $x\in V$, $y\in W$ esetén

$$\langle Cx,y\rangle_W=\langle x,C^*y\rangle_V. \tag{1}$$

Valós mátrix esetén az adjungált a mátrixtranszponált: $C^*=C^\top$, mert $(Cx)^\top y=x^\top C^\top y$. Komplex terekben a konjugált transzponált lenne az adjungált; ebben a fejezetben minden mennyiség valós, így a transzponált és az adjungált azonosítható.

Tétel (az adjungált egyértelműsége). Ha $C^*$ és $C^\dagger$ is teljesíti az (1) feltételt, akkor $C^*=C^\dagger$.

Bizonyítás. Minden $y\in W$ esetén válasszuk az $x=(C^*-C^\dagger)y$ vektort. Ekkor

$$0=\langle x,C^*y\rangle-\langle x,C^\dagger y\rangle =\langle Cx,y\rangle-\langle Cx,y\rangle =\|x\|^2,$$

tehát $x=0$, azaz $C^*y=C^\dagger y$, minden $y$-ra. $\blacksquare$

A neurális hálózatok nyelvén az adjungált a vektor–Jacobi-szorzat szerepét tölti be. Ha $L=g(y)$ skalárfüggvény és $y=Cx$, akkor a láncszabály szerint

$$\nabla_x L=C^\top\nabla_y L. \tag{2}$$

A 4.3. Jacobi-mátrix, láncszabály és VJP alfejezetben bevezetett VJP éppen ezt a transzponált alkalmazást jelenti; a 15.2. Inputgradiens és átfedő recepciós mezők alfejezetben levezetett $dX$ képlet ennek a konvolúciós $C$ mátrixra specializált, indexelt alakja.

15.3.3 A Conv2d mint lineáris operátor

A 15.2. Inputgradiens és átfedő recepciós mezők és [D10] jelölése szerint legyen a bemeneti képbatch $X\in\mathbb R^{N\times C_{in}\times H\times W}$, a kimenet $Y\in\mathbb R^{N\times C_{out}\times H_{out}\times W_{out}}$, a kernel pedig $K\in\mathbb R^{C_{out}\times C_{in}\times k_h\times k_w}$. Ha a bias $b=0$, akkor a cross-correlation minden egyes kimeneti eleme a bemenet lineáris kombinációja:

$$y_{n,o,i,j}=\sum_{c=0}^{C_{in}-1}\sum_{r=0}^{k_h-1}\sum_{t=0}^{k_w-1} K_{o,c,r,t}\,\bar x_{n,c,\;i s_h+r d_h-p_h,\;j s_w+t d_w-p_w}.$$

Itt $r,t$ a kernel sor- és oszlopindexe, $s_h,s_w$ a stride, $d_h,d_w$ a dilation, $p_h,p_w$ a padding. Az $\bar x$ a bemenet virtuális nullakiterjesztése: $\bar x_{n,c,u,v}=x_{n,c,u,v}$, ha $0\le u<H$ és $0\le v<W$, különben $0$. (A paddingen kívüli virtuális elemek hozzájárulása így nulla.) Vektorizáljuk a tensort a memóriabeli, NCHW-sorrendű lapítással: $\operatorname{vec}(X)\in\mathbb R^{N C_{in}HW}$. A fenti összeg egy $C(K)$ mátrixot határoz meg, amelyre $\operatorname{vec}(Y)=C(K)\operatorname{vec}(X)$. A mátrix sorai a kernel együtthatóit tartalmazzák a megfelelő bemeneti pozíciókban, a padding miatt pedig nulla hozzájárulásokat. A backward bemeneti gradiense ezért

$$\operatorname{vec}(dX)=C(K)^\top\operatorname{vec}(dY),$$

amely pontosan a 15.2. Inputgradiens és átfedő recepciós mezők alfejezetben levezetett scatter-add: minden $dY$-elem a kernel súlyával visszaszóródik az őt létrehozó bemeneti pozíciókra, és az átfedések gradienshozzájárulásai összegződnek.

15.3.4 Transposed convolution mint adjungált

A transposed convolution (transzponált konvolúció) a diszkrét jelfeldolgozásban az az operátor, amely a forward cross-correlation lineáris leképezésének adjungáltját valósítja meg. A „transposed” szó a leképezés mátrixának transzponáltjára utal, nem a kernel valamely geometriai megfordítására, és nem is egy általános inverzre.

A PyTorch ConvTranspose2d modul ennek a diszkrét operátornak a paraméterezett rétege. Csatornaszempontból a forward $C_{in}\to C_{out}$ út megfordul: a gradiensirányú modul bemenete $C_{out}$, kimenete $C_{in}$ csatornát kezel. Két dolgot kell elválasztani. Az operátormátrix transzponálódik: $C(K)\in\mathbb R^{d_{out}\times d_{in}}$ helyett $C(K)^\top\in\mathbb R^{d_{in}\times d_{out}}$. Az API súlytenzorának tárolási konvenciója viszont nem cserél dimenziót: a Conv2d(C_in, C_out) súlya $(C_{out},C_{in},k_h,k_w)$, a ConvTranspose2d(in_channels=C_out, out_channels=C_in) súlya pedig $(\text{in\_channels},\text{out\_channels},k_h,k_w)=(C_{out},C_{in},k_h,k_w)$ — ugyanaz az alak. Az adjungált modulba ezért a forward súlya csere nélkül, változatlanul másolható; a transzponálást a modul műveleti definíciója végzi el. A bias nem része a lineáris adjungált azonosságnak; az affin $x\mapsto Cx+b$ leképezés Jacobi-mátrixa továbbra is $C$, ezért a bemeneti gradiensben a bias nem jelenik meg, a bias saját gradiense pedig az upstream elemek összege.

Többcsatornás ellenőrzés: egy $2\to3$ csatornás, stride-os, paddinges forward és a $3\to2$ csatornás transzponált modul ugyanazzal a súllyal, az adjungált $\langle Cx,y\rangle=\langle x,C^\top y\rangle$ skalárszorzat-azonossággal:

import torch

torch.manual_seed(20261020)
dt = torch.float64
fwd = torch.nn.Conv2d(2, 3, kernel_size=(2, 3), stride=2, padding=1, bias=False, dtype=dt)
adj = torch.nn.ConvTranspose2d(3, 2, kernel_size=(2, 3), stride=2, padding=1, bias=False, dtype=dt)
print("Conv2d súly:", tuple(fwd.weight.shape))           # (C_out, C_in, kh, kw) = (3, 2, 2, 3)
print("ConvTranspose2d súly:", tuple(adj.weight.shape))  # (in_channels, out_channels/groups, kh, kw) = (3, 2, 2, 3)
with torch.no_grad():
    adj.weight.copy_(fwd.weight)                         # ugyanaz a tensor, csere nélkül

x = torch.randn(1, 2, 7, 6, dtype=dt)                    # C: R^(2*7*6) -> R^(3*H'*W')
y_shape = fwd(x).shape
y = torch.randn(y_shape, dtype=dt)
ct_y = adj(y, output_size=x.shape[-2:])                  # C^T y, a bemenet alakjára
lhs = (fwd(x) * y).sum()                                 # <Cx, y>
rhs = (x * ct_y).sum()                                   # <x, C^T y>
print("<Cx,y> =", lhs.item(), " <x,C^T y> =", rhs.item())
assert torch.allclose(lhs, rhs, rtol=1e-12, atol=1e-12)

A lab-profilban (PyTorch 2.14.1+cpu, float64) mindkét súlytenzor alakja (3, 2, 2, 3), és a két skalárszorzat $3{,}7917631382168{\ldots}$, gépi pontossággal egyezik. Az output_size argumentum rögzíti a transzponált kimenet méretét (lásd az output_padding alább); stride esetén enélkül a kimeneti alak nem egyértelmű.

Ezt a fogalmat élesen el kell választani az inverztől. Az inverzhez olyan $C^{-1}:W\to V$ kellene, amelyre $C^{-1}C=I_{d_{in}}$ és $CC^{-1}=I_{d_{out}}$. Ilyen csak akkor létezhet, ha $d_{in}=d_{out}$ és $C$ teljes rangú. A konvolúciós forward általában dimenziót változtat vagy ranghiányos, ezért az adjungált legfeljebb a skalárszorzatos irányítást őrzi meg, az adatot általában nem állítja vissza.

15.3.5 Levezetés: explicit 1D operátormátrix és adjungált azonosság

Tekintsünk egy 4 elemű bemenetet, $x=(x_0,x_1,x_2,x_3)^\top\in\mathbb R^4$, és egy 2 elemű kernelt $k=(k_0,k_1)^\top$. A valid, stride=1, padding=0 cross-correlation kimenete három elemű:

$$y_0=k_0x_0+k_1x_1,\qquad y_1=k_0x_1+k_1x_2,\qquad y_2=k_0x_2+k_1x_3.$$

A leképezés mátrixa

$$C= \begin{pmatrix} k_0&k_1&0&0\\ 0&k_0&k_1&0\\ 0&0&k_0&k_1 \end{pmatrix}\in\mathbb R^{3\times4}. \tag{3}$$

Lemma (valid cross-correlation adjungáltja). A (3) mátrix adjungáltja a transzponált

$$C^\top= \begin{pmatrix} k_0&0&0\\ k_1&k_0&0\\ 0&k_1&k_0\\ 0&0&k_1 \end{pmatrix}\in\mathbb R^{4\times3},$$

azaz $C^\top y$ elemei

$$(C^\top y)_0=k_0y_0,\quad (C^\top y)_1=k_1y_0+k_0y_1,\quad (C^\top y)_2=k_1y_1+k_0y_2,\quad (C^\top y)_3=k_1y_2. \tag{4}$$

Bizonyítás. Tetszőleges $x\in\mathbb R^4$, $y\in\mathbb R^3$ esetén a forward mátrixszorzást beírva:

$$\langle Cx,y\rangle =y_0(k_0x_0+k_1x_1)+y_1(k_0x_1+k_1x_2)+y_2(k_0x_2+k_1x_3).$$

Csoportosítsunk $x$ komponensei szerint:

$$=x_0(k_0y_0)+x_1(k_1y_0+k_0y_1)+x_2(k_1y_1+k_0y_2)+x_3(k_1y_2)=\langle x,C^\top y\rangle.$$

Mivel ez minden $x,y$ párra fennáll, a (4) képlet éppen az adjungált definícióját teljesíti, és a fenti tétel miatt az adjungált egyértelmű. $\blacksquare$

A (4) alak a scatter-add: a $y_1$ gradiens például $k_0$ súllyal az $x_1$ pozícióra és $k_1$ súllyal az $x_2$ pozícióra hullik vissza, mert a forwardban mindkét bemeneti elem részt vett a $y_1$ előállításában, $x_1$ a $k_0$, $x_2$ a $k_1$ együtthatóval. Így a mátrixtranszponált oszlopszerkezete közvetlenül az átfedő recepciós mezők elvét kódolja.

15.3.6 Alak-visszaállítás, output_padding és inverz limit

A transzponált konvolúció egyik leggyakoribb felhasználási módja a térbeli felbontás növelése egy downsampling után. A mátrixtranszponált eleve a megfelelő irányú méretet adja: ha $C:V\to W$, akkor $C^\top:W\to V$. Az alak-visszaállítás tehát nem extra tulajdonság, hanem a transzponált dimenzióinak következménye; az értékek visszaállítása ellenben csak a teljes rangú négyzetes esetben lenne lehetséges.

A stride felső egészrészes osztást vezet be a forward oldalon. A 14.3. Paraméterszám, MAC és aktivációmemória alfejezetben és a [D10]-ben használt képlet szerint

$$H_{out}=\left\lfloor\frac{H+2p-d(k-1)-1}{s}\right\rfloor+1.$$

A padlófüggvény miatt több különböző $H$ is adhatja ugyanazt a $H_{out}$ értéket. A transzponált oldalon ezért nem mindig dönthető el egyértelműen, mekkora legyen a kimeneti méret. A PyTorch ConvTranspose2d ezt az output_padding paraméterrel teszi eldönthetővé: a szokásos jelöléssel, ha a transzponált bemenete $H_{in}^{T}$ méretű,

$$H_{out}^{T}=(H_{in}^{T}-1)s-2p+d(k-1)+1+\text{output\_padding}. \tag{5}$$

Az output_padding tehát csak a méretválasztást egészíti ki; a mátrixtranszponált értékszerkezetén nem változtat. A megadott kimeneti képlet mellett a ConvTranspose2d konstruktorának output_padding-korlátait is teljesíteni kell; ezeket a választott stride és dilation paraméterekkel együtt ellenőrizzük [D11].

Következmény (inverz limit). Legyen $C\in\mathbb R^{d_{out}\times d_{in}}$. A 3.3. Vetítés, legkisebb négyzetek és kondicionáltság alfejezetben tanult rangfeltétel szerint $C^\top C\in\mathbb R^{d_{in}\times d_{in}}$ pontosan akkor invertálható, ha $C$ teljes oszloprangú, és $CC^\top\in\mathbb R^{d_{out}\times d_{out}}$ pontosan akkor, ha $C$ teljes sorrangú. A két feltétel független: például $C=\begin{pmatrix}1&0\\0&1\\0&0\end{pmatrix}$-ra $C^\top C=I_2$ invertálható, miközben a sorrang $2<3$, így $CC^\top$ szinguláris. Kétoldali inverzhez ($C^{-1}C=I$ és $CC^{-1}=I$) négyzetes ($d_{in}=d_{out}$), teljes rangú mátrix kell. A $C^\top$ még ekkor sem általában $C^{-1}$: ehhez $C^\top C=I$, vagyis ortogonális $C$ kellene, ami egy konvolúciós operátornál kivételes eset.

15.3.7 Eredeti kézi számpélda

Legyen $k=(2,-1)^\top$, $x=(1,3,0,2)^\top$. A forward:

$$y=Cx= \begin{pmatrix} 2\cdot1+(-1)\cdot3\\ 2\cdot3+(-1)\cdot0\\ 2\cdot0+(-1)\cdot2 \end{pmatrix} = \begin{pmatrix} -1\\6\\-2 \end{pmatrix}.$$

Válasszuk az upstream gradienst $g=\nabla_y L=(-1,6,-2)^\top$ értékűnek; ez a [JELOLESEK] kivételes kézi konvenciójában egyszerűen az $y$ vektor, de az adjungált azonosság tetszőleges $g$-re külön is ellenőrizhető. A (4) képlet:

$$C^\top g= \begin{pmatrix} 2(-1)\\ (-1)(-1)+2\cdot6\\ (-1)\cdot6+2(-2)\\ (-1)(-2) \end{pmatrix} = \begin{pmatrix} -2\\13\\-10\\2 \end{pmatrix}.$$

Ellenőrzés a skalárszorzatos azonossággal:

$$\langle Cx,g\rangle=(-1)^2+6^2+(-2)^2=1+36+4=41,$$

$$\langle x,C^\top g\rangle=1(-2)+3\cdot13+0(-10)+2\cdot2=-2+39+4=41.$$

A két oldal egyezik, így a transzponált mátrix teljesíti az adjungált feltételt.

Minimális NumPy-ellenőrzés:

# n059_manual_example.py
import numpy as np

k = np.array([2.0, -1.0])
x = np.array([1.0, 3.0, 0.0, 2.0])
C = np.zeros((3, 4))
C[0, 0:2] = k
C[1, 1:3] = k
C[2, 2:4] = k

y = C @ x                      # [-1, 6, -2]
g = np.array([-1.0, 6.0, -2.0])
dx = C.T @ g                   # [-2, 13, -10, 2]
lhs = float(y @ g)             # 41
rhs = float(x @ dx)            # 41
print("y =", y)
print("C^T g =", dx)
print("adjoint difference =", abs(lhs - rhs))

15.3.8 Labor: mátrixtranszponált és könyvtári művelet egybevetése

A labor célja, hogy az 1D valid cross-correlation explicit mátrixának transzponáltját összehasonlítsa a PyTorch conv_transpose1d függvényével. A conv_transpose1d a forward 1D konvolúció adjungált útját adja; egycsatornás esetben a súly alakja megegyezik, így a mátrixos és a könyvtári eredmény közvetlenül összevethető. A teszt determinisztikus, véletlen generálást nem használ; a seed megadása a laborprotokoll részeként mégis rögzíti a környezetet.

# labor/n059_adjoint_check.py
import numpy as np
import torch
import torch.nn.functional as F

def make_valid_cc_matrix(n_in: int, k: np.ndarray) -> np.ndarray:
    """1D valid, stride=1, padding=0 cross-correlation matrix."""
    k = np.asarray(k, dtype=np.float64)
    n_out = n_in - k.size + 1
    C = np.zeros((n_out, n_in), dtype=np.float64)
    for i in range(n_out):
        C[i, i:i + k.size] = k
    return C

torch.manual_seed(0)          # nincs véletlen input; a seed a napló része
dtype = torch.float64
device = torch.device("cpu")

k = np.array([2.0, -1.0])
n_in = 4
C = make_valid_cc_matrix(n_in, k)

# upstream gradiens a forward kimeneti terében
g = np.array([-1.0, 6.0, -2.0])
manual = C.T @ g              # (4,)

g_t = torch.tensor(g, dtype=dtype, device=device).view(1, 1, -1)
w_t = torch.tensor(k, dtype=dtype, device=device).view(1, 1, -1)
# stride=1, padding=0, dilation=1, output_padding=0 explicit
library = F.conv_transpose1d(
    g_t, w_t, bias=None, stride=1, padding=0,
    output_padding=0, groups=1, dilation=1,
).cpu().numpy().reshape(-1)

max_abs_diff = float(np.max(np.abs(manual - library)))
print("C^T g manual :", manual)
print("conv_transpose :", library)
print("max_abs_diff   :", max_abs_diff)
print("PASS" if np.allclose(manual, library, atol=1e-12, rtol=0) else "FAIL")

A kód futtatási parancsa a tankönyvi munkakönyvtárból:

python labor/n059_adjoint_check.py

A várt, számított kimenet:

C^T g manual   : [-2. 13. -10.  2.]
conv_transpose : [-2. 13. -10.  2.]
max_abs_diff   : 0.0
PASS

Ez a numerikus egyezés arra a kicsi esetre igazolja, hogy a könyvtári művelet a várt mátrixtranszponáltat alkalmazza; ez nem általános bizonyítás, hanem a [D05] irányelve szerinti független numerikus kontroll egy konfigurációra. A [D11] API-szakaszának teljes ellenőrzése után a labor a 2D ConvTranspose2d-re, valamint stride>1 és output_padding esetekre is kiterjesztendő; jelen kimenet számított várt érték, nem mért futtatás.

15.3.9 Feladatok

F1 (fogalmi, nehézség 1). Definiálja külön-külön a mátrixtranszponáltat, az alak-visszaállítást és az inverzet. Adjon egy konkrét $C$ mátrixot, amelyre $C^\top C\neq I$, és mutassa meg, hogy $C^\top C$ mérete miért árulhatja el már az inverz hiányát. Átadandó: három definíció és egy konkrét mátrix a számítással.

F2 (levezetési/bizonyítási, nehézség 2). Legyen a bemenet $x\in\mathbb R^5$, a kernel $k=(1,1)^\top$, stride=2, padding=0, 1D valid cross-correlation. Írja fel a $C$ mátrixot, a $C^\top$ mátrixot, és tetszőleges, majd a konkrét $x=(1,2,-1,0,3)^\top$, $y=(4,-2)^\top$ párral igazolja a skalárszorzatos adjungált azonosságot. Mutassa meg, hogy $C^\top C$ nem invertálható, és adjon meg egy nemnulla vektort a nullterében. Átadandó: teljes mátrixok, azonosságellenőrzés, rang-indoklás, nulltérvektor.

F3 (implementációs, nehézség 2). Írjon függvényt, amely tetszőleges 1D kernelre felépíti a valid cross-correlation mátrixot, majd a transzponált mátrixszorzást a F.conv_transpose1d kimenetével hasonlítja össze. Ellenőrzés két különböző kernelre, legalább $10^{-13}$ abszolút toleranciával, float64 típuson. Átadandó: futtatható kód, függvény, két teszteset és PASS kimenet.

F4 (hibakeresési, nehézség 2). Adott az alábbi érvelés: „Mivel a réteg neve ConvTranspose2d, ezért az általa számított kimenet a megfelelő Conv2d inverze, tehát stride=2 downsampling után az eredeti képet adja vissza.” Lokalizálja a hibát, adjon 1D ellenpéldát két különböző bemenettel, amelyek forwardja azonos, és ezért a transzponált kimenetük is azonos. Írja le a javított állítást és annak ellenőrzését. Átadandó: hibaelemzés, ellenpélda, javítás.

F5 (kísérleti/kutatói transzfer, nehézség 3). Tervezzen kis kontrollált kísérletet, amely eldönti, hogy egy rögzített ConvTranspose2d konfiguráció pusztán alak-visszaállítást vagy numerikusan is inverzet ad. Használjon 5×5-ös bemenetet, 3×3-ast kernelt, stride=2, padding=1, output_padding=1 értéket. Adja meg a nullhipotézist, a metrikát, a baseline-t, az ismétlésszámot és a következtetés érvényességi korlátját. Futtatás nem kötelező. Átadandó: legfeljebb egy oldalas protokoll.

15.3.10 Megoldások és indoklás

F1 megoldás. A mátrixtranszponált $C^\top$ a sorok és oszlopok felcserélése: $(C^\top)_{ij}=C_{ji}$. Az alak-visszaállítás csak annyit jelent, hogy $C^\top$ a $C$ értelmezési tartományának dimenziójába képez; ez a mátrixméretből következik, nem garantál értékazonosságot. Az inverz $C^{-1}$ a kétoldali azonosságot teljesítő mátrix: $C^{-1}C=I$ és $CC^{-1}=I$.

Konkrét példa a fenti (3) mátrix $k=(2,-1)$ választással:

$$C= \begin{pmatrix} 2&-1&0&0\\ 0&2&-1&0\\ 0&0&2&-1 \end{pmatrix}, \qquad C^\top C= \begin{pmatrix} 4&-2&0&0\\ -2&5&-2&0\\ 0&-2&5&-2\\ 0&0&-2&1 \end{pmatrix}.$$

Mivel $C$ mérete $3\times4$, a $C^\top C$ mérete $4\times4$, de rangja legfeljebb $3$, ezért nem lehet az identitás. Például $x=(1,2,4,8)^\top$ a $C$ nullterében van, mert $Cx=0$, így $C^\top Cx=0\neq x$.

F2 megoldás. A forward: $y_0=x_0+x_1$, $y_1=x_2+x_3$; az $x_4$ elem a stride miatt nem járul hozzá. A mátrix:

$$C= \begin{pmatrix} 1&1&0&0&0\\ 0&0&1&1&0 \end{pmatrix}, \qquad C^\top= \begin{pmatrix} 1&0\\ 1&0\\ 0&1\\ 0&1\\ 0&0 \end{pmatrix}.$$

Általánosan:

$$\langle Cx,y\rangle =y_0(x_0+x_1)+y_1(x_2+x_3) =x_0y_0+x_1y_0+x_2y_1+x_3y_1 =\langle x,C^\top y\rangle.$$

A konkrét párral $Cx=(3,-1)^\top$, ezért $\langle Cx,y\rangle=3\cdot4+(-1)(-2)=14$, míg $C^\top y=(4,4,-2,-2,0)^\top$, tehát $\langle x,C^\top y\rangle=1\cdot4+2\cdot4+(-1)(-2)+0(-2)+3\cdot0=14$. Az azonosság fennáll.

A $C^\top C$ mátrix:

$$C^\top C= \begin{pmatrix} 1&1&0&0&0\\ 1&1&0&0&0\\ 0&0&1&1&0\\ 0&0&1&1&0\\ 0&0&0&0&0 \end{pmatrix}.$$

Rangja 2, kisebb, mint 5, tehát szinguláris. A nulltérnek eleme például $v=(0,0,0,0,1)^\top$, mert $Cv=0$, így $C^\top Cv=0$. Alakellenőrzés: $C$ mérete $2\times5$, $C^\top$ mérete $5\times2$, a szorzat $5\times5$.

F3 megoldás.

# tasks/n059_f3.py
import numpy as np
import torch
import torch.nn.functional as F

def make_valid_cc_matrix(n_in: int, k: np.ndarray) -> np.ndarray:
    k = np.asarray(k, dtype=np.float64)
    n_out = n_in - k.size + 1
    C = np.zeros((n_out, n_in), dtype=np.float64)
    for i in range(n_out):
        C[i, i:i + k.size] = k
    return C

def check_adjoint(k, n_in=8):
    C = make_valid_cc_matrix(n_in, k)
    n_out = C.shape[0]
    g = np.arange(1.0, n_out + 1.0)
    manual = C.T @ g
    g_t = torch.tensor(g, dtype=torch.float64).view(1, 1, -1)
    w_t = torch.tensor(k, dtype=torch.float64).view(1, 1, -1)
    library = F.conv_transpose1d(
        g_t, w_t, stride=1, padding=0, output_padding=0
    ).numpy().reshape(-1)
    return C, manual, library

for k in ([2.0, -1.0], [0.5, 0.25, 0.5]):
    C, manual, library = check_adjoint(np.array(k))
    ok = np.allclose(manual, library, atol=1e-13, rtol=0)
    print("kernel ", k)
    print("C shape ", C.shape)
    print("max_abs_diff", float(np.max(np.abs(manual - library))))
    print("PASS" if ok else "FAIL")

Futtatás: python tasks/n059_f3.py. Mindkét kernelre a várt kimenet PASS, max_abs_diff a $10^{-16}$ nagyságrendben, így a $10^{-13}$ tolerancia elegendő.

F4 megoldás. A hiba a „transposed convolution = inverz” azonosításban van. A ConvTranspose2d a forward lineáris operátor adjungáltja, nem az inverze; a stride=2 downsampling nem injektív, ezért inverz nem is létezhet. 1D ellenpélda a F2 feladat $C$ mátrixával: $x=(1,0,0,0,0)^\top$ és $x'=(2,-1,0,0,0)^\top$ esetén $Cx=Cx'=(1,0)^\top$, tehát a transzponált kimenet mindkettőre $C^\top(1,0)^\top=(1,1,0,0,0)^\top$. Egyetlen dekódolt vektor nem állíthatja vissza mindkét bemenetet. Javított állítás: a réteg a forward adjungáltját, vagy másként az upsampling irányú gradiens-szórást számolja; rekonstrukcióhoz tanított dekódert, invertálható architektúrát vagy kiegészítő loss-t kell használni. Ellenőrzés: rangszámítás vagy a fenti kétinputos teszt.

F5 megoldásminta. Kérdés: a megadott konfiguráció érték szerint is inverze-e a forwardnak? Nullhipotézis: a réteg kimenete $A^\top A x$ alakú, és ez nem egyezik $x$-szel; az inverz hipotézis akkor lenne tartható, ha a hiba numerikusan nulla lenne. Metrika: $e=\|A^\top A x-x\|_2/\|x\|_2$, valamint külön shape-ellenőrzés. Adat: 20 darab, seedelt, $[-1,1]$-beli 5×5-ös kép, NCHW float64. Baseline: identitás kimenet, $e=0$. Protokoll: minden x-re kiszámítjuk a forward és a transzponált kimenetet; ha $e<10^{-12}$ minden esetben, az inverz hipotézist a tesztelt konfigurációban elfogadjuk, különben elvetjük. Várható értelmezés: a ranghiány miatt $e$ nem nulla, így a modul csak alakot állít vissza. Korlát: a numerikus mérés egy konfigurációra vonatkozik; az általános érvénytelenséget a mátrix rangja bizonyítja lineáris algebrából, a mérés csak demonstrál.

15.3.11 Tipikus tévedés és ellenpélda

A leggyakoribb tévedés, hogy a transposed convolutiont dekonvolúciónak vagy inverznek nevezik, és elvárják, hogy egy veszteséges forward után visszaadja az eredeti képet. A fenti $k=(2,-1)$ példában a forward 4 elemű jelet 3 eleművé képez. A $C$ mátrixnak nemtriviális nulltere van: $x=(1,2,4,8)^\top$ esetén $Cx=0$. Ha a transzponált konvolúció inverz lenne, akkor a nulla forward kimenetből ezt a nemnulla $x$-et kellene visszaállítania; de lineáris leképezés nullát nullába visz, tehát ez lehetetlen. Az alak lehet helyes, a pixelértékek nem. A tanulság: a ConvTranspose2d a mátrixtranszponáltat számolja, és a skalárszorzat-azonosságot őrzi, nem a rekonstrukciós azonosságot.

15.3.12 Önellenőrzés és visszahívás

Ellenőrző kérdések: (1) A (3) mátrix esetén mi a $C$ és $C^\top$ mérete, és miért nem lehet $C^\top C=I$? (2) Írja fel a (4) képlet egy tetszőleges $y$-ra, és ellenőrizze, hogy a $y_1$ komponens két helyre is szóródik; melyik forward együtthatók miatt? (3) Egy $4\to3$ forward után miért adhat a transzponált réteg $3\to4$ alakot úgy, hogy közben az értékek nem állnak vissza? A válaszok a fenti levezetésekben találhatók.

Visszahívás 3.3. Vetítés, legkisebb négyzetek és kondicionáltság alfejezetből: a normálegyenlet $A^\top A$ mátrixa csak teljes oszloprang esetén invertálható; itt a $C$ oszloprangja kisebb, mint a bemeneti dimenzió, ezért $C^\top C$ szingularitása ugyanaz a jelenség. Visszahívás 14.3. Paraméterszám, MAC és aktivációmemória alfejezetből: a paraméterszám és a MAC a kimeneti felbontáshoz kötődik, ezért az adjungált réteg költségét is a tényleges kimeneti méretből kell számolni, nem az „inverz” elnevezésből. Visszahívás 11.3. Dataset és DataLoader a split után alfejezetből: a transzponált konvolúció is NCHW batch-szerződésű, a batchdimenziót érintetlenül hagyja; a split- és transzformációs határok a tesztkód szintetikus tenzorain nem íródnak felül.

15.3.13 Rövid összefoglaló

A konvolúciós forward lineáris operátor; a backward bemeneti gradiense az operátor adjungáltja, amely valós mátrixreprezentációban a mátrixtranszponált alkalmazása. Kis 1D valid cross-correlation mátrixon levezettük a skalárszorzatos adjungált azonosságot, és megmutattuk, hogy a transzponált a scatter-add gradiensszórást adja. A ConvTranspose2d ezt az adjungált utat valósítja meg, nem általános inverzet. Az output_padding csak a padlófüggvény miatt nem egyértelmű kimeneti méretet választja. Numerikus labor egy 1D mátrixtranszponáltat hasonlít a könyvtári művelethez.

15.3.14 Következő alkalmazás

A 15.4. Független gradiensellenőrzési protokoll egységben a teljes konvolúciós réteg forward és backward implementációját független numerikus gradiensellenőrzés alá vetjük. Az itteni mátrixos adjungált azonosítás adja az analitikus referenciaértéket, és a laborban használt float64 toleranciaszint lesz a hibamérce alapja. A ReLU töréspontját és a nemsima pontokat külön elkerülő ellenőrzési protokollban a most levezetett lineáris rész pontos gradiense nélkülözhetetlen.

15.3.15 Források

• [D10] PyTorch contributors (2.14). Conv2d. https://docs.pytorch.org/docs/2.14/generated/torch.nn.Conv2d.html.
• [D11] PyTorch contributors (2.14). ConvTranspose2d. https://docs.pytorch.org/docs/2.14/generated/torch.nn.ConvTranspose2d.html.
• [D05] PyTorch contributors (2.14). Autograd mechanics. https://docs.pytorch.org/docs/2.14/notes/autograd.html.
• [S01] Stanford CS231n kurzus (n.d.). Convolutional Neural Networks. https://cs231n.github.io/convolutional-networks/.