15 udvalgte computer vision interviewspørgsmål grupperet efter anciennitetsniveau. Brug dem til at gennemgå grundlæggende principper, praktiske afvejninger og ræsonnement på seniorniveau i produktion.
1Hvad er en diskret 2D-konvolution på et billede, og hvordan relaterer det sig til kerner, filtre og krydskorrelation?
Diskret 2D-konvolution på et billede er en lineær, rumlig filtreringsoperation, hvor en matrix af vægte (en kerne) skydes henover inputbilledet. På hver rumlig placering beregnes et elementvis produkt mellem kernevægtene og det overlappende lokale billedudsnit (receptivt felt), og resultaterne summeres (ofte med en bias-term) for at producere en enkelt pixelværdi i output-feature map'et. I klassisk matematik og signalbehandling involverer ægte konvolution at vende (rotere 180 grader) kernen horisontalt og vertikalt, før det glidende indre produkt beregnes: $(I * K)(i, j) = \sum_m \sum_n I(i - m, j - n) K(m, n)$. I modsætning hertil beregner krydskorrelation det glidende prikprodukt direkte uden at vende kernen: $(I \star K)(i, j) = \sum_m \sum_n I(i + m, j + n) K(m, n)$. I deep learning-rammeværker som PyTorch og TensorFlow er den operation, der implementeres under navnet "konvolution", faktisk krydskorrelation. Fordi kernevægtene er trænbare parametre, der optimeres direkte via backpropagation, lærer netværket simpelthen de passende orienterede vægte, hvilket gør det matematiske kerneflip beregningsmæssigt redundant under både træning og inferens.
2Hvornår ville du bruge RGB, HSV, Lab, YCbCr eller gråskala-repræsentationer i en vision-pipeline?
Forskellige farverum afkobler specifikke fysiske, perceptuelle og statistiske egenskaber ved visuelle data, hvilket gør dem velegnede til specifikke vision-opgaver:
1. **RGB / BGR**: Standardformat for kamerasensorer og skærmhardware, der repræsenterer additive grundfarver (rød, grøn, blå). Farvekanaler er stærkt korrelerede med luminans (lysændringer påvirker alle tre kanaler samtidigt). Det er standardinput for dybe neurale netværk (CNN'er, Vision Transformers). Et stort produktionsproblem er RGB- vs. BGR-kanalombytning (f.eks. indlæser OpenCV BGR, mens PIL/PyTorch forventer RGB), hvilket stille og roligt skader modellens nøjagtighed.
2. **HSV / HSL**: Afkobler eksplicit kromaticitet (Hue = farvetone, Saturation = farvemætning) fra intensitet (Value/Lightness). Det er ideelt til klassisk farvetærskling (color thresholding), objektsporing via farve og farvesegmentering under varierende belysning, fordi Hue er relativt invariant over for skygger og lysstyrkeændringer.
3. **CIE Lab**: Et perceptuelt ensartet farverum, hvor den Euklidiske afstand mellem to punkter ($\Delta E$) direkte afspejler menneskelig perceptuel forskel. Det adskiller lyshed ($L^*$) fra modfarveakser ($a^*$ grøn-rød, $b^*$ blå-gul). Det bruges til inspektion af farveforskelle, farvekorrektion, vurdering af billedkvalitet og farvelægningsopgaver.
4. **YCbCr**: Adskiller luminans ($Y$) fra blå-forskel ($Cb$) og rød-forskel ($Cr$) kroma-komponenter. Det er rygraden i video- og billedkompressionsstandarder (JPEG, MPEG, H.264/H.265), fordi det menneskelige visuelle system er mindre følsomt over for kromadetaljer, hvilket muliggør kroma-subsampling (f.eks. 4:2:0) for at reducere båndbredde og beregningskrav.
5. **Gråskala (Grayscale)**: Enkeltkanals intensitetsrepræsentation ($Y \approx 0.299R + 0.587G + 0.114B$). Det er ideelt til geometri- og teksturbaserede opgaver, hvor farve er irrelevant (f.eks. optisk flow, SLAM, klassisk feature-ekstraktion som SIFT/ORB, kantdetektion) for at spare 66% hukommelse og beregningskraft. Det bør dog ikke bruges, når farve er et afgørende diskriminerende signal (f.eks. klassificering af trafiklysstatus).
import cv2
import numpy as np
# Sample image: saturated red under normal and shaded lighting
img_bgr = np.zeros((100, 100, 3), dtype=np.uint8)
img_bgr[:, :50] = [0, 0, 255] # Bright Red in BGR
img_bgr[:, 50:] = [0, 0, 120] # Shaded/Dark Red in BGR
# Convert to HSV (OpenCV H: 0-179, S: 0-255, V: 0-255)
img_hsv = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2HSV)
# Red Hue wraps around 0/180; track red with single Hue range [0, 10] & high saturation
lower_red = np.array([0, 100, 50])
upper_red = np.array([10, 255, 255])
mask_hsv = cv2.inRange(img_hsv, lower_red, upper_red)
print("HSV segmented pixels:", np.count_nonzero(mask_hsv), "out of", mask_hsv.size)
3Hvorfor er kanal-baseret billednormalisering, per-billede normalisering og konsistent pixelskalering vigtige i synssystemer?
Billednormalisering er afgørende i vision-pipelines for at opretholde numerisk stabilitet, accelerere konvergens af gradient descent og forhindre forskydning i trænings- og serving-distribution:
1. **Pixelskalering ([0, 1] eller [-1, 1])**: Rå billedpixels gemmes som usignerede 8-bit heltal (`uint8` $\in [0, 255]$). At føde rå $[0, 255]$ værdier ind i neurale netværk forårsager ekstremt store tidlige aktiveringer og gradient-eksplosion eller -mætning. Skalering til $[0.0, 1.0]$ (ved at dividere med 255.0) eller $[-1.0, 1.0]$ centrerer input omkring nul, hvilket stemmer overens med standard vægtinitialiseringsmetoder (He, Xavier).
2. **Dataset-niveau Kanalnormalisering (Middel-Standardafvigelsesstandardisering)**: Standardiserer input via $x_{norm} = \frac{x - \mu_c}{\sigma_c}$ ved hjælp af forudberegnede globale statistikker per kanal (f.eks. ImageNet middel `[0.485, 0.456, 0.406]` og standardafvigelse `[0.229, 0.224, 0.225]`). Dette centrerer hver kanal omkring nul middelværdi med enhedsvarians på tværs af datasættet, hvilket sikrer balanceret gradientflow på tværs af kanaler. En kritisk operationel fejl er **trænings-serving skævhed**: hvis inferens udelader division med 255, bruger uoverensstemmende middel-/standardafvigelseskonstanter eller anvender dem i forkert kanalrækkefølge (RGB vs BGR), falder modellens ydeevne drastisk.
3. **Per-billede Normalisering (Instance Normalization / Min-Max / Z-score)**: Beregner middelværdi og standardafvigelse for hvert enkelt billede: $x_{norm} = \frac{x - \mu_{img}}{\sigma_{img}}$. Dette fjerner globale kontrast- og belysningsvariationer på tværs af forskellige optagelsesforhold. Selvom det er effektivt i stiloverførsel, MRI/CT medicinsk billeddannelse eller satellitbilleder, kan det være skadeligt, når absolut pixelintensitet har fysisk betydning (f.eks. dag- vs natklassifikation, materialereflektans eller defektdetektering under kalibreret belysning).
import torch
import torchvision.transforms as T
from PIL import Image
import numpy as np
# Create a mock uint8 RGB image
raw_img = Image.fromarray(np.random.randint(0, 256, (224, 224, 3), dtype=np.uint8))
# Standard transform pipeline:
# 1. ToTensor scales uint8 [0, 255] -> float32 [0.0, 1.0] and permutes HWC -> CHW
# 2. Normalize standardizes per-channel using dataset mean and std
preprocess = T.Compose([
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
tensor_img = preprocess(raw_img)
print("Tensor shape:", tensor_img.shape)
print("Tensor dtype:", tensor_img.dtype)
print("Channel 0 min/max:", round(tensor_img[0].min().item(), 2), round(tensor_img[0].max().item(), 2))
4Hvordan fremmer geometriske og fotometriske augmentationer invarians, og hvordan afgør man, om en augmentation bevarer etiketter?
Geometriske augmentationer (såsom rotation, translation, skalering og spejling) ændrer den rumlige koordinatmapping af pixels, mens fotometriske augmentationer (såsom lysstyrke, kontrast, hue jitter og sløring) ændrer pixelintensitet og farvekanaler uden at modificere rumlige koordinater. Inden for klassifikation udsætter begge kategorier modellen for realistiske variationer, hvilket opmuntrer den til at lære invariante repræsentationer, hvor forudsigelser forbliver stabile på trods af ændringer i positur, synspunkt eller lysforhold. I rumlige forudsigelsesopgaver (detektion og segmentering) kræver geometriske transformationer matchende transformationer til ground-truth-bokse eller masker for at bevare ækvarians. Beslutningen om, hvorvidt en augmentation bevarer etiketter, kræver evaluering af domænesemantik og fysisk forhåndsviden. En transformation er etiketbevarende, hvis det resulterende billede forbliver en sandsynlig instans af den originale målgruppe uden at ændre dens semantiske identitet. For eksempel bevarer horisontal spejling identitet for generelle objekter (som biler eller dyr), men ændrer identitet eller ugyldiggør tegn i optisk tegngenkendelse (OCR) og cifferklassifikation. Tilsvarende er fuld 360-graders rotation gyldig i histologi eller satellitbilleder, hvor ingen kanonisk orientering eksisterer, men unaturlig i autonom kørsel, hvor objekter på hovedet krænker virkelige fysiske begrænsninger.
5Hvad er nearest-neighbor, bilinear, bicubic og area-interpolering, og hvordan kan skalering introducere aliasing eller sløring?
Interpolationsmetoder estimerer pixelintensiteter ved kontinuerlige koordinater, når der resampling foretages til et nyt diskret gitter:
- **Nearest-Neighbor:** Tildeler intensiteten fra den nærmeste diskrete pixel. Det er beregningsmæssigt $O(1)$ og bevarer nøjagtige originale værdier, men skaber blokkede artefakter ved opskalering og kraftige takkede kanter ved nedskalering.
- **Bilinear Interpolation:** Beregner et afstands-vægtet gennemsnit af de $2 \times 2$ (4 nærmeste) nabopixels ved hjælp af lineær interpolation langs begge akser, hvilket giver jævne overgange med moderat sløring.
- **Bicubic Interpolation:** Sampler et $4 \times 4$ (16 nærmeste) nabolag ved hjælp af kubiske polynomielle kerner. Det fanger lokale intensitetsgradienter og producerer skarpere kanter og jævnere kurver end bilinear, men kan give overshoot/ringing-artefakter omkring skarpe overgange.
- **Area (Box) Interpolation:** Beregner det fraktionerede områdeoverlap af målpixels projiceret på kildepixels og gennemsnitliggør de underliggende kildeintensiteter. Det er især effektivt til nedskalering uden moiré.
**Aliasing kontra sløringsmekanismer:**
- **Aliasing** opstår under nedskalering, når højfrekvent indhold overstiger Nyquist-frekvensen ($f_s / 2$) af den nye samplingrate uden tilstrækkelig lavpasfiltrering. Højfrekvenser folder tilbage i lavere frekvensbånd, hvilket producerer falske mønstre, moiré og takkede kanter.
- **Sløring (Blur)** opstår, når interpolationskerner fungerer som lavpas-udjævningsfiltre, der dæmper legitime højfrekvenser (f.eks. bilinear udjævning), eller når højfrekvente detaljer udjævnes under nedskalering.
6Hvilke visuelle fejltyper fra den virkelige verden bør et synssystem evalueres ud fra, og hvordan ændrer de inputfordelingen?
Visuelle fejltyper fra den virkelige verden falder i flere brede kategorier: miljøforhold (svagt lys, direkte genskin, regn, sne, tåge), sensor- og optiske effekter (bevægelsessløring, defokuseringssløring, høj ISO-sensorstøj, rolling shutter-skævhed), kompressions- og transmissionsnedbrydning (JPEG-blokdannelse, videobitrate-begrænsning, nedskalering) og semantiske/rumlige forskydninger (delvis okklusion, trunkering, objektpositioner uden for fordelingen). Disse fejltyper forskubber inputfordelingen væk fra nominelle træningsdomæner på flere niveauer. På pixel-niveau ændrer de luminans- og krominanshistogrammer, ødelægger lokal kontrast, reducerer signal-støj-forholdet (SNR) og introducerer kunstige højfrekvente artefakter eller sløringskerneler. På strukturelt og semantisk niveau svækker de kantgradienter, tilslører centrale visuelle træk, forvrænger silhuetter og skjuler kritiske diagnostiske regioner. Når modeller trænet på rene data møder disse forskudte inputs, aktiveres lavniveaus konvolutionelle eller attention feature extractors ikke korrekt, hvilket fører til manglende detektioner, hallicinerende falske positiver på støjbilleder og overkonfidente fejl.
7Hvordan repræsenterer klassiske deskriptorer som HOG billedstruktur, og hvilke begrænsninger har de sammenlignet med indlærte CNN (Convolutional Neural Network)-features?
Histogram of Oriented Gradients (HOG) er en klassisk, håndlavet feature-deskriptor designet til at fange lokal objektform og -udseende gennem fordelingen af intensitetsgradientorienteringer. HOG-beregningspipeline involverer: (1) beregning af horisontale og vertikale billedgradienter (f.eks. med 1D derivationsfiltre [-1, 0, 1]) for at opnå gradientstørrelse og -orientering; (2) opdeling af billedet i små rumlige regioner kaldet 'celler' (såsom 8x8 pixels) og akkumulering af 1D histogrammer af gradientorienteringer vægtet efter gradientstørrelse; (3) gruppering af tilstødende celler i større overlappende 'blokke' (såsom 2x2 celler) og normalisering af blok-feature-vektorer (ved hjælp af L2-norm eller L1-sqrt) for at opnå robusthed over for lokale belysnings-, kontrast- og skyggevariationer; og (4) konkatenering af normaliserede blokvektorer til en endelig 1D feature-repræsentation, historisk parret med lineære SVM'er til fodgænger- og objektdetektion. Sammenlignet med indlærte Convolutional Neural Network (CNN)-features har HOG store begrænsninger: For det første er HOG-features faste og håndlavede, og de fanger kun lavniveau lokale kantorienteringsstatistikker uden evnen til at lære opgavespecifikke hierarkiske repræsentationer (såsom teksturer, objektdelene og semantiske koncepter). For det andet giver HOG meget begrænset geometrisk invarians: mens bloknormalisering håndterer monotone belysningsændringer og små rumlige forskydninger inden for celler, er HOG sårbar over for 3D rotationer ud af planen, betydelige skalavariationer, ikke-stive positionelle artikulationer og kraftig baggrundsforstyrrelse. I modsætning hertil lærer CNN'er flerlags ikke-lineære abstraktioner optimeret end-to-end for målet.
8Hvordan bestemmer stride, padding, dilation og kernelstørrelse konvolutionens outputstørrelse og receptive felt?
De rumlige output-dimensioner af et konvolutionelt lag og dets kumulative receptive felt bestemmes af kernelstørrelse $k$, stride $s$, padding $p$ og dilation $d$:
1. **Outputets rumlige størrelse**:
Dilation introducerer $(d - 1)$ mellemrum mellem kerneelementer, hvilket giver en effektiv kernelstørrelse på $k' = d(k - 1) + 1$. Output-dimensionen langs en akse er givet ved:
$$O = \left\lfloor \frac{I + 2p - k'}{s} \right\rfloor + 1 = \left\lfloor \frac{I + 2p - d(k - 1) - 1}{s} \right\rfloor + 1$$
Her nedprøver stride (eller reducerer opløsningen) ved at flytte kernen $s$ pixel per trin, padding tilføjer virtuelle kantpixel for at bevare eller justere rumlige dimensioner, og dilation udvider filterets aftryk uden at tilføje ekstra parametre.
2. **Receptive Felt (RF)**:
Det teoretiske receptive felt beskriver den rumlige udstrækning i inputbilledet, der påvirker en bestemt aktivering. På tværs af stablede lag opdateres det receptive felt $RF_l$ og den kumulative stride (jump $j_l$) rekursivt:
* Jump: $j_l = j_{l-1} \cdot s_l$, med $j_0 = 1$
* Receptive Felt: $RF_l = RF_{l-1} + (k'_l - 1) \cdot j_{l-1}$, med $RF_0 = 1$
Strides og pooling udvider det receptive felt multiplikativt på tværs af dybde, fordi efterfølgende lags kernel-trin svarer til større pixel-spring i den oprindelige input-koordinatrum. Dilation udvider det receptive felt additivt inden for et enkelt lag ved at øge $k'_l$ uden rumlig nedprøvning.
9Hvordan svarer en konvolutionskerne til et klassisk lineært billedfilter, og hvornår kan et 2D filter gøres separabelt?
I klassisk lineær signal- og billedbehandling repræsenterer en konvolutionskerne den rumlige impulsrespons (punktspredningsfunktion) for et Lineært Skift-Invariant (LSI) system. Anvendelsen af kernen er en lineær filtreringsoperation i det rumlige domæne, der former billedets frekvensrespons (dets 2D Fouriertransformation). Lavpasfiltre (f.eks. Gaussian, box blur) dæmper høje rumlige frekvenser for at undertrykke støj og udglatte teksturer, mens højpas- eller båndpasfiltre (f.eks. Sobel, Laplacian, Prewitt) forstærker høje frekvenser for at detektere kanter og gradienter. Et 2D filterkerne $K \in \mathbb{R}^{M \times N}$ er rumligt separabelt, hvis det kan dekomponeres til yderproduktet af to 1D filtre: $K = u \cdot v^T$, hvor $u \in \mathbb{R}^{M \times 1}$ og $v \in \mathbb{R}^{N \times 1}$. I lineær algebra-termer er en 2D matrix separabel, hvis og kun hvis dens matrixrang er 1. Dette kan verificeres via Singularværdidekomponering (SVD), hvor præcis én singulær værdi er ikke-nul ($ \sigma_1 > 0, \sigma_2 = \dots = 0$). Separabilitet reducerer den beregningsmæssige kompleksitet betydeligt. Anvendelse af en ikke-separabel $K \times K$ kerne på et $H \times W$ billede kræver $O(H \cdot W \cdot K^2)$ multiplikationer og additioner. Når den dekomponeres i to på hinanden følgende 1D passager (horisontal og derefter vertikal), falder kompleksiteten til $O(H \cdot W \cdot 2K)$. For en $15 \times 15$ kerne giver dette omtrent en 7.5x hastighedsforøgelse.
10Hvordan ændrer ændring af størrelse, centerbeskæring, `Random-Resized Cropping` (tilfældig størrelsesændret beskæring), strækning og `letterboxing` inputdatafordelingen?
Forskellige strategier for ændring af størrelse og beskæring ændrer inputdatafordelingen på tværs af geometri, skala, indholdsdækning og rumlige grænser:
1. **Direkte ændring af størrelse (strækning/sammentrykning):** Skalerer billedet ikke-isotropisk til en måldimension $(H, W)$, hvilket forvrænger de originale billedformater. Dette tvinger modellen til at behandle deformerede objektformer (f.eks. bliver cirkulære objekter aflange ellipser).
2. **Centerbeskæring:** Uddrager en central beskæring af fast størrelse eller forhold. Den bevarer det oprindelige billedformat og den lokale skala, men introducerer en stærk central bias (forudsat at målobjekter er centralt indrammet) og kasserer perifert indhold eller skærer objekter ved kanten af.
3. **`Random-Resized Cropping` (RRC):** Uddrager tilfældige delregioner på tværs af varierende arealstørrelser og billedformater, hvorefter de ændres til en fast dimension. Dette udvider træningsskalafordelingen og fremmer delfokuseret feature-læring, men ekstreme beskæringer kan udelukke målobjektet fuldstændigt.
4. **`Letterboxing` (isotropisk størrelsesændring med udfyldning):** Skalerer billedet ensartet, indtil dets længste dimension passer til målstørrelsen, og udfylder derefter de resterende kanter med en konstant værdi. Den opretholder ægte objektdimensioner og billedformater, men introducerer kunstige højkonstrastkanter og uinformative udfyldte pixels.
11Hvilke former for annoteringsstøj forekommer i computer vision-datasæt, og hvordan ville du detektere eller afhjælpe dem?
Computer vision-datasæt udviser almindeligvis fire primære former for annoteringsstøj: 1. **Kategorisk labelstøj:** Et billede eller objekt tildeles den forkerte klasselabel (f.eks. fejlkategorisering af en kat som en hund, eller forveksling af subtile finkornede klasser). 2. **Manglende annoteringer (udladelsesstøj):** Gyldige forgrundsobjekter forbliver uannoterede. Inden for objektdetektering behandles udeladte mål som negative baggrunde, hvilket direkte straffer korrekte modeldetekteringer under træning. 3. **Bounding-Box / Keypoint Jitter (lokaliseringsstøj):** Unøjagtige, løse eller forskudte `bounding box`-koordinater og landmark-lokationer forårsaget af menneskelig annotator-inkonsistens. 4. **Maskegrænseambiguitet:** Inkonsistente eller grove segmenteringskonturer langs komplekse eller slørede grænser (f.eks. hår, semi-transparente overflader, bevægelsesslør). **Detektions- og afhjælpningsstrategier:** - **Loss Outlier Tracking & Confident Learning:** Sporing af sample-loss på tværs af træningsepoker identificerer vedvarende `high-loss outliers`, som ofte indikerer fejllabelerede eller udeladte instanser. Algoritmer som Confident Learning estimerer støjfordelinger for at fjerne eller korrigere fejl. - **Out-of-Fold (OOF) Prediction Discrepancies:** Træning af `cross-validation`-modeller og sammenligning af `holdout`-forudsigelser mod grundsandhed fremhæver fejllabelerede billeder og manglende `bounding boxes`. - **Inter-Annotator Agreement (IAA) og konsensusgennemgang:** Måling af metrikker som Cohens Kappa (klassifikation) eller gennemsnitlig Intersection-over-Union (IoU) (lokalisering) på tværs af flere annotatorer markerer prøver med lav enighed for konsensusgennemgang. - **Robuste loss-formuleringer:** Brug af `label smoothing`, støjtolerante klassifikations-loss-funktioner eller robuste IoU-baserede regressions-loss-funktioner reducerer følsomhed over for `jitter` og fejllabelering.
import torch
import torch.nn.functional as F
def find_label_noise_candidates(model, dataloader, device, top_k=50):
model.eval()
sample_losses = []
with torch.no_grad():
for batch_idx, (images, targets, sample_ids) in enumerate(dataloader):
images, targets = images.to(device), targets.to(device)
logits = model(images)
loss_per_sample = F.cross_entropy(logits, targets, reduction='none')
for sid, l, target, pred in zip(sample_ids, loss_per_sample.cpu(), targets.cpu(), logits.argmax(dim=-1).cpu()):
sample_losses.append({'id': sid, 'loss': l.item(), 'target': target.item(), 'pred': pred.item()})
sample_losses.sort(key=lambda x: x['loss'], reverse=True)
return sample_losses[:top_k]
12Hvordan påvirker klasseubalance træning af billedklassifikation, detektion og tæt prædiktion?
Klasseubalance påvirker optimeringsdynamik og tabsfunkionslandskaber på tværs af synsopgaver: 1. **Billedklassifikation:** Når flertalsklasser er i overtal i forhold til mindretalsklasser, medfører empirisk risikominimering, at parameteropdateringer domineres af gradienter fra flertalsklasser. Modellen lærer den empiriske klasseprior $P(Y)$ og fordrejer sin beslutningsgrænse mod sjældne klasser. Dette giver en høj samlet top-1 nøjagtighed, men lider af et alvorligt sammenbrud i mindretals recall. 2. **Objektdetektion:** - *For-/baggrundsubalance:* I tætte et-trins- og ankerbaserede detektorer evalueres hundredtusindvis af kandidatplaceringer pr. billede, hvor >99% er baggrund. Selvom individuelle lette baggrundsankre giver små tab, overskygger deres store aggregerede gradient de informative gradientsignaler fra spredte forgrundsobjekter. - *Forgrundsklasseubalance:* Almindelige objektkategorier forekommer størrelsesordener hyppigere end sjældne kategorier, hvilket reducerer den effektive stikprøvestørrelse og læringssignal for sjældne klasser. 3. **Tæt Prædiktion (Segmentering):** Pixelniveau-ubalance er alvorlig, fordi store baggrunds- og 'stuff'-klasser (f.eks. vej, himmel) optager millioner af pixels, mens små 'thing'-klasser (f.eks. trafikskilte, fodgængere) kan optage færre end 0,1% af billedpixels. Standard pixel-per-pixel krydsentropitab domineres af klasser med stort areal, hvilket fører til undersegmentering eller fuldstændig forsvinden af små, tynde strukturer.
13Hvordan ville du fejlfinde NaN-værdier (ikke-et-tal-værdier) eller ustabilt tab under storstilet distribueret visionstræning?
Fejlfinding af NaN-værdier eller ustabilt tab i storstilet distribueret visionstræning med Distributed Data Parallel (DDP) kræver isolering af, om rodårsagen stammer fra dårlige inputdata, numerisk overløb/underløb i blandet præcision (Automatic Mixed Precision - AMP) eller optimeringsustabiliteter på tværs af workers. For det første skal determinisme og sikkerhedshooks etableres: aktiver anomalidetektion (`torch.autograd.set_detect_anomaly(True)`), registrer gradient-/aktiveringshooks for at fange det præcise lag, hvor NaN-værdier dukker op, og tilføj streng datavalidering i DataLoader (sikring af endelige værdier, kontrol af 0-byte korrupte billeder, tomme bounding boxes eller normaliseringsdivisorer med nul varians). Logning på minibatch-niveau bør spore tab pr. rank, input-URI'er, gradientnorm før klipning og GradScaler-skalafaktorer. For det andet skal Automatic Mixed Precision (AMP) og dynamisk tabsskalering inspiceres: I FP16 (Floating Point 16) kan store gradienter let overløbe (`> 65504`), hvilket får tabsskaleren til at springe trin over og gentagne gange halvere sin skalafaktor, indtil skalaen når nul; at skifte ustabile operationer (f.eks. softmax, LayerNorm, focal loss-eksponenter eller bounding box IoU-nævnere) til FP32 (Floating Point 32) eller anvende BF16 (Bfloat16), som matcher FP32's dynamiske område, stabiliserer typisk træningen. Endelig skal DDP-specifikke faldgruber kontrolleres, såsom all-reduce-operationer, der propagerer NaN-værdier fra en enkelt worker til alle ranks, opskalering af learning rate warmup (f.eks. lineær skaleringsregel med store globale batchstørrelser) og gradientklipning.
import torch
from torch.cuda.amp import autocast, GradScaler
scaler = GradScaler()
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)
for step, (images, targets, uris) in enumerate(dataloader):
# 1. Input sanitization
if not torch.isfinite(images).all():
print(f"Corrupt input detected from URIs: {uris}")
continue
optimizer.zero_grad(set_to_none=True)
with autocast(dtype=torch.float16):
outputs = model(images)
loss = criterion(outputs, targets)
if not torch.isfinite(loss):
print(f"NaN/Inf loss at step {step} on rank {torch.distributed.get_rank()}; skipping step.")
continue
scaler.scale(loss).backward()
# Unscale before clipping to inspect true gradient norms
scaler.unscale_(optimizer)
grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
if torch.isnan(grad_norm) or torch.isinf(grad_norm):
print(f"Warning: Grad norm is {grad_norm}. Scaler will adjust.")
scaler.step(optimizer)
scaler.update()
14Hvordan ville du designe en online digital videostabiliseringskomponent til et kamera med billedrystelser?
At designe en online digital videostabiliseringspipeline til realtids kamerarystelser involverer fire primære trin: bevægelsesestimering, bevægelsesudjævning, bevægelseskompensation (warping) og grænsehåndtering.
1. **Mellem-billed bevægelsesestimering:** Udtræk 2D sparse nøglepunkter på tværs af på hinanden følgende billeder ved hjælp af hurtige feature-detektorer (f.eks. ORB, FAST eller Shi-Tomasi hjørner) og beregn korrespondancer ved hjælp af Lucas-Kanade optisk flow eller feature descriptor matching. Estimer en geometrisk transformation mellem billeder (såsom en Affine- eller homografi-model) ved hjælp af RANSAC for at afvise outlier-matches forårsaget af uafhængigt bevægelige forgrundsobjekter.
2. **Akkumulering af bevægelsesbane og online udjævning:** Integrer transformationer fra billede til billede over tid for at opretholde den kumulative kamerapath $P_t = P_{t-1} \cdot H_t$. Anvend et online udjævningsfilter – såsom et 1D/2D Kalman-filter eller et kausalt bevægende gennemsnit med kort vindue – for at adskille højfrekvent utilsigtet rystelse fra lavfrekvent intentionel kamerapanorering.
3. **Kompensation og billedwarping:** Beregn korrektionstransformationen $C_t = S_t \cdot P_t^{-1}$ (hvor $S_t$ er den udjævnede path) og warp det nuværende billede ved hjælp af bilinær/bikubisk interpolation.
4. **Grænsehåndtering og latenstidskrav:** Warping introducerer manglende kantpixler / sorte kanter; løs dette ved at anvende en fast dynamisk beskæringsfaktor (f.eks. 5-10% zoom ind) med grænseekstrapolation eller adaptiv skala. I et online miljø skal der opretholdes minimal buffering (1-3 lookahead-billeder) for at begrænse behandlingslatenstiden.
15Hvordan ville du optimere en realtids-vision-pipeline, når detektoren er langsommere end den tilsigtede billedhastighed?
Når en objektdetektor ikke kan opretholde den tilsigtede billedhastighed (f.eks. kører med 15-20 FPS på et 60 FPS videofeed), afkobler en robust produktionsarkitektur detektering fra realtidspræsentationsloopet ved hjælp af en asynkron flertrådet pipeline, der kombinerer tung detektering med letvægtssporing. I denne hybridarkitektur fanger en indtags-tråd kontinuerligt videobilleder. Den tunge detektor kører asynkront som en 'keyframe'-detektor på en baggrunds-arbejdstråd. I mellemtiden kører en letvægtssporer (såsom optisk flow Lucas-Kanade, ByteTrack/BoT-SORT eller et hurtigt korrelationsfilter/Kalman-filter) synkront på hvert billede med fuld 60 FPS, opretholder objekttilstand, identitet og jævne bounding box-trajektorier. For at håndtere forsinkelse og backpressure uden at introducere ubegrænset latenstid eller forældede billeder, bruges begrænsede ringbuffere og politikker for at droppe seneste billede. Når detektoren er færdig med et billede T_0 på tidspunkt T_curr, er dens output forældet. Pipelinen udfører koordinat-genjustering/bagudprojektion: den associerer de forsinkede detektionsresultater med den historiske tracklet-tilstand ved T_0, opdaterer identiteter og mistede spor og propagerer korrektionerne fremad til T_curr via sporings-bevægelsesvektorerne eller Kalman-filterets forudsigelsestrin.
import queue
import threading
frame_queue = queue.Queue(maxsize=1) # Drop stale frames, keep latest
det_result_queue = queue.Queue()
def detector_worker():
while True:
frame, frame_id, timestamp = frame_queue.get()
boxes, scores, classes = heavy_detector.infer(frame)
det_result_queue.put({'frame_id': frame_id, 'boxes': boxes, 'timestamp': timestamp})
def realtime_pipeline(video_stream):
tracker = FastTracker() # e.g. Optical flow or Kalman tracker
for frame, frame_id, timestamp in video_stream:
if frame_queue.empty():
frame_queue.put((frame, frame_id, timestamp))
if not det_result_queue.empty():
det_result = det_result_queue.get()
tracker.reconcile_and_correct(det_result, current_frame_id=frame_id)
active_tracks = tracker.update(frame)
display_or_downstream(frame, active_tracks)