Appunti esame completi di Computational Imaging

Computational Imaging - Appunti per

l'Esame Orale

Università di Bologna - Laurea Magistrale in Informatica Modulo 1:

Prof.ssa Elena Loli Piccolomini | Modulo 2: Davide Evangelista

Indice

Modulo 1: Fondamenti Modulo 2: Deep Learning

1. Introduzione 7. Processing per Reti Neurali

2. Pixel Processing 8. PyTorch Essentials

→

3. Filtri e Convoluzione 9. ML Neural Networks

4. Trasformata di Fourier 10. CNN

5. Problemi Inversi 11. UNet

6. Regolarizzazione 12. ViT & Loss Design

13. Cross-Domain

14. VAE & GAN

15. Diffusion Models

16. Diffusion per Problemi Inversi

Riepilogo

Schede Riassuntive — Formule chiave e mappa concettuale

Domande d'Esame — 10 domande con risposte complete

PARTE I - FONDAMENTI DI IMAGING (Modulo 1)

1. Introduzione al Computational Imaging

Computational Imaging (CI) = campo interdisciplinare che unisce

acquisizione, elaborazione e analisi delle immagini attraverso modelli

computazionali.

Tre pilastri:

Image Processing: elaborare un'immagine per migliorarla o estrarre

informazione (filtraggio, enhancement, restauro)

Computer Vision: estrarre informazione semantica dalle immagini

(riconoscimento, segmentazione, ricostruzione 3D)

Computer Graphics: sintetizzare immagini a partire da modelli

(rendering, simulazione)

Immagine Digitale

Un'immagine digitale e una matrice discreta $I \in \mathbb{R}^{M \times N}$

(o $\mathbb{R}^{M \times N \times C}$ per immagini a colori).

Risoluzione spaziale: $M \times N$ pixel

Profondita di bit: numero di valori per pixel (8-bit = 256 livelli)

Canali: 1 (grigio), 3 (RGB), 4 (RGBA)

Formati file:

DICOM (Digital Imaging and Communications in Medicine): standard

per imaging medico, include metadati clinici

PNG: compressione lossless

JPEG: compressione lossy (DCT + quantizzazione)

python import cv2 # OpenCV: BGR,

Lettura immagini in Python:

uint8, shape (H,W,C) import matplotlib # RGB, float

[0,1] from PIL import Image # Pillow: RGB, vari

formati import imageio # versatile, supporta DICOM

2. Pixel Processing

Operazioni che agiscono su ogni pixel indipendentemente dagli altri (punto-

a-punto).

2.1 Istogramma

L'istogramma $h(k)$ conta il numero di pixel con intensita $k$:

$$h(k) = |{(i,j) : I(i,j) = k}|$$

L'istogramma normalizzato e una stima della PDF dell'intensita: $p(k) = h(k) /

(M \cdot N)$.

2.2 Equalizzazione dell'Istogramma

Trasformazione che rende l'istogramma il piu possibile uniforme. La funzione

di trasformazione e la CDF:

$$T(k) = \sum_{i=0}^{k} p(i)$$

Effetto: aumenta il contrasto globale dell'immagine

Limite: non preserva il contrasto locale; puo amplificare il rumore

2.3 Rumore

Il rumore e una degradazione stocastica dell'immagine.

Modelli principali:

Tipo Modello Caratteristica

Gaussiano $I_{noisy} = I + n$, $n \sim Indipendente dal segnale,

additivo \mathcal{N}(0, \sigma^2)$ sempre presente

Impulsivo, colpisce una

Salt & Pepper Pixel casuali a 0 o 255 frazione di pixel

Correlato all'intensita (shot

Poisson $I_{noisy} \sim \text{Poisson}(I)$ noise)

$I_{noisy} = I \cdot n$, $n \sim Moltiplicativo, tipico di

Speckle \mathcal{N}(1, \sigma^2)$ radar/ultrasuoni

3. Filtri e Convoluzione

3.1 Sistemi LSIS (Lineari Shift-Invarianti)

Un sistema LSIS e completamente caratterizzato dalla sua risposta impulsiva

$h$. L'uscita e la convoluzione dell'ingresso con $h$:

$$y = x * h$$

Proprieta: commutativa, associativa, distributiva.

3.2 Convoluzione 1D e 2D

Il kernel $H$ viene "ribaltato" e fatto scorrere sull'immagine

Ai bordi si usa padding (zero, replicate, reflect)

3.3 Filtri Lineari

Box Filter (media uniforme): $$H = \frac{1}{k^2} \begin{bmatrix} 1 & \cdots

& 1 \ \vdots & \ddots & \vdots \ 1 & \cdots & 1 \end{bmatrix}$$

Effetto: sfocatura (low-pass), rimuove alte frequenze

Costo: $O(k^2)$ per pixel

Filtro Gaussiano: $$G(x,y) = \frac{1}{2\pi\sigma^2} e^{-\frac{x^2+y^2}

{2\sigma^2}}$$

Sfocatura piu naturale del box filter (pesi maggiori al centro, minori ai

bordi)

Separabile: $G(x,y) = G(x) \cdot G(y)$ -> costo $O(k)$ per asse invece

di $O(k^2)$

$\sigma$ controlla l'ampiezza: $\sigma$ grande = piu sfocatura

3.4 Filtri Non Lineari

Filtro Mediana:

Sostituisce ogni pixel con la mediana del vicinato

Non lineare (non esprimibile come convoluzione)

Eccellente per rimuovere salt & pepper preservando i bordi

Filtro Bilaterale: $$I_{filtered}[i,j] = \frac{\sum_{(m,n) \in \Omega} w_s(m,n)

\cdot w_r(I[m,n], I[i,j]) \cdot I[m,n]}{\sum_{(m,n) \in \Omega} w_s(m,n) \cdot

w_r(I[m,n], I[i,j])}$$

Due pesi:

$w_s$: peso spaziale (vicinanza, gaussiano) pixel vicini pesano di piu

$w_r$: peso di range (similarita di intensita, gaussiano) pixel con

intensita simile pesano di piu

4. Trasformata di Fourier

4.1 Numeri Complessi

Un numero complesso $z = a + ib = r e^{i\theta}$:

Magnitudine: $|z| = \sqrt{a^2 + b^2}$ ? "quanto"

Fase: $\theta = \arctan(b/a)$ ? "dove"

4.2 Serie di Fourier

Ogni segnale periodico $f(t)$ con periodo $T$ si puo scrivere come somma di

sinusoidi:

$$f(t) = \sum_{n=-\infty}^{\infty} c_n e^{i 2\pi n t / T}$$

4.3 DFT (Discrete Fourier Transform)

1D: $X[k] = \sum_{n=0}^{N-1} x[n] e^{-i 2\pi kn/N}$

2D: $X[u,v] = \sum_{m=0}^{M-1}\sum_{n=0}^{N-1} I[m,n] e^{-i 2\pi (um/M +

vn/N)}$

FFT: calcola la DFT in $O(N \log N)$ invece di $O(N^2)$

Simmetria coniugata: $X[u,v] = X^*[-u,-v]$

4.4 Teorema della Convoluzione

$$x * h \xleftrightarrow{\mathcal{F}} X \cdot H$$

La convoluzione nel dominio spaziale diventa prodotto nel dominio della

frequenza (e viceversa).

Implicazione pratica: filtrare in frequenza e $O(N \log N)$ contro $O(N \cdot

k^2)$ nello spazio.

4.5 Filtraggio in Frequenza

Low-pass (taglia alte frequenze): sfocatura, denoising

High-pass (taglia basse frequenze): edge detection, sharpening

Band-pass: seleziona una banda di frequenze

4.6 Importanza di Fase e Magnitudine

Fase ? contiene la struttura (bordi, forme, posizione)

Magnitudine ? contiene il "quanto" (contrasto globale, energia)

4.7 Compressione DFT

Si possono scartare le componenti di Fourier con magnitudine piccola (sotto

una soglia). Poche componenti a bassa frequenza catturano l'essenza

dell'immagine.

4.8 Hybrid Images

Combinare basse frequenze di un'immagine con alte frequenze di un'altra:

Da vicino si vede l'immagine ad alta frequenza

Da lontano si vede l'immagine a bassa frequenza

5. Computational Imaging e Problemi Inversi

5.1 Il Framework dei Problemi Inversi

$$\boldsymbol{y} = A\boldsymbol{x} + \boldsymbol{e}$$

$\boldsymbol{x} \in \mathbb{R}^n$: immagine incognita (ground

truth)

$A \in \mathbb{R}^{m \times n}$: operatore di acquisizione (forward

model)

$\boldsymbol{y} \in \mathbb{R}^m$: dati misurati

$\boldsymbol{e}$: rumore di misura

Problema diretto: dato $x$, calcolare $y = Ax$ ? facile, ben posto. Problema

inverso: dato $y$, trovare $x$ ? difficile, spesso mal posto.

5.2 Problemi Ill-Posed (Mal Posti)

Un problema e ben posto (Hadamard) se soddisfa:

1. Esistenza: la soluzione esiste

2. Unicita: la soluzione e unica

3. Stabilita: la soluzione dipende con continuita dai dati

I problemi inversi in imaging sono tipicamente ill-posed.

5.3 SVD (Singular Value Decomposition)

$$A = U \Sigma V^T$$

$U, V$: matrici ortogonali (basi ortonormali)

$\Sigma = \text{diag}(\sigma_1, \sigma_2, \ldots, \sigma_r)$: valori

singolari, $\sigma_1 \geq \sigma_2 \geq \cdots \geq \sigma_r > 0$

5.4 Soluzione Naive e Amplificazione del Rumore

La soluzione naive (inversa diretta):

$$\boldsymbol{x}_{naive} = A^{-1}\boldsymbol{y} = A^{-1}(A\boldsymbol{x} +

\boldsymbol{e}) = \boldsymbol{x} + A^{-1}\boldsymbol{e}$$

In termini SVD: {naive} = \sum

$$\boldsymbol{x} {i=1}^{n} \frac{\boldsymbol{u}_i^T

\boldsymbol{y}}{\sigma_i} \boldsymbol{v}_i$$

Il problema: quando $\sigma_i$ e piccolo, $1/\sigma_i$ amplifica

enormemente il rumore.

6. Regolarizzazione

6.1 Il Framework Model-Based

$$\hat{\boldsymbol{x}} = \arg\min_{\boldsymbol{x}}

2^2}

\underbrace{|A\boldsymbol{x} - \boldsymbol{y}| {\text{data fidelity}} +

\lambda \underbrace{R(\boldsymbol{x})}_{\text{regolarizzazione}}$$

6.2 Scelta di $\lambda$

$\lambda \to 0$: overfitting (soluzione rumorosa)

$\lambda \to \infty$: underfitting (soluzione troppo liscia)

$\lambda$ ottimale: bilancia fedelta e plausibilita

6.3 Tipi di Regolarizzazione

Regolarizzatore Formula Effetto

Soluzione liscia, penalizza grandi

Tikhonov ($L_2$) $R(x) = |x|_2^2$ valori

TV (Total $R(x) = |\nabla Preserva bordi, piecewise constant

Variation) x|_1$ Soluzione sparsa (compressed

Sparsita ($L_1$) $R(x) = |x|_1$ sensing)

6.4 Collegamento con il Deep Learning

Il framework model-based classico usa regolarizzatori hand-crafted. Il deep

learning sostituisce $R(\boldsymbol{x})$ con un prior appreso dai dati.

PARTE II - DEEP LEARNING PER IMAGING

(Modulo 2)

7. Processing Images per Reti Neurali

7.1 Tensori

Le immagini per le NN sono tensori 4D: $(B, C, H, W)$

$B$: batch size

$C$: canali (1=grigio, 3=RGB)

$H, W$: altezza e larghezza

`python

Esempio: batch di 32 immagini RGB

256x256

x.shape # torch.Size([32, 3, 256, 256]) `

7.2 Normalizzazione

x = x.float() / 255.0

Range [0, 1]: o

transforms.ToTensor()

x = (x - 0.5) / 0.5

Range [-1, 1]: (usato con GAN,

diffusion) x = (x - mean) / std

Standardizzazione: (per canale)

float32

dtype: per il training (bilancio precisione/memoria).

7.3 Dataset e DataLoader

`python class MayoDataset(Dataset): def init(self, data_path): self.files =

/

sorted(glob(f'{data_path}/ .png')) self.transform = transforms.Compose([

transforms.ToTensor(), transforms.Resize((256, 256)), ]) def len(self): return

len(self.files) def getitem(self, idx): return

self.transform(Image.open(self.files[idx]).convert('L'))

loader = DataLoader(dataset, batch_size=32, shuffle=True) `

Mayo Dataset: 3305 immagini train, 327 test - slice CT addominali.

7.4 Pipeline di Ricostruzione

End-to-end: $y^\delta \xrightarrow{f_\Theta} x_{pred}$

Hybrid: $y^\delta \xrightarrow{\text{FBP}} \tilde{x} \xrightarrow{f_\Theta}

x_{pred}$

8. PyTorch Essentials

8.1 Tensori

python x = torch.randn(3, 4) x.shape, x.dtype,

x.device x.requires_grad = True

8.2 Moduli Parametrizzati

python class MyNet(nn.Module): def __init__(self):

super().__init__() self.linear = nn.Linear(784, 10)

def forward(self, x): return self.linear(x)

8.3 Autograd

python x = torch.tensor([2.0], requires_grad=True) y

= x**2 + 3*x y.backward() print(x.grad) #

tensor([7.0]) = 2*2 + 3

8.4 Ottimizzatori

Ottimizzatore Formula Note

Semplice, puo

SGD $\theta \leftarrow \theta - \eta \nabla L$ oscillare

SGD + $v \leftarrow \mu v + \nabla L$; $\theta Riduce

momentum \leftarrow \theta - \eta v$ oscillazioni

Default nella

Adam Combina momentum + RMSProp pratica

CosineAnnealingLR

Learning Rate Scheduler:

8.5 IPPy (libreria del corso)

IPPy/ +-- operators/ # Forward operators (Blurring,

Radon, etc.) +-- solvers/ # Solvers classici

(Tikhonov, ISTA, etc.) +-- nn/ # Architetture neurali

(UNet, DiffusionUNet, etc.) +-- utilities/ # Device

detection, noise generation, etc.

9. Da Machine Learning a Neural Networks

9.1 Limiti dei Modelli Lineari

Un modello lineare $f(x) = Wx + b$ puo rappresentare solo relazioni lineari.

9.2 Funzioni di Attivazione

Attivazione Formula Uso

ReLU $\max(0, x)$ Default per hidden layers

LeakyReLU $\max(\alpha x, x)$ Evita "dying ReLU"

Sigmoid $1/(1+e^{-x})$ Output binario [0,1]

Tanh $(e^x - e^{-x})/(e^x + e^{-x})$ Output [-1,1]

GELU $x \cdot \Phi(x)$ Transformers

SiLU/Swish $x \cdot \sigma(x)$ Modelli generativi

Softmax $e^{x_i}/\sum e^{x_j}$ Classificazione

9.3 MLP (Multi-Layer Perceptron)

Teorema di approssimazione universale: un MLP con un solo hidden layer

(sufficientemente largo) puo approssimare qualsiasi funzione continua su un

compatto.

9.4 Feature Gerarchiche

Layer bassi: bordi, texture, gradienti

Layer intermedi: forme, pattern locali

Layer alti: oggetti, strutture semantiche

9.5 Training

SGD/Minibatch: aggiornamento su sottoinsiemi

Backpropagation: calcolo efficiente dei gradienti

Generalizzazione: performance su dati non visti

10. CNN (Convolutional Neural Networks)

10.1 Convoluzione 2D nelle CNN

$$y[i,j] = \sum_{m}\sum_{n} x[i+m, j+n] \cdot w[m,n] + b$$

Nota: nelle CNN si usa la cross-correlazione (senza ribaltamento del kernel),

non la convoluzione matematica.

Padding: aggiunta di pixel ai bordi per controllare la dimensione dell'output.

padding = (k-1)/2 (con stride=1) -> output stessa dimensione

dell'input

10.2 Architettura CNN

python class Si